private static void testInsertions(
int tests,
int perTestCount,
float testKeyRatio,
int modificationBatchSize,
boolean quickEquality)
throws ExecutionException, InterruptedException {
int batchesPerTest = perTestCount / modificationBatchSize;
int testKeyRange = (int) (perTestCount * testKeyRatio);
long totalCount = (long) perTestCount * tests;
log(
"Performing %d tests of %d operations, with %.2f max size/key-range ratio in batches of ~%d ops",
tests, perTestCount, 1 / testKeyRatio, modificationBatchSize);
// if we're not doing quick-equality, we can spam with garbage for all the checks we perform, so
// we'll split the work into smaller chunks
int chunkSize = quickEquality ? tests : (int) (100000 / Math.pow(perTestCount, 2));
for (int chunk = 0; chunk < tests; chunk += chunkSize) {
final List<ListenableFutureTask<List<ListenableFuture<?>>>> outer = new ArrayList<>();
for (int i = 0; i < chunkSize; i++) {
int maxRunLength =
modificationBatchSize == 1
? 1
: ThreadLocalRandom.current().nextInt(1, modificationBatchSize);
outer.add(
doOneTestInsertions(
testKeyRange, maxRunLength, modificationBatchSize, batchesPerTest, quickEquality));
}
final List<ListenableFuture<?>> inner = new ArrayList<>();
long complete = 0;
int reportInterval = Math.max(1000, (int) (totalCount / 10000));
long lastReportAt = 0;
for (ListenableFutureTask<List<ListenableFuture<?>>> f : outer) {
inner.addAll(f.get());
complete += perTestCount;
if (complete - lastReportAt >= reportInterval) {
long done = (chunk * perTestCount) + complete;
float ratio = done / (float) totalCount;
log("Completed %.1f%% (%d of %d operations)", ratio * 100, done, totalCount);
lastReportAt = complete;
}
}
Futures.allAsList(inner).get();
}
Snapshot snap = BTREE_TIMER.getSnapshot();
log(
"btree: %.2fns, %.2fns, %.2fns",
snap.getMedian(), snap.get95thPercentile(), snap.get999thPercentile());
snap = TREE_TIMER.getSnapshot();
log(
"java: %.2fns, %.2fns, %.2fns",
snap.getMedian(), snap.get95thPercentile(), snap.get999thPercentile());
log("Done");
}
private void collectTimerReports(
List<DBObject> docs, SortedMap<String, Timer> timers, Date timestamp) {
if (timers.isEmpty()) return;
for (Map.Entry<String, Timer> entry : timers.entrySet()) {
final BasicDBObject report = getBasicDBObject(timestamp, entry.getKey(), "timer");
final Timer v = entry.getValue();
final Snapshot s = v.getSnapshot();
// meter part
report.put("count", v.getCount());
report.put("rate-unit", getRateUnit());
report.put("1-minute-rate", convertRate(v.getOneMinuteRate()));
report.put("5-minute-rate", convertRate(v.getFiveMinuteRate()));
report.put("15-minute-rate", convertRate(v.getFifteenMinuteRate()));
report.put("mean-rate", convertRate(v.getMeanRate()));
// histogram part
report.put("duration-unit", getDurationUnit());
report.put("75-percentile", convertDuration(s.get75thPercentile()));
report.put("95-percentile", convertDuration(s.get95thPercentile()));
report.put("98-percentile", convertDuration(s.get98thPercentile()));
report.put("99-percentile", convertDuration(s.get99thPercentile()));
report.put("999-percentile", convertDuration(s.get999thPercentile()));
report.put("max", convertDuration(s.getMax()));
report.put("min", convertDuration(s.getMin()));
report.put("mean", convertDuration(s.getMean()));
report.put("median", convertDuration(s.getMedian()));
report.put("stddev", convertDuration(s.getStdDev()));
docs.add(report);
}
}
@Override
public void run() {
samplerLock.lock();
try {
for (Histogram histogram : schedulerHistogramList) {
Timer timer = histogramTimerMap.get(histogram);
histogram.update((int) timer.getSnapshot().getMean());
}
} finally {
samplerLock.unlock();
}
}
protected Map<String, Object> buildTimerMap(Timer t) {
Map<String, Object> metrics = Maps.newHashMap();
if (t == null) {
return metrics;
}
TimeUnit timeUnit = TimeUnit.MICROSECONDS;
Map<String, Object> time = Maps.newHashMap();
time.put("max", TimeUnit.MICROSECONDS.convert(t.getSnapshot().getMax(), TimeUnit.NANOSECONDS));
time.put("min", TimeUnit.MICROSECONDS.convert(t.getSnapshot().getMin(), TimeUnit.NANOSECONDS));
time.put(
"mean",
TimeUnit.MICROSECONDS.convert((long) t.getSnapshot().getMean(), TimeUnit.NANOSECONDS));
time.put(
"95th_percentile",
TimeUnit.MICROSECONDS.convert(
(long) t.getSnapshot().get95thPercentile(), TimeUnit.NANOSECONDS));
time.put(
"98th_percentile",
TimeUnit.MICROSECONDS.convert(
(long) t.getSnapshot().get98thPercentile(), TimeUnit.NANOSECONDS));
time.put(
"99th_percentile",
TimeUnit.MICROSECONDS.convert(
(long) t.getSnapshot().get99thPercentile(), TimeUnit.NANOSECONDS));
time.put(
"std_dev",
TimeUnit.MICROSECONDS.convert((long) t.getSnapshot().getStdDev(), TimeUnit.NANOSECONDS));
Map<String, Object> rate = Maps.newHashMap();
rate.put("one_minute", t.getOneMinuteRate());
rate.put("five_minute", t.getFiveMinuteRate());
rate.put("fifteen_minute", t.getFifteenMinuteRate());
rate.put("total", t.getCount());
rate.put("mean", t.getMeanRate());
metrics.put("rate_unit", "events/second");
metrics.put("duration_unit", timeUnit.toString().toLowerCase());
metrics.put("time", time);
metrics.put("rate", rate);
return metrics;
}
@Override
public String toString() {
StringWriter sw = new StringWriter();
Locale locale = Locale.ROOT;
try (PrintWriter output = new PrintWriter(sw)) {
final Snapshot snapshot = timer.getSnapshot();
output.printf(locale, "Benchmark Results%n");
output.printf(locale, " count = %d%n", timer.getCount());
output.printf(locale, " mean rate = %2.2f calls/%s%n", timer.getMeanRate(), "s");
output.printf(
locale,
" min = %d %s%n",
TimeUnit.NANOSECONDS.toMillis(snapshot.getMin()),
"ms");
output.printf(
locale,
" max = %d %s%n",
TimeUnit.NANOSECONDS.toMillis(snapshot.getMax()),
"ms");
output.printf(locale, " mean = %2.2f %s%n", snapshot.getMean() / 1000000, "ms");
output.printf(
locale, " stddev = %2.2f %s%n", snapshot.getStdDev() / 1000000, "ms");
output.printf(
locale, " median = %2.2f %s%n", snapshot.getMedian() / 1000000, "ms");
output.printf(
locale, " 75%% <= %2.2f %s%n", snapshot.get75thPercentile() / 1000000, "ms");
output.printf(
locale, " 95%% <= %2.2f %s%n", snapshot.get95thPercentile() / 1000000, "ms");
output.printf(
locale,
" 99.9%% <= %2.2f %s%n",
snapshot.get999thPercentile() / 1000000,
"ms");
}
return sw.toString();
}
private void adjustMetrics(
Map<String, Map<Integer, MetricSnapshot>> metrics,
Map<String, Integer> metaCounters,
Map<String, Map<Integer, Histogram>> histograms,
Map<String, Map<Integer, Timer>> timers) {
for (Map.Entry<String, Map<Integer, MetricSnapshot>> metricEntry : metrics.entrySet()) {
String meta = metricEntry.getKey();
MetricType metricType = MetricUtils.metricType(meta);
MetaType metaType = MetricUtils.metaType(meta);
Map<Integer, MetricSnapshot> winData = metricEntry.getValue();
if (metricType == MetricType.HISTOGRAM) {
for (Map.Entry<Integer, MetricSnapshot> dataEntry : winData.entrySet()) {
MetricSnapshot snapshot = dataEntry.getValue();
Integer cnt = metaCounters.get(meta);
Histogram histogram = histograms.get(meta).get(dataEntry.getKey());
if (cnt != null && cnt > 1) {
Snapshot snapshot1 = histogram.getSnapshot();
snapshot.set_mean(snapshot1.getMean());
snapshot.set_p50(snapshot1.getMedian());
snapshot.set_p75(snapshot1.get75thPercentile());
snapshot.set_p95(snapshot1.get95thPercentile());
snapshot.set_p98(snapshot1.get98thPercentile());
snapshot.set_p99(snapshot1.get99thPercentile());
snapshot.set_p999(snapshot1.get999thPercentile());
snapshot.set_stddev(snapshot1.getStdDev());
snapshot.set_min(snapshot1.getMin());
snapshot.set_max(snapshot1.getMax());
if (metaType == MetaType.TOPOLOGY) {
snapshot.set_points(Arrays.asList(ArrayUtils.toObject(snapshot1.getValues())));
}
}
if (metaType != MetaType.TOPOLOGY) {
snapshot.set_points(new ArrayList<Long>(0));
}
}
} else if (metricType == MetricType.TIMER) {
for (Map.Entry<Integer, MetricSnapshot> dataEntry : winData.entrySet()) {
MetricSnapshot snapshot = dataEntry.getValue();
Integer cnt = metaCounters.get(meta);
if (cnt != null && cnt > 1) {
Timer timer = timers.get(meta).get(dataEntry.getKey());
Snapshot snapshot1 = timer.getSnapshot();
snapshot.set_p50(snapshot1.getMedian());
snapshot.set_p75(snapshot1.get75thPercentile());
snapshot.set_p95(snapshot1.get95thPercentile());
snapshot.set_p98(snapshot1.get98thPercentile());
snapshot.set_p99(snapshot1.get99thPercentile());
snapshot.set_p999(snapshot1.get999thPercentile());
snapshot.set_stddev(snapshot1.getStdDev());
snapshot.set_min(snapshot1.getMin());
snapshot.set_max(snapshot1.getMax());
}
snapshot.set_points(new ArrayList<Long>(0));
}
}
}
}
@Override
public boolean matchesSafely(JsonObject jsonObject) {
JsonObject jsonMetric = jsonObject.get("metric").asObject();
JsonObject jsonCounter;
JsonObject jsonMeter;
JsonObject jsonTimer;
Counter counter;
Meter meter;
Timer timer;
// check counter metric
if (jsonMetric.get("counter") != null) {
jsonCounter = jsonMetric.get("counter").asObject();
counter = (Counter) metric;
if (jsonCounter.get("counter").asLong() != counter.getCount()) {
reason = "counter " + counter.getCount();
return false;
}
}
// check meter metric
if (jsonMetric.get("meter") != null) {
jsonMeter = jsonMetric.get("meter").asObject();
meter = (Meter) metric;
if (jsonMeter.get("counter").asLong() != meter.getCount()) {
reason = "counter " + meter.getCount();
return false;
}
if (jsonMeter.get("1_min_rate").asDouble() != meter.getOneMinuteRate()) {
reason = "1 minute rate " + meter.getOneMinuteRate();
return false;
}
if (jsonMeter.get("5_min_rate").asDouble() != meter.getOneMinuteRate()) {
reason = "5 minute rate " + meter.getFiveMinuteRate();
return false;
}
if (jsonMeter.get("15_min_rate").asDouble() != meter.getFifteenMinuteRate()) {
reason = "15 minute rate " + meter.getFifteenMinuteRate();
return false;
}
}
if (jsonMetric.get("timer") != null) {
jsonTimer = jsonMetric.get("timer").asObject();
timer = (Timer) metric;
if (jsonTimer.get("counter").asLong() != timer.getCount()) {
reason = "counter " + timer.getCount();
return false;
}
if (jsonTimer.get("1_min_rate").asDouble() != timer.getOneMinuteRate()) {
reason = "1 minute rate " + timer.getOneMinuteRate();
return false;
}
if (jsonTimer.get("5_min_rate").asDouble() != timer.getOneMinuteRate()) {
reason = "5 minute rate " + timer.getFiveMinuteRate();
return false;
}
if (jsonTimer.get("15_min_rate").asDouble() != timer.getFifteenMinuteRate()) {
reason = "15 minute rate " + timer.getFifteenMinuteRate();
return false;
}
if (jsonTimer.get("mean").asDouble() != nanoToMs(timer.getSnapshot().getMean())) {
reason = "mean " + timer.getSnapshot().getMean();
return false;
}
if (jsonTimer.get("min").asDouble() != nanoToMs(timer.getSnapshot().getMin())) {
reason = "min " + timer.getSnapshot().getMin();
return false;
}
if (jsonTimer.get("max").asDouble() != nanoToMs(timer.getSnapshot().getMax())) {
reason = "max " + timer.getSnapshot().getMax();
return false;
}
if (jsonTimer.get("stddev").asDouble() != nanoToMs(timer.getSnapshot().getStdDev())) {
reason = "stddev " + timer.getSnapshot().getStdDev();
return false;
}
}
return true;
}