import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
@Override
public Collection<? extends Result> afterIteration(BenchmarkParams benchmarkParams,
                                                   IterationParams iterationParams,
                                                   IterationResult result) {
    final ArrayList<Result> results = Lists.newArrayList();
    if (metricRegistry == null) {
        return results;
    }
    final SortedMap<String, Meter> counters = metricRegistry.getMeters((name, metric) -> {
        return name.startsWith(MetricRegistry.name(Rule.class)) || name.startsWith(MetricRegistry.name(Pipeline.class));
    });
    counters.entrySet()
            .forEach(stringCounterEntry -> result.addResult(new ScalarResult(stringCounterEntry.getKey(),
                                                                             stringCounterEntry.getValue().getCount(),
                                                                             "calls",
                                                                             AggregationPolicy.SUM)));

    return results;
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
@Override
public Collection<? extends Result> afterIteration(BenchmarkParams benchmarkParams,
    IterationParams iterationParams, IterationResult result) {
  final Runtime runtime = Runtime.getRuntime();

  final long max = runtime.maxMemory();
  final long total = runtime.totalMemory();
  final long free = runtime.freeMemory();
  final long used = total - free;

  return Arrays
      .asList(new ProfilerResult(PREFIX + "rt.mem.max", max, "bytes", AggregationPolicy.MAX),
          new ProfilerResult(PREFIX + "rt.mem.total", total, "bytes", AggregationPolicy.MAX),
          new ProfilerResult(PREFIX + "rt.mem.free", free, "bytes", AggregationPolicy.MAX),
          new ProfilerResult(PREFIX + "rt.mem.used", used, "bytes", AggregationPolicy.MAX));
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
@Override
public Collection<? extends Result> afterIteration(final BenchmarkParams benchmarkParams, final IterationParams iterationParams, final IterationResult result) {
  if (usedMemory <= 0) {
    recordUsedMemory();
    if (usedMemory <= 0) {
      return Collections.emptyList();
    }
  }
  List<Result> l = new ArrayList<>();
  addLinuxVmStats(l);
  l.addAll(Arrays.asList(
    new ScalarResult("+forced-gc-mem.used.settled", (double) usedMemorySettled, "bytes", AggregationPolicy.AVG),
    new ScalarResult("+forced-gc-mem.used.after", (double) usedMemory, "bytes", AggregationPolicy.AVG),
    new ScalarResult("+forced-gc-mem.total", (double) totalMemory, "bytes", AggregationPolicy.AVG),
    new ScalarResult("+forced-gc-mem.gcTimeMillis", (double) gcTimeMillis, "ms", AggregationPolicy.AVG),
    new ScalarResult("+forced-gc-mem.usedHeap", (double) usedHeapMemory, "bytes", AggregationPolicy.AVG)
  ));
  keepReference = null;
  return l;
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
private RunResult createMockedRunResult(final double value) {
	final IterationResult iterationResult = new IterationResult(null, null, null);
	iterationResult.addResult(new SingleShotResult(ResultRole.PRIMARY, "", (long) value, TimeUnit.NANOSECONDS));
	final Collection<IterationResult> iterationResults = Arrays.asList(iterationResult);
	final BenchmarkResult benchmarkResult = new BenchmarkResult(null, iterationResults);
	final Collection<BenchmarkResult> benchmarkResults = Arrays.asList(benchmarkResult);
	return new RunResult(null, benchmarkResults);
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
/**
 * Run this code after a benchmark iteration finished
 *
 * @param benchmarkParams benchmark parameters used for current launch
 * @param iterationParams iteration parameters used for current launch
 * @param result iteration result
 * @return profiler results
 */
@Override
public Collection<? extends Result<ProfilerResult>> afterIteration(
    BenchmarkParams benchmarkParams, IterationParams iterationParams, IterationResult result) {
  String unit = "invocations";
  AggregationPolicy policy = AggregationPolicy.AVG;

  final ProfilerResult hashCodeResult =
      new ProfilerResult("hashCode", CountingInteger.getHashcodeCounter(), unit, policy);

  final ProfilerResult equalsResult =
      new ProfilerResult("equals", CountingInteger.getEqualsCounter(), unit, policy);

  return Arrays.asList(hashCodeResult, equalsResult);
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
protected void stopProfilers(BenchmarkParams benchmarkParams, IterationParams iterationParams, IterationResult iterationResults) {
    // stop profilers
    for (InternalProfiler prof : registeredProfilers) {
        try {
            iterationResults.addResults(prof.afterIteration(benchmarkParams, iterationParams));
        } catch (Throwable ex) {
            throw new BenchmarkException(ex);
        }
    }
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
@Override
public Collection<? extends Result> afterIteration(final BenchmarkParams benchmarkParams, final IterationParams iterationParams, final IterationResult result) {
  List<Result<?>> all = new ArrayList<>();
  counters.values().stream()
    .map(e ->
      new ScalarResult(SECONDARY_RESULT_PREFIX + e.key, (double) e.counter.get(), e.unit, e.aggregationPolicy))
    .sequential().forEach(e -> all.add(e));
  all.addAll(results.values());
  return all;
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
private List<Double> getTimes(String algorithmId,
                              String datasetId,
                              int warmUps,
                              int measurements) throws CLIWrapperException, RunnerException {
    Options options = new OptionsBuilder()
            .forks(1)
            .measurementIterations(measurements)
            .warmupIterations(warmUps)
            .param("datasetId", datasetId)
            .param("algorithmId", algorithmId)
            .include(JMHBenchmark.class.getName())
            .build();

    Collection<RunResult> results = new Runner(options).run();
    List<Double> times = new ArrayList<>();
    for (RunResult result : results) {
        for (BenchmarkResult benchmarkResult : result.getBenchmarkResults()) {
            BenchmarkParams params = benchmarkResult.getParams();
            String myDatasetId = params.getParam("datasetId");
            if (!datasetId.equals(myDatasetId)) {
                throw new CLIWrapperException("Unable to dig through JMH output: Value for 'datasetId' parameter is '"
                        + myDatasetId + "' but expected '" + datasetId + "'", null);
            }
            String myAlgorithmId = params.getParam("algorithmId");
            if (!algorithmId.equals(myAlgorithmId)) {
                throw new CLIWrapperException("Unable to dig through JMH output: Value for 'algorithmId' parameter is '"
                        + myAlgorithmId + "' but expected '" + algorithmId + "'", null);
            }
            int count = 0;
            for (IterationResult iterationResult : benchmarkResult.getIterationResults()) {
                for (Result<?> primary : iterationResult.getRawPrimaryResults()) {
                    if (primary.getStatistics().getN() != 1) {
                        throw new CLIWrapperException("Unable to dig through JMH output: getN() != 1", null);
                    }
                    if (!primary.getScoreUnit().equals("us/op")) {
                        throw new CLIWrapperException("Unable to dig through JMH output: getScoreUnit() = " + primary.getScoreUnit(), null);
                    }
                    double value = primary.getScore() / 1e6;
                    times.add(value / IdCollection.getDataset(datasetId).getNumberOfInstances());
                    ++count;
                }
            }
            if (count != measurements) {
                throw new CLIWrapperException("Unable to dig through JMH output: Expected "
                        + measurements + " measurements, found " + count, null);
            }
        }
    }
    return times;
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
/**
   * Run this code after a benchmark iteration finished
   *
   * @param benchmarkParams benchmark parameters used for current launch
   * @param iterationParams iteration parameters used for current launch
   * @param result iteration result
   * @return profiler results
   */
  @Override
  public Collection<? extends Result<ProfilerResult>> afterIteration(
      BenchmarkParams benchmarkParams, IterationParams iterationParams, IterationResult result) {

    try {
      final String benchmarkClassName = benchmarkToClassName(benchmarkParams.getBenchmark());
      final Method factoryMethod = factoryMethod(benchmarkClassName);

      final JmhValue wrappedObject =
          (JmhValue) factoryMethod.invoke(null, initializeArguments(benchmarkParams));
      final Object objectToMeasure = wrappedObject.unwrap();

      final Predicate<Object> predicateDataStructureOverhead =
          Predicates.not(Predicates.instanceOf(JmhValue.class));
      final Predicate<Object> predicateRetainedSize = Predicates.alwaysTrue();

      final List<ProfilerResult> profilerResults = new ArrayList<>();

      /**
       * Traverse object graph for measuring memory footprint (in bytes).
       */
      long memoryInBytes = objectexplorer.MemoryMeasurer
          .measureBytes(objectToMeasure, predicateDataStructureOverhead);

      // NOTE: non-standard constructor for passing ResultRole.PRIMARY
      final ProfilerResult memoryResult =
          new ProfilerResult(ResultRole.PRIMARY, "memory", memoryInBytes, UNIT_BYTES, POLICY);

      // hack: substitute results
      result.resetResults();
      result.addResult(memoryResult);

//      /**
//       * Traverse object graph for measuring field statistics.
//       */
//      final Footprint statistic = objectexplorer.ObjectGraphMeasurer
//          .measure(objectToMeasure, predicateDataStructureOverhead);
//
//      final ProfilerResult objectsResult =
//          new ProfilerResult("objects", statistic.getObjects(), UNIT_COUNT, POLICY);
//      profilerResults.add(objectsResult);
//
//      final ProfilerResult referencesResult =
//          new ProfilerResult("references", statistic.getReferences(), UNIT_COUNT, POLICY);
//      profilerResults.add(referencesResult);
//
//      final ProfilerResult primitivesResult =
//          new ProfilerResult("primitives", statistic.getPrimitives().size(), UNIT_COUNT, POLICY);
//      profilerResults.add(primitivesResult);

      return profilerResults;
    } catch (Exception e) {
      e.printStackTrace();
      return Arrays.asList();
    }
  }
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
private Collection<RunResult> getStub() {
    Collection<RunResult> results = new TreeSet<RunResult>(RunResult.DEFAULT_SORT_COMPARATOR);

    Random r = new Random(12345);
    for (int b = 0; b < r.nextInt(10); b++) {
        WorkloadParams ps = new WorkloadParams();
        for (int p = 0; p < 5; p++) {
            ps.put("param" + p, "value" + p, p);
        }
        BenchmarkParams params = new BenchmarkParams(
                "benchmark_" + b,
                JSONResultFormat.class.getName() + ".benchmark_" + b + "_" + Mode.Throughput,
                false,
                r.nextInt(1000),
                new int[]{ r.nextInt(1000) },
                r.nextInt(1000),
                r.nextInt(1000),
                new IterationParams(IterationType.WARMUP,      r.nextInt(1000), TimeValue.seconds(r.nextInt(1000)), 1),
                new IterationParams(IterationType.MEASUREMENT, r.nextInt(1000), TimeValue.seconds(r.nextInt(1000)), 1),
                Mode.Throughput,
                ps,
                TimeUnit.SECONDS, 1,
                Utils.getCurrentJvm(),
                Collections.<String>emptyList(),
                TimeValue.days(1));

        Collection<BenchmarkResult> benchmarkResults = new ArrayList<BenchmarkResult>();
        for (int f = 0; f < r.nextInt(10); f++) {
            Collection<IterationResult> iterResults = new ArrayList<IterationResult>();
            for (int c = 0; c < r.nextInt(10); c++) {
                IterationResult res = new IterationResult(params, params.getMeasurement());
                res.addResult(new ThroughputResult(ResultRole.PRIMARY, "test", r.nextInt(1000), 1000 * 1000, TimeUnit.MILLISECONDS));
                res.addResult(new ThroughputResult(ResultRole.SECONDARY, "secondary1", r.nextInt(1000), 1000 * 1000, TimeUnit.MILLISECONDS));
                res.addResult(new ThroughputResult(ResultRole.SECONDARY, "secondary2", r.nextInt(1000), 1000 * 1000, TimeUnit.MILLISECONDS));
                iterResults.add(res);
            }
            benchmarkResults.add(new BenchmarkResult(iterResults));
        }
        results.add(new RunResult(benchmarkResults));
    }
    return results;
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
@Override
public Collection<? extends Result> afterIteration(final BenchmarkParams benchmarkParams, final IterationParams iterationParams, final IterationResult result) {
  List<Result> l = new ArrayList<>();
  addLinuxVmStats(l);
  return l;
}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
@Override
public void iterationResult(BenchmarkParams benchmarkParams, IterationParams params, int iteration, IterationResult data) {

}
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
/**
 * Format for end-of-iteration.
 *
 * @param benchParams      name of benchmark
 * @param params    iteration params in use
 * @param iteration iteration-number
 * @param data    result of iteration
 */
public void iterationResult(BenchmarkParams benchParams, IterationParams params, int iteration, IterationResult data);
 

import org.openjdk.jmh.results.IterationResult; //导入依赖的package包/类
/**
 * Runs an iteration on the handled benchmark.
 *
 * @param benchmarkParams Benchmark parameters
 * @param params  Iteration parameters
 * @param last    Should this iteration considered to be the last
 * @return IterationResult
 */
public IterationResult runIteration(BenchmarkParams benchmarkParams, IterationParams params, boolean last);