import org.openjdk.jmh.infra.IterationParams; //导入依赖的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.infra.IterationParams; //导入依赖的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.infra.IterationParams; //导入依赖的package包/类
@Benchmark
public void testBig(IterationParams params) {
    if (!recorded) {
        recorded = true;
        switch (params.getType()) {
            case WARMUP:
                testSequence.add("W");
                break;
            case MEASUREMENT:
                testSequence.add("I");
                break;
            default:
                throw new IllegalStateException(params.getType().toString());
        }
    }
    Fixtures.work();
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
@Benchmark
public void testSmall(IterationParams params) {
    if (!recorded) {
        recorded = true;
        switch (params.getType()) {
            case WARMUP:
                testSequence.add("w");
                break;
            case MEASUREMENT:
                testSequence.add("i");
                break;
            default:
                throw new IllegalStateException(params.getType().toString());
        }
    }
    Fixtures.work();
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
@Override
public Collection<? extends Result> afterIteration(BenchmarkParams benchmarkParams, IterationParams iterationParams) {
    Map<String, Long> current = counters().getCurrent();
    return Arrays.asList(
            new ProfilerResult("@threads.alive",
                    current.get("java.threads.live"),
                    "threads", AggregationPolicy.AVG),

            new ProfilerResult("@threads.daemon",
                    current.get("java.threads.daemon"),
                    "threads", AggregationPolicy.AVG),

            new ProfilerResult("@threads.started",
                    current.get("java.threads.started"),
                    "threads", AggregationPolicy.MAX)
    );
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
@Override
public Collection<? extends Result> afterIteration(BenchmarkParams benchmarkParams, IterationParams iterationParams) {
    long gcTime = 0;
    long gcCount = 0;
    for (GarbageCollectorMXBean bean : ManagementFactory.getGarbageCollectorMXBeans()) {
        gcCount += bean.getCollectionCount();
        gcTime += bean.getCollectionTime();
    }

    return Arrays.asList(
            new ProfilerResult("@gc.count.profiled", gcCount - beforeGCCount, "counts", AggregationPolicy.SUM),
            new ProfilerResult("@gc.count.total", gcCount, "counts", AggregationPolicy.MAX),
            new ProfilerResult("@gc.time.profiled", gcTime - beforeGCTime, "ms", AggregationPolicy.SUM),
            new ProfilerResult("@gc.time.total", gcTime, "ms", AggregationPolicy.MAX)
    );
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
private void generateImport(PrintWriter writer) {
    Class<?>[] imports = new Class<?>[]{
            List.class, AtomicInteger.class,
            Collection.class, ArrayList.class,
            TimeUnit.class, Generated.class, CompilerControl.class,
            InfraControl.class, ThreadParams.class,
            Result.class, ThroughputResult.class, AverageTimeResult.class,
            SampleTimeResult.class, SingleShotResult.class, SampleBuffer.class,
            Mode.class, Fork.class, Measurement.class, Threads.class, Warmup.class,
            BenchmarkMode.class, RawResults.class, ResultRole.class,
            Field.class, BenchmarkParams.class, IterationParams.class
    };

    for (Class<?> c : imports) {
        writer.println("import " + c.getName() + ';');
    }
    writer.println();
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
private long estimateTimeSingleFork(BenchmarkParams params) {
    IterationParams wp = params.getWarmup();
    IterationParams mp = params.getMeasurement();

    long estimatedTime;
    if (params.getMode() == Mode.SingleShotTime) {
        // No way to tell how long it will execute,
        // guess anything, and let ETA compensation to catch up.
        estimatedTime = (wp.getCount() + mp.getCount()) * TimeUnit.MILLISECONDS.toNanos(1);
    } else {
        estimatedTime =
                (wp.getCount() * wp.getTime().convertTo(TimeUnit.NANOSECONDS) +
                 mp.getCount() * mp.getTime().convertTo(TimeUnit.NANOSECONDS));
    }
    return estimatedTime;
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
public InfraControlL2(BenchmarkParams benchmarkParams, IterationParams iterationParams, CountDownLatch preSetup, CountDownLatch preTearDown, boolean lastIteration) {
    warmupVisited = new AtomicInteger();
    warmdownVisited = new AtomicInteger();

    warmupDone = new CountDownLatch(1);
    warmdownDone = new CountDownLatch(1);

    shouldSynchIterations = benchmarkParams.shouldSynchIterations();
    threads = benchmarkParams.getThreads();

    warmupShouldWait = shouldSynchIterations;
    warmdownShouldWait = shouldSynchIterations;

    this.preSetup = preSetup;
    this.preTearDown = preTearDown;
    this.lastIteration = lastIteration;
    this.benchmarkParams = benchmarkParams;
    this.iterationParams = iterationParams;
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
@Test
public void testEmptyOptsHaveCompileCommandFile() {
    Runner blade = new Runner(new OptionsBuilder());
    BenchmarkParams bp = new BenchmarkParams("Foo", "bar", false, 1, new int[]{1}, 1, 1,
            new IterationParams(IterationType.WARMUP,      1, TimeValue.seconds(1), 1),
            new IterationParams(IterationType.MEASUREMENT, 1, TimeValue.seconds(1), 1),
            Mode.Throughput, null, TimeUnit.SECONDS, 1,
            Utils.getCurrentJvm(), Collections.<String>emptyList(),
            TimeValue.days(1));
    String[] command = blade.getSeparateExecutionCommand(bp, DUMMY_HOST, DUMMY_PORT, Collections.<String>emptyList(), Collections.<String>emptyList());

    // expecting 1 compile command file
    List<String> files = CompilerHints.getCompileCommandFiles(Arrays.asList(command));
    assertEquals(1, files.size());

    // file should exist
    final String hintFileName = files.get(0);
    File hintsFile = new File(hintFileName);
    assertTrue(hintsFile.exists());

    // hints should be the default as none were specified
    Set<String> hints = CompilerHints.fromFile(hintFileName).get();
    assertEquals(hints, defaultHints);
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的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.infra.IterationParams; //导入依赖的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.infra.IterationParams; //导入依赖的package包/类
@Override
public void beforeIteration(BenchmarkParams benchmarkParams, IterationParams iterationParams) {
    CompilationMXBean comp = ManagementFactory.getCompilationMXBean();
    try {
        startCompTime = comp.getTotalCompilationTime();
    } catch (UnsupportedOperationException e) {
        startCompTime = -1;
    }
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
@Override
public Collection<? extends Result> afterIteration(BenchmarkParams benchmarkParams, IterationParams iterationParams) {
    long compTime = -startCompTime;
    CompilationMXBean comp = ManagementFactory.getCompilationMXBean();
    try {
        compTime += comp.getTotalCompilationTime();
    } catch (UnsupportedOperationException e) {
        compTime = -1;
    }

    return Arrays.asList(
            new ProfilerResult("@compiler.time.profiled", compTime, "ms", AggregationPolicy.SUM),
            new ProfilerResult("@compiler.time.total", comp.getTotalCompilationTime(), "ms", AggregationPolicy.MAX)
    );
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
@Override
public Collection<? extends Result> afterIteration(BenchmarkParams benchmarkParams, IterationParams iterationParams) {
    HotspotInternalResult res = counters();
    Collection<ProfilerResult> results = new ArrayList<ProfilerResult>();
    for (Map.Entry<String, Long> e : res.getDiff().entrySet()) {
        results.add(new ProfilerResult("@unknown." + e.getKey(), e.getValue(), "unit?", AggregationPolicy.AVG));
    }
    return results;
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
@Override
public void beforeIteration(BenchmarkParams benchmarkParams, IterationParams iterationParams) {
    prevs = new HashMap<String, Long>();
    for (Counter counter : getCounters()) {
        prevs.put(counter.getName(), convert(counter.getValue()));
    }
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
@Override
public void beforeIteration(BenchmarkParams benchmarkParams, IterationParams iterationParams) {
    long gcTime = 0;
    long gcCount = 0;
    for (GarbageCollectorMXBean bean : ManagementFactory.getGarbageCollectorMXBeans()) {
        gcCount += bean.getCollectionCount();
        gcTime += bean.getCollectionTime();
    }
    this.beforeGCCount = gcCount;
    this.beforeGCTime = gcTime;
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的package包/类
public void addSuperCall(PrintWriter writer, StateObject so, String suffix) throws IOException {
    // These classes have copying constructor:
    if (so.userType.equals(BenchmarkParams.class.getCanonicalName()) ||
        so.userType.equals(IterationParams.class.getCanonicalName()) ||
        so.userType.equals(ThreadParams.class.getCanonicalName())) {
        writer.println("    public " + so.type + suffix + "(" + so.userType + " other) {");
        writer.println("        super(other);");
        writer.println("    }");
    }
}
 

import org.openjdk.jmh.infra.IterationParams; //导入依赖的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.infra.IterationParams; //导入依赖的package包/类
protected void startProfilers(BenchmarkParams benchmarkParams, IterationParams iterationParams) {
    // start profilers
    for (InternalProfiler prof : registeredProfilers) {
        try {
            prof.beforeIteration(benchmarkParams, iterationParams);
        } catch (Throwable ex) {
            throw new BenchmarkException(ex);
        }
    }
}