@Setup public void setUp() { Random random = new Random(123456789012345L); this.elements = new String[this.size]; this.troveMap = new THashMap<>(this.size); for (int i = 0; i < this.size; i++) { String element = RandomStringUtils.random(RANDOM_COUNT, 0, 0, false, true, null, random); this.elements[i] = element; this.troveMap.put(element, "dummy"); } }
@Benchmark public void get() { int localSize = this.size; String[] localElements = this.elements; TMap<String, String> localTroveMap = this.troveMap; for (int i = 0; i < localSize; i++) { if (localTroveMap.get(localElements[i]) == null) { throw new AssertionError(i); } } } }
newSubNodes = cloneSubNodes(node1); } else { final TMap<Method, SampleNode> ns = new MethodMap<>((int) ((node1.subNodes.size() + node2.subNodes.size()) / 0.7)); node1.subNodes.forEachEntry((final Method m, final SampleNode b) -> { SampleNode other = node2.subNodes.get(m); if (other == null) { ns.put(m, SampleNode.clone(b)); } else { ns.put(m, aggregate(b, other)); node2.subNodes.forEachEntry((final Method m, final SampleNode b) -> { if (!node1.subNodes.containsKey(m)) { ns.put(m, SampleNode.clone(b));
} else for ( ServerInfo oldServer : servers.values() ) if ( !servers.containsValue( newServer.getValue() ) ) servers.put( newServer.getKey(), newServer.getValue() ); Preconditions.checkArgument( servers.containsKey( server ), "Server %s (priority %s) is not defined", server, i ); if ( !servers.containsKey( server ) )
@Override public Map<String, SampleNode> getCollectionsAndReset() { TMap<String, SampleNode> result = new THashMap<>(collections.size()); collections.forEachEntry((k, v) -> { result.put(k, v.getAndReset()); return true; }); return result; }
public void add(final SampleNode node) { this.sampleCount += node.getSampleCount(); TMap<Method, SampleNode> oSubNodes = (TMap<Method, SampleNode>) node.getSubNodes(); if (this.subNodes == null) { this.subNodes = oSubNodes; } else if (oSubNodes != null) { oSubNodes.forEachEntry((final Method m, final SampleNode b) -> { SampleNode other = subNodes.get(m); if (other == null) { subNodes.put(m, b); } else { other.sampleCount += b.sampleCount; } return true; }); } }
public static void addToSampleNode(final SampleNode node, final StackTraceElement... stackTrace) { SampleNode prevResult = node; prevResult.sampleCount++; for (int i = stackTrace.length - 1; i >= 0; i--) { StackTraceElement elem = stackTrace[i]; final Method method = Methods.getMethod(elem); SampleNode nNode; if (prevResult.subNodes == null) { prevResult.subNodes = new MethodMap<>(); nNode = new SampleNode(1, null); prevResult.subNodes.put(method, nNode); } else { nNode = prevResult.subNodes.get(method); if (nNode != null) { nNode.sampleCount++; } else { nNode = new SampleNode(1, null); prevResult.subNodes.put(method, nNode); } } prevResult = nNode; } }
public static void putAllClones(final TMap<Method, SampleNode> source, final TMap<Method, SampleNode> destination) { source.forEachEntry((final Method a, final SampleNode b) -> { destination.put(a, SampleNode.clone(b)); return true; }); }
public static void traverse(final Method m, final SampleNode node, final Invocation handler, final Function<Deque, TraversalData> func) { Deque<TraversalData> dq = new ArrayDeque<>(); dq.add(new TraversalData(m, node)); TraversalData t; while ((t = func.apply(dq)) != null) { if (t.n.subNodes != null) { Method from = t.m; boolean conti = t.n.subNodes.forEachEntry(new TObjectObjectProcedure<Method, SampleNode>() { @Override public boolean execute(final Method a, final SampleNode b) { boolean result = handler.invocation(from, a, b.sampleCount); if (result) { dq.addLast(new TraversalData(a, b)); } return result; } }); if (!conti) { return; } } } }
Preconditions.checkArgument( servers.containsKey( server ), "Server %s (priority %s) is not defined", server, i ); if ( !servers.containsKey( server ) )
public int height() { if (subNodes == null) { return 1; } else { int subHeight = 0; for (SampleNode node : subNodes.values()) { int nHeight = node.height(); if (nHeight > subHeight) { subHeight = nHeight; } } return subHeight + 1; } }
@Override public void sample() { Iterable<Map.Entry<Thread, ExecutionContext>> currentThreads = execCtxSupplier.get(); int i = 0; for (Map.Entry<Thread, ExecutionContext> entry : currentThreads) { requestFor[i] = entry.getKey(); contexts[i++] = entry.getValue(); if (i >= requestFor.length) { break; } } Arrays.fill(requestFor, i, requestFor.length, null); StackTraceElement[][] stackTraces = Threads.getStackTraces(requestFor); for (int j = 0; j < i; j++) { StackTraceElement[] stackTrace = stackTraces[j]; if (stackTrace != null && stackTrace.length > 0) { ExecutionContext context = contexts[j]; context.add(stackTrace); String name = ctxToCategory.apply(context); StackCollector c = collections.computeIfAbsent(name, (k) -> new StackCollectorImpl()); c.collect(stackTrace); } } }
@Override public Map<String, SampleNode> getCollections() { TMap<String, SampleNode> result = new THashMap<>(collections.size()); collections.forEachEntry((k, v) -> { result.put(k, v.get()); return true; }); return result; }
void addSample(final StackTraceElement[] stackTrace, final int from) { sampleCount++; if (from >= 0) { Method method = Methods.getMethod(stackTrace[from]); SampleNode subNode = null; if (subNodes == null) { subNodes = new MethodMap(); } else { subNode = subNodes.get(method); } if (subNode == null) { subNodes.put(method, new SampleNode(stackTrace, from - 1)); } else { subNode.addSample(stackTrace, from - 1); } } }
public static <E extends Exception> int convert(final Method method, final StackSamples node, final int parentId, final int id, final Handler<StackSampleElement, E> handler) throws E { final Deque<TraversalNode> dq = new ArrayDeque<>(); dq.addLast(new TraversalNode(method, node, parentId)); int nid = id; while (!dq.isEmpty()) { TraversalNode first = dq.removeFirst(); StackSamples n = first.getNode(); StackSampleElement sample = new StackSampleElement(nid, first.getParentId(), n.getSampleCount(), first.getMethod()); final TMap<Method, ? extends StackSamples> subNodes = n.getSubNodes(); final int pid = nid; if (subNodes != null) { subNodes.forEachEntry((a, b) -> { dq.addLast(new TraversalNode(a, b, pid)); return true; }); } handler.handle(sample, parentId); nid++; } return nid; }
/** * to do: have to remove recursion... * * @return the total number of nodes in this tree. */ public int getNrNodes() { if (subNodes == null) { return 1; } else { int nrNodes = 0; for (SampleNode node : subNodes.values()) { nrNodes += node.getNrNodes(); } return nrNodes + 1; } }
public static SampleNode clone(final SampleNode node) { if (node.subNodes == null) { return new SampleNode(node.sampleCount, null); } final TMap<Method, SampleNode> newSubNodes = new MethodMap<>(node.subNodes.size()); node.subNodes.forEachEntry((final Method a, final SampleNode b) -> { newSubNodes.put(a, SampleNode.clone(b)); return true; }); return new SampleNode(node.sampleCount, newSubNodes); }
@Benchmark public TMap<String, String> trove() { int localSize = this.size; float localLoadFactor = this.loadFactor; String[] localElements = this.elements; int defaultInitialCapacity = Constants.DEFAULT_CAPACITY; TMap<String, String> trove = this.isPresized ? new THashMap<>(localSize, localLoadFactor) : new THashMap<>(defaultInitialCapacity, localLoadFactor); for (int i = 0; i < localSize; i++) { trove.put(localElements[i], "dummy"); } return trove; } }
Assert.assertEquals(node1.getSampleCount() + node2.getSampleCount(), agg.getSampleCount()); final Method method = Methods.getMethod("C1", "m3"); Assert.assertEquals(node1.getSubNodes().get(method).getSampleCount() + node2.getSubNodes().get(method).getSampleCount(), agg.getSubNodes().get(method).getSampleCount());