optimize using kth algorithm by cuiweixie · Pull Request #9599 · besu-eth/besu

cuiweixie · 2026-01-04T11:58:35Z

PR description

Fixed Issue(s)

Thanks for sending a pull request! Have you done the following?

Checked out our contribution guidelines?
Considered documentation and added the doc-change-required label to this PR if updates are required.
Considered the changelog and included an update if required.
For database changes (e.g. KeyValueSegmentIdentifier) considered compatibility and performed forwards and backwards compatibility tests

Locally, you can run these tests to catch failures early:

spotless: ./gradlew spotlessApply
unit tests: ./gradlew build
acceptance tests: ./gradlew acceptanceTest
integration tests: ./gradlew integrationTest
reference tests: ./gradlew ethereum:referenceTests:referenceTests
hive tests: Engine or other RPCs modified?

cuiweixie · 2026-01-04T12:10:01Z

benchmark code:

/*
 * Copyright contributors to Besu.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
package org.hyperledger.besu.ethereum.api.query;

import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.util.OrderStatistics;

import java.util.Arrays;
import java.util.SplittableRandom;
import java.util.concurrent.TimeUnit;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.infra.Blackhole;

/**
 * A smaller parameter set than {@link GasPriceSelectionBenchmark} for quicker local runs.
 *
 * <p>Run: {@code ./gradlew :ethereum:api:jmh -Pincludes=GasPriceSelectionBenchmarkQuick}
 */
@State(Scope.Thread)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@BenchmarkMode(Mode.AverageTime)
public class GasPriceSelectionBenchmarkQuick {

  public enum Distribution {
    RANDOM,
    DUPLICATES
  }

  @Param({"1024", "32768"})
  public int size;

  @Param({"0.6", "0.9"})
  public double fraction;

  @Param({"RANDOM", "DUPLICATES"})
  public Distribution distribution;

  private Wei[] base;
  private int k;

  @Setup(Level.Trial)
  public void setup() {
    k = Math.min(size - 1, (int) (size * fraction));

    final long[] data = new long[size];
    final SplittableRandom rnd = new SplittableRandom(1L);

    if (distribution == Distribution.DUPLICATES) {
      for (int i = 0; i < size; i++) {
        data[i] = rnd.nextLong(0, 128);
      }
    } else {
      for (int i = 0; i < size; i++) {
        data[i] = rnd.nextLong(0, Long.MAX_VALUE);
      }
    }

    // Shuffle to avoid being already sorted.
    shuffleInPlace(data, rnd.split());

    base = new Wei[size];
    for (int i = 0; i < size; i++) {
      base[i] = Wei.of(data[i]);
    }
  }

  @Benchmark
  public void sortThenPick(final Blackhole bh) {
    final Wei[] copy = base.clone();
    Arrays.sort(copy);
    bh.consume(copy[k]);
  }

  @Benchmark
  public void kthPick(final Blackhole bh) {
    final Wei[] copy = base.clone();
    bh.consume(OrderStatistics.selectKthInPlace(copy, k));
  }

  private static void shuffleInPlace(final long[] a, final SplittableRandom rnd) {
    for (int i = a.length - 1; i > 0; i--) {
      final int j = rnd.nextInt(i + 1);
      final long tmp = a[i];
      a[i] = a[j];
      a[j] = tmp;
    }
  }
}

result in: