Don't use so many partitions in the benchmarks.

tobixdev · tobixdev · commit 34cc43c06337 · 2025-06-11T15:11:40.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/lib/encoding/Cargo.toml b/lib/encoding/Cargo.toml
@@ -8,11 +8,15 @@ rust-version.workspace = true
 
 [dependencies]
 rdf-fusion-common.workspace = true
-rdf-fusion-functions-scalar.workspace = true
 rdf-fusion-model.workspace = true
 datafusion.workspace = true
-thiserror.workspace = true
-uuid.workspace = true
+
+[dev-dependencies]
+codspeed-criterion-compat = { workspace = true, features = ["async_tokio"] }
 
 [lints]
 workspace = true
+
+[[bench]]
+name = "builders"
+harness = false
diff --git a/lib/encoding/benches/builders.rs b/lib/encoding/benches/builders.rs
@@ -0,0 +1,95 @@
+#![allow(clippy::panic)]
+
+use codspeed_criterion_compat::{criterion_group, criterion_main, Criterion};
+use rdf_fusion_encoding::plain_term::PlainTermArrayBuilder;
+use rdf_fusion_encoding::sortable_term::SortableTermArrayBuilder;
+use rdf_fusion_encoding::typed_value::TypedValueArrayBuilder;
+use rdf_fusion_model::{NamedNodeRef, TermRef};
+use std::hint::black_box;
+
+/// These benchmarks measure instantiating [PlainTermArrayBuilder].
+fn plain_term_builder_new(c: &mut Criterion) {
+    c.bench_function("PlainTermArrayBuilder::new - Create empty builder", |b| {
+        b.iter(|| black_box(PlainTermArrayBuilder::new(0)));
+    });
+
+    c.bench_function(
+        "PlainTermArrayBuilder::new - Create record batch builder",
+        |b| {
+            b.iter(|| black_box(PlainTermArrayBuilder::new(8192)));
+        },
+    );
+}
+
+/// These benchmarks measure encoding quads and finishing the builder for [PlainTermArrayBuilder].
+fn plain_term_builder_build_array(c: &mut Criterion) {
+    c.bench_function(
+        "PlainTermArrayBuilder::append_term - With empty builder",
+        |b| {
+            b.iter(|| {
+                let mut builder = PlainTermArrayBuilder::new(0);
+                for _ in 0..8192 {
+                    builder.append_term(TermRef::NamedNode(NamedNodeRef::new_unchecked(
+                        "http://example.com/test",
+                    )))
+                }
+                let result = builder.finish();
+                assert_eq!(result.len(), 8192);
+            });
+        },
+    );
+    c.bench_function(
+        "PlainTermArrayBuilder::append_term - With pre-allocated builder",
+        |b| {
+            b.iter(|| {
+                let mut builder = PlainTermArrayBuilder::new(8192);
+                for _ in 0..8192 {
+                    builder.append_term(TermRef::NamedNode(NamedNodeRef::new_unchecked(
+                        "http://example.com/test",
+                    )))
+                }
+                let result = builder.finish();
+                assert_eq!(result.len(), 8192);
+            });
+        },
+    );
+}
+
+/// These benchmarks measure instantiating [SortableTermArrayBuilder].
+fn sortable_term_builder_new(c: &mut Criterion) {
+    c.bench_function(
+        "SortableTermArrayBuilder::new - Create empty builder",
+        |b| {
+            b.iter(|| black_box(SortableTermArrayBuilder::new(0)));
+        },
+    );
+    c.bench_function(
+        "SortableTermArrayBuilder::new - Create record batch builder",
+        |b| {
+            b.iter(|| black_box(SortableTermArrayBuilder::new(8192)));
+        },
+    );
+}
+
+/// These benchmarks measure instantiating [TypedValueArrayBuilder].
+fn typed_value_builder_default(c: &mut Criterion) {
+    c.bench_function(
+        "TypedValueArrayBuilder::default - Create empty builder",
+        |b| {
+            b.iter(|| black_box(TypedValueArrayBuilder::default()));
+        },
+    );
+}
+
+criterion_group!(
+    plain_term_builder,
+    plain_term_builder_new,
+    plain_term_builder_build_array
+);
+criterion_group!(sortable_term_builder, sortable_term_builder_new);
+criterion_group!(typed_value_array_builder, typed_value_builder_default);
+criterion_main!(
+    plain_term_builder,
+    sortable_term_builder,
+    typed_value_array_builder
+);
diff --git a/lib/rdf-fusion/benches/store.rs b/lib/rdf-fusion/benches/store.rs
@@ -21,59 +21,41 @@ fn store_load(c: &mut Criterion) {
     });
 }
 
-/// This benchmarks measure the duration of running a simple query (1 triple pattern). Hopefully,
+/// These benchmarks measure the duration of running a simple query (1 triple pattern). Hopefully,
 /// this can provide insights into the "baseline" overhead of the query engine.
 fn store_single_pattern(c: &mut Criterion) {
     let runtime = Builder::new_current_thread().enable_all().build().unwrap();
 
     // No Quads
     c.bench_function("Store::query - Single Pattern / No Quads", |b| {
         let store = runtime.block_on(prepare_store_with_generated_triples(0));
-        b.to_async(&runtime)
-            .iter(|| async { trivial_query(&store, 0).await });
+        b.to_async(&runtime).iter(|| trivial_query(&store, 0));
     });
     // One Quad
     c.bench_function("Store::query - Single Pattern / Single Quad", |b| {
         let store = runtime.block_on(prepare_store_with_generated_triples(1));
-        b.to_async(&runtime)
-            .iter(|| async { trivial_query(&store, 1).await });
+        b.to_async(&runtime).iter(|| trivial_query(&store, 1));
     });
     // One Record Batch
-    c.bench_function("Store::query - Single Pattern / 8096 Quads", |b| {
-        let store = runtime.block_on(prepare_store_with_generated_triples(8096));
-        b.to_async(&runtime)
-            .iter(|| async { trivial_query(&store, 8096).await });
+    c.bench_function("Store::query - Single Pattern / 8192 Quads", |b| {
+        let store = runtime.block_on(prepare_store_with_generated_triples(8192));
+        b.to_async(&runtime).iter(|| trivial_query(&store, 8192));
     });
 }
 
-/// This benchmarks measure the duration of running a simple query that fixes a single part of the
+/// These benchmarks measure the duration of running a simple query that fixes a single part of the
 /// pattern (i.e., subject, predicate, object, graph).
 fn store_single_pattern_with_fixed_element(c: &mut Criterion) {
     let runtime = Builder::new_current_thread().enable_all().build().unwrap();
 
-    // Graph
-    c.bench_function(
-        "Store::query - Single Pattern With Fixed Element (graph)",
-        |b| {
-            let store = runtime.block_on(prepare_store_with_generated_triples(8096));
-            b.to_async(&runtime).iter(|| async {
-                let result = store
-                    .query("SELECT ?s ?p ?o { GRAPH <http://example.com/graph0> { ?s ?p ?o } }")
-                    .await
-                    .unwrap();
-                assert_number_of_results(result, 1).await;
-            });
-        },
-    );
-
     // Subject
     c.bench_function(
         "Store::query - Single Pattern With Fixed Element (subject)",
         |b| {
-            let store = runtime.block_on(prepare_store_with_generated_triples(8096));
+            let store = runtime.block_on(prepare_store_with_generated_triples(8192));
             b.to_async(&runtime).iter(|| async {
                 let result = store
-                    .query("SELECT ?g ?p ?o { GRAPH ?g { <http://example.com/subject0> ?p ?o } }")
+                    .query("SELECT ?p ?o { <http://example.com/subject0> ?p ?o }")
                     .await
                     .unwrap();
                 assert_number_of_results(result, 1).await;
@@ -85,10 +67,10 @@ fn store_single_pattern_with_fixed_element(c: &mut Criterion) {
     c.bench_function(
         "Store::query - Single Pattern With Fixed Element (predicate)",
         |b| {
-            let store = runtime.block_on(prepare_store_with_generated_triples(8096));
+            let store = runtime.block_on(prepare_store_with_generated_triples(8192));
             b.to_async(&runtime).iter(|| async {
                 let result = store
-                    .query("SELECT ?g ?s ?o { GRAPH ?g { ?s <http://example.com/predicate0> ?o } }")
+                    .query("SELECT ?s ?o { ?s <http://example.com/predicate0> ?o }")
                     .await
                     .unwrap();
                 assert_number_of_results(result, 1).await;
@@ -100,10 +82,10 @@ fn store_single_pattern_with_fixed_element(c: &mut Criterion) {
     c.bench_function(
         "Store::query - Single Pattern With Fixed Element (object)",
         |b| {
-            let store = runtime.block_on(prepare_store_with_generated_triples(8096));
+            let store = runtime.block_on(prepare_store_with_generated_triples(8192));
             b.to_async(&runtime).iter(|| async {
                 let result = store
-                    .query("SELECT ?g ?s ?p { GRAPH ?g { ?s ?p <http://example.com/object0> } }")
+                    .query("SELECT ?s ?p { ?s ?p <http://example.com/object0> }")
                     .await
                     .unwrap();
                 assert_number_of_results(result, 1).await;
@@ -130,24 +112,20 @@ async fn prepare_store_with_generated_triples(n: usize) -> Store {
 
 fn generate_quads(count: usize) -> impl Iterator<Item = Quad> {
     (0..count).map(|i| {
-        let graph = format!("http://example.com/graph{}", i);
         let subject = format!("http://example.com/subject{}", i);
         let predicate = format!("http://example.com/predicate{}", i);
         let object = format!("http://example.com/object{}", i);
         Quad::new(
             Subject::NamedNode(NamedNode::new_unchecked(subject)),
             NamedNode::new_unchecked(predicate),
             Term::NamedNode(NamedNode::new_unchecked(object)),
-            GraphName::NamedNode(NamedNode::new_unchecked(graph)),
+            GraphName::DefaultGraph,
         )
     })
 }
 
 async fn trivial_query(store: &Store, n: usize) {
-    let result = store
-        .query("SELECT ?s ?p ?o { GRAPH ?g { ?s ?p ?o } }")
-        .await
-        .unwrap();
+    let result = store.query("SELECT ?s ?p ?o { ?s ?p ?o }").await.unwrap();
     assert_number_of_results(result, n).await;
 }
 
diff --git a/lib/storage/src/oxigraph_memory/planner.rs b/lib/storage/src/oxigraph_memory/planner.rs
@@ -89,6 +89,7 @@ impl ExtensionPlanner for OxigraphMemoryQuadNodePlanner {
         }
     }
 }
+
 #[async_trait]
 impl QuadPatternEvaluator for MemoryStorageReader {
     fn quads_for_pattern(
diff --git a/lib/storage/src/oxigraph_memory/quad_storage_stream.rs b/lib/storage/src/oxigraph_memory/quad_storage_stream.rs
@@ -37,19 +37,24 @@ impl Stream for QuadIteratorBatchRecordStream {
         mut self: std::pin::Pin<&mut Self>,
         _ctx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        let mut rb_builder = RdfQuadsRecordBatchBuilder::new();
+        // Early return if the iterator is empty
+        let Some(first_quad) = self.iterator.next() else {
+            return Poll::Ready(None);
+        };
 
-        while let Some(quad) = self.iterator.next() {
-            rb_builder.encode_quad(&quad);
-            if rb_builder.count() == self.batch_size {
+        let mut rb_builder = RdfQuadsRecordBatchBuilder::new(self.batch_size);
+        rb_builder.encode_quad(&first_quad);
+
+        for _ in 0..(self.batch_size - 1) {
+            let Some(quad) = self.iterator.next() else {
                 break;
-            }
+            };
+            rb_builder.encode_quad(&quad);
         }
 
         let record_batch = rb_builder.finish();
         match record_batch {
-            Ok(Some(rb)) => Poll::Ready(Some(Ok(rb))),
-            Ok(None) => Poll::Ready(None),
+            Ok(rb) => Poll::Ready(Some(Ok(rb))),
             Err(err) => Poll::Ready(Some(Err(DataFusionError::External(Box::new(err))))),
         }
     }
@@ -71,20 +76,16 @@ struct RdfQuadsRecordBatchBuilder {
 }
 
 impl RdfQuadsRecordBatchBuilder {
-    fn new() -> Self {
+    fn new(capacity: usize) -> Self {
         Self {
-            graph: PlainTermArrayBuilder::new(0),
-            subject: PlainTermArrayBuilder::new(0),
-            predicate: PlainTermArrayBuilder::new(0),
-            object: PlainTermArrayBuilder::new(0),
+            graph: PlainTermArrayBuilder::new(capacity),
+            subject: PlainTermArrayBuilder::new(capacity),
+            predicate: PlainTermArrayBuilder::new(capacity),
+            object: PlainTermArrayBuilder::new(capacity),
             count: 0,
         }
     }
 
-    fn count(&self) -> usize {
-        self.count
-    }
-
     fn encode_quad(&mut self, quad: &EncodedQuad) {
         encode_term(&mut self.graph, &quad.graph_name);
         encode_term(&mut self.subject, &quad.subject);
@@ -93,11 +94,7 @@ impl RdfQuadsRecordBatchBuilder {
         self.count += 1;
     }
 
-    fn finish(self) -> AResult<Option<RecordBatch>> {
-        if self.count == 0 {
-            return Ok(None);
-        }
-
+    fn finish(self) -> AResult<RecordBatch> {
         let fields: Vec<Arc<dyn Array>> = vec![
             Arc::new(self.graph.finish()),
             Arc::new(self.subject.finish()),
@@ -108,7 +105,7 @@ impl RdfQuadsRecordBatchBuilder {
         let options = RecordBatchOptions::default().with_row_count(Some(self.count));
         let record_batch =
             RecordBatch::try_new_with_options(Arc::clone(&DEFAULT_QUAD_SCHEMA), fields, &options)?;
-        Ok(Some(record_batch))
+        Ok(record_batch)
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,7 @@ impl ExtensionPlanner for OxigraphMemoryQuadNodePlanner {`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`}`
	`92`	`+`
`92`	`93`	`#[async_trait]`
`93`	`94`	`impl QuadPatternEvaluator for MemoryStorageReader {`
`94`	`95`	`fn quads_for_pattern(`