/** 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
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MINUTES)
@Warmup(iterations = 10, time = 3, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 50, time = 3, timeUnit = TimeUnit.SECONDS)
@Threads(1)
public void testBasicStringSplit(Blackhole blackhole, MyState state) throws IOException {
    BufferedReader bf = new BufferedReader(new StringReader(state.eventListStr));

    StringBuilder sb = new StringBuilder();
    String line;
    List<String> msseList = new ArrayList<>();
    int dollarCnt = 0;
    while ((line = bf.readLine()) != null) {
        for (int i = 0; i < line.length(); i++) {
            if (dollarCnt == 3) {
                msseList.add(sb.toString());
                dollarCnt = 0;
                sb = new StringBuilder();
            }
            if (line.charAt(i) != '$') {
                sb.append(line.charAt(i));
            } else {
                dollarCnt++;
            }
        }

    }
    blackhole.consume(msseList);
    //blackhole.consume(state.eventListStr.split("$$"));
    //state.sum = state.a + state.b;
}
 

@Benchmark
@Warmup(iterations = 5)
public void mathSin(ThreadState state) {
    double[] data = state.data;
    for (int i = 0; i < data.length; i++) {
        double[] result = state.result;
        result[i] = Math.sin(data[i]);
    }
}
 

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

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

/** 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.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 for measuring inject with default trace state and sampled trace options. */
@Benchmark
@BenchmarkMode({Mode.AverageTime})
@Fork(1)
@Measurement(iterations = 15, time = 1)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@OperationsPerInvocation(COUNT)
public Map<String, String> measureInject() {
  for (int i = 0; i < COUNT; i++) {
    httpTraceContext.inject(contexts.get(i), carrier, setter);
  }
  return carrier;
}
 

/** Benchmark for measuring inject with default trace state and sampled trace options. */
@Benchmark
@Measurement(iterations = 15, time = 1)
@Warmup(iterations = 5, time = 1)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Fork(1)
public Map<String, String> measureInject() {
  Context context =
      TracingContextUtils.withSpan(DefaultSpan.create(contextToTest), Context.current());
  doInject(context, carrier);
  return carrier;
}
 

@Benchmark
@Measurement(iterations = 15, time = 1)
@Warmup(iterations = 5, time = 1)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Fork(1)
public Span measureExtract() {
  return TracingContextUtils.getSpan(doExtract());
}
 

@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 = 2)
@Fork(1)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void addAttributesEventsStatusEnd_02Threads() {
  doSpanWork(span);
}
 

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

@Benchmark
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@BenchmarkMode(Mode.AverageTime)
public List<String> measureWrong_1() {
    list.add(list.size() / 2, "something");
    return list;
}
 

@Benchmark
@Warmup(iterations = 5)
public void mathLog(ThreadState state) {
    double[] data = state.data;
    for (int i = 0; i < data.length; i++) {
        double[] result = state.result;
        result[i] = Math.log(data[i]);
    }
}
 

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

@Warmup(iterations = 5)
@Measurement(iterations = 10)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(value = 1)
@Threads(8)
@Benchmark
public void get(Blackhole blackhole,BenchmarkState state,ThreadState threadState) {
    String key = state.keys.get(threadState.i++ % state.numRows);
    String val = state.oakMap.get(key);
    blackhole.consume(val);
}
 

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

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

@Benchmark
@Warmup(iterations = 5, time = 100, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 5, time = 100, timeUnit = TimeUnit.MILLISECONDS)
public void incrementalHash(Blackhole bh) {
  ListViewWrite<UInt64View> l2w = l2r.createWritableCopy();
  l2w.set(12345, new UInt64View(UnsignedLong.valueOf(77777)));
  ListViewRead<UInt64View> l2r_ = l2w.commitChanges();
  l2r_.hashTreeRoot();
}
 

@Benchmark
@Warmup(iterations = 5, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
public void iterateValidatorsWithMethods(Blackhole bh) {
  for (Validator validator : beaconState.getValidators()) {
    bh.consume(validator.isSlashed());
    bh.consume(validator.getPubkey());
    bh.consume(validator.getEffective_balance());
    bh.consume(validator.getActivation_epoch());
    bh.consume(validator.getExit_epoch());
    bh.consume(validator.getWithdrawable_epoch());
  }
}
 

@Benchmark
@Warmup(iterations = 20)
public int valueNumberLeaf_HASHMAP_COMPUTE_IF_ABSENT(HashMapComputeIfAbsent s) {
    int result = 0;
    for (Node n : s.valueNumberableLeafNodes) {
        result += (n.getNodeClass().isLeafNode() ? 1 : 0);
    }
    return result;
}
 

@Benchmark
@Warmup(iterations = 5, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
public void verifySignatureSimple() {
  for (int i = 0; i < sigCnt; i++) {
    boolean res = BLS.verify(keyPairs.get(i).getPublicKey(), messages.get(i), signatures.get(i));
    if (!res) throw new IllegalStateException();
  }
}
 

@Warmup(iterations = 20)
@Measurement(iterations = 10)
@Benchmark
public void sortNewWay() {
    for (int i = 0; i < NUMBER_OF_ITERATIONS; i++) {
        SortingIntTestJMH.sort(this.array, 0, this.array.length - 1, null, 0, 0);
    }
}
 

@Benchmark
@BenchmarkMode(Mode.All)
@Fork(value=1)
@Warmup(iterations = 20)
@Measurement(iterations = 20)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Subsegment constructSubsegmentPutInSegmentBenchmark(BenchmarkState state) {
    // TODO: Find a way to create just the subsegment and not force it into the parent segment?
    return new SubsegmentImpl(state.recorder, SEGMENT_NAME, state.parentSegment);
}
 

@Benchmark
@Warmup(iterations = 10, time = 100, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 100, timeUnit = TimeUnit.MILLISECONDS)
public void sha256of33bytes(Blackhole bh) {
  int idx = cnt++ % data.size();
  data.set(idx, (byte) (data.get(idx) + 1));
  Bytes32 hash = Hash.sha2_256(data);
  bh.consume(hash);
}
 

@Warmup(iterations = 20)
@Measurement(iterations = 10)
@Benchmark
public void sortNewWay() {
    for (int i = 0; i < NUMBER_OF_ITERATIONS; i++) {
        SortingLongTestJMH.sort(this.array, 0, this.array.length - 1, null, 0, 0);
    }
}
 

@Benchmark
@Warmup(iterations = 2)
@Measurement(iterations = 5)
public void shuffledListBench(Blackhole bh) {
  int[] indexes = IntStream.range(0, indexCount).toArray();
  CommitteeUtil.shuffle_list(indexes, seed);
  bh.consume(indexes);
}