Update hashmap benchmarks

With inspiration taken from https://tessil.github.io/2016/08/29/benchmark-hopscotch-map.html and https://martin.ankerl.com/2022/08/27/hashmap-bench-01/.

Author: Kobzol

collector/runtime-benchmarks/hashmap/Cargo.lock

@@ -7,7 +7,7 @@ edition = "2021"
 
 [dependencies]
 benchlib = { path = "../../benchlib" }
-hashbrown = "0.12.3"
+hashbrown = { version = "0.13.2" }
 fxhash = "0.2.1"
 
 [workspace]

collector/runtime-benchmarks/hashmap/Cargo.toml

@@ -1,19 +1,85 @@
 use benchlib;
-use benchlib::benchmark::run_benchmark_group;
+use benchlib::benchmark::{black_box, run_benchmark_group};
 
 fn main() {
     run_benchmark_group(|group| {
-        // Measures how long does it take to insert 10 thousand numbers into a `hashbrown` hashmap.
-        group.register_benchmark("hashmap_insert_10k", || {
+        // Measures how long does it take to insert 1 million numbers into a hashmap.
+        group.register_benchmark("hashmap_insert_1m", || {
+            let count = 1_000_000;
             let mut map = hashbrown::HashMap::with_capacity_and_hasher(
-                10000,
+                // Over allocate the hashmap to avoid reallocations when inserting
+                count * 2,
                 fxhash::FxBuildHasher::default(),
             );
             move || {
-                for index in 0..10000 {
+                for index in 0..count {
                     map.insert(index, index);
                 }
             }
         });
+
+        // Measures how long it takes to remove 1 million elements from a hashmap.
+        group.register_benchmark("hashmap_remove_1m", || {
+            let mut map = hashbrown::HashMap::with_capacity_and_hasher(
+                1_000_000,
+                fxhash::FxBuildHasher::default(),
+            );
+            for index in 0..map.capacity() {
+                map.insert(index, index);
+            }
+
+            move || {
+                for index in 0..map.capacity() {
+                    map.remove(&index);
+                }
+            }
+        });
+
+        // Measures how long it takes to find 1 million elements that are in a hashmap.
+        group.register_benchmark("hashmap_find_1m", || {
+            let mut map = hashbrown::HashMap::with_capacity_and_hasher(
+                1_000_000,
+                fxhash::FxBuildHasher::default(),
+            );
+            for index in 0..map.capacity() {
+                map.insert(index, index);
+            }
+
+            move || {
+                for index in 0..map.capacity() {
+                    black_box(map.get(&index));
+                }
+            }
+        });
+
+        // Measures how long it takes to find 1 million elements that are not in a hashmap.
+        group.register_benchmark("hashmap_find_misses_1m", || {
+            let mut map = hashbrown::HashMap::with_capacity_and_hasher(
+                1_000_000,
+                fxhash::FxBuildHasher::default(),
+            );
+            for index in 0..map.capacity() {
+                map.insert(index, index);
+            }
+
+            move || {
+                for index in map.capacity()..(map.capacity() * 2) {
+                    black_box(map.get(&index));
+                }
+            }
+        });
+
+        // Measures how long it takes to iterate through values of a hashmap with 1 million elements.
+        group.register_benchmark("hashmap_iterate_1m", || {
+            let mut map = hashbrown::HashMap::with_capacity_and_hasher(
+                1_000_000,
+                fxhash::FxBuildHasher::default(),
+            );
+            for index in 0..map.capacity() {
+                map.insert(index, index as u64);
+            }
+
+            move || map.values().sum::<u64>()
+        });
     });
 }