blob: 374f26335c9d930280fa1cfd7b50bdc15bd5b8b1 [file] [log] [blame]
// Copyright 2018 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.skyframe;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedSet;
import com.google.devtools.build.lib.analysis.TargetAndConfiguration;
import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
import com.google.devtools.build.lib.analysis.config.BuildConfigurationCollection;
import com.google.devtools.build.lib.analysis.config.BuildOptions;
import com.google.devtools.build.lib.analysis.config.ConfigurationResolver.TopLevelTargetsAndConfigsResult;
import com.google.devtools.build.lib.analysis.config.FragmentClassSet;
import com.google.devtools.build.lib.analysis.config.InvalidConfigurationException;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.events.ExtendedEventHandler;
import com.google.devtools.build.lib.packages.NoSuchPackageException;
import com.google.devtools.build.lib.packages.NoSuchTargetException;
import com.google.devtools.build.lib.packages.Target;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec.VisibleForSerialization;
import com.google.devtools.build.skyframe.SkyFunctionName;
import com.google.devtools.build.skyframe.SkyKey;
import com.google.devtools.build.skyframe.SkyValue;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
/**
* A value referring to a set of build configuration keys in order to reconstruct the
* legacy {@link BuildConfigurationCollection} as well as a set of top level configured target keys
* that are subsequently requested to trigger the analysis phase.
*
* <p>The public interface returns {@link BuildConfigurationCollection} and {@link
* TargetAndConfiguration} even though these are not internally stored - the construction of these
* objects requires additional Skyframe calls. The intention is that these are temporary until a
* larger fraction of the code has been ported to Skyframe, at which point we'll use the internal
* representation.
*/
@Immutable
@ThreadSafe
@AutoCodec
public final class PrepareAnalysisPhaseValue implements SkyValue {
private final BuildConfigurationValue.Key hostConfigurationKey;
private final ImmutableList<BuildConfigurationValue.Key> targetConfigurationKeys;
private final ImmutableList<ConfiguredTargetKey> topLevelCtKeys;
PrepareAnalysisPhaseValue(
BuildConfigurationValue.Key hostConfigurationKey,
ImmutableList<BuildConfigurationValue.Key> targetConfigurationKeys,
ImmutableList<ConfiguredTargetKey> topLevelCtKeys) {
this.hostConfigurationKey = Preconditions.checkNotNull(hostConfigurationKey);
this.targetConfigurationKeys = Preconditions.checkNotNull(targetConfigurationKeys);
this.topLevelCtKeys = Preconditions.checkNotNull(topLevelCtKeys);
}
/**
* Returns the legacy {@link BuildConfigurationCollection}. Note that this performs additional
* Skyframe calls, which may be expensive.
*/
public BuildConfigurationCollection getConfigurations(
ExtendedEventHandler eventHandler, SkyframeExecutor skyframeExecutor)
throws InvalidConfigurationException {
BuildConfiguration hostConfiguration =
skyframeExecutor.getConfiguration(eventHandler, hostConfigurationKey);
ImmutableList<BuildConfiguration> targetConfigurations =
ImmutableList.copyOf(
skyframeExecutor.getConfigurations(eventHandler, targetConfigurationKeys).values());
return new BuildConfigurationCollection(targetConfigurations, hostConfiguration);
}
/**
* Returns the intended top-level targets and configurations for the build. Note that this
* performs additional Skyframe calls for the involved configurations and targets, which may be
* expensive.
*
* <p>Skips targets that have errors and registers the errors to be reported later as part of
* {@link com.google.devtools.build.lib.analysis.AnalysisResult} error resolution.
*/
public TopLevelTargetsAndConfigsResult getTopLevelCts(
ExtendedEventHandler eventHandler, SkyframeExecutor skyframeExecutor) {
List<TargetAndConfiguration> result = new ArrayList<>();
Map<BuildConfigurationValue.Key, BuildConfiguration> configs =
skyframeExecutor.getConfigurations(
eventHandler,
topLevelCtKeys.stream()
.map(ctk -> ctk.getConfigurationKey())
.filter(Predicates.notNull())
.collect(Collectors.toSet()));
// TODO(ulfjack): This performs one Skyframe call per top-level target. This is not a
// regression, but we should fix it nevertheless, either by doing a bulk lookup call or by
// migrating the consumers of these to Skyframe so they can directly request the values.
boolean hasError = false;
for (ConfiguredTargetKey key : topLevelCtKeys) {
Target target;
try {
target = skyframeExecutor.getPackageManager().getTarget(eventHandler, key.getLabel());
} catch (NoSuchPackageException | NoSuchTargetException | InterruptedException e) {
eventHandler.handle(
Event.error("Failed to get package from TargetPatternPhaseValue: " + e.getMessage()));
hasError = true;
continue;
}
BuildConfiguration config =
key.getConfigurationKey() == null ? null : configs.get(key.getConfigurationKey());
result.add(new TargetAndConfiguration(target, config));
}
return new TopLevelTargetsAndConfigsResult(result, hasError);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof PrepareAnalysisPhaseValue)) {
return false;
}
PrepareAnalysisPhaseValue that = (PrepareAnalysisPhaseValue) obj;
return this.hostConfigurationKey.equals(that.hostConfigurationKey)
&& this.targetConfigurationKeys.equals(that.targetConfigurationKeys)
&& this.topLevelCtKeys.equals(that.topLevelCtKeys);
}
@Override
public int hashCode() {
return Objects.hash(
this.hostConfigurationKey,
this.targetConfigurationKeys,
this.topLevelCtKeys);
}
/** Create a prepare analysis phase key. */
@ThreadSafe
public static SkyKey key(
FragmentClassSet fragments,
BuildOptions.OptionsDiffForReconstruction optionsDiff,
Set<String> multiCpu,
Collection<Label> labels) {
return new PrepareAnalysisPhaseKey(fragments, optionsDiff, multiCpu, labels);
}
/** The configuration needed to prepare the analysis phase. */
@ThreadSafe
@VisibleForSerialization
@AutoCodec
public static final class PrepareAnalysisPhaseKey implements SkyKey, Serializable {
private final FragmentClassSet fragments;
private final BuildOptions.OptionsDiffForReconstruction optionsDiff;
private final ImmutableSortedSet<String> multiCpu;
private final ImmutableSet<Label> labels;
PrepareAnalysisPhaseKey(
FragmentClassSet fragments,
BuildOptions.OptionsDiffForReconstruction optionsDiff,
Set<String> multiCpu,
Collection<Label> labels) {
this.fragments = Preconditions.checkNotNull(fragments);
this.optionsDiff = Preconditions.checkNotNull(optionsDiff);
this.multiCpu = ImmutableSortedSet.copyOf(multiCpu);
this.labels = ImmutableSet.copyOf(labels);
}
@Override
public SkyFunctionName functionName() {
return SkyFunctions.PREPARE_ANALYSIS_PHASE;
}
public FragmentClassSet getFragments() {
return fragments;
}
public BuildOptions.OptionsDiffForReconstruction getOptionsDiff() {
return optionsDiff;
}
public ImmutableSortedSet<String> getMultiCpu() {
return multiCpu;
}
public ImmutableSet<Label> getLabels() {
return labels;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(PrepareAnalysisPhaseKey.class)
.add("fragments", fragments)
.add("optionsDiff", optionsDiff)
.add("multiCpu", multiCpu)
.add("labels", labels)
.toString();
}
@Override
public int hashCode() {
return Objects.hash(
fragments,
optionsDiff,
multiCpu,
labels);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof PrepareAnalysisPhaseKey)) {
return false;
}
PrepareAnalysisPhaseKey other = (PrepareAnalysisPhaseKey) obj;
return other.fragments.equals(this.fragments)
&& other.optionsDiff.equals(this.optionsDiff)
&& other.multiCpu.equals(multiCpu)
&& other.labels.equals(labels);
}
}
}