All branch conditions test the original unshifted value, eliminating sequential + * data dependencies between condition evaluations and enabling CPU instruction-level parallelism. + */ +@SuppressWarnings("MismatchedReadAndWriteOfArray") +@State(Scope.Benchmark) +public class SmartNoDataDependencyByteArray { + private byte[] buffer; + private int position = 0; + + @Setup(Level.Trial) + public void setup() { + buffer = new byte[10 * VarIntWriterBench.NUM_OF_VALUES]; + } + + public void writeVarint(long value) { + if ((value & ~0x7FL) == 0) { + buffer[position++] = (byte) value; + } else { + buffer[position++] = (byte) ((value & 0x7F) | 0x80); + if ((value & ~0x3FFFL) == 0) { + buffer[position++] = (byte) (value >>> 7); + } else { + buffer[position++] = (byte) ((value >>> 7) & 0x7F | 0x80); + if ((value & ~0x1FFFFFL) == 0) { + buffer[position++] = (byte) (value >>> 14); + } else { + buffer[position++] = (byte) ((value >>> 14) & 0x7F | 0x80); + if ((value & ~0xFFFFFFFL) == 0) { + buffer[position++] = (byte) (value >>> 21); + } else { + buffer[position++] = (byte) ((value >>> 21) & 0x7F | 0x80); + if ((value & ~0x7FFFFFFFFL) == 0) { + buffer[position++] = (byte) (value >>> 28); + } else { + buffer[position++] = (byte) ((value >>> 28) & 0x7F | 0x80); + if ((value & ~0x3FFFFFFFFFFL) == 0) { + buffer[position++] = (byte) (value >>> 35); + } else { + buffer[position++] = (byte) ((value >>> 35) & 0x7F | 0x80); + if ((value & ~0x1FFFFFFFFFFFFL) == 0) { + buffer[position++] = (byte) (value >>> 42); + } else { + buffer[position++] = (byte) ((value >>> 42) & 0x7F | 0x80); + if ((value & ~0xFFFFFFFFFFFFFFL) == 0) { + buffer[position++] = (byte) (value >>> 49); + } else { + buffer[position++] = (byte) ((value >>> 49) & 0x7F | 0x80); + if ((value & ~0x7FFFFFFFFFFFFFFFL) == 0) { + buffer[position++] = (byte) (value >>> 56); + } else { + buffer[position++] = (byte) ((value >>> 56) & 0x7F | 0x80); + buffer[position++] = (byte) (value >>> 63); + } + } + } + } + } + } + } + } + } + } + + public void endLoop() { + position = 0; + } +} diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/varint/writers/SteinbornBlendedByteArray.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/varint/writers/SteinbornBlendedByteArray.java new file mode 100644 index 000000000..f5e591b09 --- /dev/null +++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/varint/writers/SteinbornBlendedByteArray.java @@ -0,0 +1,113 @@ +// SPDX-License-Identifier: Apache-2.0 +package com.hedera.pbj.integration.jmh.varint.writers; + +import com.hedera.pbj.integration.jmh.varint.VarIntWriterBench; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; + +/** + * Varint writer inspired by the "Blended" approach from Andrew Steinborn's varint writing showdown + * (link) adapted for 64-bit + * longs. + * + *
Uses per-size-case branches with direct sequential byte array writes. Avoids ByteBuffer or + * stream overhead; each branch writes only the exact bytes needed for that varint size. + */ +@SuppressWarnings("MismatchedReadAndWriteOfArray") +@State(Scope.Benchmark) +public class SteinbornBlendedByteArray { + private byte[] buffer; + private int position = 0; + + @Setup(Level.Trial) + public void setup() { + buffer = new byte[10 * VarIntWriterBench.NUM_OF_VALUES]; + } + + public void writeVarint(long value) { + if (value < (1L << 7)) { + buffer[position++] = (byte) value; + } else if (value < (1L << 14)) { + buffer[position] = (byte) ((value & 0x7F) | 0x80); + buffer[position + 1] = (byte) (value >>> 7); + position += 2; + } else if (value < (1L << 21)) { + buffer[position] = (byte) ((value & 0x7F) | 0x80); + buffer[position + 1] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[position + 2] = (byte) (value >>> 14); + position += 3; + } else if (value < (1L << 28)) { + buffer[position] = (byte) ((value & 0x7F) | 0x80); + buffer[position + 1] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[position + 2] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[position + 3] = (byte) (value >>> 21); + position += 4; + } else if (value < (1L << 35)) { + buffer[position] = (byte) ((value & 0x7F) | 0x80); + buffer[position + 1] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[position + 2] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[position + 3] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[position + 4] = (byte) (value >>> 28); + position += 5; + } else if (value < (1L << 42)) { + buffer[position] = (byte) ((value & 0x7F) | 0x80); + buffer[position + 1] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[position + 2] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[position + 3] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[position + 4] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[position + 5] = (byte) (value >>> 35); + position += 6; + } else if (value < (1L << 49)) { + buffer[position] = (byte) ((value & 0x7F) | 0x80); + buffer[position + 1] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[position + 2] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[position + 3] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[position + 4] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[position + 5] = (byte) (((value >>> 35) & 0x7F) | 0x80); + buffer[position + 6] = (byte) (value >>> 42); + position += 7; + } else if (value < (1L << 56)) { + buffer[position] = (byte) ((value & 0x7F) | 0x80); + buffer[position + 1] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[position + 2] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[position + 3] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[position + 4] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[position + 5] = (byte) (((value >>> 35) & 0x7F) | 0x80); + buffer[position + 6] = (byte) (((value >>> 42) & 0x7F) | 0x80); + buffer[position + 7] = (byte) (value >>> 49); + position += 8; + } else //noinspection ConstantValue + if (value >= 0) { + // 9 bytes: value in [2^56, Long.MAX_VALUE] + buffer[position] = (byte) ((value & 0x7F) | 0x80); + buffer[position + 1] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[position + 2] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[position + 3] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[position + 4] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[position + 5] = (byte) (((value >>> 35) & 0x7F) | 0x80); + buffer[position + 6] = (byte) (((value >>> 42) & 0x7F) | 0x80); + buffer[position + 7] = (byte) (((value >>> 49) & 0x7F) | 0x80); + buffer[position + 8] = (byte) (value >>> 56); + position += 9; + } else { + // 10 bytes: negative values (signed int64 treated as uint64 by protobuf) + buffer[position] = (byte) ((value & 0x7F) | 0x80); + buffer[position + 1] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[position + 2] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[position + 3] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[position + 4] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[position + 5] = (byte) (((value >>> 35) & 0x7F) | 0x80); + buffer[position + 6] = (byte) (((value >>> 42) & 0x7F) | 0x80); + buffer[position + 7] = (byte) (((value >>> 49) & 0x7F) | 0x80); + buffer[position + 8] = (byte) (((value >>> 56) & 0x7F) | 0x80); + buffer[position + 9] = (byte) (value >>> 63); + position += 10; + } + } + + public void endLoop() { + position = 0; + } +} diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/varint/writers/SteinbornBulkByteArray.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/varint/writers/SteinbornBulkByteArray.java new file mode 100644 index 000000000..dc366f0f6 --- /dev/null +++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/varint/writers/SteinbornBulkByteArray.java @@ -0,0 +1,130 @@ +// SPDX-License-Identifier: Apache-2.0 +package com.hedera.pbj.integration.jmh.varint.writers; + +import com.hedera.pbj.integration.jmh.varint.VarIntWriterBench; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.VarHandle; +import java.nio.ByteOrder; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; + +/** + * Varint writer based on the "Lucky 5" / bulk-write technique from Andrew Steinborn's showdown + * (link) adapted for 64-bit longs. + * + *
Packs multiple encoded varint bytes into a short, int, or long value and writes them with + * a single bulk VarHandle set, reducing the number of individual byte write operations. + * For example, a 4-byte varint is packed into one {@code int} and written in a single operation + * instead of four separate byte writes. + */ +@State(Scope.Benchmark) +public class SteinbornBulkByteArray { + private static final VarHandle SHORT_BE = + MethodHandles.byteArrayViewVarHandle(short[].class, ByteOrder.BIG_ENDIAN); + private static final VarHandle INT_BE = + MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.BIG_ENDIAN); + private static final VarHandle LONG_BE = + MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.BIG_ENDIAN); + + private byte[] buffer; + private int position = 0; + + @Setup(Level.Trial) + public void setup() { + buffer = new byte[10 * VarIntWriterBench.NUM_OF_VALUES]; + } + + public void writeVarint(long value) { + if (value < (1L << 7)) { + buffer[position++] = (byte) value; + } else if (value < (1L << 14)) { + SHORT_BE.set(buffer, position, + (short) (((value & 0x7F) | 0x80) << 8 | (value >>> 7))); + position += 2; + } else if (value < (1L << 21)) { + SHORT_BE.set(buffer, position, + (short) (((value & 0x7F) | 0x80) << 8 | (((value >>> 7) & 0x7F) | 0x80))); + buffer[position + 2] = (byte) (value >>> 14); + position += 3; + } else if (value < (1L << 28)) { + INT_BE.set(buffer, position, + (int) (((value & 0x7F) | 0x80) << 24 + | (((value >>> 7) & 0x7F) | 0x80) << 16 + | (((value >>> 14) & 0x7F) | 0x80) << 8 + | (value >>> 21))); + position += 4; + } else if (value < (1L << 35)) { + INT_BE.set(buffer, position, + (int) (((value & 0x7F) | 0x80) << 24 + | (((value >>> 7) & 0x7F) | 0x80) << 16 + | (((value >>> 14) & 0x7F) | 0x80) << 8 + | (((value >>> 21) & 0x7F) | 0x80))); + buffer[position + 4] = (byte) (value >>> 28); + position += 5; + } else if (value < (1L << 42)) { + INT_BE.set(buffer, position, + (int) (((value & 0x7F) | 0x80) << 24 + | (((value >>> 7) & 0x7F) | 0x80) << 16 + | (((value >>> 14) & 0x7F) | 0x80) << 8 + | (((value >>> 21) & 0x7F) | 0x80))); + SHORT_BE.set(buffer, position + 4, + (short) ((((value >>> 28) & 0x7F) | 0x80) << 8 | (value >>> 35))); + position += 6; + } else if (value < (1L << 49)) { + INT_BE.set(buffer, position, + (int) (((value & 0x7F) | 0x80) << 24 + | (((value >>> 7) & 0x7F) | 0x80) << 16 + | (((value >>> 14) & 0x7F) | 0x80) << 8 + | (((value >>> 21) & 0x7F) | 0x80))); + SHORT_BE.set(buffer, position + 4, + (short) ((((value >>> 28) & 0x7F) | 0x80) << 8 | (((value >>> 35) & 0x7F) | 0x80))); + buffer[position + 6] = (byte) (value >>> 42); + position += 7; + } else if (value < (1L << 56)) { + LONG_BE.set(buffer, position, + ((value & 0x7FL) | 0x80L) << 56 + | (((value >>> 7) & 0x7FL) | 0x80L) << 48 + | (((value >>> 14) & 0x7FL) | 0x80L) << 40 + | (((value >>> 21) & 0x7FL) | 0x80L) << 32 + | (((value >>> 28) & 0x7FL) | 0x80L) << 24 + | (((value >>> 35) & 0x7FL) | 0x80L) << 16 + | (((value >>> 42) & 0x7FL) | 0x80L) << 8 + | (value >>> 49)); + position += 8; + } else //noinspection ConstantValue + if (value >= 0) { + // 9 bytes: value in [2^56, Long.MAX_VALUE] + LONG_BE.set(buffer, position, + ((value & 0x7FL) | 0x80L) << 56 + | (((value >>> 7) & 0x7FL) | 0x80L) << 48 + | (((value >>> 14) & 0x7FL) | 0x80L) << 40 + | (((value >>> 21) & 0x7FL) | 0x80L) << 32 + | (((value >>> 28) & 0x7FL) | 0x80L) << 24 + | (((value >>> 35) & 0x7FL) | 0x80L) << 16 + | (((value >>> 42) & 0x7FL) | 0x80L) << 8 + | (((value >>> 49) & 0x7FL) | 0x80L)); + buffer[position + 8] = (byte) (value >>> 56); + position += 9; + } else { + // 10 bytes: negative long (protobuf treats int64 as uint64) + LONG_BE.set(buffer, position, + ((value & 0x7FL) | 0x80L) << 56 + | (((value >>> 7) & 0x7FL) | 0x80L) << 48 + | (((value >>> 14) & 0x7FL) | 0x80L) << 40 + | (((value >>> 21) & 0x7FL) | 0x80L) << 32 + | (((value >>> 28) & 0x7FL) | 0x80L) << 24 + | (((value >>> 35) & 0x7FL) | 0x80L) << 16 + | (((value >>> 42) & 0x7FL) | 0x80L) << 8 + | (((value >>> 49) & 0x7FL) | 0x80L)); + SHORT_BE.set(buffer, position + 8, + (short) ((((value >>> 56) & 0x7F) | 0x80) << 8 | (value >>> 63))); + position += 10; + } + } + + public void endLoop() { + position = 0; + } +} From d4f26989c3a6f51f8cd580b7368366809455a831 Mon Sep 17 00:00:00 2001 From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com> Date: Mon, 27 Apr 2026 14:17:11 -0700 Subject: [PATCH 2/5] Cleaned up and updated ProtobufObjectBench Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com> --- .../integration/jmh/ProtobufObjectBench.java | 380 ++++++++++++++---- 1 file changed, 294 insertions(+), 86 deletions(-) diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/ProtobufObjectBench.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/ProtobufObjectBench.java index e0cf43b57..29ab888b9 100644 --- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/ProtobufObjectBench.java +++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/ProtobufObjectBench.java @@ -12,6 +12,8 @@ import com.hedera.pbj.runtime.Codec; import com.hedera.pbj.runtime.ParseException; import com.hedera.pbj.runtime.io.buffer.BufferedData; +import com.hedera.pbj.runtime.io.buffer.Bytes; +import com.hedera.pbj.runtime.io.buffer.MemoryData; import com.hedera.pbj.runtime.io.stream.ReadableStreamingData; import com.hedera.pbj.runtime.io.stream.WritableStreamingData; import com.hedera.pbj.test.proto.pbj.Everything; @@ -22,6 +24,7 @@ import java.util.concurrent.TimeUnit; import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.CompilerControl; import org.openjdk.jmh.annotations.Fork; import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; @@ -33,6 +36,28 @@ import org.openjdk.jmh.annotations.Warmup; import org.openjdk.jmh.infra.Blackhole; +/** + * Benchmark matrix for protobuf object serialization and deserialization across all PBJ and + * Google Protobuf IO types. + * + *
Method names encode the full backing-store identity: + *
+ * {parse|write}{Pbj|ProtoC}{WrapperType[BackingDetail]}
+ *
+ *
+ * PBJ backing-store coverage: + *
+ * BufferedDataHeap — BufferedData wrapping a heap ByteBuffer (ByteArrayBufferedData) + * BufferedDataDirect — BufferedData wrapping a direct ByteBuffer (DirectBufferedData) + * MemoryDataHeap — MemoryData backed by MemorySegment.ofArray(byte[]) (heap) + * MemoryDataNative — MemoryData backed by MemorySegment.ofBuffer(directBB) (native) + * MemoryDataOffHeap — MemoryData backed by Arena.ofAuto().allocate() (native) + * Bytes — immutable Bytes wrapping a byte[] (parse only) + * InputStream — ReadableStreamingData over a NonSynchronizedByteArrayInputStream + * OutputStream — WritableStreamingData over a NonSynchronizedByteArrayOutputStream + * ByteArray — raw byte[] via Codec.write(T, byte[], int) (write only) + *+ */ @SuppressWarnings("unused") @Fork(1) @Warmup(iterations = 3, time = 2) @@ -40,7 +65,7 @@ @OutputTimeUnit(TimeUnit.NANOSECONDS) @BenchmarkMode(Mode.AverageTime) public abstract class ProtobufObjectBench
PBJ backing-store coverage: + *
+ * protobuf — Original byte array (parse only) + * Bytes — immutable Bytes wrapping a byte[] (parse only) + *+ */ +@SuppressWarnings("unused") +@Fork(1) +@Warmup(iterations = 3, time = 2) +@Measurement(iterations = 7, time = 2) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@BenchmarkMode(Mode.AverageTime) +public abstract class ProtobufObjectArrayBench
pbjCodec;
+ private ProtobufParseFunction pbjCodec, ProtobufParseFunction