blob: 24450879ce58748837b7c8944faafd1753cddd68 [file] [log] [blame]
// Copyright 2014 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.buildtool;
import static com.google.common.collect.ImmutableSet.toImmutableSet;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Predicate;
import com.google.common.base.Stopwatch;
import com.google.common.base.Suppliers;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.devtools.build.lib.actions.Action;
import com.google.devtools.build.lib.actions.ActionCacheChecker;
import com.google.devtools.build.lib.actions.ActionGraph;
import com.google.devtools.build.lib.actions.ActionInputPrefetcher;
import com.google.devtools.build.lib.actions.ArtifactFactory;
import com.google.devtools.build.lib.actions.BuildFailedException;
import com.google.devtools.build.lib.actions.Executor;
import com.google.devtools.build.lib.actions.ExecutorInitException;
import com.google.devtools.build.lib.actions.LocalHostCapacity;
import com.google.devtools.build.lib.actions.MetadataProvider;
import com.google.devtools.build.lib.actions.PackageRoots;
import com.google.devtools.build.lib.actions.ResourceManager;
import com.google.devtools.build.lib.actions.ResourceSet;
import com.google.devtools.build.lib.actions.TestExecException;
import com.google.devtools.build.lib.actions.cache.ActionCache;
import com.google.devtools.build.lib.actions.cache.Protos.ActionCacheStatistics;
import com.google.devtools.build.lib.analysis.AnalysisResult;
import com.google.devtools.build.lib.analysis.ConfiguredTarget;
import com.google.devtools.build.lib.analysis.TopLevelArtifactContext;
import com.google.devtools.build.lib.analysis.TopLevelArtifactHelper;
import com.google.devtools.build.lib.analysis.WorkspaceStatusAction;
import com.google.devtools.build.lib.analysis.actions.SymlinkTreeActionContext;
import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
import com.google.devtools.build.lib.buildtool.buildevent.ExecutionPhaseCompleteEvent;
import com.google.devtools.build.lib.buildtool.buildevent.ExecutionStartingEvent;
import com.google.devtools.build.lib.cmdline.PackageIdentifier;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.events.EventHandler;
import com.google.devtools.build.lib.events.EventKind;
import com.google.devtools.build.lib.events.Reporter;
import com.google.devtools.build.lib.exec.ActionContextProvider;
import com.google.devtools.build.lib.exec.BlazeExecutor;
import com.google.devtools.build.lib.exec.CheckUpToDateFilter;
import com.google.devtools.build.lib.exec.ExecutionOptions;
import com.google.devtools.build.lib.exec.ExecutorBuilder;
import com.google.devtools.build.lib.exec.SingleBuildFileCache;
import com.google.devtools.build.lib.exec.SpawnActionContextMaps;
import com.google.devtools.build.lib.exec.SymlinkTreeStrategy;
import com.google.devtools.build.lib.profiler.AutoProfiler;
import com.google.devtools.build.lib.profiler.ProfilePhase;
import com.google.devtools.build.lib.profiler.Profiler;
import com.google.devtools.build.lib.profiler.ProfilerTask;
import com.google.devtools.build.lib.profiler.SilentCloseable;
import com.google.devtools.build.lib.runtime.BlazeModule;
import com.google.devtools.build.lib.runtime.BlazeRuntime;
import com.google.devtools.build.lib.runtime.CommandEnvironment;
import com.google.devtools.build.lib.skyframe.AspectValue;
import com.google.devtools.build.lib.skyframe.AspectValue.AspectKey;
import com.google.devtools.build.lib.skyframe.Builder;
import com.google.devtools.build.lib.skyframe.ConfiguredTargetKey;
import com.google.devtools.build.lib.skyframe.SkyframeExecutor;
import com.google.devtools.build.lib.util.AbruptExitException;
import com.google.devtools.build.lib.util.LoggingUtil;
import com.google.devtools.build.lib.vfs.FileSystemUtils;
import com.google.devtools.build.lib.vfs.ModifiedFileSet;
import com.google.devtools.build.lib.vfs.OutputService;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.devtools.build.lib.vfs.Root;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* This class manages the execution phase. The entry point is {@link #executeBuild}.
*
* <p>This is only intended for use by {@link BuildTool}.
*
* <p>This class contains an ActionCache, and refers to the Blaze Runtime's BuildView and
* PackageCache.
*
* @see BuildTool
* @see com.google.devtools.build.lib.analysis.BuildView
*/
public class ExecutionTool {
static final Logger logger = Logger.getLogger(ExecutionTool.class.getName());
private final CommandEnvironment env;
private final BlazeRuntime runtime;
private final BuildRequest request;
private BlazeExecutor executor;
private final MetadataProvider fileCache;
private final ActionInputPrefetcher prefetcher;
private final ImmutableList<ActionContextProvider> actionContextProviders;
private SpawnActionContextMaps spawnActionContextMaps;
ExecutionTool(CommandEnvironment env, BuildRequest request) throws ExecutorInitException {
this.env = env;
this.runtime = env.getRuntime();
this.request = request;
try {
env.getExecRoot().createDirectoryAndParents();
} catch (IOException e) {
throw new ExecutorInitException("Execroot creation failed", e);
}
ExecutorBuilder builder = new ExecutorBuilder();
for (BlazeModule module : runtime.getBlazeModules()) {
try (SilentCloseable closeable = Profiler.instance().profile(module + ".executorInit")) {
module.executorInit(env, request, builder);
}
}
builder.addActionContext(new SymlinkTreeStrategy(
env.getOutputService(), env.getBlazeWorkspace().getBinTools()));
// TODO(philwo) - the ExecutionTool should not add arbitrary dependencies on its own, instead
// these dependencies should be added to the ActionContextConsumer of the module that actually
// depends on them.
builder
.addStrategyByContext(WorkspaceStatusAction.Context.class, "")
.addStrategyByContext(SymlinkTreeActionContext.class, "");
// Unfortunately, the exec root cache is not shared with caches in the remote execution client.
this.fileCache =
new SingleBuildFileCache(
env.getExecRoot().getPathString(), env.getRuntime().getFileSystem());
this.prefetcher = builder.getActionInputPrefetcher();
this.actionContextProviders = builder.getActionContextProviders();
for (ActionContextProvider provider : actionContextProviders) {
try (SilentCloseable closeable = Profiler.instance().profile(provider + ".init")) {
provider.init(fileCache);
}
}
// There are many different SpawnActions, and we want to control the action context they use
// independently from each other, for example, to run genrules locally and Java compile action
// in prod. Thus, for SpawnActions, we decide the action context to use not only based on the
// context class, but also the mnemonic of the action.
spawnActionContextMaps =
builder.getSpawnActionContextMapsBuilder().build(
actionContextProviders, request.getOptions(ExecutionOptions.class).testStrategy);
}
Executor getExecutor() throws ExecutorInitException {
if (executor == null) {
executor = createExecutor();
}
return executor;
}
/**
* Creates an executor for the current set of blaze runtime, execution options, and request.
*/
private BlazeExecutor createExecutor()
throws ExecutorInitException {
return new BlazeExecutor(
runtime.getFileSystem(),
env.getExecRoot(),
getReporter(),
env.getEventBus(),
runtime.getClock(),
request,
spawnActionContextMaps,
actionContextProviders);
}
void init() throws ExecutorInitException {
getExecutor();
}
void shutdown() {
for (ActionContextProvider actionContextProvider : actionContextProviders) {
actionContextProvider.executionPhaseEnding();
}
}
/**
* Performs the execution phase (phase 3) of the build, in which the Builder is applied to the
* action graph to bring the targets up to date. (This function will return prior to
* execution-proper if --nobuild was specified.)
*
* @param buildId UUID of the build id
* @param analysisResult the analysis phase output
* @param buildResult the mutable build result
* @param packageRoots package roots collected from loading phase and BuildConfigurationCollection
* creation. May be empty if {@link
* SkyframeExecutor#getForcedSingleSourceRootIfNoExecrootSymlinkCreation} is false.
*/
void executeBuild(
UUID buildId,
AnalysisResult analysisResult,
BuildResult buildResult,
PackageRoots packageRoots,
TopLevelArtifactContext topLevelArtifactContext)
throws BuildFailedException, InterruptedException, TestExecException, AbruptExitException {
Stopwatch timer = Stopwatch.createStarted();
prepare(packageRoots);
ActionGraph actionGraph = analysisResult.getActionGraph();
OutputService outputService = env.getOutputService();
ModifiedFileSet modifiedOutputFiles = ModifiedFileSet.EVERYTHING_MODIFIED;
if (outputService != null) {
try (SilentCloseable c = Profiler.instance().profile("outputService.startBuild")) {
modifiedOutputFiles =
outputService.startBuild(
env.getReporter(), buildId, request.getBuildOptions().finalizeActions);
}
} else {
// TODO(bazel-team): this could be just another OutputService
try (SilentCloseable c = Profiler.instance().profile("startLocalOutputBuild")) {
startLocalOutputBuild();
}
}
if (outputService == null || !outputService.supportsActionFileSystem()) {
// Must be created after the output path is created above.
createActionLogDirectory();
}
// Create convenience symlinks from the configurations actually used by the requested targets.
// Symlinks will be created if all such configurations would point the symlink to the same path;
// if this does not hold, stale symlinks (if present from a previous invocation) will be
// deleted instead.
Set<BuildConfiguration> targetConfigurations =
request.getBuildOptions().useTopLevelTargetsForSymlinks()
? analysisResult
.getTargetsToBuild()
.stream()
.map(ConfiguredTarget::getConfigurationKey)
.filter(configuration -> configuration != null)
.distinct()
.map((key) -> env.getSkyframeExecutor().getConfiguration(env.getReporter(), key))
.collect(toImmutableSet())
: ImmutableSet.copyOf(
analysisResult.getConfigurationCollection().getTargetConfigurations());
String productName = runtime.getProductName();
String workspaceName = env.getWorkspaceName();
try (SilentCloseable c =
Profiler.instance().profile("OutputDirectoryLinksUtils.createOutputDirectoryLinks")) {
OutputDirectoryLinksUtils.createOutputDirectoryLinks(
workspaceName, env.getWorkspace(), env.getDirectories().getExecRoot(workspaceName),
env.getDirectories().getOutputPath(workspaceName), getReporter(), targetConfigurations,
request.getBuildOptions().getSymlinkPrefix(productName), productName);
}
ActionCache actionCache = getActionCache();
actionCache.resetStatistics();
SkyframeExecutor skyframeExecutor = env.getSkyframeExecutor();
Builder builder;
try (SilentCloseable c = Profiler.instance().profile("createBuilder")) {
builder = createBuilder(
request, actionCache, skyframeExecutor, modifiedOutputFiles);
}
//
// Execution proper. All statements below are logically nested in
// begin/end pairs. No early returns or exceptions please!
//
Collection<ConfiguredTarget> configuredTargets = buildResult.getActualTargets();
try (SilentCloseable c = Profiler.instance().profile("ExecutionStartingEvent")) {
env.getEventBus().post(new ExecutionStartingEvent(configuredTargets));
}
getReporter().handle(Event.progress("Building..."));
// Conditionally record dependency-checker log:
ExplanationHandler explanationHandler =
installExplanationHandler(request.getBuildOptions().explanationPath,
request.getOptionsDescription());
Set<ConfiguredTargetKey> builtTargets = new HashSet<>();
Set<AspectKey> builtAspects = new HashSet<>();
Collection<AspectValue> aspects = analysisResult.getAspects();
if (request.isRunningInEmacs()) {
// The syntax of this message is tightly constrained by lisp/progmodes/compile.el in emacs
request
.getOutErr()
.printErrLn(
env.getRuntime().getProductName() + ": Entering directory `" + getExecRoot() + "/'");
}
Throwable catastrophe = null;
boolean buildCompleted = false;
try {
for (ActionContextProvider actionContextProvider : actionContextProviders) {
try (SilentCloseable c =
Profiler.instance().profile(actionContextProvider + ".executionPhaseStarting")) {
actionContextProvider.executionPhaseStarting(
actionGraph,
Suppliers.memoize(
() ->
TopLevelArtifactHelper.makeTopLevelArtifactsToOwnerLabels(
analysisResult, aspects)));
}
}
executor.executionPhaseStarting();
skyframeExecutor.drainChangedFiles();
if (request.getViewOptions().discardAnalysisCache
|| !skyframeExecutor.tracksStateForIncrementality()) {
// Free memory by removing cache entries that aren't going to be needed.
try (SilentCloseable c = Profiler.instance().profile("clearAnalysisCache")) {
env.getSkyframeBuildView()
.clearAnalysisCache(analysisResult.getTargetsToBuild(), analysisResult.getAspects());
}
}
try (SilentCloseable c = Profiler.instance().profile("configureResourceManager")) {
configureResourceManager(request);
}
Profiler.instance().markPhase(ProfilePhase.EXECUTE);
builder.buildArtifacts(
env.getReporter(),
analysisResult.getTopLevelArtifactsToOwnerLabels().getArtifacts(),
analysisResult.getParallelTests(),
analysisResult.getExclusiveTests(),
analysisResult.getTargetsToBuild(),
analysisResult.getTargetsToSkip(),
analysisResult.getAspects(),
executor,
builtTargets,
builtAspects,
request,
env.getBlazeWorkspace().getLastExecutionTimeRange(),
topLevelArtifactContext);
buildCompleted = true;
} catch (BuildFailedException | TestExecException e) {
buildCompleted = true;
throw e;
} catch (Error | RuntimeException e) {
catastrophe = e;
} finally {
// These may flush logs, which may help if there is a catastrophic failure.
for (ActionContextProvider actionContextProvider : actionContextProviders) {
actionContextProvider.executionPhaseEnding();
}
// Handlers process these events and others (e.g. CommandCompleteEvent), even in the event of
// a catastrophic failure. Posting these is consistent with other behavior.
env.getEventBus()
.post(
new ExecutionFinishedEvent(
ImmutableMap.of(),
0L,
skyframeExecutor.getOutputDirtyFilesAndClear(),
skyframeExecutor.getModifiedFilesDuringPreviousBuildAndClear()));
env.getEventBus()
.post(new ExecutionPhaseCompleteEvent(timer.stop().elapsed(TimeUnit.MILLISECONDS)));
if (catastrophe != null) {
Throwables.throwIfUnchecked(catastrophe);
}
// NOTE: No finalization activities below will run in the event of a catastrophic error!
env.recordLastExecutionTime();
if (request.isRunningInEmacs()) {
request
.getOutErr()
.printErrLn(
env.getRuntime().getProductName() + ": Leaving directory `" + getExecRoot() + "/'");
}
if (buildCompleted) {
getReporter().handle(Event.progress("Building complete."));
}
executor.executionPhaseEnding();
if (buildCompleted) {
saveActionCache(actionCache);
}
try (SilentCloseable c = Profiler.instance().profile("Show results")) {
buildResult.setSuccessfulTargets(
determineSuccessfulTargets(configuredTargets, builtTargets));
buildResult.setSuccessfulAspects(determineSuccessfulAspects(aspects, builtAspects));
buildResult.setSkippedTargets(analysisResult.getTargetsToSkip());
BuildResultPrinter buildResultPrinter = new BuildResultPrinter(env);
buildResultPrinter.showBuildResult(
request,
buildResult,
configuredTargets,
analysisResult.getTargetsToSkip(),
analysisResult.getAspects());
}
try (SilentCloseable c = Profiler.instance().profile("Show artifacts")) {
if (request.getBuildOptions().showArtifacts) {
BuildResultPrinter buildResultPrinter = new BuildResultPrinter(env);
buildResultPrinter.showArtifacts(
request, configuredTargets, analysisResult.getAspects());
}
}
if (explanationHandler != null) {
uninstallExplanationHandler(explanationHandler);
try {
explanationHandler.close();
} catch (IOException _ignored) {
// Ignored
}
}
// Finalize output service last, so that if we do throw an exception, we know all the other
// code has already run.
if (env.getOutputService() != null) {
boolean isBuildSuccessful =
buildResult.getSuccessfulTargets().size() == configuredTargets.size();
env.getOutputService().finalizeBuild(isBuildSuccessful);
}
}
}
private void prepare(PackageRoots packageRoots)
throws ExecutorInitException, InterruptedException {
Optional<ImmutableMap<PackageIdentifier, Root>> packageRootMap =
packageRoots.getPackageRootsMap();
if (!packageRootMap.isPresent()) {
return;
}
// Prepare for build.
Profiler.instance().markPhase(ProfilePhase.PREPARE);
// Plant the symlink forest.
try (SilentCloseable c = Profiler.instance().profile("plantSymlinkForest")) {
new SymlinkForest(
packageRootMap.get(), getExecRoot(), runtime.getProductName(), env.getWorkspaceName())
.plantSymlinkForest();
} catch (IOException e) {
throw new ExecutorInitException("Source forest creation failed", e);
}
}
private void createActionLogDirectory() throws ExecutorInitException {
Path directory = env.getActionConsoleOutputDirectory();
try {
if (directory.exists()) {
FileSystemUtils.deleteTree(directory);
}
FileSystemUtils.createDirectoryAndParents(directory);
} catch (IOException e) {
throw new ExecutorInitException("Couldn't delete action output directory", e);
}
}
/**
* Prepare for a local output build.
*/
private void startLocalOutputBuild() throws ExecutorInitException {
try (SilentCloseable c = Profiler.instance().profile("Starting local output build")) {
Path outputPath = env.getDirectories().getOutputPath(env.getWorkspaceName());
Path localOutputPath = env.getDirectories().getLocalOutputPath();
if (outputPath.isSymbolicLink()) {
try {
// Remove the existing symlink first.
outputPath.delete();
if (localOutputPath.exists()) {
// Pre-existing local output directory. Move to outputPath.
localOutputPath.renameTo(outputPath);
}
} catch (IOException e) {
throw new ExecutorInitException("Couldn't handle local output directory symlinks", e);
}
}
}
}
/**
* If a path is supplied, creates and installs an ExplanationHandler. Returns
* an instance on success. Reports an error and returns null otherwise.
*/
private ExplanationHandler installExplanationHandler(PathFragment explanationPath,
String allOptions) {
if (explanationPath == null) {
return null;
}
ExplanationHandler handler;
try {
handler = new ExplanationHandler(
getWorkspace().getRelative(explanationPath).getOutputStream(),
allOptions);
} catch (IOException e) {
getReporter().handle(Event.warn(String.format(
"Cannot write explanation of rebuilds to file '%s': %s",
explanationPath, e.getMessage())));
return null;
}
getReporter().handle(
Event.info("Writing explanation of rebuilds to '" + explanationPath + "'"));
getReporter().addHandler(handler);
return handler;
}
/**
* Uninstalls the specified ExplanationHandler (if any) and closes the log
* file.
*/
private void uninstallExplanationHandler(ExplanationHandler handler) {
if (handler != null) {
getReporter().removeHandler(handler);
handler.log.close();
}
}
/**
* An ErrorEventListener implementation that records DEPCHECKER events into a log file, iff the
* --explain flag is specified during a build.
*/
private static class ExplanationHandler implements EventHandler, AutoCloseable {
private final PrintWriter log;
private ExplanationHandler(OutputStream log, String optionsDescription) {
this.log = new PrintWriter(new OutputStreamWriter(log, StandardCharsets.UTF_8));
this.log.println("Build options: " + optionsDescription);
}
@Override
public void close() throws IOException {
this.log.close();
}
@Override
public void handle(Event event) {
if (event.getKind() == EventKind.DEPCHECKER) {
log.println(event.getMessage());
}
}
}
/**
* Computes the result of the build. Sets the list of successful (up-to-date) targets in the
* request object.
*
* @param configuredTargets The configured targets whose artifacts are to be built.
*/
private Collection<ConfiguredTarget> determineSuccessfulTargets(
Collection<ConfiguredTarget> configuredTargets, Set<ConfiguredTargetKey> builtTargets) {
// Maintain the ordering by copying builtTargets into a LinkedHashSet in the same iteration
// order as configuredTargets.
Collection<ConfiguredTarget> successfulTargets = new LinkedHashSet<>();
for (ConfiguredTarget target : configuredTargets) {
if (builtTargets.contains(ConfiguredTargetKey.inTargetConfig(target))) {
successfulTargets.add(target);
}
}
return successfulTargets;
}
private Collection<AspectValue> determineSuccessfulAspects(
Collection<AspectValue> aspects, Set<AspectKey> builtAspects) {
// Maintain the ordering by copying builtTargets into a LinkedHashSet in the same iteration
// order as configuredTargets.
Collection<AspectValue> successfulAspects = new LinkedHashSet<>();
for (AspectValue aspect : aspects) {
if (builtAspects.contains(aspect.getKey())) {
successfulAspects.add(aspect);
}
}
return successfulAspects;
}
/** Get action cache if present or reload it from the on-disk cache. */
private ActionCache getActionCache() throws LocalEnvironmentException {
try {
return env.getPersistentActionCache();
} catch (IOException e) {
// TODO(bazel-team): (2010) Ideally we should just remove all cache data and reinitialize
// caches.
LoggingUtil.logToRemote(Level.WARNING, "Failed to initialize action cache: "
+ e.getMessage(), e);
throw new LocalEnvironmentException(
"couldn't create action cache: "
+ e.getMessage()
+ ". If error persists, use 'bazel clean'");
}
}
private Builder createBuilder(BuildRequest request,
ActionCache actionCache,
SkyframeExecutor skyframeExecutor,
ModifiedFileSet modifiedOutputFiles) {
BuildRequestOptions options = request.getBuildOptions();
Path actionOutputRoot = env.getActionConsoleOutputDirectory();
Predicate<Action> executionFilter = CheckUpToDateFilter.fromOptions(
request.getOptions(ExecutionOptions.class));
skyframeExecutor.setActionOutputRoot(actionOutputRoot);
ArtifactFactory artifactFactory = env.getSkyframeBuildView().getArtifactFactory();
return new SkyframeBuilder(
skyframeExecutor,
new ActionCacheChecker(
actionCache,
artifactFactory,
skyframeExecutor.getActionKeyContext(),
executionFilter,
ActionCacheChecker.CacheConfig.builder()
.setEnabled(options.useActionCache)
.setVerboseExplanations(options.verboseExplanations)
.build()),
request.getPackageCacheOptions().checkOutputFiles
? modifiedOutputFiles
: ModifiedFileSet.NOTHING_MODIFIED,
fileCache,
prefetcher);
}
@VisibleForTesting
public static void configureResourceManager(BuildRequest request) {
ResourceManager resourceMgr = ResourceManager.instance();
ExecutionOptions options = request.getOptions(ExecutionOptions.class);
ResourceSet resources;
if (options.availableResources != null) {
logger.warning(
"--local_resources will be deprecated. Please use --local_ram_resources "
+ "and/or --local_cpu_resources.");
resources = options.availableResources;
resourceMgr.setRamUtilizationPercentage(100);
} else if (options.ramUtilizationPercentage != 0) {
logger.warning(
"--ram_utilization_factor will soon be deprecated. Please use "
+ "--local_ram_resources=HOST_RAM*<float>, where <float> is the percentage of "
+ "available RAM you want to devote to Bazel.");
resources =
ResourceSet.createWithRamCpu(
LocalHostCapacity.getLocalHostCapacity().getMemoryMb(), options.localCpuResources);
resourceMgr.setRamUtilizationPercentage(options.ramUtilizationPercentage);
} else {
resources =
ResourceSet.createWithRamCpu(options.localRamResources, options.localCpuResources);
resourceMgr.setRamUtilizationPercentage(100);
}
resourceMgr.setUseLocalMemoryEstimate(options.localMemoryEstimate);
resourceMgr.setAvailableResources(ResourceSet.create(
resources.getMemoryMb(),
resources.getCpuUsage(),
request.getExecutionOptions().usingLocalTestJobs()
? request.getExecutionOptions().localTestJobs : Integer.MAX_VALUE
));
}
/**
* Writes the action cache files to disk, reporting any errors that occurred during writing and
* capturing statistics.
*/
private void saveActionCache(ActionCache actionCache) {
ActionCacheStatistics.Builder builder = ActionCacheStatistics.newBuilder();
actionCache.mergeIntoActionCacheStatistics(builder);
AutoProfiler p =
AutoProfiler.profiledAndLogged("Saving action cache", ProfilerTask.INFO, logger);
try {
builder.setSizeInBytes(actionCache.save());
} catch (IOException e) {
builder.setSizeInBytes(0);
getReporter().handle(Event.error("I/O error while writing action log: " + e.getMessage()));
} finally {
builder.setSaveTimeInMs(
TimeUnit.MILLISECONDS.convert(p.completeAndGetElapsedTimeNanos(), TimeUnit.NANOSECONDS));
}
env.getEventBus().post(builder.build());
}
private Reporter getReporter() {
return env.getReporter();
}
private Path getWorkspace() {
return env.getWorkspace();
}
private Path getExecRoot() {
return env.getExecRoot();
}
}