1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
// Copyright 2015 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.skyframe;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.google.devtools.build.lib.util.Preconditions;
import com.google.devtools.build.skyframe.QueryableGraph.Reason;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import javax.annotation.Nullable;
/**
* {@link WalkableGraph} that looks nodes up in a {@link QueryableGraph}.
*/
public class DelegatingWalkableGraph implements WalkableGraph {
private final QueryableGraph graph;
public DelegatingWalkableGraph(QueryableGraph graph) {
this.graph = graph;
}
@Nullable
private NodeEntry getEntryForValue(SkyKey key) throws InterruptedException {
NodeEntry entry =
graph.getBatch(null, Reason.WALKABLE_GRAPH_VALUE, ImmutableList.of(key)).get(key);
return entry != null && entry.isDone() ? entry : null;
}
@Nullable
@Override
public SkyValue getValue(SkyKey key) throws InterruptedException {
NodeEntry entry = getEntryForValue(key);
return entry == null ? null : entry.getValue();
}
private static SkyValue getValue(NodeEntry entry) throws InterruptedException {
return entry.isDone() ? entry.getValue() : null;
}
@Override
public Map<SkyKey, SkyValue> getSuccessfulValues(Iterable<SkyKey> keys)
throws InterruptedException {
Map<SkyKey, ? extends NodeEntry> batchGet =
graph.getBatch(null, Reason.WALKABLE_GRAPH_VALUE, keys);
Map<SkyKey, SkyValue> result = Maps.newHashMapWithExpectedSize(batchGet.size());
for (Entry<SkyKey, ? extends NodeEntry> entryPair : batchGet.entrySet()) {
SkyValue value = getValue(entryPair.getValue());
if (value != null) {
result.put(entryPair.getKey(), value);
}
}
return result;
}
@Override
public Map<SkyKey, Exception> getMissingAndExceptions(Iterable<SkyKey> keys)
throws InterruptedException {
Map<SkyKey, Exception> result = new HashMap<>();
Map<SkyKey, ? extends NodeEntry> graphResult =
graph.getBatch(null, Reason.WALKABLE_GRAPH_VALUE, keys);
for (SkyKey key : keys) {
NodeEntry nodeEntry = graphResult.get(key);
if (nodeEntry == null || !nodeEntry.isDone()) {
result.put(key, null);
} else {
ErrorInfo errorInfo = nodeEntry.getErrorInfo();
if (errorInfo != null) {
result.put(key, errorInfo.getException());
}
}
}
return result;
}
@Override
public boolean isCycle(SkyKey key) throws InterruptedException {
NodeEntry entry = getEntryForValue(key);
if (entry == null) {
return false;
}
ErrorInfo errorInfo = entry.getErrorInfo();
return errorInfo != null && !Iterables.isEmpty(errorInfo.getCycleInfo());
}
@Nullable
@Override
public Exception getException(SkyKey key) throws InterruptedException {
NodeEntry entry = getEntryForValue(key);
if (entry == null) {
return null;
}
ErrorInfo errorInfo = entry.getErrorInfo();
return errorInfo == null ? null : errorInfo.getException();
}
@Override
public Map<SkyKey, Iterable<SkyKey>> getDirectDeps(Iterable<SkyKey> keys)
throws InterruptedException {
Map<SkyKey, ? extends NodeEntry> entries =
graph.getBatch(null, Reason.WALKABLE_GRAPH_DEPS, keys);
Map<SkyKey, Iterable<SkyKey>> result = new HashMap<>(entries.size());
for (Entry<SkyKey, ? extends NodeEntry> entry : entries.entrySet()) {
Preconditions.checkState(entry.getValue().isDone(), entry);
result.put(entry.getKey(), entry.getValue().getDirectDeps());
}
return result;
}
@Override
public Map<SkyKey, Iterable<SkyKey>> getReverseDeps(Iterable<SkyKey> keys)
throws InterruptedException {
Map<SkyKey, ? extends NodeEntry> entries =
graph.getBatch(null, Reason.WALKABLE_GRAPH_RDEPS, keys);
Map<SkyKey, Iterable<SkyKey>> result = new HashMap<>(entries.size());
for (Entry<SkyKey, ? extends NodeEntry> entry : entries.entrySet()) {
Preconditions.checkState(entry.getValue().isDone(), entry);
result.put(entry.getKey(), entry.getValue().getReverseDepsForDoneEntry());
}
return result;
}
@Override
public Iterable<SkyKey> getCurrentlyAvailableNodes(Iterable<SkyKey> keys, Reason reason) {
return graph.getCurrentlyAvailableNodes(keys, reason);
}
}
|
