fastconstmap 0.7.0__tar.gz → 0.9.0__tar.gz

{fastconstmap-0.7.0 → fastconstmap-0.9.0}/MANIFEST.in

@@ -7,4 +7,4 @@ recursive-include src/third_party *
 recursive-include fastconstmap *.py *.pyi py.typed
 recursive-include tests *.py
 recursive-include examples *.py
-recursive-include benchmarks *.py
+recursive-include benchmarks *.py *.c

{fastconstmap-0.7.0/fastconstmap.egg-info → fastconstmap-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastconstmap
-Version: 0.7.0
+Version: 0.9.0
 Summary: Fast, immutable, compact map from strings to uint64 (binary fuse filter).
 Author-email: Daniel Lemire <daniel@lemire.me>
 License: Apache-2.0
@@ -31,7 +31,8 @@ Given a `dict[str, int]` at build time, you get back a lookup object that:
 - answers a lookup in **one xxhash call plus three array reads**,
 - is **immutable** and **serializable** to bytes / a file,
 - exposes both a single-key API (`m[key]`) and a **batched** API
-  (`m.get_many([...])`) that amortises Python-C call overhead.
+  (`m.get_many([...])`, `m.get_many_into([...], buf)`) that amortises Python-C
+  call overhead and overlaps the memory accesses of a whole block of keys.
 
 This package is a C port of the Go library
 [`github.com/lemire/constmap`][constmap]. It vendors
@@ -68,6 +69,12 @@ vm.get("grape", -1)         # -> -1
 vm["grape"]                 # raises KeyError
 vm.get_many(["banana", "grape"], default=-1)  # -> [200, -1]
 
+# Batches can also be written straight into a buffer you own — no list of
+# Python ints is built.
+import array
+out = array.array("Q", [0]) * 3
+m.get_many_into(["apple", "banana", "cherry"], out)   # -> 3; out == [100, 200, 300]
+
 # Either kind can be saved and loaded.
 m.save("mymap.cmap")
 m2 = ConstMap.load("mymap.cmap")
@@ -89,6 +96,87 @@ m3 = ConstMap.from_bytes(blob)
 The false-positive rate of `VerifiedConstMap` (a missing key wrongly
 reported as present) is roughly 2⁻⁶⁴, which is negligible in practice.
 
+## Batched lookups
+
+`get_many` takes an iterable of keys and returns a list of values, in the same
+order:
+
+```python
+cm.get_many(["apple", "banana", "cherry"])          # -> [100, 200, 300]
+vm.get_many(["banana", "grape"], default=-1)        # -> [200, -1]
+```
+
+`get_many_into` is the same lookup writing 64-bit words into a buffer you own,
+so a repeated batch allocates nothing at all — no list, and no Python `int` per
+key. The buffer can be an `array("Q")`, a numpy `uint64` array, a
+`SharedMemory` block, or any other writable buffer of at least `8 * len(keys)`
+bytes. It returns the number of values written:
+
+```python
+import array
+out = array.array("Q", [0]) * 4096
+for batch in batches:
+    n = cm.get_many_into(batch, out)
+    use(out[:n])
+```
+
+`VerifiedConstMap.get_many_into` writes `fastconstmap.NOT_FOUND` (`2**64 - 1`)
+for a key that was not in the original mapping — a buffer of raw words has no
+room for a Python default.
+
+A batch is faster than a loop over single lookups because it hashes a block of
+eight keys before gathering any values. That lets the three array reads of all
+eight keys be in flight at once, instead of each key's loads waiting behind the
+hashing of the key before it. A lookup is memory-latency bound as soon as the
+map outgrows the last-level cache, which is where the gain comes from.
+
+### Measured
+
+At the C level, 2000-key batches against a 1,000,000-key map, ns/key, medians
+of three runs (`benchmarks/bench_batch.c`). *Cold* rotates through 64 distinct
+random batches so the cache lines the lookups touch are not already resident;
+*hot* replays one batch, so the touched region stays cache-resident and hashing
+dominates instead.
+
+| | | loop over lookup | `lookup_many` | |
+|---|---|---|---|---|
+| **Apple M4 Max** | `ConstMap` cold | 5.5 | **3.8** | 30% |
+| | `ConstMap` hot | 4.2 | **3.1** | 27% |
+| | `VerifiedConstMap` cold | 9.6 | **7.8** | 19% |
+| | `VerifiedConstMap` hot | 5.4 | **5.2** | 4% |
+| **Xeon Gold 6548N** | `ConstMap` cold | 12.6 | **10.4** | 18% |
+| | `ConstMap` hot | 6.3 | **5.0** | 21% |
+| | `VerifiedConstMap` cold | 15.9 | 16.6 | −5% |
+| | `VerifiedConstMap` hot | 7.9 | **6.7** | 15% |
+
+The one case where batching does not pay is `VerifiedConstMap` in the cold
+regime on the Xeon. That map probes two arrays per lookup, so a fresh batch is
+bound by a memory latency the overlapping cannot hide. The Go original reports
+the same result on the same processor.
+
+Through the Python API, ns/key on the same batches — 0.8.0 is the previous
+per-key loop, 0.9.0 the batched path:
+
+| | | 0.8.0 | 0.9.0 | `get_many_into` |
+|---|---|---|---|---|
+| **Apple M4 Max** | `ConstMap` cold | 30.7 | **20.6** | **14.2** |
+| | `ConstMap` hot | 16.4 | **14.1** | **6.1** |
+| | `VerifiedConstMap` cold | 35.5 | 35.3 | **23.9** |
+| **Xeon Gold 6548N** | `ConstMap` cold | 34.9 | **25.5** | **16.5** |
+| | `ConstMap` hot | 18.7 | **17.2** | **8.8** |
+| | `VerifiedConstMap` cold | 37.6 | **31.9** | **23.3** |
+
+What is left in the `get_many` column is the cost of boxing each value in a
+Python `int` and building the list, which is why `get_many_into` — which does
+neither — is another 30-60% faster again.
+
+To reproduce:
+
+```
+cc -O3 -std=c11 -Isrc benchmarks/bench_batch.c src/constmap.c -lm -o bench_batch
+./bench_batch 1000000
+```
+
 ## Keys and values
 
 - **Keys** may be `str` or `bytes`. `str` is encoded as UTF-8 internally;
@@ -176,41 +264,46 @@ its memory independently of the source buffer.
 
 ## Benchmark
 
-On an Apple M-series CPU, with 1,000,000 string keys
-(`key-{i}-{hex}` shaped strings):
+On an Apple M4 Max, with 1,000,000 string keys (`key-{i}-{hex}` shaped
+strings). Lookups query every key exactly once, in random order, from a list
+built in that order:
 
 ```
-=== fastconstmap benchmark — n = 1,000,000 keys, python 3.14.3 ===
+=== fastconstmap benchmark — n = 1,000,000 keys, python 3.14.5 ===
 
 Construction:
-  ConstMap.__init__                0.145 s
-  VerifiedConstMap.__init__        0.129 s
-  dict(d)                          0.005 s
+  ConstMap.__init__                       0.145 s
+  VerifiedConstMap.__init__               0.142 s
+  dict(d)                                 0.004 s
 
 Memory:
-  ConstMap.nbytes                 9,043,968 bytes  (9.04 bytes/key)
-  VerifiedConstMap.nbytes        18,087,936 bytes  (18.09 bytes/key)
-  dict (table+keys+values)      118,380,958 bytes  (118.38 bytes/key)
-  ratio dict / ConstMap          13.1x
-
-
-Single lookup, 2,000,000 ops:
-  dict[k]                         397.7 ns/op  (0.795 s total)
-  ConstMap[k]                     179.3 ns/op  (0.359 s total)
-  VerifiedConstMap[k]             213.2 ns/op  (0.426 s total)
-
-Batched lookup, 2000 × 1024:
-  dict comprehension               31.9 ns/op  (0.03 ms/batch of 1024)
-  ConstMap.get_many                14.6 ns/op  (0.01 ms/batch of 1024)
-  VerifiedConstMap.get_many        16.5 ns/op  (0.02 ms/batch of 1024)
+  ConstMap.nbytes                           9,043,968 bytes  (9.04 bytes/key)
+  VerifiedConstMap.nbytes                  18,087,936 bytes  (18.09 bytes/key)
+  dict (table+keys+values)                118,380,958 bytes  (118.38 bytes/key)
+  ratio dict / ConstMap                  13.1x
+
+Single lookup, every key once in random order (1,000,000 ops):
+  dict[k]                                   336.1 ns/op  (0.336 s total)
+  ConstMap[k]                                95.2 ns/op  (0.095 s total)
+  VerifiedConstMap[k]                       112.3 ns/op  (0.112 s total)
+
+Batched lookup, 2000 × 2000:
+  dict comprehension (cold)                 148.7 ns/op  (0.30 ms/batch of 2000)
+  ConstMap.get_many (cold)                   24.2 ns/op  (0.05 ms/batch of 2000)
+  ConstMap.get_many (hot)                    15.6 ns/op  (0.03 ms/batch of 2000)
+  ConstMap.get_many_into (cold)              14.2 ns/op  (0.03 ms/batch of 2000)
+  ConstMap.get_many_into (hot)                6.1 ns/op  (0.01 ms/batch of 2000)
+  VerifiedConstMap.get_many (cold)           33.7 ns/op  (0.07 ms/batch of 2000)
+  VerifiedConstMap.get_many_into (cold)      23.9 ns/op  (0.05 ms/batch of 2000)
 
 Serialization:
-  ConstMap.to_bytes                0.009 s  (9,044,004 bytes)
-  ConstMap.from_bytes              0.009 s
+  ConstMap.to_bytes                       0.010 s  (9,044,008 bytes)
+  ConstMap.from_bytes                     0.010 s
 ```
 
-For better performance use `get_many` when you have an array of keys to look
-up at once.
+The single-lookup numbers are dominated by Python call overhead, not by the
+map: use `get_many` when you have an array of keys to look up at once, and
+`get_many_into` when you have somewhere to put the results.
 
 To reproduce:
 

{fastconstmap-0.7.0 → fastconstmap-0.9.0}/README.md

@@ -13,7 +13,8 @@ Given a `dict[str, int]` at build time, you get back a lookup object that:
 - answers a lookup in **one xxhash call plus three array reads**,
 - is **immutable** and **serializable** to bytes / a file,
 - exposes both a single-key API (`m[key]`) and a **batched** API
-  (`m.get_many([...])`) that amortises Python-C call overhead.
+  (`m.get_many([...])`, `m.get_many_into([...], buf)`) that amortises Python-C
+  call overhead and overlaps the memory accesses of a whole block of keys.
 
 This package is a C port of the Go library
 [`github.com/lemire/constmap`][constmap]. It vendors
@@ -50,6 +51,12 @@ vm.get("grape", -1)         # -> -1
 vm["grape"]                 # raises KeyError
 vm.get_many(["banana", "grape"], default=-1)  # -> [200, -1]
 
+# Batches can also be written straight into a buffer you own — no list of
+# Python ints is built.
+import array
+out = array.array("Q", [0]) * 3
+m.get_many_into(["apple", "banana", "cherry"], out)   # -> 3; out == [100, 200, 300]
+
 # Either kind can be saved and loaded.
 m.save("mymap.cmap")
 m2 = ConstMap.load("mymap.cmap")
@@ -71,6 +78,87 @@ m3 = ConstMap.from_bytes(blob)
 The false-positive rate of `VerifiedConstMap` (a missing key wrongly
 reported as present) is roughly 2⁻⁶⁴, which is negligible in practice.
 
+## Batched lookups
+
+`get_many` takes an iterable of keys and returns a list of values, in the same
+order:
+
+```python
+cm.get_many(["apple", "banana", "cherry"])          # -> [100, 200, 300]
+vm.get_many(["banana", "grape"], default=-1)        # -> [200, -1]
+```
+
+`get_many_into` is the same lookup writing 64-bit words into a buffer you own,
+so a repeated batch allocates nothing at all — no list, and no Python `int` per
+key. The buffer can be an `array("Q")`, a numpy `uint64` array, a
+`SharedMemory` block, or any other writable buffer of at least `8 * len(keys)`
+bytes. It returns the number of values written:
+
+```python
+import array
+out = array.array("Q", [0]) * 4096
+for batch in batches:
+    n = cm.get_many_into(batch, out)
+    use(out[:n])
+```
+
+`VerifiedConstMap.get_many_into` writes `fastconstmap.NOT_FOUND` (`2**64 - 1`)
+for a key that was not in the original mapping — a buffer of raw words has no
+room for a Python default.
+
+A batch is faster than a loop over single lookups because it hashes a block of
+eight keys before gathering any values. That lets the three array reads of all
+eight keys be in flight at once, instead of each key's loads waiting behind the
+hashing of the key before it. A lookup is memory-latency bound as soon as the
+map outgrows the last-level cache, which is where the gain comes from.
+
+### Measured
+
+At the C level, 2000-key batches against a 1,000,000-key map, ns/key, medians
+of three runs (`benchmarks/bench_batch.c`). *Cold* rotates through 64 distinct
+random batches so the cache lines the lookups touch are not already resident;
+*hot* replays one batch, so the touched region stays cache-resident and hashing
+dominates instead.
+
+| | | loop over lookup | `lookup_many` | |
+|---|---|---|---|---|
+| **Apple M4 Max** | `ConstMap` cold | 5.5 | **3.8** | 30% |
+| | `ConstMap` hot | 4.2 | **3.1** | 27% |
+| | `VerifiedConstMap` cold | 9.6 | **7.8** | 19% |
+| | `VerifiedConstMap` hot | 5.4 | **5.2** | 4% |
+| **Xeon Gold 6548N** | `ConstMap` cold | 12.6 | **10.4** | 18% |
+| | `ConstMap` hot | 6.3 | **5.0** | 21% |
+| | `VerifiedConstMap` cold | 15.9 | 16.6 | −5% |
+| | `VerifiedConstMap` hot | 7.9 | **6.7** | 15% |
+
+The one case where batching does not pay is `VerifiedConstMap` in the cold
+regime on the Xeon. That map probes two arrays per lookup, so a fresh batch is
+bound by a memory latency the overlapping cannot hide. The Go original reports
+the same result on the same processor.
+
+Through the Python API, ns/key on the same batches — 0.8.0 is the previous
+per-key loop, 0.9.0 the batched path:
+
+| | | 0.8.0 | 0.9.0 | `get_many_into` |
+|---|---|---|---|---|
+| **Apple M4 Max** | `ConstMap` cold | 30.7 | **20.6** | **14.2** |
+| | `ConstMap` hot | 16.4 | **14.1** | **6.1** |
+| | `VerifiedConstMap` cold | 35.5 | 35.3 | **23.9** |
+| **Xeon Gold 6548N** | `ConstMap` cold | 34.9 | **25.5** | **16.5** |
+| | `ConstMap` hot | 18.7 | **17.2** | **8.8** |
+| | `VerifiedConstMap` cold | 37.6 | **31.9** | **23.3** |
+
+What is left in the `get_many` column is the cost of boxing each value in a
+Python `int` and building the list, which is why `get_many_into` — which does
+neither — is another 30-60% faster again.
+
+To reproduce:
+
+```
+cc -O3 -std=c11 -Isrc benchmarks/bench_batch.c src/constmap.c -lm -o bench_batch
+./bench_batch 1000000
+```
+
 ## Keys and values
 
 - **Keys** may be `str` or `bytes`. `str` is encoded as UTF-8 internally;
@@ -158,41 +246,46 @@ its memory independently of the source buffer.
 
 ## Benchmark
 
-On an Apple M-series CPU, with 1,000,000 string keys
-(`key-{i}-{hex}` shaped strings):
+On an Apple M4 Max, with 1,000,000 string keys (`key-{i}-{hex}` shaped
+strings). Lookups query every key exactly once, in random order, from a list
+built in that order:
 
 ```
-=== fastconstmap benchmark — n = 1,000,000 keys, python 3.14.3 ===
+=== fastconstmap benchmark — n = 1,000,000 keys, python 3.14.5 ===
 
 Construction:
-  ConstMap.__init__                0.145 s
-  VerifiedConstMap.__init__        0.129 s
-  dict(d)                          0.005 s
+  ConstMap.__init__                       0.145 s
+  VerifiedConstMap.__init__               0.142 s
+  dict(d)                                 0.004 s
 
 Memory:
-  ConstMap.nbytes                 9,043,968 bytes  (9.04 bytes/key)
-  VerifiedConstMap.nbytes        18,087,936 bytes  (18.09 bytes/key)
-  dict (table+keys+values)      118,380,958 bytes  (118.38 bytes/key)
-  ratio dict / ConstMap          13.1x
-
-
-Single lookup, 2,000,000 ops:
-  dict[k]                         397.7 ns/op  (0.795 s total)
-  ConstMap[k]                     179.3 ns/op  (0.359 s total)
-  VerifiedConstMap[k]             213.2 ns/op  (0.426 s total)
-
-Batched lookup, 2000 × 1024:
-  dict comprehension               31.9 ns/op  (0.03 ms/batch of 1024)
-  ConstMap.get_many                14.6 ns/op  (0.01 ms/batch of 1024)
-  VerifiedConstMap.get_many        16.5 ns/op  (0.02 ms/batch of 1024)
+  ConstMap.nbytes                           9,043,968 bytes  (9.04 bytes/key)
+  VerifiedConstMap.nbytes                  18,087,936 bytes  (18.09 bytes/key)
+  dict (table+keys+values)                118,380,958 bytes  (118.38 bytes/key)
+  ratio dict / ConstMap                  13.1x
+
+Single lookup, every key once in random order (1,000,000 ops):
+  dict[k]                                   336.1 ns/op  (0.336 s total)
+  ConstMap[k]                                95.2 ns/op  (0.095 s total)
+  VerifiedConstMap[k]                       112.3 ns/op  (0.112 s total)
+
+Batched lookup, 2000 × 2000:
+  dict comprehension (cold)                 148.7 ns/op  (0.30 ms/batch of 2000)
+  ConstMap.get_many (cold)                   24.2 ns/op  (0.05 ms/batch of 2000)
+  ConstMap.get_many (hot)                    15.6 ns/op  (0.03 ms/batch of 2000)
+  ConstMap.get_many_into (cold)              14.2 ns/op  (0.03 ms/batch of 2000)
+  ConstMap.get_many_into (hot)                6.1 ns/op  (0.01 ms/batch of 2000)
+  VerifiedConstMap.get_many (cold)           33.7 ns/op  (0.07 ms/batch of 2000)
+  VerifiedConstMap.get_many_into (cold)      23.9 ns/op  (0.05 ms/batch of 2000)
 
 Serialization:
-  ConstMap.to_bytes                0.009 s  (9,044,004 bytes)
-  ConstMap.from_bytes              0.009 s
+  ConstMap.to_bytes                       0.010 s  (9,044,008 bytes)
+  ConstMap.from_bytes                     0.010 s
 ```
 
-For better performance use `get_many` when you have an array of keys to look
-up at once.
+The single-lookup numbers are dominated by Python call overhead, not by the
+map: use `get_many` when you have an array of keys to look up at once, and
+`get_many_into` when you have somewhere to put the results.
 
 To reproduce:
 

fastconstmap-0.9.0/benchmarks/bench_batch.c

@@ -0,0 +1,225 @@
+/*
+ * bench_batch — C-level microbenchmark for the batched lookups.
+ *
+ * Mirrors the Go original's batch_bench_test.go (constmap v1.1.0): a 2000-key
+ * batch against a 1,000,000-key map, reported in ns/key.
+ *
+ *   cold — rotates through 64 distinct random batches, so the cache lines the
+ *          lookups touch are not already resident and memory latency shows.
+ *   hot  — replays one batch, so the touched region of the array stays
+ *          cache-resident and hashing dominates instead.
+ *
+ * Build:
+ *   cc -O3 -std=c11 -Isrc benchmarks/bench_batch.c src/constmap.c -lm -o bench_batch
+ */
+/* clock_gettime is POSIX; -std=c11 alone does not expose it. */
+#define _POSIX_C_SOURCE 200809L
+
+#include "constmap.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define MAP_N        1000000
+#define BATCH_SIZE   2000
+#define NUM_POOLS    64
+#define REPEATS      2000
+
+static uint64_t rng_state = 0x853c49e6748fea9bULL;
+
+static uint64_t next_rand(void) {
+    rng_state ^= rng_state << 13;
+    rng_state ^= rng_state >> 7;
+    rng_state ^= rng_state << 17;
+    return rng_state;
+}
+
+static double now_sec(void) {
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return (double)ts.tv_sec + 1e-9 * (double)ts.tv_nsec;
+}
+
+/* Key text lives in one arena, in index order, exactly as a caller's key list
+ * would. Each batch clones the keys it draws into its own arena so that a
+ * lookup is not also charged for a scattered walk over the arena — that cost
+ * belongs to whatever produced the keys, not to the map. */
+typedef struct {
+    char      *arena;
+    fcm_key_t *keys;
+    size_t     n;
+} keyset_t;
+
+static void keyset_free(keyset_t *ks) {
+    free(ks->arena);
+    free(ks->keys);
+}
+
+static int keyset_build(keyset_t *ks, size_t n) {
+    const size_t stride = 32;
+    ks->n     = n;
+    ks->arena = malloc(n * stride);
+    ks->keys  = malloc(n * sizeof(fcm_key_t));
+    if (!ks->arena || !ks->keys) return -1;
+    for (size_t i = 0; i < n; i++) {
+        char *p = ks->arena + i * stride;
+        int   len = snprintf(p, stride, "key-%zu-%08x", i,
+                             (unsigned)(next_rand() & 0x3FFFFFFF));
+        ks->keys[i].bytes = p;
+        ks->keys[i].len   = (size_t)len;
+    }
+    return 0;
+}
+
+/* Draw BATCH_SIZE keys at random from `all`, cloned into a compact arena. */
+static int batch_build(keyset_t *batch, const keyset_t *all) {
+    const size_t stride = 32;
+    batch->n     = BATCH_SIZE;
+    batch->arena = malloc(BATCH_SIZE * stride);
+    batch->keys  = malloc(BATCH_SIZE * sizeof(fcm_key_t));
+    if (!batch->arena || !batch->keys) return -1;
+    for (size_t i = 0; i < BATCH_SIZE; i++) {
+        size_t     src = (size_t)(next_rand() % all->n);
+        char      *p   = batch->arena + i * stride;
+        memcpy(p, all->keys[src].bytes, all->keys[src].len);
+        batch->keys[i].bytes = p;
+        batch->keys[i].len   = all->keys[src].len;
+    }
+    return 0;
+}
+
+static volatile uint64_t sink;
+
+static void report(const char *label, double elapsed, size_t keys, double baseline) {
+    double ns = elapsed * 1e9 / (double)keys;
+    if (baseline > 0.0) {
+        printf("  %-34s %7.2f ns/key   %+5.0f%%\n", label, ns,
+               100.0 * (baseline - ns) / baseline);
+    } else {
+        printf("  %-34s %7.2f ns/key\n", label, ns);
+    }
+    (void)keys;
+}
+
+int main(int argc, char **argv) {
+    size_t map_n = argc > 1 ? (size_t)strtoull(argv[1], NULL, 10) : MAP_N;
+
+    keyset_t all;
+    if (keyset_build(&all, map_n) < 0) { fprintf(stderr, "oom\n"); return 1; }
+    uint64_t *values = malloc(map_n * sizeof(uint64_t));
+    if (!values) { fprintf(stderr, "oom\n"); return 1; }
+    for (size_t i = 0; i < map_n; i++) values[i] = i;
+
+    fcm_constmap_t          cm;
+    fcm_verified_constmap_t vm;
+    if (fcm_constmap_new(&cm, all.keys, values, map_n) != FCM_OK) {
+        fprintf(stderr, "construction failed\n"); return 1;
+    }
+    if (fcm_verified_constmap_new(&vm, all.keys, values, map_n) != FCM_OK) {
+        fprintf(stderr, "verified construction failed\n"); return 1;
+    }
+
+    keyset_t pools[NUM_POOLS];
+    for (int p = 0; p < NUM_POOLS; p++) {
+        if (batch_build(&pools[p], &all) < 0) { fprintf(stderr, "oom\n"); return 1; }
+    }
+
+    uint64_t *out = malloc(BATCH_SIZE * sizeof(uint64_t));
+    if (!out) { fprintf(stderr, "oom\n"); return 1; }
+
+    printf("=== fastconstmap batched lookups — %zu keys, batches of %d ===\n\n",
+           map_n, BATCH_SIZE);
+
+    double t0, loop_ns;
+    size_t total = (size_t)REPEATS * BATCH_SIZE;
+
+    /* ---- ConstMap, cold ---- */
+    printf("ConstMap:\n");
+    t0 = now_sec();
+    for (int i = 0; i < REPEATS; i++) {
+        const keyset_t *q = &pools[i % NUM_POOLS];
+        for (size_t j = 0; j < q->n; j++)
+            out[j] = fcm_constmap_lookup(&cm, q->keys[j].bytes, q->keys[j].len);
+        sink = out[0];
+    }
+    loop_ns = now_sec() - t0;
+    report("loop over lookup (cold)", loop_ns, total, 0.0);
+
+    t0 = now_sec();
+    for (int i = 0; i < REPEATS; i++) {
+        const keyset_t *q = &pools[i % NUM_POOLS];
+        fcm_constmap_lookup_many(&cm, q->keys, q->n, out);
+        sink = out[0];
+    }
+    report("lookup_many (cold)", now_sec() - t0, total,
+           loop_ns * 1e9 / (double)total);
+
+    /* ---- ConstMap, hot ---- */
+    const keyset_t *hot = &pools[0];
+    t0 = now_sec();
+    for (int i = 0; i < REPEATS; i++) {
+        for (size_t j = 0; j < hot->n; j++)
+            out[j] = fcm_constmap_lookup(&cm, hot->keys[j].bytes, hot->keys[j].len);
+        sink = out[0];
+    }
+    loop_ns = now_sec() - t0;
+    report("loop over lookup (hot)", loop_ns, total, 0.0);
+
+    t0 = now_sec();
+    for (int i = 0; i < REPEATS; i++) {
+        fcm_constmap_lookup_many(&cm, hot->keys, hot->n, out);
+        sink = out[0];
+    }
+    report("lookup_many (hot)", now_sec() - t0, total,
+           loop_ns * 1e9 / (double)total);
+
+    /* ---- VerifiedConstMap, cold ---- */
+    printf("\nVerifiedConstMap:\n");
+    t0 = now_sec();
+    for (int i = 0; i < REPEATS; i++) {
+        const keyset_t *q = &pools[i % NUM_POOLS];
+        for (size_t j = 0; j < q->n; j++)
+            out[j] = fcm_verified_constmap_lookup(&vm, q->keys[j].bytes, q->keys[j].len);
+        sink = out[0];
+    }
+    loop_ns = now_sec() - t0;
+    report("loop over lookup (cold)", loop_ns, total, 0.0);
+
+    t0 = now_sec();
+    for (int i = 0; i < REPEATS; i++) {
+        const keyset_t *q = &pools[i % NUM_POOLS];
+        fcm_verified_constmap_lookup_many(&vm, q->keys, q->n, out);
+        sink = out[0];
+    }
+    report("lookup_many (cold)", now_sec() - t0, total,
+           loop_ns * 1e9 / (double)total);
+
+    /* ---- VerifiedConstMap, hot ---- */
+    t0 = now_sec();
+    for (int i = 0; i < REPEATS; i++) {
+        for (size_t j = 0; j < hot->n; j++)
+            out[j] = fcm_verified_constmap_lookup(&vm, hot->keys[j].bytes, hot->keys[j].len);
+        sink = out[0];
+    }
+    loop_ns = now_sec() - t0;
+    report("loop over lookup (hot)", loop_ns, total, 0.0);
+
+    t0 = now_sec();
+    for (int i = 0; i < REPEATS; i++) {
+        fcm_verified_constmap_lookup_many(&vm, hot->keys, hot->n, out);
+        sink = out[0];
+    }
+    report("lookup_many (hot)", now_sec() - t0, total,
+           loop_ns * 1e9 / (double)total);
+
+    for (int p = 0; p < NUM_POOLS; p++) keyset_free(&pools[p]);
+    keyset_free(&all);
+    free(values);
+    free(out);
+    fcm_constmap_free(&cm);
+    fcm_verified_constmap_free(&vm);
+    return 0;
+}