From 26639e9c8c95dca59d73a2d4b6e17eb286d82bc3 Mon Sep 17 00:00:00 2001
From: Emil Ernerfeldt <emil.ernerfeldt@gmail.com>
Date: Mon, 23 May 2022 17:10:09 +0200
Subject: [PATCH] Fast data access prototype (#7)

A new data store which is homogeneous (same type at each type path) and supports batching for fast logging of a lot of data.
---
 .vscode/launch.json                 |  18 +
 Cargo.lock                          | 301 ++++++++++++++-
 Cargo.toml                          |   8 +
 deny.toml                           |   1 +
 prototype/Cargo.toml                |  23 ++
 prototype/benches/data_benchmark.rs | 149 ++++++++
 prototype/examples/memory_usage.rs  | 188 ++++++++++
 prototype/src/lib.rs                | 280 ++++++++++++++
 prototype/src/scene.rs              |  40 ++
 prototype/src/storage.rs            | 434 ++++++++++++++++++++++
 prototype/tests/test_data_store.rs  | 557 ++++++++++++++++++++++++++++
 11 files changed, 1993 insertions(+), 6 deletions(-)
 create mode 100644 prototype/Cargo.toml
 create mode 100644 prototype/benches/data_benchmark.rs
 create mode 100644 prototype/examples/memory_usage.rs
 create mode 100644 prototype/src/lib.rs
 create mode 100644 prototype/src/scene.rs
 create mode 100644 prototype/src/storage.rs
 create mode 100644 prototype/tests/test_data_store.rs

diff --git a/.vscode/launch.json b/.vscode/launch.json
index 282bd5c7f86b..307d5919fa26 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -42,5 +42,23 @@
             ],
             "cwd": "${workspaceFolder}"
         },
+        {
+            "name": "Debug 'prototype' tests",
+            "type": "lldb",
+            "request": "launch",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--package=prototype"
+                ],
+                "filter": {
+                    "name": "prototype",
+                    "kind": "lib"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
     ]
 }
diff --git a/Cargo.lock b/Cargo.lock
index c3d05b997e5a..8de0c3b38cb1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -181,6 +181,15 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "bitmaps"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2"
+dependencies = [
+ "typenum",
+]
+
 [[package]]
 name = "block"
 version = "0.1.6"
@@ -196,6 +205,18 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "bstr"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+dependencies = [
+ "lazy_static",
+ "memchr",
+ "regex-automata",
+ "serde",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.9.1"
@@ -254,6 +275,15 @@ dependencies = [
  "nix",
 ]
 
+[[package]]
+name = "cast"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c24dab4283a142afa2fdca129b80ad2c6284e073930f964c3a1293c225ee39a"
+dependencies = [
+ "rustc_version",
+]
+
 [[package]]
 name = "cc"
 version = "1.0.73"
@@ -325,6 +355,17 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "clap"
+version = "2.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+dependencies = [
+ "bitflags",
+ "textwrap 0.11.0",
+ "unicode-width",
+]
+
 [[package]]
 name = "clap"
 version = "3.1.17"
@@ -339,7 +380,7 @@ dependencies = [
  "lazy_static",
  "strsim",
  "termcolor",
- "textwrap",
+ "textwrap 0.15.0",
 ]
 
 [[package]]
@@ -558,6 +599,42 @@ dependencies = [
  "cfg-if 1.0.0",
 ]
 
+[[package]]
+name = "criterion"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1604dafd25fba2fe2d5895a9da139f8dc9b319a5fe5354ca137cbbce4e178d10"
+dependencies = [
+ "atty",
+ "cast",
+ "clap 2.34.0",
+ "criterion-plot",
+ "csv",
+ "itertools",
+ "lazy_static",
+ "num-traits",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_cbor",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d00996de9f2f7559f7f4dc286073197f83e92256a59ed395f9aac01fe717da57"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.4"
@@ -568,6 +645,31 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
+dependencies = [
+ "cfg-if 1.0.0",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1145cf131a2c6ba0615079ab6a638f7e1973ac9c2634fcbeaaad6114246efe8c"
+dependencies = [
+ "autocfg",
+ "cfg-if 1.0.0",
+ "crossbeam-utils",
+ "lazy_static",
+ "memoffset",
+ "scopeguard",
+]
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.8"
@@ -588,6 +690,28 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "csv"
+version = "1.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1"
+dependencies = [
+ "bstr",
+ "csv-core",
+ "itoa 0.4.8",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "cty"
 version = "0.2.2"
@@ -1305,7 +1429,7 @@ checksum = "ff8670570af52249509a86f5e3e18a08c60b177071826898fde8997cf5f6bfbb"
 dependencies = [
  "bytes",
  "fnv",
- "itoa",
+ "itoa 1.0.1",
 ]
 
 [[package]]
@@ -1346,7 +1470,7 @@ dependencies = [
  "http-body",
  "httparse",
  "httpdate",
- "itoa",
+ "itoa 1.0.1",
  "pin-project-lite",
  "socket2",
  "tokio",
@@ -1372,6 +1496,20 @@ dependencies = [
  "unicode-normalization",
 ]
 
+[[package]]
+name = "im"
+version = "15.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0acd33ff0285af998aaf9b57342af478078f53492322fafc47450e09397e0e9"
+dependencies = [
+ "bitmaps",
+ "rand_core",
+ "rand_xoshiro",
+ "sized-chunks",
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "image"
 version = "0.23.14"
@@ -1428,6 +1566,12 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itoa"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
+
 [[package]]
 name = "itoa"
 version = "1.0.1"
@@ -1911,7 +2055,7 @@ name = "objectron"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "clap",
+ "clap 3.1.17",
  "comms",
  "glam",
  "image",
@@ -1934,6 +2078,12 @@ version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9"
 
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
 [[package]]
 name = "os_str_bytes"
 version = "6.0.0"
@@ -2058,6 +2208,34 @@ version = "0.3.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae"
 
+[[package]]
+name = "plotters"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a3fd9ec30b9749ce28cd91f255d569591cdf937fe280c312143e3c4bad6f2a"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d88417318da0eaf0fdcdb51a0ee6c3bed624333bff8f946733049380be67ac1c"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521fa9638fa597e1dc53e9412a4f9cefb01187ee1f7413076f9e6749e2885ba9"
+dependencies = [
+ "plotters-backend",
+]
+
 [[package]]
 name = "png"
 version = "0.16.8"
@@ -2174,6 +2352,18 @@ dependencies = [
  "prost",
 ]
 
+[[package]]
+name = "prototype"
+version = "0.1.0"
+dependencies = [
+ "ahash",
+ "criterion",
+ "im",
+ "mimalloc",
+ "nohash-hasher",
+ "tracing",
+]
+
 [[package]]
 name = "puffin"
 version = "0.13.1"
@@ -2241,6 +2431,15 @@ dependencies = [
  "getrandom",
 ]
 
+[[package]]
+name = "rand_xoshiro"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
+dependencies = [
+ "rand_core",
+]
+
 [[package]]
 name = "raw-window-handle"
 version = "0.4.3"
@@ -2250,6 +2449,30 @@ dependencies = [
  "cty",
 ]
 
+[[package]]
+name = "rayon"
+version = "1.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd99e5772ead8baa5215278c9b15bf92087709e9c1b2d1f97cdb5a183c933a7d"
+dependencies = [
+ "autocfg",
+ "crossbeam-deque",
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "258bcdb5ac6dad48491bb2992db6b7cf74878b0384908af124823d118c99683f"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "num_cpus",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.2.13"
@@ -2279,6 +2502,12 @@ dependencies = [
  "regex-syntax",
 ]
 
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+
 [[package]]
 name = "regex-syntax"
 version = "0.6.25"
@@ -2366,6 +2595,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
+
 [[package]]
 name = "rustls"
 version = "0.20.4"
@@ -2431,6 +2669,12 @@ dependencies = [
  "untrusted",
 ]
 
+[[package]]
+name = "semver"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cb243bdfdb5936c8dc3c45762a19d12ab4550cdc753bc247637d4ec35a040fd"
+
 [[package]]
 name = "serde"
 version = "1.0.137"
@@ -2440,6 +2684,16 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde_cbor"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
+dependencies = [
+ "half",
+ "serde",
+]
+
 [[package]]
 name = "serde_derive"
 version = "1.0.137"
@@ -2457,7 +2711,7 @@ version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b7ce2b32a1aed03c558dc61a5cd328f15aff2dbc17daad8fb8af04d2100e15c"
 dependencies = [
- "itoa",
+ "itoa 1.0.1",
  "ryu",
  "serde",
 ]
@@ -2492,6 +2746,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "sized-chunks"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e"
+dependencies = [
+ "bitmaps",
+ "typenum",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.6"
@@ -2635,6 +2899,15 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
 [[package]]
 name = "textwrap"
 version = "0.15.0"
@@ -2711,6 +2984,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "tinyvec"
 version = "1.6.0"
@@ -2945,6 +3228,12 @@ dependencies = [
  "tinyvec",
 ]
 
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
 [[package]]
 name = "unicode-xid"
 version = "0.2.3"
@@ -3018,7 +3307,7 @@ dependencies = [
  "arboard",
  "bytemuck",
  "cgmath",
- "clap",
+ "clap 3.1.17",
  "comms",
  "console_error_panic_hook",
  "eframe",
diff --git a/Cargo.toml b/Cargo.toml
index b7fb6b4fe21e..977198ac1da1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,6 +4,7 @@ members = [
     "comms",
     "log_types",
     "objectron",
+    "prototype",
     "viewer",
     "web_server",
 ]
@@ -11,3 +12,10 @@ members = [
 
 [profile.dev]
 # opt-level = 1 # Speed up debug builds
+
+[profile.release]
+# debug = true # good for profilers
+
+[profile.bench]
+debug = true
+
diff --git a/deny.toml b/deny.toml
index 0fd5b77010e1..04fb112ef498 100644
--- a/deny.toml
+++ b/deny.toml
@@ -32,6 +32,7 @@ skip = [
     { name = "windows_x86_64_msvc" }, # Fix coming in https://github.com/PolyMeilex/rfd/pull/64
 ]
 skip-tree = [
+    { name = "criterion" }, # dev-dependency
     { name = "winit" }, # winit pulls in a lot of old, duplicated crates. at least it is not wasm
 ]
 
diff --git a/prototype/Cargo.toml b/prototype/Cargo.toml
new file mode 100644
index 000000000000..6a04779d1412
--- /dev/null
+++ b/prototype/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "prototype"
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.60"
+license = "MIT OR Apache-2.0"
+publish = false
+
+
+[dependencies]
+ahash = "0.7"
+im = "15"
+mimalloc = "0.1"
+nohash-hasher = "0.2"
+tracing = "0.1"
+
+[dev-dependencies]
+criterion = "0.3"
+
+
+[[bench]]
+name = "data_benchmark"
+harness = false
diff --git a/prototype/benches/data_benchmark.rs b/prototype/benches/data_benchmark.rs
new file mode 100644
index 000000000000..93f438418fe7
--- /dev/null
+++ b/prototype/benches/data_benchmark.rs
@@ -0,0 +1,149 @@
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use prototype::TypePathDataStore;
+use prototype::*;
+
+use std::sync::Arc;
+
+const NUM_FRAMES: i64 = 1_000; // this can have a big impact on performance
+const NUM_POINTS_PER_CAMERA: u64 = 1_000;
+const TOTAL_POINTS: u64 = 2 * NUM_POINTS_PER_CAMERA;
+
+fn data_path(camera: &str, index: u64, field: &str) -> DataPath {
+    im::vector![
+        DataPathComponent::Name("camera".into()),
+        DataPathComponent::Index(Index::String(camera.into())),
+        DataPathComponent::Name("point".into()),
+        DataPathComponent::Index(Index::Sequence(index)),
+        DataPathComponent::Name(field.into()),
+    ]
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+struct Time(i64);
+
+fn generate_date(individual_pos: bool, individual_radius: bool) -> TypePathDataStore<Time> {
+    let mut data_store = TypePathDataStore::default();
+
+    for frame in 0..NUM_FRAMES {
+        let time_value = Time(frame);
+        for camera in ["left", "right"] {
+            if individual_pos {
+                for point in 0..NUM_POINTS_PER_CAMERA {
+                    let (type_path, index_path) = into_type_path(data_path(camera, point, "pos"));
+                    data_store
+                        .insert_individual::<[f32; 3]>(
+                            type_path,
+                            index_path,
+                            time_value,
+                            [1.0, 2.0, 3.0],
+                        )
+                        .unwrap();
+                }
+            } else {
+                let type_path = im::vector![
+                    TypePathComponent::Name("camera".into()),
+                    TypePathComponent::Index,
+                    TypePathComponent::Name("point".into()),
+                    TypePathComponent::Index,
+                    TypePathComponent::Name("pos".into())
+                ];
+                let mut index_path_prefix = IndexPathKey::default();
+                index_path_prefix.push_back(Index::String(camera.into()));
+
+                let batch = Arc::new(
+                    (0..NUM_POINTS_PER_CAMERA)
+                        .map(|pi| {
+                            let pos: [f32; 3] = [1.0, 2.0, 3.0];
+                            (IndexKey::new(Index::Sequence(pi)), pos)
+                        })
+                        .collect(),
+                );
+
+                data_store
+                    .insert_batch(type_path, index_path_prefix, time_value, batch)
+                    .unwrap();
+            }
+
+            if individual_radius {
+                for point in 0..NUM_POINTS_PER_CAMERA {
+                    let (type_path, index_path) =
+                        into_type_path(data_path(camera, point, "radius"));
+                    data_store
+                        .insert_individual(type_path, index_path, time_value, 1.0_f32)
+                        .unwrap();
+                }
+            } else {
+                let type_path = im::vector![
+                    TypePathComponent::Name("camera".into()),
+                    TypePathComponent::Index,
+                    TypePathComponent::Name("point".into()),
+                    TypePathComponent::Index,
+                    TypePathComponent::Name("radius".into())
+                ];
+                let mut index_path_prefix = IndexPathKey::default();
+                index_path_prefix.push_back(Index::String(camera.into()));
+
+                let batch = Arc::new(
+                    (0..NUM_POINTS_PER_CAMERA)
+                        .map(|pi| (IndexKey::new(Index::Sequence(pi)), 1.0_f32))
+                        .collect(),
+                );
+
+                data_store
+                    .insert_batch(type_path, index_path_prefix, time_value, batch)
+                    .unwrap();
+            }
+        }
+    }
+
+    data_store
+}
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("query-points-throughput");
+    group.throughput(criterion::Throughput::Elements(TOTAL_POINTS as _));
+
+    let data_store = generate_date(false, false);
+    group.bench_function("batched_pos_batched_radius", |b| {
+        b.iter(|| {
+            let scene =
+                Scene3D::from_store(&data_store, &TimeQuery::LatestAt(Time(NUM_FRAMES / 2)));
+            assert_eq!(scene.points.len(), TOTAL_POINTS as usize);
+        });
+    });
+
+    let data_store = generate_date(true, true);
+    group.bench_function("individual_pos_individual_radius", |b| {
+        b.iter(|| {
+            let scene =
+                Scene3D::from_store(&data_store, &TimeQuery::LatestAt(Time(NUM_FRAMES / 2)));
+            assert_eq!(scene.points.len(), TOTAL_POINTS as usize);
+        });
+    });
+
+    let data_store = generate_date(false, true);
+    group.bench_function("batched_pos_individual_radius", |b| {
+        b.iter(|| {
+            let scene =
+                Scene3D::from_store(&data_store, &TimeQuery::LatestAt(Time(NUM_FRAMES / 2)));
+            assert_eq!(scene.points.len(), TOTAL_POINTS as usize);
+        });
+    });
+
+    let data_store = generate_date(true, false);
+    group.bench_function("individual_pos_batched_radius", |b| {
+        b.iter(|| {
+            let scene =
+                Scene3D::from_store(&data_store, &TimeQuery::LatestAt(Time(NUM_FRAMES / 2)));
+            assert_eq!(scene.points.len(), TOTAL_POINTS as usize);
+        });
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/prototype/examples/memory_usage.rs b/prototype/examples/memory_usage.rs
new file mode 100644
index 000000000000..f4f596db7b1b
--- /dev/null
+++ b/prototype/examples/memory_usage.rs
@@ -0,0 +1,188 @@
+use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+
+pub struct TrackingAllocator {
+    allocator: mimalloc::MiMalloc,
+
+    cumul_alloc_count: AtomicUsize,
+    cumul_alloc_size: AtomicUsize,
+    cumul_free_count: AtomicUsize,
+    cumul_free_size: AtomicUsize,
+
+    high_water_mark_bytes: AtomicUsize,
+}
+
+#[global_allocator]
+pub static GLOBAL_ALLOCATOR: TrackingAllocator = TrackingAllocator {
+    allocator: mimalloc::MiMalloc,
+
+    cumul_alloc_count: AtomicUsize::new(0),
+    cumul_alloc_size: AtomicUsize::new(0),
+    cumul_free_count: AtomicUsize::new(0),
+    cumul_free_size: AtomicUsize::new(0),
+
+    high_water_mark_bytes: AtomicUsize::new(0),
+};
+
+#[allow(unsafe_code)]
+unsafe impl std::alloc::GlobalAlloc for TrackingAllocator {
+    #[allow(clippy::let_and_return)]
+    unsafe fn alloc(&self, layout: std::alloc::Layout) -> *mut u8 {
+        self.cumul_alloc_count.fetch_add(1, SeqCst);
+        self.cumul_alloc_size.fetch_add(layout.size(), SeqCst);
+
+        let used = self.used_bytes();
+        self.high_water_mark_bytes
+            .store(self.high_water_mark_bytes.load(SeqCst).max(used), SeqCst);
+
+        self.allocator.alloc(layout)
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: std::alloc::Layout) {
+        self.cumul_free_count.fetch_add(1, SeqCst);
+        self.cumul_free_size.fetch_add(layout.size(), SeqCst);
+        self.allocator.dealloc(ptr, layout);
+    }
+}
+
+use prototype::*;
+
+impl TrackingAllocator {
+    fn used_bytes(&self) -> usize {
+        self.cumul_alloc_size.load(SeqCst) - self.cumul_free_size.load(SeqCst)
+    }
+}
+
+fn data_path(camera: u64, index: u64, field: &str) -> DataPath {
+    im::vector![
+        DataPathComponent::Name("camera".into()),
+        DataPathComponent::Index(Index::Sequence(camera)),
+        DataPathComponent::Name("point".into()),
+        DataPathComponent::Index(Index::Sequence(index)),
+        DataPathComponent::Name(field.into()),
+    ]
+}
+
+const BYTES_PER_POINT: usize = 16 + 24; // IndexPathKey + [f32; 3]
+
+pub static GLOBAL_MUTEXT: Option<std::sync::Mutex<()>> = None;
+
+fn tracking_points() {
+    let used_bytes_start = GLOBAL_ALLOCATOR.used_bytes();
+
+    const NUM_FRAMES: usize = 10_000;
+    const OVERLAP: usize = 100;
+
+    let mut num_points = 0;
+
+    let mut store = TypePathDataStore::default();
+    for frame in 0..NUM_FRAMES {
+        for offset in 0..OVERLAP {
+            let (type_path, index_path) =
+                into_type_path(data_path(0, (frame + offset) as _, "pos"));
+            store
+                .insert_individual::<[f32; 3]>(
+                    type_path,
+                    index_path,
+                    TimeValue::Sequence(frame as _),
+                    [1.0, 2.0, 3.0],
+                )
+                .unwrap();
+            num_points += 1;
+        }
+    }
+
+    let used_bytes = GLOBAL_ALLOCATOR.used_bytes() - used_bytes_start;
+
+    let bytes_per_point = used_bytes as f32 / num_points as f32;
+    let overhead_factor = bytes_per_point / BYTES_PER_POINT as f32;
+
+    println!("individual points overhead_factor: {overhead_factor}");
+}
+
+fn big_clouds() {
+    let used_bytes_start = GLOBAL_ALLOCATOR.used_bytes();
+
+    const NUM_CAMERAS: usize = 4;
+    const NUM_FRAMES: usize = 100;
+    const NUM_POINTS_PER_CAMERA: usize = 1_000;
+
+    let mut store = TypePathDataStore::default();
+    let mut frame = 0;
+    let mut num_points = 0;
+    while frame < NUM_FRAMES {
+        for camera in 0..NUM_CAMERAS {
+            for point in 0..NUM_POINTS_PER_CAMERA {
+                let (type_path, index_path) =
+                    into_type_path(data_path(camera as _, point as _, "pos"));
+                store
+                    .insert_individual::<[f32; 3]>(
+                        type_path,
+                        index_path,
+                        TimeValue::Sequence(frame as _),
+                        [1.0, 2.0, 3.0],
+                    )
+                    .unwrap();
+                num_points += 1;
+            }
+            frame += 1;
+        }
+    }
+
+    let used_bytes = GLOBAL_ALLOCATOR.used_bytes() - used_bytes_start;
+
+    let bytes_per_point = used_bytes as f32 / num_points as f32;
+    let overhead_factor = bytes_per_point / BYTES_PER_POINT as f32;
+
+    println!("big clouds overhead_factor: {overhead_factor}");
+}
+
+fn big_clouds_batched() {
+    let used_bytes_start = GLOBAL_ALLOCATOR.used_bytes();
+
+    const NUM_CAMERAS: usize = 4;
+    const NUM_FRAMES: usize = 100;
+    const NUM_POINTS_PER_CAMERA: usize = 1_000;
+
+    let mut store = TypePathDataStore::default();
+    let mut frame = 0;
+    let mut num_points = 0;
+    while frame < NUM_FRAMES {
+        for camera in 0..NUM_CAMERAS {
+            let batch = std::sync::Arc::new(
+                (0..NUM_POINTS_PER_CAMERA)
+                    .map(|i| {
+                        let point: [f32; 3] = [1.0, 2.0, 3.0];
+                        (IndexKey::new(Index::Sequence(i as _)), point)
+                    })
+                    .collect(),
+            );
+            let (type_path, index_path) = into_type_path(data_path(camera as _, 0, "pos"));
+            let (index_path_prefix, _) = index_path.split_last();
+            store
+                .insert_batch::<[f32; 3]>(
+                    type_path,
+                    index_path_prefix,
+                    TimeValue::Sequence(frame as _),
+                    batch,
+                )
+                .unwrap();
+
+            num_points += NUM_POINTS_PER_CAMERA;
+
+            frame += 1;
+        }
+    }
+
+    let used_bytes = GLOBAL_ALLOCATOR.used_bytes() - used_bytes_start;
+
+    let bytes_per_point = used_bytes as f32 / num_points as f32;
+    let overhead_factor = bytes_per_point / BYTES_PER_POINT as f32;
+
+    println!("big clouds batched overhead_factor: {overhead_factor}");
+}
+
+fn main() {
+    tracking_points();
+    big_clouds();
+    big_clouds_batched();
+}
diff --git a/prototype/src/lib.rs b/prototype/src/lib.rs
new file mode 100644
index 000000000000..781fa37778ce
--- /dev/null
+++ b/prototype/src/lib.rs
@@ -0,0 +1,280 @@
+mod scene;
+mod storage;
+
+pub use scene::*;
+pub use storage::*;
+
+use std::collections::BTreeMap;
+
+pub enum AtomType {
+    // 1D:
+    I32,
+    F32,
+
+    Color,
+
+    // ----------------------------
+    // 2D:
+    Pos2,
+    BBox2D,
+    LineSegment2D,
+    Image,
+
+    // ----------------------------
+    // 3D:
+    Pos3,
+    BBox3,
+    Path3D,
+    LineSegment3D,
+    Mesh3D,
+    Camera,
+
+    // ----------------------------
+    // N-D:
+    Vecf32,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum Data {
+    F32(f32),
+    Pos3([f32; 3]),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum StructType {
+    /// ```ignore
+    /// pos: Pos3,
+    /// radius: Option<F32>,
+    /// color: Option<Color>,
+    /// ```
+    Point3D,
+}
+
+// pub struct TypePath(Vec<TypePathComponent>);
+pub type TypePath = im::Vector<TypePathComponent>;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum TypePathComponent {
+    /// Struct member
+    Name(String),
+
+    /// Table (array/map) member.
+    /// Tables are homogenous, so it is the same type path for all.
+    Index,
+}
+
+// pub struct DataPath(Vec<DataPathComponent>);
+pub type DataPath = im::Vector<DataPathComponent>;
+
+pub fn into_type_path(data_path: DataPath) -> (TypePath, IndexPathKey) {
+    let mut type_path = im::Vector::default();
+    let mut index_path = IndexPathKey::default();
+    for component in data_path {
+        match component {
+            DataPathComponent::Name(name) => {
+                type_path.push_back(TypePathComponent::Name(name));
+            }
+            DataPathComponent::Index(index) => {
+                type_path.push_back(TypePathComponent::Index);
+                index_path.push_back(index);
+            }
+        }
+    }
+    (type_path, index_path)
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum DataPathComponent {
+    /// struct member
+    Name(String),
+
+    /// array/table/map member
+    Index(Index),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum Index {
+    /// For arrays, assumed to be dense (0, 1, 2, …)
+    Sequence(u64),
+
+    /// X,Y pixel coordinates, from top left.
+    Pixel([u64; 2]),
+
+    /// Any integer, e.g. a hash
+    Integer(i128),
+
+    /// UUID/GUID
+    // Uuid(Uuid),
+
+    /// Anything goes
+    String(String),
+}
+
+// ----------------------------------------------------------------------------
+
+/// Like `Index` but also includes a precomputed hash.
+#[derive(Clone, Debug, Eq, PartialOrd, Ord)]
+pub struct IndexKey {
+    index: Index,
+    hashes: [u64; 2], // 128 bit to avoid collisions
+}
+
+impl IndexKey {
+    #[inline]
+    pub fn new(index: Index) -> Self {
+        let hashes = double_hash(&index);
+        Self { index, hashes }
+    }
+
+    pub fn index(&self) -> &Index {
+        &self.index
+    }
+}
+
+impl std::cmp::PartialEq for IndexKey {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.hashes == other.hashes // much faster, and low chance of collision
+    }
+}
+
+impl std::hash::Hash for IndexKey {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        state.write_u64(self.hashes[0]);
+    }
+}
+
+impl nohash_hasher::IsEnabled for IndexKey {}
+
+impl From<Index> for IndexKey {
+    #[inline]
+    fn from(index: Index) -> Self {
+        IndexKey::new(index)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Debug, Default, Eq, PartialOrd, Ord)]
+pub struct IndexPathKey {
+    components: im::Vector<Index>,
+    hashes: [u64; 2], // 128 bit to avoid collisions
+}
+
+impl IndexPathKey {
+    #[inline]
+    pub fn new(components: im::Vector<Index>) -> Self {
+        let mut slf = Self::default();
+        for index in components {
+            slf.push_back(index);
+        }
+        slf
+    }
+
+    pub fn push_back(&mut self, index: impl Into<IndexKey>) {
+        let index = index.into();
+
+        self.components.push_back(index.index);
+        self.hashes[0] = self.hashes[0].rotate_left(5);
+        self.hashes[1] = self.hashes[1].rotate_left(5);
+        self.hashes[0] ^= index.hashes[0];
+        self.hashes[1] ^= index.hashes[1];
+    }
+
+    /// Split off the last component.
+    pub fn split_last(mut self) -> (IndexPathKey, IndexKey) {
+        let index = IndexKey::new(self.components.pop_back().unwrap());
+        self.hashes[0] ^= index.hashes[0];
+        self.hashes[1] ^= index.hashes[1];
+        self.hashes[0] = self.hashes[0].rotate_right(5);
+        self.hashes[1] = self.hashes[1].rotate_right(5);
+        (self, index)
+    }
+}
+
+impl std::cmp::PartialEq for IndexPathKey {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.hashes == other.hashes // much faster, and low chance of collision
+    }
+}
+
+impl std::hash::Hash for IndexPathKey {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        state.write_u64(self.hashes[0]);
+    }
+}
+
+impl nohash_hasher::IsEnabled for IndexPathKey {}
+
+#[test]
+fn test_index_path_key() {
+    let key0 = IndexPathKey::default();
+
+    let mut key1 = key0.clone();
+    key1.push_back(Index::Sequence(0));
+    let key1 = key1;
+
+    let mut key2 = key1.clone();
+    key2.push_back(Index::Sequence(1));
+    let key2 = key2;
+
+    assert_eq!(key0.components.len(), 0);
+    assert_eq!(key1.components.len(), 1);
+    assert_eq!(key2.components.len(), 2);
+
+    let (key0_again, seq0) = key1.clone().split_last();
+    assert_eq!(key0_again.components.len(), 0);
+    assert_eq!(key0_again, key0);
+    assert_eq!(seq0, IndexKey::new(Index::Sequence(0)));
+
+    let (key1_again, seq1) = key2.split_last();
+    assert_eq!(key1_again.components.len(), 1);
+    assert_eq!(key1_again, key1);
+    assert_eq!(seq1, IndexKey::new(Index::Sequence(1)));
+}
+
+// ----------------------------------------------------------------------------
+
+#[inline]
+fn double_hash(value: impl std::hash::Hash + Copy) -> [u64; 2] {
+    [hash_with_seed(value, 123), hash_with_seed(value, 456)]
+}
+
+/// Hash the given value.
+#[inline]
+fn hash_with_seed(value: impl std::hash::Hash, seed: u128) -> u64 {
+    use std::hash::Hasher as _;
+    let mut hasher = ahash::AHasher::new_with_keys(666, seed);
+    value.hash(&mut hasher);
+    hasher.finish()
+}
+
+// ----------------------------------------------------------------------------
+
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub enum TimeValue {
+    // Time(Time), // TODO
+    Sequence(i64),
+}
+
+impl TimeValue {
+    pub fn to_i64(&self) -> i64 {
+        match self {
+            Self::Sequence(value) => *value,
+        }
+    }
+}
+
+/// A point in time.
+///
+/// It can be represented by [`Time`], a sequence index, or a mix of several things.
+#[derive(Clone, Debug, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct TimeStamp(pub BTreeMap<String, TimeValue>);
+
+pub enum TimeQuery<Time> {
+    LatestAt(Time),
+    Range(std::ops::RangeInclusive<Time>),
+}
diff --git a/prototype/src/scene.rs b/prototype/src/scene.rs
new file mode 100644
index 000000000000..d7e8bd765a79
--- /dev/null
+++ b/prototype/src/scene.rs
@@ -0,0 +1,40 @@
+use crate::*;
+
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub struct Point3<'s> {
+    pub pos: &'s [f32; 3],
+    pub radius: Option<f32>,
+}
+
+#[derive(Default)]
+pub struct Scene3D<'s> {
+    pub points: Vec<Point3<'s>>,
+}
+
+impl<'s> Scene3D<'s> {
+    pub fn from_store<Time: 'static + Clone + Ord>(
+        store: &'s TypePathDataStore<Time>,
+        time_query: &TimeQuery<Time>,
+    ) -> Self {
+        let mut slf = Self::default();
+
+        for (type_path, _) in store.iter() {
+            if type_path.last() == Some(&TypePathComponent::Name("pos".into())) {
+                visit_data_and_siblings(
+                    store,
+                    time_query,
+                    type_path,
+                    ("radius",),
+                    |pos: &[f32; 3], radius: Option<&f32>| {
+                        slf.points.push(Point3 {
+                            pos,
+                            radius: radius.copied(),
+                        });
+                    },
+                );
+            }
+        }
+
+        slf
+    }
+}
diff --git a/prototype/src/storage.rs b/prototype/src/storage.rs
new file mode 100644
index 000000000000..887d1db1e94f
--- /dev/null
+++ b/prototype/src/storage.rs
@@ -0,0 +1,434 @@
+use crate::{IndexKey, IndexPathKey, TimeQuery, TypePath, TypePathComponent};
+
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use ahash::AHashMap;
+use nohash_hasher::IntMap;
+
+#[derive(Clone, Copy, Debug)]
+pub enum Error {
+    /// First stored as a batch, then individually. Not supported.
+    BatchFollowedByIndividual,
+
+    /// First stored individually, then followed by a batch. Not supported.
+    IndividualFollowedByBatch,
+
+    /// One type was first logged, then another.
+    WrongType,
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+// ----------------------------------------------------------------------------
+
+/// Can be shared between different timelines.
+pub type Batch<T> = Arc<IntMap<IndexKey, T>>;
+
+/// One per each time source.
+pub struct TypePathDataStore<Time> {
+    data: AHashMap<TypePath, DataStoreTypeErased<Time>>,
+}
+
+impl<Time> Default for TypePathDataStore<Time> {
+    fn default() -> Self {
+        Self {
+            data: Default::default(),
+        }
+    }
+}
+
+impl<Time: 'static + Ord> TypePathDataStore<Time> {
+    pub fn insert_individual<T: 'static>(
+        &mut self,
+        type_path: TypePath,
+        index_path: IndexPathKey,
+        time: Time,
+        value: T,
+    ) -> Result<()> {
+        if let Some(store) = self
+            .data
+            .entry(type_path)
+            .or_insert_with(|| DataStoreTypeErased::new_individual::<T>())
+            .write::<T>()
+        {
+            store.insert_individual(index_path, time, value)
+        } else {
+            Err(Error::WrongType)
+        }
+    }
+
+    pub fn insert_batch<T: 'static>(
+        &mut self,
+        type_path: TypePath,
+        index_path_prefix: IndexPathKey,
+        time: Time,
+        values: Batch<T>,
+    ) -> Result<()> {
+        if let Some(store) = self
+            .data
+            .entry(type_path)
+            .or_insert_with(|| DataStoreTypeErased::new_batched::<T>())
+            .write::<T>()
+        {
+            store.insert_batch(index_path_prefix, time, values)
+        } else {
+            Err(Error::WrongType)
+        }
+    }
+
+    pub fn get<T: 'static>(&self, type_path: &TypePath) -> Option<&DataStore<Time, T>> {
+        self.data.get(type_path).and_then(|x| x.read::<T>())
+    }
+
+    pub fn iter(&self) -> impl ExactSizeIterator<Item = (&TypePath, &DataStoreTypeErased<Time>)> {
+        self.data.iter()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Type-erased version of [`DataStore`].
+pub struct DataStoreTypeErased<Time>(Box<dyn std::any::Any>, std::marker::PhantomData<Time>);
+
+impl<Time: 'static + Ord> DataStoreTypeErased<Time> {
+    fn new_individual<T: 'static>() -> Self {
+        Self(
+            Box::new(DataStore::<Time, T>::new_individual()),
+            Default::default(),
+        )
+    }
+
+    fn new_batched<T: 'static>() -> Self {
+        Self(
+            Box::new(DataStore::<Time, T>::new_batched()),
+            Default::default(),
+        )
+    }
+
+    pub fn read_no_warn<T: 'static>(&self) -> Option<&DataStore<Time, T>> {
+        self.0.downcast_ref::<DataStore<Time, T>>()
+    }
+
+    pub fn read<T: 'static>(&self) -> Option<&DataStore<Time, T>> {
+        if let Some(read) = self.read_no_warn() {
+            Some(read)
+        } else {
+            tracing::warn!("Expected {}", std::any::type_name::<T>());
+            None
+        }
+    }
+
+    pub fn write<T: 'static>(&mut self) -> Option<&mut DataStore<Time, T>> {
+        self.0.downcast_mut::<DataStore<Time, T>>()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub enum DataStore<Time, T> {
+    /// Individual data at this path.
+    Individual(IndividualDataHistory<Time, T>),
+
+    Batched(BatchedDataHistory<Time, T>),
+}
+
+impl<Time: Ord, T: 'static> DataStore<Time, T> {
+    fn new_individual() -> Self {
+        Self::Individual(Default::default())
+    }
+
+    fn new_batched() -> Self {
+        Self::Batched(Default::default())
+    }
+
+    pub fn insert_individual(
+        &mut self,
+        index_path: IndexPathKey,
+        time: Time,
+        value: T,
+    ) -> Result<()> {
+        match self {
+            Self::Individual(individual) => {
+                individual.insert(index_path, time, value);
+                Ok(())
+            }
+            Self::Batched(_) => Err(Error::BatchFollowedByIndividual),
+        }
+    }
+
+    pub fn insert_batch(
+        &mut self,
+        index_path_prefix: IndexPathKey,
+        time: Time,
+        values: Batch<T>,
+    ) -> Result<()> {
+        match self {
+            Self::Individual(_) => Err(Error::IndividualFollowedByBatch),
+            Self::Batched(batched) => {
+                batched.insert(index_path_prefix, time, values);
+                Ok(())
+            }
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// For a specific [`TypePath`].
+pub struct IndividualDataHistory<Time, T> {
+    /// fast to find latest value at a certain time.
+    values: IntMap<IndexPathKey, BTreeMap<Time, T>>,
+}
+
+impl<Time: Ord, T> Default for IndividualDataHistory<Time, T> {
+    fn default() -> Self {
+        Self {
+            values: Default::default(),
+        }
+    }
+}
+
+impl<Time: Ord, T> IndividualDataHistory<Time, T> {
+    pub fn insert(&mut self, index_path: IndexPathKey, time: Time, value: T) {
+        self.values
+            .entry(index_path)
+            .or_default()
+            .insert(time, value);
+    }
+
+    pub fn iter(&self) -> impl ExactSizeIterator<Item = (&IndexPathKey, &BTreeMap<Time, T>)> {
+        self.values.iter()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// For a specific [`TypePath`].
+pub struct BatchedDataHistory<Time, T> {
+    /// The index is the path prefix (everything but the last value).
+    batches_over_time: IntMap<IndexPathKey, BTreeMap<Time, Batch<T>>>,
+}
+
+impl<Time: Ord, T> Default for BatchedDataHistory<Time, T> {
+    fn default() -> Self {
+        Self {
+            batches_over_time: Default::default(),
+        }
+    }
+}
+
+impl<Time: Ord, T> BatchedDataHistory<Time, T> {
+    pub fn insert(&mut self, index_path_prefix: IndexPathKey, time: Time, values: Batch<T>) {
+        self.batches_over_time
+            .entry(index_path_prefix)
+            .or_default()
+            .insert(time, values);
+    }
+
+    pub fn iter(
+        &self,
+    ) -> impl ExactSizeIterator<Item = (&IndexPathKey, &BTreeMap<Time, Batch<T>>)> {
+        self.batches_over_time.iter()
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub enum IndividualDataReader<'store, Time, T> {
+    None,
+    Individual(&'store IndividualDataHistory<Time, T>),
+    Batched(&'store BatchedDataHistory<Time, T>),
+}
+
+impl<'store, Time: 'static + Ord, T: 'static> IndividualDataReader<'store, Time, T> {
+    pub fn new(store: &'store TypePathDataStore<Time>, type_path: &TypePath) -> Self {
+        if let Some(data) = store.get::<T>(type_path) {
+            match data {
+                DataStore::Individual(individual) => Self::Individual(individual),
+                DataStore::Batched(batched) => Self::Batched(batched),
+            }
+        } else {
+            Self::None
+        }
+    }
+
+    pub fn latest_at(&self, index_path: &IndexPathKey, query_time: &Time) -> Option<&'store T> {
+        match self {
+            Self::None => None,
+            Self::Individual(history) => {
+                latest_at(history.values.get(index_path)?, query_time).map(|(_time, value)| value)
+            }
+            Self::Batched(data) => {
+                let (prefix, suffix) = index_path.clone().split_last();
+                latest_at(data.batches_over_time.get(&prefix)?, query_time)?
+                    .1
+                    .get(&suffix)
+            }
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub enum BatchedDataReader<'store, Time, T> {
+    None,
+    Individual(IndexPathKey, Time, &'store IndividualDataHistory<Time, T>),
+    Batched(&'store IntMap<IndexKey, T>),
+}
+
+impl<'store, Time: Clone + Ord, T: 'static> BatchedDataReader<'store, Time, T> {
+    pub fn new(
+        data: Option<&'store DataStore<Time, T>>,
+        index_path_prefix: &IndexPathKey,
+        query_time: &Time,
+    ) -> Self {
+        data.and_then(|data| Self::new_opt(data, index_path_prefix, query_time))
+            .unwrap_or(Self::None)
+    }
+
+    fn new_opt(
+        data: &'store DataStore<Time, T>,
+        index_path_prefix: &IndexPathKey,
+        query_time: &Time,
+    ) -> Option<Self> {
+        match data {
+            DataStore::Individual(individual) => Some(Self::Individual(
+                index_path_prefix.clone(),
+                query_time.clone(),
+                individual,
+            )),
+            DataStore::Batched(batched) => {
+                let everything_per_time = &batched.batches_over_time.get(index_path_prefix)?;
+                let (_, map) = latest_at(everything_per_time, query_time)?;
+                Some(Self::Batched(map))
+            }
+        }
+    }
+
+    pub fn latest_at(&self, index_path_suffix: &IndexKey) -> Option<&'store T> {
+        match self {
+            Self::None => None,
+            Self::Individual(index_path_prefix, query_time, history) => {
+                let mut index_path = index_path_prefix.clone();
+                index_path.push_back(index_path_suffix.clone());
+                latest_at(history.values.get(&index_path)?, query_time).map(|(_time, value)| value)
+            }
+            Self::Batched(data) => data.get(index_path_suffix),
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+fn latest_at<'data, Time: Ord, T>(
+    data_over_time: &'data BTreeMap<Time, T>,
+    query_time: &'_ Time,
+) -> Option<(&'data Time, &'data T)> {
+    data_over_time.range(..=query_time).rev().next()
+}
+
+fn values_in_range<'data, Time: Ord, T>(
+    data_over_time: &'data BTreeMap<Time, T>,
+    time_range: &'_ std::ops::RangeInclusive<Time>,
+) -> impl Iterator<Item = (&'data Time, &'data T)> {
+    data_over_time.range(time_range.start()..=time_range.end())
+}
+
+pub fn query<'data, Time: Ord, T>(
+    data_over_time: &'data BTreeMap<Time, T>,
+    time_query: &TimeQuery<Time>,
+    mut visit: impl FnMut(&Time, &'data T),
+) {
+    match time_query {
+        TimeQuery::LatestAt(query_time) => {
+            if let Some((_data_time, data)) = latest_at(data_over_time, query_time) {
+                // we use `query_time` here instead of a`data_time`
+                // because we want to also query for the latest radius, not the latest radius at the time of the position.
+                visit(query_time, data);
+            }
+        }
+        TimeQuery::Range(query_range) => {
+            for (data_time, data) in values_in_range(data_over_time, query_range) {
+                visit(data_time, data);
+            }
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+pub fn visit_data<'s, Time: 'static + Ord, T: 'static>(
+    store: &'s TypePathDataStore<Time>,
+    time_query: &TimeQuery<Time>,
+    primary_type_path: &TypePath,
+    mut visit: impl FnMut(&'s T),
+) -> Option<()> {
+    let primary_data = store.get::<T>(primary_type_path)?;
+
+    match primary_data {
+        DataStore::Individual(primary) => {
+            for (_index_path, values_over_time) in primary.iter() {
+                query(values_over_time, time_query, |_time, primary| {
+                    visit(primary);
+                });
+            }
+        }
+        DataStore::Batched(primary) => {
+            for (_index_path_prefix, primary) in primary.iter() {
+                query(primary, time_query, |_time, primary| {
+                    for primary in primary.values() {
+                        visit(primary);
+                    }
+                });
+            }
+        }
+    }
+
+    Some(())
+}
+
+pub fn visit_data_and_siblings<'s, Time: 'static + Clone + Ord, T: 'static, S1: 'static>(
+    store: &'s TypePathDataStore<Time>,
+    time_query: &TimeQuery<Time>,
+    primary_type_path: &TypePath,
+    (sibling1,): (&str,),
+    mut visit: impl FnMut(&'s T, Option<&'s S1>),
+) -> Option<()> {
+    let primary_data = store.get::<T>(primary_type_path)?;
+    let sibling1_path = sibling(primary_type_path, sibling1);
+
+    match primary_data {
+        DataStore::Individual(primary) => {
+            let sibling1_reader = IndividualDataReader::<Time, S1>::new(store, &sibling1_path);
+            for (index_path, values_over_time) in primary.iter() {
+                query(values_over_time, time_query, |time, primary| {
+                    let sibling1 = sibling1_reader.latest_at(index_path, time);
+                    visit(primary, sibling1);
+                });
+            }
+        }
+        DataStore::Batched(primary) => {
+            for (index_path_prefix, primary) in primary.iter() {
+                let sibling1_store = store.get::<S1>(&sibling1_path);
+                query(primary, time_query, |time, primary| {
+                    let sibling1_reader =
+                        BatchedDataReader::new(sibling1_store, index_path_prefix, time);
+                    for (index_path_suffix, primary) in primary.iter() {
+                        let sibling1 = sibling1_reader.latest_at(index_path_suffix);
+                        visit(primary, sibling1);
+                    }
+                });
+            }
+        }
+    }
+
+    Some(())
+}
+
+fn sibling(type_path: &TypePath, name: &str) -> TypePath {
+    let mut type_path = type_path.clone();
+    type_path.pop_back();
+    type_path.push_back(TypePathComponent::Name(name.into()));
+    type_path
+}
diff --git a/prototype/tests/test_data_store.rs b/prototype/tests/test_data_store.rs
new file mode 100644
index 000000000000..e9ebf9187ec1
--- /dev/null
+++ b/prototype/tests/test_data_store.rs
@@ -0,0 +1,557 @@
+use prototype::*;
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+struct Time(i64);
+
+fn batch<T, const N: usize>(batch: [(IndexKey, T); N]) -> Batch<T> {
+    let batch: nohash_hasher::IntMap<IndexKey, T> = batch.into_iter().collect();
+    std::sync::Arc::new(batch)
+}
+
+#[test]
+fn test_singular() -> prototype::Result<()> {
+    fn points_at(store: &TypePathDataStore<Time>, frame: i64) -> Vec<Point3<'_>> {
+        let time_query = TimeQuery::LatestAt(Time(frame));
+        let mut points = Scene3D::from_store(store, &time_query).points;
+        points.sort_by(|a, b| a.partial_cmp(b).unwrap());
+        points
+    }
+
+    fn index_path(cam: &str, point: u64) -> IndexPathKey {
+        IndexPathKey::new(im::vector![
+            Index::String(cam.into()),
+            Index::Sequence(point)
+        ])
+    }
+
+    fn pos_type_path() -> TypePath {
+        im::vector![
+            TypePathComponent::Name("camera".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("point".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("pos".into()),
+        ]
+    }
+    fn radius_type_path() -> TypePath {
+        im::vector![
+            TypePathComponent::Name("camera".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("point".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("radius".into()),
+        ]
+    }
+
+    let mut store = TypePathDataStore::default();
+
+    store.insert_individual::<[f32; 3]>(
+        pos_type_path(),
+        index_path("left", 0),
+        Time(1),
+        [1.0, 1.0, 1.0],
+    )?;
+
+    store.insert_individual::<[f32; 3]>(
+        pos_type_path(),
+        index_path("left", 0),
+        Time(3),
+        [3.0, 3.0, 3.0],
+    )?;
+
+    store.insert_individual::<f32>(radius_type_path(), index_path("left", 0), Time(2), 1.0)?;
+
+    store.insert_individual::<[f32; 3]>(
+        pos_type_path(),
+        index_path("left", 1),
+        Time(4),
+        [4.0, 4.0, 4.0],
+    )?;
+
+    assert_eq!(points_at(&store, 0), vec![]);
+
+    assert_eq!(
+        points_at(&store, 1),
+        vec![Point3 {
+            pos: &[1.0, 1.0, 1.0],
+            radius: None
+        }]
+    );
+
+    assert_eq!(
+        points_at(&store, 2),
+        vec![Point3 {
+            pos: &[1.0, 1.0, 1.0],
+            radius: Some(1.0)
+        }]
+    );
+
+    assert_eq!(
+        points_at(&store, 3),
+        vec![Point3 {
+            pos: &[3.0, 3.0, 3.0],
+            radius: Some(1.0)
+        }]
+    );
+
+    assert_eq!(
+        points_at(&store, 4),
+        vec![
+            Point3 {
+                pos: &[3.0, 3.0, 3.0],
+                radius: Some(1.0)
+            },
+            Point3 {
+                pos: &[4.0, 4.0, 4.0],
+                radius: None
+            }
+        ]
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_batches() -> prototype::Result<()> {
+    fn index_path_prefix(cam: &str) -> IndexPathKey {
+        IndexPathKey::new(im::vector![Index::String(cam.into())])
+    }
+
+    fn prim() -> TypePath {
+        im::vector![
+            TypePathComponent::Name("camera".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("point".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("pos".into()),
+        ]
+    }
+    fn sibling() -> TypePath {
+        im::vector![
+            TypePathComponent::Name("camera".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("point".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("label".into()),
+        ]
+    }
+
+    fn values(store: &TypePathDataStore<Time>, frame: i64) -> Vec<(i32, Option<&str>)> {
+        let time_query = TimeQuery::LatestAt(Time(frame));
+        let mut values = vec![];
+        visit_data_and_siblings(store, &time_query, &prim(), ("label",), |prim, sibling| {
+            values.push((*prim, sibling.copied()));
+        });
+        values.sort();
+        values
+    }
+
+    fn index(seq: u64) -> IndexKey {
+        IndexKey::new(Index::Sequence(seq))
+    }
+
+    let mut store = TypePathDataStore::default();
+
+    store.insert_batch(
+        prim(),
+        index_path_prefix("left"),
+        Time(1),
+        batch([
+            (index(0), 0_i32),
+            (index(1), 1_i32),
+            (index(2), 2_i32),
+            (index(3), 3_i32),
+        ]),
+    )?;
+    store.insert_batch(
+        prim(),
+        index_path_prefix("right"),
+        Time(2),
+        batch([
+            (index(0), 1_000_i32),
+            (index(1), 1_001_i32),
+            (index(2), 1_002_i32),
+            (index(3), 1_003_i32),
+        ]),
+    )?;
+    store.insert_batch(
+        prim(),
+        index_path_prefix("left"),
+        Time(3),
+        batch([
+            // 0, 1 omitted = dropped
+            (index(2), 22_i32),
+            (index(3), 33_i32),
+        ]),
+    )?;
+    store.insert_batch(
+        sibling(),
+        index_path_prefix("left"),
+        Time(4),
+        batch([(index(1), "one"), (index(2), "two")]),
+    )?;
+    store.insert_batch(
+        sibling(),
+        index_path_prefix("right"),
+        Time(5),
+        batch([
+            (index(0), "r0"),
+            (index(1), "r1"),
+            (index(2), "r2"),
+            (index(3), "r3"),
+            (index(4), "r4"), // has no point yet
+        ]),
+    )?;
+    store.insert_batch(
+        prim(),
+        index_path_prefix("right"),
+        Time(6),
+        batch([
+            (index(3), 1_003_i32),
+            (index(4), 1_004_i32),
+            (index(5), 1_005_i32),
+        ]),
+    )?;
+    store.insert_batch(
+        sibling(),
+        index_path_prefix("right"),
+        Time(7),
+        batch([
+            (index(3), "r3_new"),
+            // omitted = replaced
+        ]),
+    )?;
+
+    assert_eq!(values(&store, 0), vec![]);
+    assert_eq!(
+        values(&store, 1),
+        vec![(0, None), (1, None), (2, None), (3, None),]
+    );
+    assert_eq!(
+        values(&store, 2),
+        vec![
+            (0, None),
+            (1, None),
+            (2, None),
+            (3, None),
+            (1_000, None),
+            (1_001, None),
+            (1_002, None),
+            (1_003, None),
+        ]
+    );
+    assert_eq!(
+        values(&store, 3),
+        vec![
+            (22, None),
+            (33, None),
+            (1_000, None),
+            (1_001, None),
+            (1_002, None),
+            (1_003, None),
+        ]
+    );
+    assert_eq!(
+        values(&store, 4),
+        vec![
+            (22, Some("two")),
+            (33, None),
+            (1_000, None),
+            (1_001, None),
+            (1_002, None),
+            (1_003, None),
+        ]
+    );
+    assert_eq!(
+        values(&store, 5),
+        vec![
+            (22, Some("two")),
+            (33, None),
+            (1_000, Some("r0")),
+            (1_001, Some("r1")),
+            (1_002, Some("r2")),
+            (1_003, Some("r3")),
+        ]
+    );
+    assert_eq!(
+        values(&store, 6),
+        vec![
+            (22, Some("two")),
+            (33, None),
+            (1_003, Some("r3")),
+            (1_004, Some("r4")),
+            (1_005, None),
+        ]
+    );
+    assert_eq!(
+        values(&store, 7),
+        vec![
+            (22, Some("two")),
+            (33, None),
+            (1_003, Some("r3_new")),
+            (1_004, None),
+            (1_005, None),
+        ]
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_batched_and_individual() -> prototype::Result<()> {
+    fn index_path_prefix(cam: &str) -> IndexPathKey {
+        IndexPathKey::new(im::vector![Index::String(cam.into())])
+    }
+
+    fn index_path_key(cam: &str, point: u64) -> IndexPathKey {
+        IndexPathKey::new(im::vector![
+            Index::String(cam.into()),
+            Index::Sequence(point)
+        ])
+    }
+
+    fn prim() -> TypePath {
+        im::vector![
+            TypePathComponent::Name("camera".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("point".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("pos".into()),
+        ]
+    }
+    fn sibling() -> TypePath {
+        im::vector![
+            TypePathComponent::Name("camera".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("point".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("label".into()),
+        ]
+    }
+
+    fn values(store: &TypePathDataStore<Time>, frame: i64) -> Vec<(i32, Option<&str>)> {
+        let time_query = TimeQuery::LatestAt(Time(frame));
+        let mut values = vec![];
+        visit_data_and_siblings(store, &time_query, &prim(), ("label",), |prim, sibling| {
+            values.push((*prim, sibling.copied()));
+        });
+        values.sort();
+        values
+    }
+
+    fn index(seq: u64) -> IndexKey {
+        IndexKey::new(Index::Sequence(seq))
+    }
+
+    let mut store = TypePathDataStore::default();
+
+    store.insert_batch(
+        prim(),
+        index_path_prefix("left"),
+        Time(1),
+        batch([
+            (index(0), 0_i32),
+            (index(1), 1_i32),
+            (index(2), 2_i32),
+            (index(3), 3_i32),
+        ]),
+    )?;
+    store.insert_batch(
+        prim(),
+        index_path_prefix("right"),
+        Time(2),
+        batch([
+            (index(0), 1_000_i32),
+            (index(1), 1_001_i32),
+            (index(2), 1_002_i32),
+            (index(3), 1_003_i32),
+        ]),
+    )?;
+    store.insert_batch(
+        prim(),
+        index_path_prefix("left"),
+        Time(3),
+        batch([
+            // 0, 1 omitted = dropped
+            (index(2), 22_i32),
+            (index(3), 33_i32),
+        ]),
+    )?;
+    store.insert_individual(sibling(), index_path_key("left", 1), Time(4), "one")?;
+    store.insert_individual(sibling(), index_path_key("left", 2), Time(4), "two")?;
+    for (index, value) in [
+        (0, "r0"),
+        (1, "r1"),
+        (2, "r2"),
+        (3, "r3"),
+        (4, "r4"), // has no point yet
+    ] {
+        store.insert_individual(sibling(), index_path_key("right", index), Time(5), value)?;
+    }
+    store.insert_batch(
+        prim(),
+        index_path_prefix("right"),
+        Time(6),
+        batch([
+            (index(3), 1_003_i32),
+            (index(4), 1_004_i32),
+            (index(5), 1_005_i32),
+        ]),
+    )?;
+    store.insert_individual(sibling(), index_path_key("right", 5), Time(7), "r5")?;
+
+    assert_eq!(values(&store, 0), vec![]);
+    assert_eq!(
+        values(&store, 1),
+        vec![(0, None), (1, None), (2, None), (3, None),]
+    );
+    assert_eq!(
+        values(&store, 2),
+        vec![
+            (0, None),
+            (1, None),
+            (2, None),
+            (3, None),
+            (1_000, None),
+            (1_001, None),
+            (1_002, None),
+            (1_003, None),
+        ]
+    );
+    assert_eq!(
+        values(&store, 3),
+        vec![
+            (22, None),
+            (33, None),
+            (1_000, None),
+            (1_001, None),
+            (1_002, None),
+            (1_003, None),
+        ]
+    );
+    assert_eq!(
+        values(&store, 4),
+        vec![
+            (22, Some("two")),
+            (33, None),
+            (1_000, None),
+            (1_001, None),
+            (1_002, None),
+            (1_003, None),
+        ]
+    );
+    assert_eq!(
+        values(&store, 5),
+        vec![
+            (22, Some("two")),
+            (33, None),
+            (1_000, Some("r0")),
+            (1_001, Some("r1")),
+            (1_002, Some("r2")),
+            (1_003, Some("r3")),
+        ]
+    );
+    assert_eq!(
+        values(&store, 6),
+        vec![
+            (22, Some("two")),
+            (33, None),
+            (1_003, Some("r3")),
+            (1_004, Some("r4")),
+            (1_005, None),
+        ]
+    );
+    assert_eq!(
+        values(&store, 7),
+        vec![
+            (22, Some("two")),
+            (33, None),
+            (1_003, Some("r3")),
+            (1_004, Some("r4")),
+            (1_005, Some("r5")),
+        ]
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_individual_and_batched() -> prototype::Result<()> {
+    fn index_path_prefix(cam: &str) -> IndexPathKey {
+        IndexPathKey::new(im::vector![Index::String(cam.into())])
+    }
+
+    fn index_path_key(cam: &str, point: u64) -> IndexPathKey {
+        IndexPathKey::new(im::vector![
+            Index::String(cam.into()),
+            Index::Sequence(point)
+        ])
+    }
+
+    fn prim() -> TypePath {
+        im::vector![
+            TypePathComponent::Name("camera".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("point".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("pos".into()),
+        ]
+    }
+    fn sibling() -> TypePath {
+        im::vector![
+            TypePathComponent::Name("camera".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("point".into()),
+            TypePathComponent::Index,
+            TypePathComponent::Name("label".into()),
+        ]
+    }
+
+    fn values(store: &TypePathDataStore<Time>, frame: i64) -> Vec<(i32, Option<&str>)> {
+        let time_query = TimeQuery::LatestAt(Time(frame));
+        let mut values = vec![];
+        visit_data_and_siblings(store, &time_query, &prim(), ("label",), |prim, sibling| {
+            values.push((*prim, sibling.copied()));
+        });
+        values.sort();
+        values
+    }
+
+    fn index(seq: u64) -> IndexKey {
+        IndexKey::new(Index::Sequence(seq))
+    }
+
+    let mut store = TypePathDataStore::default();
+
+    store.insert_individual(prim(), index_path_key("left", 0), Time(1), 0_i32)?;
+    store.insert_individual(prim(), index_path_key("left", 1), Time(2), 1_i32)?;
+    store.insert_batch(
+        sibling(),
+        index_path_prefix("left"),
+        Time(3),
+        batch([(index(1), "one"), (index(2), "two")]),
+    )?;
+    store.insert_individual(prim(), index_path_key("left", 2), Time(4), 2_i32)?;
+    store.insert_individual(prim(), index_path_key("left", 3), Time(4), 3_i32)?;
+    store.insert_batch(
+        sibling(),
+        index_path_prefix("left"),
+        Time(5),
+        batch([(index(2), "two"), (index(3), "three")]),
+    )?;
+
+    assert_eq!(values(&store, 0), vec![]);
+    assert_eq!(values(&store, 1), vec![(0, None)]);
+    assert_eq!(values(&store, 2), vec![(0, None), (1, None)]);
+    assert_eq!(values(&store, 3), vec![(0, None), (1, Some("one"))]);
+    assert_eq!(
+        values(&store, 4),
+        vec![(0, None), (1, Some("one")), (2, Some("two")), (3, None)]
+    );
+    assert_eq!(
+        values(&store, 5),
+        vec![(0, None), (1, None), (2, Some("two")), (3, Some("three"))]
+    );
+
+    Ok(())
+}