tests: Rename some more benchmarks

Author: poljar

benchmarks/benches/event_cache.rs

@@ -24,7 +24,7 @@ fn handle_room_updates(c: &mut Criterion) {
         .build()
         .expect("Failed to create an asynchronous runtime");
 
-    let mut group = c.benchmark_group("reading");
+    let mut group = c.benchmark_group("Event cache room updates");
     group.sample_size(10);
 
     const NUM_EVENTS: usize = 1000;
@@ -50,9 +50,9 @@ fn handle_room_updates(c: &mut Criterion) {
         // Declare new stores for this set of events.
         let sqlite_temp_dir = tempdir().unwrap();
         let stores = vec![
-            ("memory store", MemoryStore::default().into_event_cache_store()),
+            ("memory", MemoryStore::default().into_event_cache_store()),
             (
-                "sqlite store",
+                "SQLite",
                 runtime.block_on(async {
                     SqliteEventCacheStore::open(sqlite_temp_dir.path().join("bench"), None)
                         .await
@@ -70,7 +70,10 @@ fn handle_room_updates(c: &mut Criterion) {
 
             // Bench the handling of room updates.
             group.bench_function(
-                BenchmarkId::new(format!("handle_room_updates/{store_name}"), num_rooms),
+                BenchmarkId::new(
+                    format!("Event cache room updates[{store_name}]"),
+                    format!("room count: {num_rooms}"),
+                ),
                 |bencher| {
                     // Ideally we'd use `iter_with_setup` here, but it doesn't allow an async setup
                     // (which we need to setup the client), see also

benchmarks/benches/linked_chunk.rs

@@ -37,7 +37,7 @@ fn writing(c: &mut Criterion) {
     let linked_chunk_id = LinkedChunkId::Room(room_id);
     let event_factory = EventFactory::new().room(room_id).sender(&ALICE);
 
-    let mut group = c.benchmark_group("writing");
+    let mut group = c.benchmark_group("Linked chunk writing");
     group.sample_size(10).measurement_time(Duration::from_secs(30));
 
     for &number_of_events in NUMBER_OF_EVENTS {
@@ -101,7 +101,7 @@ fn writing(c: &mut Criterion) {
 
             // Get a bencher.
             group.bench_with_input(
-                BenchmarkId::new(store_name, number_of_events),
+                BenchmarkId::new(format!("Linked chunk writing [{store_name}]"), number_of_events),
                 &operations,
                 |bencher, operations| {
                     // Bench the routine.
@@ -154,7 +154,7 @@ fn reading(c: &mut Criterion) {
     let linked_chunk_id = LinkedChunkId::Room(room_id);
     let event_factory = EventFactory::new().room(room_id).sender(&ALICE);
 
-    let mut group = c.benchmark_group("reading");
+    let mut group = c.benchmark_group("Linked chunk reading");
     group.sample_size(10);
 
     for &num_events in NUMBER_OF_EVENTS {
@@ -215,7 +215,7 @@ fn reading(c: &mut Criterion) {
 
             // Bench the lazy loader.
             group.bench_function(
-                BenchmarkId::new(format!("lazy_loader/{store_name}"), num_events),
+                BenchmarkId::new(format!("Linked chunk lazy loader[{store_name}]"), num_events),
                 |bencher| {
                     // Bench the routine.
                     bencher.to_async(&runtime).iter(|| async {
@@ -243,7 +243,7 @@ fn reading(c: &mut Criterion) {
 
             // Bench the metadata loader.
             group.bench_function(
-                BenchmarkId::new(format!("metadata/{store_name}"), num_events),
+                BenchmarkId::new(format!("Linked chunk metadata loader[{store_name}]"), num_events),
                 |bencher| {
                     // Bench the routine.
                     bencher.to_async(&runtime).iter(|| async {

benchmarks/benches/room_bench.rs

@@ -85,7 +85,7 @@ pub fn receive_all_members_benchmark(c: &mut Criterion) {
     group.throughput(Throughput::Elements(count as u64));
     group.sample_size(50);
 
-    group.bench_function(BenchmarkId::new("receive_members", name), |b| {
+    group.bench_function(BenchmarkId::new("Handle /members request [SQLite]", name), |b| {
         b.to_async(&runtime).iter(|| async {
             base_client.receive_all_members(&room_id, &request, &response).await.unwrap();
         });
@@ -165,11 +165,11 @@ pub fn load_pinned_events_benchmark(c: &mut Criterion) {
 
     let count = PINNED_EVENTS_COUNT;
     let name = format!("{count} pinned events");
-    let mut group = c.benchmark_group("Test");
+    let mut group = c.benchmark_group("Load pinned events");
     group.throughput(Throughput::Elements(count as u64));
     group.sample_size(10);
 
-    group.bench_function(BenchmarkId::new("load_pinned_events", name), |b| {
+    group.bench_function(BenchmarkId::new("Load pinned events [memory]", name), |b| {
         b.to_async(&runtime).iter(|| async {
             let pinned_event_ids = room.pinned_event_ids().unwrap_or_default();
             assert!(!pinned_event_ids.is_empty());

benchmarks/benches/store_bench.rs

@@ -45,13 +45,11 @@ pub fn restore_session(c: &mut Criterion) {
     let mut group = c.benchmark_group("Client reload");
     group.throughput(Throughput::Elements(100));
 
-    const NAME: &str = "restore a session";
-
     // Memory
     let mem_store = Arc::new(MemoryStore::new());
     runtime.block_on(mem_store.save_changes(&changes)).expect("initial filling of mem failed");
 
-    group.bench_with_input(BenchmarkId::new("memory store", NAME), &mem_store, |b, store| {
+    group.bench_with_input("Restore session [memory store]", &mem_store, |b, store| {
         b.to_async(&runtime).iter(|| async {
             let client = Client::builder()
                 .homeserver_url("https://matrix.example.com")
@@ -79,7 +77,7 @@ pub fn restore_session(c: &mut Criterion) {
             .expect("initial filling of sqlite failed");
 
         group.bench_with_input(
-            BenchmarkId::new(format!("sqlite store {encrypted_suffix}"), NAME),
+            BenchmarkId::new("Restore session [SQLite]", encrypted_suffix),
             &sqlite_store,
             |b, store| {
                 b.to_async(&runtime).iter(|| async {

benchmarks/benches/timeline.rs

@@ -94,12 +94,12 @@ pub fn create_timeline_with_initial_events(c: &mut Criterion) {
         room
     });
 
-    let mut group = c.benchmark_group("Test");
+    let mut group = c.benchmark_group("Create a timeline");
     group.throughput(Throughput::Elements(NUM_EVENTS as _));
     group.sample_size(10);
 
     group.bench_function(
-        BenchmarkId::new("create_timeline_with_initial_events", format!("{NUM_EVENTS} events")),
+        BenchmarkId::new("Create a timeline with initial events", format!("{NUM_EVENTS} events")),
         |b| {
             b.to_async(&runtime).iter(|| async {
                 let timeline = TimelineBuilder::new(&room)