Best Java code snippets using org.openjdk.jmh.runner.InfraControl.preSetup (Showing top 20 results out of 369)

public BenchmarkTaskResult testBitSet_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    HashSetvBitSetTest_jmhType l_hashsetvbitsettest0_0 = _jmh_tryInit_f_hashsetvbitsettest0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    testBitSet_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_hashsetvbitsettest0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_hashsetvbitsettest0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "testBitSet", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult timeBitSetRemoveAll_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    HashSetvBitSetTest_jmhType l_hashsetvbitsettest0_0 = _jmh_tryInit_f_hashsetvbitsettest0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    timeBitSetRemoveAll_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_hashsetvbitsettest0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_hashsetvbitsettest0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "timeBitSetRemoveAll", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult testHashSet_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    HashSetvBitSetTest_jmhType l_hashsetvbitsettest0_0 = _jmh_tryInit_f_hashsetvbitsettest0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    testHashSet_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_hashsetvbitsettest0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_hashsetvbitsettest0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "testHashSet", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult timeExtractRemoveAll_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    HashSetvBitSetTest_jmhType l_hashsetvbitsettest0_0 = _jmh_tryInit_f_hashsetvbitsettest0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    timeExtractRemoveAll_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_hashsetvbitsettest0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_hashsetvbitsettest0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "timeExtractRemoveAll", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult baseLineNegate_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkBigIntOperators_jmhType l_benchmarkbigintoperators0_0 = _jmh_tryInit_f_benchmarkbigintoperators0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    baseLineNegate_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkbigintoperators0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkbigintoperators0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "baseLineNegate", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult doubleBaseline_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkRoundFunction_jmhType l_benchmarkroundfunction0_0 = _jmh_tryInit_f_benchmarkroundfunction0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    doubleBaseline_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkroundfunction0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkroundfunction0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "doubleBaseline", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult baseLineSubtract_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkBigIntOperators_jmhType l_benchmarkbigintoperators0_0 = _jmh_tryInit_f_benchmarkbigintoperators0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    baseLineSubtract_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkbigintoperators0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkbigintoperators0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "baseLineSubtract", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult compiled_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkPageProcessor_jmhType l_benchmarkpageprocessor0_0 = _jmh_tryInit_f_benchmarkpageprocessor0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    compiled_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkpageprocessor0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkpageprocessor0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "compiled", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult baseLineAdd_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkBigIntOperators_jmhType l_benchmarkbigintoperators0_0 = _jmh_tryInit_f_benchmarkbigintoperators0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    baseLineAdd_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkbigintoperators0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkbigintoperators0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "baseLineAdd", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult overflowChecksMultiply_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkBigIntOperators_jmhType l_benchmarkbigintoperators0_0 = _jmh_tryInit_f_benchmarkbigintoperators0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    overflowChecksMultiply_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkbigintoperators0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkbigintoperators0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "overflowChecksMultiply", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult overflowChecksDivide_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkBigIntOperators_jmhType l_benchmarkbigintoperators0_0 = _jmh_tryInit_f_benchmarkbigintoperators0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    overflowChecksDivide_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkbigintoperators0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkbigintoperators0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "overflowChecksDivide", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult floatActual_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkRoundFunction_jmhType l_benchmarkroundfunction0_0 = _jmh_tryInit_f_benchmarkroundfunction0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    floatActual_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkroundfunction0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkroundfunction0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "floatActual", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult floatBaseline_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkRoundFunction_jmhType l_benchmarkroundfunction0_0 = _jmh_tryInit_f_benchmarkroundfunction0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    floatBaseline_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkroundfunction0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkroundfunction0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "floatBaseline", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult rowOriented_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    PageProcessorBenchmark_jmhType l_pageprocessorbenchmark0_0 = _jmh_tryInit_f_pageprocessorbenchmark0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    rowOriented_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_pageprocessorbenchmark0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_pageprocessorbenchmark0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "rowOriented", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult computePositionWithMask_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkComputePosition_jmhType l_benchmarkcomputeposition0_0 = _jmh_tryInit_f_benchmarkcomputeposition0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    computePositionWithMask_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkcomputeposition0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkcomputeposition0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "computePositionWithMask", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult overflowChecksNegate_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkBigIntOperators_jmhType l_benchmarkbigintoperators0_0 = _jmh_tryInit_f_benchmarkbigintoperators0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    overflowChecksNegate_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkbigintoperators0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkbigintoperators0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "overflowChecksNegate", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult overflowChecksSubtract_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkBigIntOperators_jmhType l_benchmarkbigintoperators0_0 = _jmh_tryInit_f_benchmarkbigintoperators0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    overflowChecksSubtract_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkbigintoperators0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkbigintoperators0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "overflowChecksSubtract", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult baseLineDivide_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkBigIntOperators_jmhType l_benchmarkbigintoperators0_0 = _jmh_tryInit_f_benchmarkbigintoperators0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    baseLineDivide_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkbigintoperators0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkbigintoperators0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "baseLineDivide", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult userTime_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkCPUCounters_jmhType l_benchmarkcpucounters0_0 = _jmh_tryInit_f_benchmarkcpucounters0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    userTime_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkcpucounters0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkcpucounters0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "userTime", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}

public BenchmarkTaskResult baseLineMultiply_SingleShotTime(InfraControl control, ThreadParams threadParams) throws Throwable {
  this.benchmarkParams = control.benchmarkParams;
  this.iterationParams = control.iterationParams;
  this.threadParams    = threadParams;
  this.notifyControl   = control.notifyControl;
  if (this.blackhole == null) {
    this.blackhole = new Blackhole("Today's password is swordfish. I understand instantiating Blackholes directly is dangerous.");
  }
  if (threadParams.getSubgroupIndex() == 0) {
    BenchmarkBigIntOperators_jmhType l_benchmarkbigintoperators0_0 = _jmh_tryInit_f_benchmarkbigintoperators0_0(control);
    control.preSetup();
    notifyControl.startMeasurement = true;
    RawResults res = new RawResults();
    int batchSize = iterationParams.getBatchSize();
    baseLineMultiply_ss_jmhStub(control, res, benchmarkParams, iterationParams, threadParams, blackhole, notifyControl, startRndMask, batchSize, l_benchmarkbigintoperators0_0);
    control.preTearDown();
    if (control.isLastIteration()) {
      f_benchmarkbigintoperators0_0 = null;
    }
    int opsPerInv = control.benchmarkParams.getOpsPerInvocation();
    long totalOps = opsPerInv;
    BenchmarkTaskResult results = new BenchmarkTaskResult(totalOps, totalOps);
    results.add(new SingleShotResult(ResultRole.PRIMARY, "baseLineMultiply", res.getTime(), benchmarkParams.getTimeUnit()));
    this.blackhole.evaporate("Yes, I am Stephen Hawking, and know a thing or two about black holes.");
    return results;
  } else
    throw new IllegalStateException("Harness failed to distribute threads among groups properly");
}