use of com.insightfullogic.honest_profiler.core.profiles.lean.LeanNode 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);
});
}
use of com.insightfullogic.honest_profiler.core.profiles.lean.LeanNode in project honest-profiler by jvm-profiling-tools.
the class FlatProfileAggregator method aggregate.
/**
* Aggregates an {@link AggregationProfile} into a {@link Flat}. The {@link CombinedGrouping} specifies which
* {@link LeanNode}s are aggregated together.
*
* @see ProfileAggregator#aggregate(AggregationProfile, CombinedGrouping)
*/
@Override
public Flat aggregate(AggregationProfile input, CombinedGrouping grouping) {
// Prepare result.
Flat result = new Flat(input, grouping);
LeanProfile source = input.getSource();
// Flatten all LeanNodes into a Stream, then collect it into a Map where the key is calculated by the groupings,
// and the value is the aggregation of the LeanNodes corresponding to the key.
Map<String, Entry> entryMap = source.getThreads().values().stream().flatMap(LeanNode::flatten).filter(node -> !node.isThreadNode()).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 Entry
() -> new Entry(result), // Accumulator, aggregates a LeanNode into the Entry accumulator
(entry, leanNode) -> entry.add(leanNode), // Combiner, combines two Entries with the same key
(entry1, entry2) -> entry1.combine(entry2))));
// Add the aggregated Entries to the result list, after setting their key and reference.
result.getData().addAll(entryMap.entrySet().stream().map(mapEntry -> {
Entry entry = mapEntry.getValue();
// The key must be set explicitly here because it isn't set in the collector.
entry.setKey(mapEntry.getKey());
// Set the reference by default for all nodes to the global aggregation.
entry.setReference(input.getGlobalData());
return entry;
}).collect(toList()));
return result;
}
use of com.insightfullogic.honest_profiler.core.profiles.lean.LeanNode 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;
}
use of com.insightfullogic.honest_profiler.core.profiles.lean.LeanNode in project honest-profiler by jvm-profiling-tools.
the class LeanProfileGenerator method assertProfileContainsStack.
public void assertProfileContainsStack(long threadId, StackFrame... stack) {
LeanNode current = currentProfile.getThreads().get(threadId);
assertNotNull("Thread not found in Profile", current);
int level = 0;
List<StackFrame> frames = asList(stack);
reverse(frames);
for (StackFrame frame : frames) {
level++;
Optional<LeanNode> child = current.getChildren().stream().filter(node -> node.getFrame().getMethodId() == frame.getMethodId() && node.getFrame().getLineNr() == frame.getLineNumber() && node.getFrame().getBci() == frame.getBci()).findFirst();
assertTrue("Descendant at level " + level + " not found", child.isPresent());
current = child.get();
assertNodeRepresentsFrame(current, frame);
}
}
use of com.insightfullogic.honest_profiler.core.profiles.lean.LeanNode in project honest-profiler by jvm-profiling-tools.
the class LeanProfileGenerator method getNode.
public LeanNode getNode(long threadId, StackFrame... stack) {
LeanNode current = currentProfile.getThreads().get(threadId);
List<StackFrame> frames = asList(stack);
reverse(frames);
for (StackFrame frame : frames) {
Optional<LeanNode> child = current.getChildren().stream().filter(node -> node.getFrame().getMethodId() == frame.getMethodId()).findFirst();
current = child.get();
}
return current;
}
Aggregations