org.openjdk.jmh.runner.InfraControl.preSetup java code examples

Refine search

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 BufferedReader b =InputStream in;new BufferedReader(new InputStreamReader(in))
Reader in;new BufferedReader(in)
File file;new BufferedReader(new FileReader(file))
Smart code suggestions by Codota
}

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");
}

Popular methods of InfraControl

Popular in Java

Reading from database using SQL prepared statement
getResourceAsStream (ClassLoader)
getApplicationContext (Context)
getSharedPreferences (Context)
Kernel (java.awt.image)
SocketTimeoutException (java.net)
This exception is thrown when a timeout expired on a socket read or accept operation.
Collections (java.util)
This class consists exclusively of static methods that operate on or return collections. It contains
LinkedHashMap (java.util)
Hash table and linked list implementation of the Map interface, with predictable iteration order. Th
Queue (java.util)
A collection designed for holding elements prior to processing. Besides basic java.util.Collection o
JLabel (javax.swing)

How to use preSetupmethodin org.openjdk.jmh.runner.InfraControl

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

Refine search

How to use
preSetup
method
in
org.openjdk.jmh.runner.InfraControl