org.openjdk.jmh.results.RawResults java code examples

Refine search

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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 nanoTime_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();
    nanoTime_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, "nanoTime", 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");
}

Most used methods

Popular in Java

Parsing JSON documents to java classes using gson
requestLocationUpdates (LocationManager)
getContentResolver (Context)
putExtra (Intent)
Permission (java.security)
Legacy security code; do not use.
Connection (java.sql)
A connection represents a link from a Java application to a database. All SQL statements and results
Map (java.util)
A Map is a data structure consisting of a set of keys and values in which each key is mapped to a si
Random (java.util)
This class provides methods that return pseudo-random values.It is dangerous to seed Random with the
LogFactory (org.apache.commons.logging)
Factory for creating Log instances, with discovery and configuration features similar to that employ
Loader (org.hibernate.loader)
Abstract superclass of object loading (and querying) strategies. This class implements useful common
Top Sublime Text plugins

How to useRawResults in org.openjdk.jmh.results

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

Refine search

How to use
RawResults
in
org.openjdk.jmh.results