SampleNode sn = entry.getValue(); if (predicate.test(method)) { newCount -= sn.getSampleCount(); } else { if (sns == null) { sns = new MethodMap<>(); SampleNode sn2 = sn.filteredBy(predicate); if (sn2 == null) { newCount -= sn.getSampleCount(); } else { newCount -= sn.getSampleCount() - sn2.getSampleCount(); sns.put(method, sn2); throw new IllegalStateException("child sample counts must be <= parent sample count, detail: " + this); } else { return new SampleNode(newCount, sns);
@Override public void collect(final StackTraceElement[] stackTrace) { if (samples == null) { samples = SampleNode.createSampleNode(stackTrace); } else { SampleNode.addToSampleNode(samples, stackTrace); } }
public int getNrNodes() { if (samples == null) { return 0; } else { return samples.getNrNodes(); } }
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); }
st1[1] = new StackTraceElement("C1", "m2", "C1.java", 11); st1[2] = new StackTraceElement("C1", "m3", "C1.java", 12); SampleNode node1 = SampleNode.createSampleNode(st1); SampleNode node2 = new SampleNode(st1, st1.length - 1); LOG.debug("Node 1", node1); LOG.debug("Node 2", node2); Assert.assertEquals(4, node1.getNrNodes()); Assert.assertEquals(4, node2.getNrNodes()); SampleNode.addToSampleNode(node1, st2); node2.addSample(st2, st2.length - 1); LOG.debug("Node 1", node1); LOG.debug("Node 2", node2); Assert.assertEquals(5, node1.getNrNodes()); Assert.assertEquals(5, node2.getNrNodes()); st3[1] = new StackTraceElement("C2", "m2", "C2.java", 11); st3[2] = new StackTraceElement("C2", "m3", "C2.java", 12); SampleNode.addToSampleNode(node1, st3); node2.addSample(st3, st3.length - 1); LOG.debug("Node 1", node1); LOG.debug("Node 2", node2); st4[1] = new StackTraceElement("C1", "m2", "C1.java", 11); st4[2] = new StackTraceElement("C1", "m4", "C1.java", 14); SampleNode.addToSampleNode(node1, st4); node2.addSample(st4, st4.length - 1);
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; }); } }
newSubNodes = null; } else if (node1.subNodes == null) { newSubNodes = cloneSubNodes(node2); } else if (node2.subNodes == null) { newSubNodes = cloneSubNodes(node1); } else { final TMap<Method, SampleNode> ns = new MethodMap<>((int) ((node1.subNodes.size() 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)); return new SampleNode(newSampleCount, newSubNodes);
private static Pair<Method, SampleNode> parse(final JsonParser jsonP) throws IOException { consume(jsonP, JsonToken.FIELD_NAME); String name = jsonP.getCurrentName(); consume(jsonP, JsonToken.VALUE_NUMBER_INT); int sc = jsonP.getIntValue(); JsonToken nextToken = jsonP.nextToken(); if (nextToken == JsonToken.END_OBJECT) { return Pair.of(Methods.from(name), new SampleNode(sc, null)); } else if (nextToken == JsonToken.FIELD_NAME) { consume(jsonP, JsonToken.START_ARRAY); TMap<Method, SampleNode> nodes = new MethodMap<>(); while (jsonP.nextToken() != JsonToken.END_ARRAY) { Pair<Method, SampleNode> parse = parse(jsonP); nodes.put(parse.getKey(), parse.getValue()); } consume(jsonP, JsonToken.END_OBJECT); return Pair.of(Methods.from(name), new SampleNode(sc, nodes)); } else { throw new IllegalArgumentException("Expected field name or end Object, not: " + nextToken); } }
public static SampleNode convert(final Iterator<StackSampleElement> samples) { TIntObjectMap<SampleNode> index = new TIntObjectHashMap<>(); while (samples.hasNext()) { StackSampleElement asmp = samples.next(); SampleNode sn = new SampleNode(asmp.getCount(), new THashMap<Method, SampleNode>(4)); SampleNode parent = index.get(asmp.getParentId()); if (parent != null) { Method m = asmp.getMethod(); final Map<Method, SampleNode> subNodes = parent.getSubNodes(); if (subNodes == null) { throw new IllegalStateException("Bug, state " + index + "; at node " + asmp); } subNodes.put(m, sn); } index.put(asmp.getId(), sn); } return index.get(0); }
@Override public StackResult aggregate(final Collection<StackResult> results) { if (results.isEmpty()) { throw new IllegalArgumentException("Nothig to aggregate: " + results); } else if (results.size() == 1) { return results.iterator().next(); } Iterator<StackResult> it = results.iterator(); StackResult result = it.next(); SampleNode agg = result.getSamples(); final String benchmark = result.getBenchmark(); while (it.hasNext()) { result = it.next(); String obenchmark = result.getBenchmark(); if (!benchmark.equals(obenchmark)) { throw new Spf4jProfilerException("Should not aggregate " + benchmark + " with " + obenchmark); } agg = SampleNode.aggregate(agg, result.getSamples()); } try { return new StackResult(agg, benchmark, false); } catch (IOException ex) { throw new UncheckedIOException(ex); } }
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 SampleNode createSampleNode(final StackTraceElement... stackTrace) { SampleNode result = new SampleNode(1, null); SampleNode prevResult = result; for (int i = stackTrace.length - 1; i >= 0; i--) { StackTraceElement elem = stackTrace[i]; if (prevResult.subNodes == null) { prevResult.subNodes = new MethodMap<>(); } SampleNode node = new SampleNode(1, null); prevResult.subNodes.put(Methods.getMethod(elem), node); prevResult = node; } return result; }
@Override @SuppressFBWarnings("ISB_TOSTRING_APPENDING") @Nullable public String getDetail(final Point location) { List<Pair<Method, SampleNode>> tips = search(location.x, location.y, 0, 0); if (tips.size() >= 1) { final Pair<Method, SampleNode> m = tips.get(0); return Methods.toString(m.getFirst()) + '-' + m.getSecond().getSampleCount(); } else { return null; } }
@SuppressFBWarnings("UP_UNUSED_PARAMETER") private void displayActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_displayActionPerformed try { String text = jTextPane1.getText().trim(); if (text.startsWith("[")) { Schema schema = Schema.createArray(StackSampleElement.getClassSchema()); DatumReader reader = new SpecificDatumReader(schema); List<StackSampleElement> samples; try { Decoder decoder = DecoderFactory.get().jsonDecoder(schema, text); samples = (List<StackSampleElement>) reader.read(null, decoder); } catch (IOException | RuntimeException ex) { throw new RuntimeException("Unable to read samples: " + text, ex); } nodeConsumer.accept(Converter.convert(samples.iterator())); } else { nodeConsumer.accept(SampleNode.parse(new StringReader(text)).getSecond()); } } catch (IOException | RuntimeException ex) { errorConsumer.accept(ex); } }//GEN-LAST:event_displayActionPerformed
/** * Creates new form StackDumpJInternalFrame */ public StackDumpJInternalFrame(final SampleNode samples, final String title, final boolean isgraph) { super(title); setName(title); initComponents(); if (samples == null) { this.samples = SampleNode.createSampleNode( new StackTraceElement[]{new StackTraceElement("NO SAMPLES", "", "", -1)}); } else { this.samples = samples; } setViewType(isgraph); ssScrollPanel.setVisible(true); pack(); }
@Override public void filter() { List<Pair<Method, SampleNode>> tips = search(xx, yy, 0, 0); if (tips.size() >= 1) { final Method value = tips.get(0).getFirst(); updateSamples(getMethod(), getSamples().filteredBy(new EqualsPredicate<Method>(value))); repaint(); } }
appendable.append("\":"); SampleNode sn = s.getValue(); appendable.append(Integer.toString(sn.getSampleCount())); TMap<Method, SampleNode> cSn = sn.getSubNodes(); if (cSn != null) { Iterator<Map.Entry<Method, SampleNode>> iterator = cSn.entrySet().iterator();
for (int j = 0; j < nrArrayItems; j++) { asmp = reader.read(asmp, decoder); SampleNode sn = new SampleNode(asmp.getCount(), new MethodMap<SampleNode>()); SampleNode parent = index.get(asmp.getParentId()); if (parent != null) { Method readMethod = asmp.getMethod(); Method m = new Method(readMethod.getDeclaringClass(), readMethod.getName()); final Map<Method, SampleNode> subNodes = parent.getSubNodes(); if (subNodes == null) { throw new IllegalStateException("Bug, state " + index + "; at node " + asmp);
@Override public void drill() { List<SampleKey> tips = search(xx, yy, 0, 0); if (tips.size() >= 1) { SampleKey sample = tips.get(0); Set<Sample> samples = completeGraph.getSamples(sample); Iterator<SampleGraph.Sample> iterator = samples.iterator(); SampleNode agg = iterator.next().getNode(); while (iterator.hasNext()) { agg = SampleNode.aggregate(agg, iterator.next().getNode()); } updateSamples(sample.getMethod(), agg); repaint(); } }