Optimise toFastHex for engine_getBlobsV2 (#9426)

- Avoids Tuweni's megamorphic get() and size() calls
- Add jmh ToFastHexBenchmark

Signed-off-by: Simon Dudley <[email protected]>

Author: siladu

CHANGELOG.md

@@ -25,6 +25,7 @@
 - Use error code 3 for execution reverted [#9365](https://github.com/hyperledger/besu/pull/9365)
 - eth_createAccessList now returns success result if execution reverted [#9358](https://github.com/hyperledger/besu/pull/9358)
 - Use Eclipse Temurin OpenJDK JRE in Besu docker image [#9392](https://github.com/hyperledger/besu/pull/9392)
+- Performance: 5-6x faster toFastHex calculation for engine_getBlobsV2 [#9426](https://github.com/hyperledger/besu/pull/9426)
 
 ### Bug fixes
 - Fix loss of colored output in terminal when using `--color-enabled=true` option [#8908](https://github.com/hyperledger/besu/issues/8908)

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/engine/EngineGetBlobsV2.java

@@ -36,6 +36,7 @@
 import org.hyperledger.besu.metrics.BesuMetricCategory;
 import org.hyperledger.besu.plugin.services.MetricsSystem;
 import org.hyperledger.besu.plugin.services.metrics.Counter;
+import org.hyperledger.besu.util.HexUtils;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -164,9 +165,9 @@ private VersionedHash[] extractVersionedHashes(final JsonRpcRequestContext reque
 
   private BlobAndProofV2 createBlobAndProofV2(final BlobProofBundle blobProofBundle) {
     return new BlobAndProofV2(
-        blobProofBundle.getBlob().getData().toHexString(),
+        HexUtils.toFastHex(blobProofBundle.getBlob().getData(), true),
         blobProofBundle.getKzgProof().stream()
-            .map(proof -> proof.getData().toHexString())
+            .map(proof -> HexUtils.toFastHex(proof.getData(), true))
             .toList());
   }
 

ethereum/core/src/jmh/java/org/hyperledger/besu/ethereum/vm/operations/ToFastHexBenchmark.java

@@ -0,0 +1,108 @@
+/*
+ * 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.vm.operations;
+
+import org.hyperledger.besu.util.HexUtils;
+
+import java.nio.ByteBuffer;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.tuweni.bytes.Bytes;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OperationsPerInvocation;
+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;
+
+@State(Scope.Thread)
+@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
+@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
+@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
+@BenchmarkMode(Mode.AverageTime)
+public class ToFastHexBenchmark {
+
+  // engine_getBlobsV2 worse case sizes:
+  // 1 blob = 128 KB = 131072 bytes + (1 * 128 proofs * 48 bytes) = 137,216 bytes
+  // 9 blobs = 9 * 131072 = 1,179,648 bytes + (9 * 128 proofs * 48 bytes) = 1,234,944 bytes (~1.2
+  // MB)
+  // 21 blobs = 21 * 131072 = 2,752,512 bytes + (21 * 128 proofs * 48 bytes) = 2,881,536 bytes (~2.7
+  // MB)
+  // 72 blobs = 72 * 131072 = 9,437,184 bytes + (72 * 128 proofs * 48 bytes) = 9,879,552 bytes (~9.4
+  // MB)
+  // 128 blobs = 128 * 131072 = 16,777,216 bytes + (128 * 128 proofs * 48 bytes) = 17,563,648 bytes
+  // (~16.7 MB)
+  public enum Case {
+    SIZE_1_BLOB(137_216),
+    SIZE_9_BLOBS(1_234_944),
+    SIZE_21_BLOBS(2_881_536),
+    SIZE_72_BLOBS(9_879_552),
+    SIZE_128_BLOBS(17_563_648);
+
+    final int inputSize;
+
+    Case(final int inputSize) {
+      this.inputSize = inputSize;
+    }
+  }
+
+  @Param({"SIZE_1_BLOB", "SIZE_9_BLOBS", "SIZE_21_BLOBS", "SIZE_72_BLOBS", "SIZE_128_BLOBS"})
+  private Case caseName;
+
+  private static final int N = 3;
+  private static final int FACTOR = 1;
+  private static final Random RANDOM = new Random(23L);
+  Bytes[] bytes;
+
+  @Setup
+  public void setup() {
+    // force megamorphic tuweni behavior by mixing different Bytes implementations
+    bytes = new Bytes[N * FACTOR];
+    for (int i = 0; i < N * FACTOR; i += N) {
+      bytes[i] = Bytes.wrap(getBytes(caseName.inputSize));
+      bytes[i + 1] = Bytes.wrapByteBuffer(ByteBuffer.wrap(getBytes(caseName.inputSize)));
+      bytes[i + 2] = Bytes.repeat((byte) 0x09, caseName.inputSize);
+    }
+  }
+
+  private static byte[] getBytes(final int size) {
+    byte[] b = new byte[size];
+    RANDOM.nextBytes(b);
+    return b;
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(N * FACTOR)
+  public void hexUtils(final Blackhole blackhole) {
+    for (Bytes b : bytes) {
+      blackhole.consume(HexUtils.toFastHex(b, true));
+    }
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(N * FACTOR)
+  public void tuweni(final Blackhole blackhole) {
+    for (Bytes b : bytes) {
+      blackhole.consume(b.toFastHex(true));
+    }
+  }
+}

util/src/main/java/org/hyperledger/besu/util/HexUtils.java

@@ -0,0 +1,58 @@
+/*
+ * 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.util;
+
+import org.apache.tuweni.bytes.Bytes;
+
+/** Utility class for Hexadecimal operations. */
+public class HexUtils {
+
+  private HexUtils() {}
+
+  private static final char[] HEX = "0123456789abcdef".toCharArray();
+
+  /**
+   * Optimized version of org.apache.tuweni.bytes.Bytes.toFastHex that avoids the megamorphic get
+   * and size calls
+   *
+   * @param abytes The bytes to convert
+   * @param prefix whether to include the "0x" prefix
+   * @return The hex string representation
+   */
+  public static String toFastHex(final Bytes abytes, final boolean prefix) {
+    final byte[] bytes = abytes.toArrayUnsafe();
+    final int size = bytes.length;
+
+    final int offset = prefix ? 2 : 0;
+
+    final int resultSize = (size * 2) + offset;
+
+    final char[] result = new char[resultSize];
+
+    if (prefix) {
+      result[0] = '0';
+      result[1] = 'x';
+    }
+
+    for (int i = 0; i < size; i++) {
+      byte b = bytes[i];
+      int pos = i * 2;
+      result[pos + offset] = HEX[b >> 4 & 15];
+      result[pos + offset + 1] = HEX[b & 15];
+    }
+
+    return new String(result);
+  }
+}

util/src/test/java/org/hyperledger/besu/util/HexUtilsTest.java

@@ -0,0 +1,82 @@
+/*
+ * 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.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.apache.tuweni.bytes.Bytes;
+import org.junit.jupiter.api.Test;
+
+class HexUtilsTest {
+
+  @Test
+  public void testToFastHexEmptyWithPrefix() {
+    Bytes emptyBytes = Bytes.EMPTY;
+    String result = HexUtils.toFastHex(emptyBytes, true);
+    assertEquals("0x", result, "Expected '0x' for an empty byte array with prefix");
+  }
+
+  @Test
+  public void testToFastHexEmptyWithoutPrefix() {
+    Bytes emptyBytes = Bytes.EMPTY;
+    String result = HexUtils.toFastHex(emptyBytes, false);
+    assertEquals("", result, "Expected '' for an empty byte array without prefix");
+  }
+
+  @Test
+  public void testToFastHexSingleByteWithPrefix() {
+    Bytes bytes = Bytes.fromHexString("0x01");
+    String result = HexUtils.toFastHex(bytes, true);
+    assertEquals("0x01", result, "Expected '0x01' for the byte 0x01 with prefix");
+  }
+
+  @Test
+  public void testToFastHexSingleByteWithoutPrefix() {
+    Bytes bytes = Bytes.fromHexString("0x01");
+    String result = HexUtils.toFastHex(bytes, false);
+    assertEquals("01", result, "Expected '01' for the byte 0x01 without prefix");
+  }
+
+  @Test
+  public void testToFastHexMultipleBytesWithPrefix() {
+    Bytes bytes = Bytes.fromHexString("0x010203");
+    String result = HexUtils.toFastHex(bytes, true);
+    assertEquals("0x010203", result, "Expected '0x010203' for the byte array 0x010203 with prefix");
+  }
+
+  @Test
+  public void testToFastHexMultipleBytesWithoutPrefix() {
+    Bytes bytes = Bytes.fromHexString("0x010203");
+    String result = HexUtils.toFastHex(bytes, false);
+    assertEquals("010203", result, "Expected '010203' for the byte array 0x010203 without prefix");
+  }
+
+  @Test
+  public void testToFastHexWithLeadingZeros() {
+    Bytes bytes = Bytes.fromHexString("0x0001");
+    String result = HexUtils.toFastHex(bytes, true);
+    assertEquals(
+        "0x0001",
+        result,
+        "Expected '0x0001' for the byte array 0x0001 with prefix (leading zeros retained)");
+  }
+
+  @Test
+  public void testToFastHexWithLargeData() {
+    Bytes bytes = Bytes.fromHexString("0x0102030405060708090a");
+    String result = HexUtils.toFastHex(bytes, true);
+    assertEquals("0x0102030405060708090a", result, "Expected correct hex output for large data");
+  }
+}