Examples with Tree com.insightfullogic.honest_profiler.core.aggregation.result.straight.Tree used on opensource projects

Example 1 with Tree

use of com.insightfullogic.honest_profiler.core.aggregation.result.straight.Tree in project honest-profiler by jvm-profiling-tools.

the class ReferenceUtil method switchReference.

/**
 * Set the reference of all {@link Node}s contained in the provided {@link Tree} according to the specified
 * {@link ReferenceMode}. The reference of a {@link Node} is used for calculating the percentage values.
 * <p>
 * Please consult the {@link ReferenceMode} documentation for more information about the meaning of the reference
 * modes.
 * <p>
 * WARNING : the {@link ReferenceMode#THREAD} mode can only be used for {@link Tree}s or {@link TreeDiff}s where the
 * top-level children represent thread-level aggregations. Similarly, the {@link ReferenceMode#PARENT} mode can only
 * be used in {@link Tree}s or {@link TreeDiff}s.
 * <p>
 * @param tree the {@link Tree} whose references are to be changed
 * @param mode the strategy for setting the references
 */
public static void switchReference(Tree tree, ReferenceMode mode) {
    switch(mode) {
        case GLOBAL:
            NumericInfo global = tree.getSource().getGlobalData();
            tree.flatten().forEach(node -> node.setReference(global));
            return;
        case THREAD:
            tree.getData().forEach(rootNode -> {
                // The root nodes are presumed to be thread-level aggregations. If not, the results are unspecified.
                NumericInfo reference = rootNode.getData();
                rootNode.getChildren().forEach(child -> child.flatten().forEach(node -> node.setReference(reference)));
            });
            return;
        case PARENT:
            tree.getData().forEach(node -> setReferenceToParent(null, node));
            return;
    }
}

Example 2 with Tree

use of com.insightfullogic.honest_profiler.core.aggregation.result.straight.Tree in project honest-profiler by jvm-profiling-tools.

the class DescendantTreeAggregator method aggregate.

// Aggregator Implementation
/**
 * @see SubAggregator#aggregate(Object)
 */
@Override
public Tree aggregate(Entry input) {
    Aggregation<Keyed<String>> aggregation = input.getAggregation();
    AggregationProfile source = aggregation.getSource();
    CombinedGrouping grouping = aggregation.getGrouping();
    Tree result = new Tree(source, input.getAggregation().getGrouping());
    Node root = new Node(input);
    result.getData().add(root);
    addChildren(source, root, result, grouping);
    return result;
}

Example 3 with Tree

use of com.insightfullogic.honest_profiler.core.aggregation.result.straight.Tree in project honest-profiler by jvm-profiling-tools.

the class DescendantTreeAggregator method addChildren.

/**
 * Recursive method for aggregating the children (and descendants) of the {@link LeanNode}s which are aggregated by
 * the provided {@link Node}.
 * <p>
 * @param source the original {@link AggregationProfile}
 * @param child the input {@link Node}
 * @param tree the resulting {@link Tree}
 * @param grouping the key calculation grouping
 */
private void addChildren(AggregationProfile source, Node child, Tree tree, CombinedGrouping grouping) {
    Map<String, Node> result = child.getAggregatedNodes().stream().flatMap(node -> node.getChildren().stream()).collect(groupingBy(// Group LeanNodes by calculated key
    node -> grouping.apply(source, node), // Downstream collector, collects LeanNodes in a single group
    of(// Supplier, creates an empty Node
    () -> {
        Node node = new Node(tree);
        // Set the reference by default for all nodes to the global aggregation.
        node.setReference(source.getGlobalData());
        return node;
    }, // Accumulator, aggregates a LeanNode into the Node accumulator
    (x, y) -> {
        x.add(y);
        x.setKey(grouping.apply(source, y));
    }, // Combiner, combines two Nodes with the same key
    (x, y) -> x.combine(y))));
    // Add the aggregated children as children to the Node, and recurse
    result.values().forEach(parent -> {
        child.addChild(parent);
        // Recursively add descendants
        addChildren(source, parent, tree, grouping);
    });
}

Example 4 with Tree

use of com.insightfullogic.honest_profiler.core.aggregation.result.straight.Tree in project honest-profiler by jvm-profiling-tools.

the class TreeProfileAggregator method aggregate.

// Aggregator Implementation
/**
 * Aggregates an {@link AggregationProfile} into a {@link Tree}. The {@link CombinedGrouping} specifies which
 * {@link LeanNode}s are aggregated together.
 *
 * @see ProfileAggregator#aggregate(AggregationProfile, CombinedGrouping)
 */
@Override
public Tree aggregate(AggregationProfile input, CombinedGrouping grouping) {
    // Prepare result.
    Tree result = new Tree(input, grouping);
    LeanProfile profile = input.getSource();
    Map<String, Node> nodeMap = profile.getThreads().values().stream().collect(groupingBy(// Group LeanNodes by calculated key
    node -> grouping.apply(input, node), // Downstream collector, aggregates LeanNodes in a single group
    of(// Supplier, creates an empty Node
    () -> new Node(result), // Accumulator, aggregates a LeanNode into the Node accumulator
    (node, leanNode) -> {
        node.add(leanNode);
        node.setKey(grouping.apply(input, leanNode));
        // Aggregate descendants of a LeanNode recursively into children of accumulator. The recursion
        // happens inside the Node.addChild() method, triggered by the boolean parameter.
        leanNode.getChildren().forEach(child -> node.addChild(child, grouping, true));
    }, // Combiner, combines two Nodes with the same key
    (node1, node2) -> node1.combine(node2))));
    // Set the reference by default for all nodes to the global aggregation.
    // We do this here because the addChild() method doesn't propagate the reference, and proably shouldn't.
    nodeMap.values().stream().flatMap(Node::flatten).forEach(node -> {
        node.setReference(input.getGlobalData());
    });
    result.getData().addAll(nodeMap.values());
    return result;
}

Example 5 with Tree

use of com.insightfullogic.honest_profiler.core.aggregation.result.straight.Tree in project honest-profiler by jvm-profiling-tools.

the class TreeViewController method refresh.

// AbstractViewController Implementation
@Override
protected void refresh() {
    Tree target = getTarget();
    if (target == null) {
        treeTable.setRoot(null);
    } else {
        treeTable.setRoot(new NodeTreeItem(getTarget().filter(getFilterSpecification())));
        expandPartial(treeTable.getRoot(), 2);
    }
    treeTable.sort();
}