@SuppressWarnings("unchecked")
public Pair<ResolveTask[], ResolvedValueProducer[]> getTasksProducing(
final ValueSpecification valueSpecification) {
do {
final MapEx<ResolveTask, ResolvedValueProducer> tasks =
getBuilder().getTasks(valueSpecification);
if (tasks != null) {
final ResolveTask[] resultTasks;
final ResolvedValueProducer[] resultProducers;
synchronized (tasks) {
if (tasks.containsKey(null)) {
continue;
}
if (tasks.isEmpty()) {
return null;
}
resultTasks = new ResolveTask[tasks.size()];
resultProducers = new ResolvedValueProducer[tasks.size()];
int i = 0;
for (final Map.Entry<ResolveTask, ResolvedValueProducer> task :
(Set<Map.Entry<ResolveTask, ResolvedValueProducer>>) tasks.entrySet()) {
// Don't ref-count the tasks; they're just used for parent comparisons
resultTasks[i] = task.getKey();
resultProducers[i++] = task.getValue();
task.getValue().addRef(); // We're holding the task lock
}
}
return Pair.of(resultTasks, resultProducers);
} else {
return null;
}
} while (true);
}
protected void reportStateSize() {
_getTerminalValuesCallback.reportStateSize();
if (!s_logger.isInfoEnabled()) {
return;
}
int count = 0;
for (final Map<ResolveTask, ResolveTask> entries : _requirements.values()) {
synchronized (entries) {
count += entries.size();
}
}
s_logger.info("Requirements cache = {} tasks for {} requirements", count, _requirements.size());
count = 0;
for (final MapEx<ResolveTask, ResolvedValueProducer> entries : _specifications.values()) {
synchronized (entries) {
count += entries.size();
}
}
s_logger.info(
"Specifications cache = {} tasks for {} specifications", count, _specifications.size());
s_logger.info("Pending requirements = {}", _pendingRequirements.getValueRequirements().size());
s_logger.info(
"Run queue length = {}, deferred queue length = {}",
_runQueue.size(),
_deferredQueue.size());
}
