The benchmark mirrors the structure of the Iceberg {@code VariantSerializationBenchmark} so + * that results from the two projects can be compared directly. Parameters are kept identical where + * the APIs permit: + * + *
Unlike the Iceberg benchmark there is no "shredded percent" axis: parquet-java's + * {@link VariantBuilder} constructs unshredded Variant binary directly; shredding is handled + * separately by the Parquet writer layer. + * + *
Build and run: + * + *
+ * ./mvnw --projects parquet-benchmarks -amd -DskipTests -Denforcer.skip=true clean package + * ./parquet-benchmarks/run.sh all org.apache.parquet.benchmarks.VariantBenchmark \ + * -wi 5 -i 5 -f 1 -rff /tmp/variant-benchmark.json + *+ * + * Change fork to 1 before merge + */ +@Fork(0) +@State(Scope.Benchmark) +@Warmup(iterations = 100) +@Measurement(iterations = 100) +@BenchmarkMode(Mode.SingleShotTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@Timeout(time = 10, timeUnit = TimeUnit.MINUTES) +public class VariantBenchmark { + + /** Whether to include nested sub-objects in the field values. */ + public enum Depth { + Shallow, + Nested + } + + /** + * Iterations on the small benchmarks whose operations are so fast that clocks, especially ARM clocks, + * can't reliably measure them. + */ + private static final int ITERATIONS = 100; + + /** Total number of top-level fields in each variant object. */ + @Param({"1000", "10000"}) + private int fieldCount; + + /** Whether to include nested variant objects as some of the field values. */ + @Param({"Shallow", "Nested"}) + private Depth depth; + + /** + * A counter of strings created; used to ensure limited uniqueness in strings. + */ + private static int counter; + + /** + * Get a count value. + * @return a new value. + */ + private static int count() { + int c = counter++; + if (c >= 512) { + c = 0; + } + return c; + } + /** + * Type of a field and the operations to (a) append an instance of that type to + * the variant builder and (b) add the type to a GroupBuilder. + */ + private enum FieldType { + String((o, builder) -> builder.appendString(((String) o) + count()), b -> b.optional(PrimitiveTypeName.BINARY) + .as(LogicalTypeAnnotation.stringType()) + .named("typed_value")), + Int((o, builder) -> builder.appendInt((Integer) o), b -> b.optional(PrimitiveTypeName.INT32) + .named("typed_value")), + Long((o, builder) -> builder.appendLong((Long) o), b -> b.optional(PrimitiveTypeName.INT64) + .named("typed_value")), + Float((o, builder) -> builder.appendFloat((Float) o), b -> b.optional(PrimitiveTypeName.FLOAT) + .named("typed_value")), + Double((o, builder) -> builder.appendDouble((Double) o), b -> b.optional(PrimitiveTypeName.DOUBLE) + .named("typed_value")), + BigDecimal((o, builder) -> builder.appendDecimal((BigDecimal) o), b -> b.optional(PrimitiveTypeName.INT32) + .as(LogicalTypeAnnotation.decimalType(0, 9)) + .named("typed_value")), + UUID((o, builder) -> builder.appendUUID((UUID) o), b -> b.optional(PrimitiveTypeName.FIXED_LEN_BYTE_ARRAY) + .length(16) + .as(LogicalTypeAnnotation.uuidType()) + .named("typed_value")), + /** Nested MUST be the last in the enum. */ + Nested( + (o, builder) -> { + throw new UnsupportedOperationException("Nested object"); + }, + b -> { + /* falls back to value column */ + }); + + /** + * Append an object during variant construction. + */ + final BiConsumer
Field values are pre-decided (type tags + numeric arrays) so benchmark methods are free of
+ * allocation and RNG cost outside what VariantBuilder itself does.
+ */
+ @Setup(Level.Trial)
+ public void setupTrial() {
+ random = new Random(0x1ceb1cebL);
+
+ // --- field names ---
+ fieldNames = new ArrayList<>(fieldCount);
+ for (int i = 0; i < fieldCount; i++) {
+ fieldNames.add("field_" + i);
+ }
+
+ // --- pre-generate typed values ---
+ // Type distribution: biased towards strings.
+
+ int typeCount = FieldType.Nested.ordinal();
+ if (depth != Depth.Nested) {
+ typeCount--;
+ }
+
+ List Because {@link Variant#getValueBuffer()} returns the existing buffer, this benchmark
+ * primarily measures the ByteBuffer access and the Blackhole overhead..
+ */
+ @Benchmark
+ public void benchmarkSerialize(Blackhole bh) {
+ // duplicate() gives an independent position/limit on the same backing array –
+ for (int i = 0; i < ITERATIONS; i++) {
+ // equivalent to the Iceberg benchmark's outputBuffer.clear() + writeTo() pattern.
+ ByteBuffer value = preBuiltVariant.getValueBuffer().duplicate();
+ ByteBuffer meta = preBuiltVariant.getMetadataBuffer().duplicate();
+ bh.consume(value);
+ bh.consume(meta);
+ }
+ }
+
+ /**
+ * Read path: iterate all fields of the pre-built variant, extracting each value. This exercises
+ * the field-name lookup and type dispatch that a query engine performs on every row.
+ */
+ @Benchmark
+ public void benchmarkDeserialize(Blackhole bh) {
+ for (int j = 0; j < ITERATIONS; j++) {
+ Variant v = preBuiltVariant;
+ int n = v.numObjectElements();
+ for (int i = 0; i < n; i++) {
+ Variant.ObjectField field = v.getFieldAtIndex(i);
+ bh.consume(field.key);
+ bh.consume(field.value.getValueBuffer());
+ }
+ }
+ }
+
+ /**
+ * Shred the pre-built variant into a fully typed schema. Measures the cost of type dispatch,
+ * field matching, and recursive decomposition that {@link VariantValueWriter} perform
+ */
+ @Benchmark
+ public void writeShredded(Blackhole bh) {
+ for (int i = 0; i < ITERATIONS; i++) {
+ VariantValueWriter.write(noopConsumer, shreddedSchema, preBuiltVariant);
+ bh.consume(noopConsumer);
+ }
+ }
+
+ /**
+ * Write the pre-built variant to an unshredded schema (metadata + value only).
+ * This is the baseline: the entire variant is written as a single binary blob.
+ * Compare with {@link #writeShredded} to see the cost of shredding.
+ */
+ @Benchmark
+ public void writeUnshredded(Blackhole bh) {
+ for (int i = 0; i < ITERATIONS; i++) {
+ VariantValueWriter.write(noopConsumer, unshreddedSchema, preBuiltVariant);
+ bh.consume(noopConsumer);
+ }
+ }
+
+ // ------------------------------------------------------------------
+ // Internal helpers
+ // ------------------------------------------------------------------
+
+ /**
+ * Build a complete Variant object from the pre-decided field types. This is the core logic shared
+ * between {@link #benchmarkBuildVariant} and setup..
+ */
+ private Variant buildVariant() {
+ VariantBuilder builder = new VariantBuilder();
+ VariantObjectBuilder ob = builder.startObject();
+
+ for (int i = 0; i < fieldCount; i++) {
+ ob.appendKey(fieldNames.get(i));
+ appendFieldValue(ob, i);
+ }
+
+ builder.endObject();
+ return builder.build();
+ }
+
+ /**
+ * Append the value for field {@code i} to {@code ob} according to its type, building nested objects on demand.
+ */
+ private void appendFieldValue(VariantObjectBuilder ob, int i) {
+ final FieldEntry entry = fieldValues[i];
+ // special handling of nested.
+ if (entry.type == FieldType.Nested) {
+ if (depth == Depth.Nested && stringFieldCount > 0) {
+ appendNestedObject(ob, i);
+ } else {
+ // outlier.
+ ob.appendNull();
+ }
+ } else {
+ entry.type.append(entry.value, ob);
+ }
+ }
+
+ /**
+ * Append a nested sub-object with {@link #NESTED_FIELD_COUNT} string fields. Field names are
+ * drawn from the set of top-level string fields so the nested dictionary overlaps with the parent.
+ */
+ private void appendNestedObject(VariantObjectBuilder parentOb, int parentIndex) {
+ // VariantObjectBuilder does not expose startObject() for nesting directly;
+ // build the nested variant separately and embed it as an encoded value.
+ VariantBuilder nestedBuilder = new VariantBuilder();
+ VariantObjectBuilder nestedOb = nestedBuilder.startObject();
+
+ for (int j = 0; j < NESTED_FIELD_COUNT; j++) {
+ int nameIdx = stringFieldIndices[random.nextInt(stringFieldCount)];
+ nestedOb.appendKey(fieldNames.get(nameIdx));
+ nestedOb.appendString("nested_" + parentIndex + "_" + j);
+ }
+
+ nestedBuilder.endObject();
+ Variant nested = nestedBuilder.build();
+ // embed the nested value buffer directly
+ parentOb.appendEncodedValue(nested.getValueBuffer());
+ }
+
+ /**
+ * Build a shredded schema with typed_value columns matching each field's type.
+ * For nested fields, the typed_value is an object group with string sub-fields.
+ */
+ private GroupType buildShreddedSchema() {
+ Types.GroupBuilder