@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 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; } }
servers.put( newServer.getKey(), newServer.getValue() );
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; }); }
SampleNode(final StackTraceElement[] stackTrace, final int from) { sampleCount = 1; if (from >= 0) { subNodes = new MethodMap<>(); subNodes.put(Methods.getMethod(stackTrace[from]), new SampleNode(stackTrace, from - 1)); } }
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; } }
@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; }
@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; }
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; }
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; }); } }
} else { newCount -= sn.getSampleCount() - sn2.getSampleCount(); sns.put(method, sn2);
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); }
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 fromProtoToSampleNode(final ProtoSampleNodes.SampleNodeOrBuilder node) { TMap<Method, SampleNode> subNodes = null; List<ProtoSampleNodes.SamplePair> sns = node.getSubNodesList(); if (sns != null) { subNodes = new THashMap<>(); for (ProtoSampleNodes.SamplePair pair : sns) { final ProtoSampleNodes.Method method = pair.getMethod(); subNodes.put(new Method(method.getDeclaringClass(), method.getMethodName()), fromProtoToSampleNode(pair.getNode())); } } return new SampleNode(node.getCount(), subNodes); }
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); } }