bench: Add a benchmark for EventCacheStore::load_all_chunks_metadata.

Author: Hywan

benchmarks/benches/linked_chunk.rs

@@ -187,11 +187,14 @@ fn reading(c: &mut Criterion) {
 
                 while events.peek().is_some() {
                     let events_chunk = events.by_ref().take(80).collect::<Vec<_>>();
+
                     if events_chunk.is_empty() {
                         break;
                     }
+
                     lc.push_items_back(events_chunk);
                     lc.push_gap_back(Gap { prev_token: format!("gap{num_gaps}") });
+
                     num_gaps += 1;
                 }
 
@@ -205,30 +208,47 @@ fn reading(c: &mut Criterion) {
             // Define the throughput.
             group.throughput(Throughput::Elements(num_events));
 
-            // Get a bencher.
-            group.bench_function(BenchmarkId::new(store_name, num_events), |bencher| {
-                // Bench the routine.
-                bencher.to_async(&runtime).iter(|| async {
-                    // Load the last chunk first,
-                    let (last_chunk, chunk_id_gen) =
-                        store.load_last_chunk(linked_chunk_id).await.unwrap();
-
-                    let mut lc =
-                        lazy_loader::from_last_chunk::<128, _, _>(last_chunk, chunk_id_gen)
-                            .expect("no error when reconstructing the linked chunk")
-                            .expect("there is a linked chunk in the store");
-
-                    // Then load until the start of the linked chunk.
-                    let mut cur_chunk_id = lc.chunks().next().unwrap().identifier();
-                    while let Some(prev) =
-                        store.load_previous_chunk(linked_chunk_id, cur_chunk_id).await.unwrap()
-                    {
-                        cur_chunk_id = prev.identifier;
-                        lazy_loader::insert_new_first_chunk(&mut lc, prev)
-                            .expect("no error when linking the previous lazy-loaded chunk");
-                    }
-                })
-            });
+            // Bench the lazy loader.
+            group.bench_function(
+                BenchmarkId::new(format!("lazy_loader/{store_name}"), num_events),
+                |bencher| {
+                    // Bench the routine.
+                    bencher.to_async(&runtime).iter(|| async {
+                        // Load the last chunk first,
+                        let (last_chunk, chunk_id_gen) =
+                            store.load_last_chunk(linked_chunk_id).await.unwrap();
+
+                        let mut lc =
+                            lazy_loader::from_last_chunk::<128, _, _>(last_chunk, chunk_id_gen)
+                                .expect("no error when reconstructing the linked chunk")
+                                .expect("there is a linked chunk in the store");
+
+                        // Then load until the start of the linked chunk.
+                        let mut cur_chunk_id = lc.chunks().next().unwrap().identifier();
+                        while let Some(prev) =
+                            store.load_previous_chunk(linked_chunk_id, cur_chunk_id).await.unwrap()
+                        {
+                            cur_chunk_id = prev.identifier;
+                            lazy_loader::insert_new_first_chunk(&mut lc, prev)
+                                .expect("no error when linking the previous lazy-loaded chunk");
+                        }
+                    })
+                },
+            );
+
+            // Bench the metadata loader.
+            group.bench_function(
+                BenchmarkId::new(format!("metadata/{store_name}"), num_events),
+                |bencher| {
+                    // Bench the routine.
+                    bencher.to_async(&runtime).iter(|| async {
+                        let _metadata = store
+                            .load_all_chunks_metadata(linked_chunk_id)
+                            .await
+                            .expect("metadata must load");
+                    })
+                },
+            );
 
             {
                 let _guard = runtime.enter();