feat: update benchmarks for wide JSON decoding and projection with increased row and batch sizes

Author: Weijun-H

arrow-json/benches/binary_hex.rs

@@ -21,14 +21,15 @@ use criterion::{Criterion, criterion_group, criterion_main};
 use std::hint::black_box;
 use std::sync::Arc;
 
-const BINARY_ROWS: usize = 1 << 15;
+const BINARY_ROWS: usize = 1 << 17;
 const BINARY_BYTES: usize = 64;
+const BINARY_BATCH_SIZE: usize = 1 << 13;
 
-fn bench_decode(c: &mut Criterion, name: &str, data: &[u8], field: Arc<Field>, rows: usize) {
+fn bench_decode(c: &mut Criterion, name: &str, data: &[u8], field: Arc<Field>) {
     c.bench_function(name, |b| {
         b.iter(|| {
             let mut decoder = ReaderBuilder::new_with_field(field.clone())
-                .with_batch_size(rows)
+                .with_batch_size(BINARY_BATCH_SIZE)
                 .build_decoder()
                 .unwrap();
 
@@ -72,35 +73,17 @@ fn criterion_benchmark(c: &mut Criterion) {
     let binary_data = build_hex_lines(BINARY_ROWS, BINARY_BYTES);
 
     let binary_field = Arc::new(Field::new("item", DataType::Binary, false));
-    bench_decode(
-        c,
-        "decode_binary_hex_json",
-        &binary_data,
-        binary_field,
-        BINARY_ROWS,
-    );
+    bench_decode(c, "decode_binary_hex_json", &binary_data, binary_field);
 
     let fixed_field = Arc::new(Field::new(
         "item",
         DataType::FixedSizeBinary(BINARY_BYTES as i32),
         false,
     ));
-    bench_decode(
-        c,
-        "decode_fixed_binary_hex_json",
-        &binary_data,
-        fixed_field,
-        BINARY_ROWS,
-    );
+    bench_decode(c, "decode_fixed_binary_hex_json", &binary_data, fixed_field);
 
     let view_field = Arc::new(Field::new("item", DataType::BinaryView, false));
-    bench_decode(
-        c,
-        "decode_binary_view_hex_json",
-        &binary_data,
-        view_field,
-        BINARY_ROWS,
-    );
+    bench_decode(c, "decode_binary_view_hex_json", &binary_data, view_field);
 }
 
 criterion_group!(benches, criterion_benchmark);

arrow-json/benches/wide_object.rs

@@ -22,6 +22,9 @@ use serde_json::{Map, Number, Value};
 use std::fmt::Write;
 use std::sync::Arc;
 
+const WIDE_ROWS: usize = 1 << 17; // 128K rows
+const WIDE_BATCH_SIZE: usize = 1 << 13; // 8K rows per batch
+
 fn build_schema(field_count: usize) -> Arc<Schema> {
     // Builds a schema with fields named f0..f{field_count-1}, all Int64 and non-nullable.
     let fields: Vec<Field> = (0..field_count)
@@ -67,15 +70,15 @@ fn build_wide_values(rows: usize, fields: usize) -> Vec<Value> {
 }
 
 fn bench_decode_wide_object(c: &mut Criterion) {
-    let rows = 4096;
+    let rows = WIDE_ROWS;
     let fields = 64;
     let data = build_wide_json(rows, fields);
     let schema = build_schema(fields);
 
     c.bench_function("decode_wide_object_i64_json", |b| {
         b.iter(|| {
             let mut decoder = ReaderBuilder::new(schema.clone())
-                .with_batch_size(1024)
+                .with_batch_size(WIDE_BATCH_SIZE)
                 .build_decoder()
                 .unwrap();
 
@@ -93,15 +96,15 @@ fn bench_decode_wide_object(c: &mut Criterion) {
 }
 
 fn bench_serialize_wide_object(c: &mut Criterion) {
-    let rows = 4096;
+    let rows = WIDE_ROWS;
     let fields = 64;
     let values = build_wide_values(rows, fields);
     let schema = build_schema(fields);
 
     c.bench_function("decode_wide_object_i64_serialize", |b| {
         b.iter(|| {
             let mut decoder = ReaderBuilder::new(schema.clone())
-                .with_batch_size(1024)
+                .with_batch_size(WIDE_BATCH_SIZE)
                 .build_decoder()
                 .unwrap();
 

arrow-json/benches/wide_projection.rs

@@ -25,8 +25,9 @@ use std::hint::black_box;
 use std::sync::Arc;
 
 // Projection benchmark constants
-const WIDE_PROJECTION_ROWS: usize = 1 << 14; // 16K rows
+const WIDE_PROJECTION_ROWS: usize = 1 << 17; // 128K rows
 const WIDE_PROJECTION_TOTAL_FIELDS: usize = 100; // 100 fields total, select only 3
+const WIDE_PROJECTION_BATCH_SIZE: usize = 1 << 13; // 8K rows per batch
 
 fn bench_decode_schema(
     c: &mut Criterion,
@@ -45,7 +46,8 @@ fn bench_decode_schema(
     group.bench_function(BenchmarkId::from_parameter(rows), |b| {
         b.iter(|| {
             let mut decoder = ReaderBuilder::new(schema.clone())
-                .with_batch_size(rows)
+                .with_batch_size(WIDE_PROJECTION_BATCH_SIZE)
+                .with_projection(projection)
                 .build_decoder()
                 .unwrap();