Examples with AcyclicDepthFirstPostOrderTraversal com.facebook.buck.graph.AcyclicDepthFirstPostOrderTraversal used on opensource projects

Example 1 with AcyclicDepthFirstPostOrderTraversal

use of com.facebook.buck.graph.AcyclicDepthFirstPostOrderTraversal in project buck by facebook.

the class Parser method buildTargetGraph.

@SuppressWarnings("PMD.PrematureDeclaration")
protected TargetGraph buildTargetGraph(final PerBuildState state, final BuckEventBus eventBus, final Iterable<BuildTarget> toExplore, final boolean ignoreBuckAutodepsFiles) throws IOException, InterruptedException, BuildFileParseException, BuildTargetException {
    if (Iterables.isEmpty(toExplore)) {
        return TargetGraph.EMPTY;
    }
    final Map<BuildTarget, TargetGroup> groups = Maps.newHashMap();
    for (TargetGroup group : state.getAllGroups()) {
        groups.put(group.getBuildTarget(), group);
    }
    final MutableDirectedGraph<TargetNode<?, ?>> graph = new MutableDirectedGraph<>();
    final Map<BuildTarget, TargetNode<?, ?>> index = new HashMap<>();
    ParseEvent.Started parseStart = ParseEvent.started(toExplore);
    eventBus.post(parseStart);
    GraphTraversable<BuildTarget> traversable = target -> {
        TargetNode<?, ?> node;
        try {
            node = state.getTargetNode(target);
        } catch (BuildFileParseException | BuildTargetException e) {
            throw new RuntimeException(e);
        }
        if (ignoreBuckAutodepsFiles) {
            return Collections.emptyIterator();
        }
        for (BuildTarget dep : node.getDeps()) {
            try {
                state.getTargetNode(dep);
            } catch (BuildFileParseException | BuildTargetException | HumanReadableException e) {
                throw new HumanReadableException(e, "Couldn't get dependency '%s' of target '%s':\n%s", dep, target, e.getMessage());
            }
        }
        return node.getDeps().iterator();
    };
    GraphTraversable<BuildTarget> groupExpander = target -> {
        TargetGroup group = Preconditions.checkNotNull(groups.get(target), "SANITY FAILURE: Tried to expand group %s but it doesn't exist.", target);
        return Iterators.filter(group.iterator(), groups::containsKey);
    };
    AcyclicDepthFirstPostOrderTraversal<BuildTarget> targetGroupExpansion = new AcyclicDepthFirstPostOrderTraversal<>(groupExpander);
    AcyclicDepthFirstPostOrderTraversal<BuildTarget> targetNodeTraversal = new AcyclicDepthFirstPostOrderTraversal<>(traversable);
    TargetGraph targetGraph = null;
    try {
        for (BuildTarget target : targetNodeTraversal.traverse(toExplore)) {
            TargetNode<?, ?> targetNode = state.getTargetNode(target);
            Preconditions.checkNotNull(targetNode, "No target node found for %s", target);
            graph.addNode(targetNode);
            MoreMaps.putCheckEquals(index, target, targetNode);
            if (target.isFlavored()) {
                BuildTarget unflavoredTarget = BuildTarget.of(target.getUnflavoredBuildTarget());
                MoreMaps.putCheckEquals(index, unflavoredTarget, state.getTargetNode(unflavoredTarget));
            }
            for (BuildTarget dep : targetNode.getDeps()) {
                graph.addEdge(targetNode, state.getTargetNode(dep));
            }
        }
        for (BuildTarget groupTarget : targetGroupExpansion.traverse(groups.keySet())) {
            ImmutableMap<BuildTarget, Iterable<BuildTarget>> replacements = Maps.toMap(groupExpander.findChildren(groupTarget), target -> {
                TargetGroup group = groups.get(target);
                return Preconditions.checkNotNull(group, "SANITY FAILURE: Tried to expand group %s but it doesn't exist.", target);
            });
            if (!replacements.isEmpty()) {
                // TODO(tophyr): Stop duplicating target lists
                groups.put(groupTarget, Preconditions.checkNotNull(groups.get(groupTarget)).withReplacedTargets(replacements));
            }
        }
        targetGraph = new TargetGraph(graph, ImmutableMap.copyOf(index), ImmutableSet.copyOf(groups.values()));
        state.ensureConcreteFilesExist(eventBus);
        return targetGraph;
    } catch (AcyclicDepthFirstPostOrderTraversal.CycleException e) {
        throw new HumanReadableException(e.getMessage());
    } catch (RuntimeException e) {
        throw propagateRuntimeCause(e);
    } finally {
        eventBus.post(ParseEvent.finished(parseStart, Optional.ofNullable(targetGraph)));
    }
}

Example 2 with AcyclicDepthFirstPostOrderTraversal

use of com.facebook.buck.graph.AcyclicDepthFirstPostOrderTraversal in project buck by facebook.

the class TargetGraphHashing method hashTargetGraph.

/**
   * Given a {@link TargetGraph} and any number of root nodes to traverse,
   * returns a map of {@code (BuildTarget, HashCode)} pairs for all root
   * build targets and their dependencies.
   */
public ImmutableMap<BuildTarget, HashCode> hashTargetGraph() throws CycleException {
    try (SimplePerfEvent.Scope scope = SimplePerfEvent.scope(eventBus, PerfEventId.of("ShowTargetHashes"))) {
        AcyclicDepthFirstPostOrderTraversal<TargetNode<?, ?>> traversal = new AcyclicDepthFirstPostOrderTraversal<>(node -> targetGraph.getAll(node.getDeps()).iterator());
        final Map<BuildTarget, ForkJoinTask<HashCode>> buildTargetHashes = new HashMap<>();
        Queue<ForkJoinTask<HashCode>> tasksToSchedule = new ArrayDeque<>();
        // Start all the node tasks, bottom up
        for (final TargetNode<?, ?> node : traversal.traverse(roots)) {
            HashNodeTask task = new HashNodeTask(node, buildTargetHashes);
            buildTargetHashes.put(node.getBuildTarget(), task);
            tasksToSchedule.add(task);
        }
        // Execute tasks in parallel
        ForkJoinPool pool = new ForkJoinPool(numThreads);
        for (ForkJoinTask<HashCode> task : tasksToSchedule) {
            pool.execute(task);
        }
        // Wait for all scheduled tasks to complete
        return ImmutableMap.copyOf(Maps.transformEntries(buildTargetHashes, (key, value) -> value.join()));
    }
}