@Benchmark
@BenchmarkMode(Mode.Throughput)
@Warmup(iterations = 10, time = 3, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 50, time = 3, timeUnit = TimeUnit.SECONDS)
@Threads(1)
public void testBuiltInStringSplit(Blackhole blackhole, MyState state) throws IOException {
    BufferedReader bf = new BufferedReader(new StringReader(state.eventListStr));
    String line;
    List<String> msseList = new ArrayList<>();

    StringBuilder outStrB = new StringBuilder();
    while ((line = bf.readLine()) != null) {
        outStrB.append(line);
    }
    String[] toks = outStrB.toString().split("\\$\\$\\$");

    for (String tok : toks) {
        msseList.add(tok);
    }

    blackhole.consume(msseList);
}
 

/** Benchmark for measuring HttpTraceContext extract. */
@Benchmark
@BenchmarkMode({Mode.AverageTime})
@Fork(1)
@Measurement(iterations = 15, time = 1)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@OperationsPerInvocation(COUNT)
@Nullable
public Context measureExtract() {
  Context result = null;
  for (int i = 0; i < COUNT; i++) {
    result = httpTraceContext.extract(Context.ROOT, carriers.get(i), getter);
  }
  return result;
}
 

@Benchmark
@Warmup(iterations = 5, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
public void verifySignatureBatchedParallelDoublePairing() {
  boolean res =
      BLS.batchVerify(
          keyPairs.stream()
              .map(kp -> Collections.singletonList(kp.getPublicKey()))
              .limit(sigCnt)
              .collect(Collectors.toList()),
          messages.subList(0, sigCnt),
          signatures.subList(0, sigCnt),
          true,
          true);
  if (!res) throw new IllegalStateException();
}
 

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Measurement(iterations = 1)
public void searchBenchmark() throws SpellCheckException {
  for (String query : queries) {
    totalMatches += spellChecker.lookup(query, Verbosity.valueOf(verbosity), maxEditDistance)
        .size();
  }
}
 

@Benchmark
@BenchmarkMode(Mode.All)
@Fork(value=1)
@Warmup(iterations = 20)
@Measurement(iterations = 20)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public String serializeTwoGenerationSegment(MultiLevelSegmentState state) {
    return state.twoLevelSegment.serialize();
}
 

@Benchmark
@Measurement(batchSize = 100)
public void readingAllPixelsChannelsByIndex() {
	long[] shape = pixels.shape().asArray();
	for (int i = 0; i < shape[0]; ++i) {
		for (int j = 0; j < shape[1]; ++j) {
			pixels.getFloat(i, j);
		}
	}
}
 

@Benchmark
@Measurement(batchSize = 2049 * 1537)
public void writeOnePixelsByIndex() {
	batches
			.setFloat(pixels.getFloat(0, 0), 0, 0, 0)
			.setFloat(pixels.getFloat(0, 1), 0, 1, 0)
			.setFloat(pixels.getFloat(0, 2), 0, 2, 0);
}
 

@Benchmark
@Measurement(batchSize = 1000)
public void initTensorByStdArrays() {
  int[][][][] data = new int[][][][] {
      {
          {
              {0, 0, 0}, {0, 0, 1}, {0, 0, 2}
          },
          {
              {0, 1, 0}, {0, 1, 1}, {0, 1, 2}
          },
          {
              {0, 2, 0}, {0, 2, 1}, {0, 2, 2}
          }
      }, {
          {
              {1, 0, 0}, {1, 0, 1}, {1, 0, 2}
          },
          {
              {1, 1, 0}, {1, 1, 1}, {1, 1, 2}
          },
          {
              {1, 2, 0}, {1, 2, 1}, {1, 2, 2}
          }
      }, {
          {
              {2, 0, 0}, {2, 0, 1}, {2, 0, 2}
          },
          {
              {2, 1, 0}, {2, 1, 1}, {2, 1, 2}
          },
          {
              {2, 2, 0}, {2, 2, 1}, {2, 2, 2}
          }
      }
  };
  TInt32.tensorOf(StdArrays.shapeOf(data), d -> StdArrays.copyTo(d, data));
}
 

@Benchmark
@Measurement(batchSize = 1000)
public void initTensorByFlatArray() {
  IntDataBuffer data = DataBuffers.of(
      0, 0, 0,
      0, 0, 1,
      0, 0, 2,
      0, 1, 0,
      0, 1, 1,
      0, 1, 2,
      0, 2, 0,
      0, 2, 1,
      0, 2, 2,
      1, 0, 0,
      1, 0, 1,
      1, 0, 2,
      1, 1, 0,
      1, 1, 1,
      1, 1, 2,
      1, 2, 0,
      1, 2, 1,
      1, 2, 2,
      2, 0, 0,
      2, 0, 1,
      2, 0, 2,
      2, 1, 0,
      2, 1, 1,
      2, 1, 2,
      2, 2, 0,
      2, 2, 1,
      2, 2, 2
  );
  TInt32.tensorOf(Shape.of(3, 3, 3, 3), data);
}
 

@Benchmark
@BenchmarkMode(Mode.Throughput)
@Warmup(iterations = 10, time = 3, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 50, time = 3, timeUnit = TimeUnit.SECONDS)
@Threads(1)
public void testGzipCompress(Blackhole blackhole, MyState state) throws IOException {
    blackhole.consume(CompressionUtils.compressAndBase64Encode(state.eventList));
}
 

/** Benchmark the full span lifecycle. */
@Benchmark
@BenchmarkMode({Mode.AverageTime})
@Fork(1)
@Measurement(iterations = 15, time = 1)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
public void measureFullSpanLifecycle() {
  span = tracer.spanBuilder("span").startSpan();
  try (io.opentelemetry.context.Scope ignored = tracer.withSpan(span)) {
    // no-op
  } finally {
    span.end();
  }
}
 

/** Benchmark just the scope lifecycle. */
@Benchmark
@BenchmarkMode({Mode.AverageTime})
@Fork(1)
@Measurement(iterations = 15, time = 1)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
public void measureScopeLifecycle() {
  try (io.opentelemetry.context.Scope ignored = tracer.withSpan(span)) {
    // no-op
  }
}
 

@Benchmark
@BenchmarkMode({Mode.AverageTime})
@Fork(1)
@Measurement(iterations = 15, time = 1)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
public void measureGetCurrentSpan() {
  tracer.getCurrentSpan();
}
 

@Benchmark
@BenchmarkMode(Mode.All)
@Fork(value=1)
@Warmup(iterations = 20)
@Measurement(iterations = 20)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public boolean noSampleSamplingBenchmark(NoSampleSamplingRulesState state) {
    return state.samplingStrategy.shouldTrace(state.samplingRequest).isSampled();
}
 

@Benchmark
@Fork(1)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Threads(value = 10)
public void aggregate_10Threads() {
  aggregator.recordDouble(100.0056);
}
 

@Benchmark
@Fork(1)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Threads(value = 5)
public void aggregate_5Threads() {
  aggregator.recordDouble(100.0056);
}
 

@Benchmark
@Fork(1)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Threads(value = 1)
public void aggregate_1Threads() {
  aggregator.recordDouble(100.0056);
}
 

@Benchmark
@BenchmarkMode(Mode.All)
@Fork(value=1)
@Warmup(iterations = 20)
@Measurement(iterations = 20)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public void endSegmentWithChildBenchmark(PopulatedRecorderState state) {
    state.recorder.endSubsegment();
    state.recorder.endSegment();
}
 

@Benchmark
@Fork(1)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Threads(value = 5)
public void aggregate_5Threads() {
  aggregator.recordLong(100);
}
 

@Benchmark
@Fork(1)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Threads(value = 1)
public void aggregate_1Threads() {
  aggregator.recordLong(100);
}
 

@Benchmark
@Threads(value = 5)
@Fork(1)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void addAttributesEventsStatusEnd_05Threads() {
  doSpanWork(span);
}
 

@Benchmark
@Threads(value = 10)
@Fork(1)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void addAttributesEventsStatusEnd_10Threads() {
  doSpanWork(span);
}
 

@Benchmark
@BenchmarkMode(Mode.All)
@Fork(value=1)
@Warmup(iterations = 20)
@Measurement(iterations = 20)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public void endSegmentBenchmark(SegmentNoChildRecorderState state) {
    state.recorder.endSegment();
}
 

@Benchmark
@Warmup(iterations = 5, batchSize = 5000)
@Measurement(iterations = 5, batchSize = 5000)
@BenchmarkMode(Mode.SingleShotTime)
public List<String> measureRight() {
    list.add(list.size() / 2, "something");
    return list;
}
 

@Warmup(iterations = 20)
@Measurement(iterations = 10)
@Benchmark
public void sortCurrentWay() {
    for (int i = 0; i < NUMBER_OF_ITERATIONS; i++) {
        Arrays.sort(this.array);
    }
}
 

@Warmup(iterations = 5)
@Measurement(iterations = 10)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(value = 1)
@Threads(8)
@Benchmark
public void put(Blackhole blackhole,BenchmarkState state,ThreadState threadState) {
    for (int i = 0; i < threadState.numRows; ++i) {
        Map.Entry<String, String> pair = threadState.rows.get(i);
        state.oakMap.zc().put(pair.getKey(), pair.getValue());
        blackhole.consume(state.oakMap);
    }
}
 

@Warmup(iterations = 1)
@Measurement(iterations = 10)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(value = 1)
@Threads(1)
@Benchmark
public void get(Blackhole blackhole, BenchmarkState state) {
    for (int i=0; i < state.bytes; ++i) {
        blackhole.consume(state.byteBuffer.get(i));
    }
}
 

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(value = 1)
@Threads(50)
@Warmup(iterations = 5)
@Measurement(iterations = 5)
public void testCascadedValidation(CascadedValidationState state, Blackhole blackhole) {
    DriverSetup driverSetup = new DriverSetup();
    Result result = state.rule.executeOn(driverSetup.model);
    assertThat(result.value()).isTrue();
    blackhole.consume(result);
}
 

@Benchmark
@BenchmarkMode(Mode.All)
@Fork(value=1)
@Warmup(iterations = 20)
@Measurement(iterations = 20)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public void beginEndSegmentSubsegmentBenchmark(RecorderState state) {
    state.recorder.beginSegment(SEGMENT_NAME);
    state.recorder.beginSubsegment(SUBSEGMENT_NAME);
    state.recorder.endSubsegment();
    state.recorder.endSegment();
}
 

@Benchmark
@Warmup(iterations = 10, time = 100, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 100, timeUnit = TimeUnit.MILLISECONDS)
public void integerSquareRoot(Blackhole bh) {
  n = n.plus(UnsignedLong.ONE);
  bh.consume(BeaconStateUtil.integer_squareroot(n));
}