diff --git a/CHANGELOG.md b/CHANGELOG.md index c9ed991..4a90f89 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - **tests**: `ReaderApiFlatBuffers.CancelledPrefetchReEntersWindow` -- focused regression for the bug above. Runs the cancel + re-enter pattern (prime chunks 0..2, jump to chunk 10 to cancel, jump to chunk 2 to revive) 50 times against a fresh reader each iteration. Pre-fix this fails ~every run under TSan and flakes at single-digit-% on stock release; post-fix it is deterministic green on both +- **benchmarks**: `BM_FrameAccessor_Creation` (isolated `reader->CreateAccessor()` cost, ~6.77 µs/iter) and `BM_EntityView_SingleGet` (isolated `EntityView view(entity); view.Get(key)` cost, 1.70 ns/iter = 585 M reads/s ceiling). Fills the "what does each accessor layer cost on its own?" framing gap -- previously every accessor number was bundled with entity iteration overhead, so customers asking "how fast is your property read?" only had the mixed number. Paired with the existing `BM_AccessorKeyResolution` (74 ns/key), the three new benchmarks decompose the public property-access API (`FrameAccessor` -> `PropertyKey` -> `EntityView`) into three independently measurable layers +- **docs**: new `docs/PERFORMANCE.md` landing page -- visual health-check table, headline numbers, three-layer accessor breakdown, cache-window finding with its 59 %-slower trap, format-choice caveat, honest "what these numbers do not prove" section. Linked from `README.md` and `docs/BUILD.md` +- **docs**: `README.md` now has a "Performance at a glance" section up top with a headline table and the traffic-light health check. Non-engineering readers landing on the GitHub page get a truthful one-screen summary before the build instructions +- **docs/BUILD.md**: new "Running benchmarks locally" section mirroring the sanitizer section -- covers configure, full-suite run, filtered run, fixture requirements +- **reports/benchmarks/**: raw output of the 2026-04-23 16:20 canonical run committed (`bench_20260423_162008.{txt,json}`) for baseline tracking and future regression comparison. First run to separately measure the three accessor layers (`FrameAccessor` creation, `PropertyKey` resolution, `EntityView::Get`). Narrative interpretation lives in `docs/PERFORMANCE.md` rather than in a per-run markdown snapshot -- evergreen doc, one source of truth ## [Unreleased] - 2026-04-22 diff --git a/README.md b/README.md index 1b553a6..124a623 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,40 @@ A high-performance C++20 toolkit for recording, reading, comparing, and inspecting structured replay data. VTX serializes frame-based entity state into a compact, chunked binary format with support for **Protocol Buffers** and **FlatBuffers** backends. +## Performance at a glance + +Measured on the CS2 (92 MB, 10 656 frames) and Rocket League (5 MB, ~21 k frames) real-world fixtures on a modern dev laptop. Full breakdown in [`docs/PERFORMANCE.md`](docs/PERFORMANCE.md). + +| Task | Number | Notes | +|---|---|---| +| Writing frames end-to-end | **~82 k frames/s** | 30-min 60 fps match ≈ 1.3 s of CPU. | +| Full sequential read (CS2, 92 MB) | **~5.6 s** (median) | Competitive with peer tooling. | +| Preview first 1 000 frames | **~1 s** | Below UX perceptibility. | +| `EntityView::Get` (isolated) | **1.70 ns** (585 M/s) | Theoretical ceiling. | +| `EntityView::Get` (realistic hot loop) | **~80 ns** (13 M/s) | What real integrations observe. | +| Diff consecutive frames | **4 µs** (267 k/s) | Instant from a user perspective. | + +### Health check + +| Area | Verdict | Why | +|---|---|---| +| Writer throughput | 🟢 Fast | ~10× headroom over real-time recording. | +| Full sequential read | 🟢 Fast enough | 5.6 s for a 92 MB replay (median). | +| Preview + seek-play | 🟢 Fast | Sub-second scrubbing. | +| Cache-window **well-sized** | 🟢 Fast | <4 s for 50 random jumps. | +| Cache-window **mis-sized** | 🔴 **Actively bad** | 59 % slower than no cache — needs docs guidance. | +| `FrameAccessor` / `PropertyKey` setup | 🟢 Negligible | 6.77 µs + 74 ns/key. Once per integration. | +| `EntityView` hot loop | 🟢 Excellent | 1.70 ns isolated / ~80 ns realistic. | +| Diff + short-circuit | 🟢 Instant | 4 µs consecutive; 10×/2× shortcut. | +| Schema parse | 🟢 Negligible | 200 µs, one-time. | +| Format choice (FBS vs Proto) | 🟡 Depends | No universal winner — fixture-shape dictates. | + +**Honest caveats** (detail in [`docs/PERFORMANCE.md`](docs/PERFORMANCE.md)): +- One machine, one run. Ratios hold across hardware; absolute numbers vary. +- No direct comparison to competitor libraries. +- `items_per_second` is CPU-time based; use wall time for user-observable claims. +- One known fixture counter inflated 2× (`BM_AccessorRandomWithinBucket`); flagged for fix. + ## Architecture ``` diff --git a/benchmarks/bench_accessor.cpp b/benchmarks/bench_accessor.cpp index a82e9cc..b6e2a59 100644 --- a/benchmarks/bench_accessor.cpp +++ b/benchmarks/bench_accessor.cpp @@ -266,3 +266,78 @@ static void BM_AccessorRandomWithinBucket(benchmark::State& state) { state.SetItemsProcessed(state.iterations() * ops_per_sweep); } BENCHMARK(BM_AccessorRandomWithinBucket)->Unit(benchmark::kMillisecond); + +// Isolated cost of `reader->CreateAccessor()` -- the one-time handshake a +// consumer pays at integration startup. Complements BM_AccessorKeyResolution +// which measures what happens *after* an accessor exists. Together they +// bracket the "SDK initialization" cost the consumer observes. +static void BM_FrameAccessor_Creation(benchmark::State& state) { + auto result = VTX::OpenReplayFile(ArenaReplayPath()); + if (!result) { + state.SkipWithError("OpenReplayFile failed"); + return; + } + auto& reader = result.reader; + + for (auto _ : state) { + auto accessor = reader->CreateAccessor(); + benchmark::DoNotOptimize(accessor); + } +} +BENCHMARK(BM_FrameAccessor_Creation)->Unit(benchmark::kMicrosecond); + +// Isolated cost of `EntityView(entity); view.Get(key)` -- one construction +// plus one typed property read, on a single Player entity held in RAM. This +// is the per-property-access cost a consumer pays in their steady state +// once everything else (accessor, keys, frame cache) is warm. +// +// Preloads a copy of frame 0 into a local Frame so the measured loop cannot +// be invalidated by chunk eviction. Picks the first Player entity it finds. +static void BM_EntityView_SingleGet(benchmark::State& state) { + auto result = VTX::OpenReplayFile(ArenaReplayPath()); + if (!result) { + state.SkipWithError("OpenReplayFile failed"); + return; + } + auto& reader = result.reader; + + auto accessor = reader->CreateAccessor(); + auto key_position = accessor.Get("Player", "Position"); + if (!key_position.IsValid()) { + state.SkipWithError("Player::Position did not resolve"); + return; + } + + // Own the frame so chunk eviction can't yank the entity out from under us. + const auto* frame_ptr = reader->GetFrameSync(0); + if (!frame_ptr) { + state.SkipWithError("frame 0 not loaded"); + return; + } + VTX::Frame frame_copy = *frame_ptr; + + const VTX::PropertyContainer* sample_entity = nullptr; + for (const auto& bucket : frame_copy.GetBuckets()) { + for (const auto& entity : bucket.entities) { + if (entity.entity_type_id == 0) { + sample_entity = &entity; + break; + } + } + if (sample_entity) + break; + } + if (!sample_entity) { + state.SkipWithError("no Player entity in frame 0"); + return; + } + + double sink = 0.0; + for (auto _ : state) { + VTX::EntityView view(*sample_entity); + sink += view.Get(key_position).x; + } + benchmark::DoNotOptimize(sink); + state.SetItemsProcessed(state.iterations()); +} +BENCHMARK(BM_EntityView_SingleGet)->Unit(benchmark::kNanosecond); diff --git a/docs/BUILD.md b/docs/BUILD.md index 1a1bace..c881dcb 100644 --- a/docs/BUILD.md +++ b/docs/BUILD.md @@ -284,6 +284,33 @@ VTX/ thirdparty/ Header-only deps + legacy Windows binary fallback vcpkg.json Windows package-manager manifest ``` +## Running benchmarks locally + +The benchmark binary is gated behind `VTX_BUILD_BENCHMARKS` and uses `google/benchmark` (fetched via `FetchContent`). Release builds only -- debug numbers are not meaningful. + +```bash +# Configure + build +cmake -S . -B build-bench -DCMAKE_BUILD_TYPE=Release -DVTX_BUILD_BENCHMARKS=ON +cmake --build build-bench --target vtx_benchmarks --config Release --parallel + +# Run the full suite (writes JSON + console side-by-side for diffing over time) +build-bench/bin/Release/vtx_benchmarks.exe \ + --benchmark_out=reports/benchmarks/bench_$(date +%Y%m%d_%H%M%S).json \ + --benchmark_out_format=json \ + --benchmark_counters_tabular=true + +# Filter to a single family +build-bench/bin/Release/vtx_benchmarks.exe \ + --benchmark_filter='BM_FrameAccessor_Creation|BM_EntityView_SingleGet|BM_AccessorKeyResolution' +``` + +Fixtures required at run time: + +- `samples/content/reader/{cs,rl,arena}/*.vtx` -- real replays; checked in. +- `benchmarks/fixtures/synth_10k.vtx` -- small synthetic fixture generated by `vtx_sample_write` when `VTX_BUILD_BENCHMARKS=ON`. + +Narrative results (what the numbers mean, not just the tables) live in [`docs/PERFORMANCE.md`](PERFORMANCE.md). The raw output of the canonical run is committed under `reports/benchmarks/` as JSON + console text for regression tracking and graphing. + ## Running sanitizers locally VTX's root `CMakeLists.txt` exposes a `VTX_SANITIZE` option that enables gcc/clang runtime sanitizers. Useful before pushing a change that touches threading or memory-ownership code. diff --git a/docs/PERFORMANCE.md b/docs/PERFORMANCE.md new file mode 100644 index 0000000..12e6302 --- /dev/null +++ b/docs/PERFORMANCE.md @@ -0,0 +1,135 @@ +# Performance + +> Numbers in this page come from the benchmark run on **2026-04-23** against `main` at commit `78b20f3`. +> Raw data for that run (re-usable for graphing or regression tracking): [`reports/benchmarks/bench_20260423_162008.json`](../reports/benchmarks/bench_20260423_162008.json). + +## At a glance + +A one-screen view of which areas of the SDK are fast, which are slow, and which depend on how you use them. + +| Area | Verdict | Why | +|---|---|---| +| Writer throughput | 🟢 Fast | 82 k frames/s end-to-end; ~10× headroom over real-time recording. | +| Full sequential read (CS, 92 MB) | 🟢 Fast enough | 5.6 s median; competitive with peer tooling. | +| Preview (first 1 000 frames) | 🟢 Fast | ~1 s; below UX perceptibility. | +| Scrubbing with **well-sized** cache | 🟢 Fast | <4 s for 50 random jumps. | +| Scrubbing with **mis-sized** cache | 🔴 **Actively bad** | 23 s for the same workload — 59 % slower than no cache. | +| `FrameAccessor` creation | 🟢 Negligible | 6.77 µs once per replay. | +| `PropertyKey` resolution | 🟢 Negligible | 74 ns per key × keys_you_resolve. | +| `EntityView` hot-loop read | 🟢 Excellent | 1.70 ns isolated / ~80 ns in realistic loop. | +| Diff on consecutive frames | 🟢 Instant | 4 µs; 267 k comparisons/s. | +| Diff short-circuit on identical frames | 🟢 Instant | xxHash shortcut working; 10× on arena, 2× on CS. | +| Schema parse | 🟢 Negligible | 200 µs, one-time per file. | +| Format choice (FBS vs Proto) | 🟡 Context-dependent | No universal winner; fixture-shape dictates. | +| CS sequential-scan stability | 🟡 Noisy | One outlier iter per run; median trustworthy, mean fluctuates. | + +## Headline numbers + +| Task | Result | Plain-language reading | +|---|---|---| +| Writing a replay | ~82 000 frames/s | A 30-minute match at 60 fps (~108 k frames) costs ~1.3 s of CPU. | +| Reading the full CS2 fixture (92 MB, median) | ~5.6 s | Comparable to opening a long video in an editor. | +| Preview (first 1 000 frames) | ~1 s | Thumbnails + file-browse UI have no perceptible lag. | +| Seek to 50 % + play 300 frames | ~0.9 s | Timeline scrubbing is fluid. | +| `FrameAccessor` creation | 6.77 µs | Once per replay. Invisible. | +| `PropertyKey` resolution | ~74 ns / key | 10 properties ≈ 0.7 µs total. Invisible. | +| `EntityView` read (isolated) | **1.70 ns** | 585 M reads/s — theoretical ceiling. | +| `EntityView` read (hot loop) | ~80 ns | ~13 M reads/s — what real integrations observe. | +| Frame diff | 4 µs | 267 k comparisons/s. | + +## The three-layer accessor API + +Customers asking "how fast is the property-access API?" are really asking about one of three layers with very different costs: + +| Layer | When you pay | How often | Cost | +|---|---|---|---| +| `FrameAccessor` (`reader->CreateAccessor()`) | Integration startup | Once per replay | **6.77 µs** | +| `PropertyKey` (`accessor.Get("Struct", "prop")`) | Integration setup | Once per property you care about | **~74 ns / key** | +| `EntityView` + `Get` (inside your hot loop) | Every property read | Millions of times per second | **1.70 ns isolated / ~80 ns realistic** | + +Lead with the hot-loop number (~13 M reads/s) when setting customer expectations. Use the isolated ceiling (585 M/s) only when explicitly asked about the theoretical upper bound. + +## Key findings + +### 1. A small cache is *worse* than no cache + +The reader has a configurable cache window (`SetCacheWindow(back, forward)`) that keeps recently-read chunks in RAM. Intuition says "bigger is better, and a small cache is still better than nothing". **This is false for random-access workloads.** + +Measured on the CS2 fixture (50 random jumps): + +| Cache window | Wall time | vs. no cache | +|---:|---:|---| +| 0 (disabled) | 14.56 s | baseline | +| 2 | **23.20 s** | **+59 % slower** | +| 5 | 16.87 s | +16 % slower | +| 10 | 3.27 s | **4.5× faster** | +| 20 | 3.09 s | plateau (fixture fits in 10) | + +**Why.** A too-small window evicts the chunks that were about to be reused. Every jump pays the eviction cost *plus* the reload cost. When the window finally fits the working set, throughput jumps 5×. + +**Guidance.** Size `SetCacheWindow` to the expected scrubbing span. Don't pick a small default and hope for the best. + +### 2. No universal "faster" format + +VTX supports both FlatBuffers and Protobuf. Which is faster depends on the replay: + +| Fixture | FBS median | Proto median | Winner | Margin | +|---|---:|---:|---|---| +| CS2 (92 MB, dense per-frame payloads) | 5.56 s | 2.93 s | **Proto** | FBS 90 % slower | +| Rocket League (5 MB, different schema shape) | **0.72 s** | 2.56 s | **FBS** | Proto 3.5× slower | + +The flip is driven by per-frame payload size and schema shape — CS2 favours Proto's streaming decode, RL favours FBS's zero-copy access. **Measure on your replay shape before picking a default.** + +### 3. Short-circuit diffing is earning its keep + +The differ fingerprints two frames (xxHash) before falling back to the full structural diff. On identical frames the shortcut pays off: + +| Fixture | Identical (short-circuit) | First-vs-last (worst case) | Speedup | +|---|---:|---:|---:| +| Arena (small) | 6.3 µs | 59 µs | **~10×** | +| CS2 (big) | 66 µs | 131 µs | **~2×** | + +Ratio shrinks on big frames because hashing itself becomes non-trivial — but the shortcut is still a clear win. + +## What these numbers do *not* prove + +- **One machine.** Windows, i9-13900H, 20 threads, SSD. Customer hardware will vary; *ratios* hold, absolute numbers don't. +- **One benchmark run.** `repeats:5` on the heavy workloads, adaptive on the rest. No multi-machine statistical harness yet. +- **No competitor comparison.** We measure VTX against itself. +- **`items_per_second` in google/benchmark uses CPU time, not wall time.** Where wall ≫ CPU (async I/O), that metric overstates user-observable throughput. For customer-facing claims use the wall-time column. +- **One known fixture bug** — `BM_AccessorRandomWithinBucket` inflates its own counter 2× due to a duplicate-push in the shuffle setup. Flagged for a follow-up fix; everything else is trustworthy. + +## Running benchmarks locally + +The benchmark binary is gated behind `VTX_BUILD_BENCHMARKS`. It uses google/benchmark (fetched via `FetchContent`), Release builds only. + +```bash +# Configure + build +cmake -S . -B build-bench -DCMAKE_BUILD_TYPE=Release -DVTX_BUILD_BENCHMARKS=ON +cmake --build build-bench --target vtx_benchmarks --config Release --parallel + +# Run the full suite (JSON + console output) +build-bench/bin/Release/vtx_benchmarks.exe \ + --benchmark_out=reports/benchmarks/bench_$(date +%Y%m%d_%H%M%S).json \ + --benchmark_out_format=json \ + --benchmark_counters_tabular=true + +# Only the three isolated accessor layers +build-bench/bin/Release/vtx_benchmarks.exe \ + --benchmark_filter='BM_FrameAccessor_Creation|BM_EntityView_SingleGet|BM_AccessorKeyResolution' + +# Only the cache-window sweep +build-bench/bin/Release/vtx_benchmarks.exe \ + --benchmark_filter='BM_CS_AccessorRandomAccess_CacheSweep_FBS' +``` + +Fixtures required: CS, RL, and arena replays under `samples/content/reader/{cs,rl,arena}/`. The small `synth_10k.vtx` fixture is generated at build time by `vtx_sample_write` whenever `VTX_BUILD_BENCHMARKS=ON`. + +## Where the raw data lives + +| Path | What it is | +|---|---| +| [`reports/benchmarks/bench_20260423_162008.json`](../reports/benchmarks/bench_20260423_162008.json) | Raw google/benchmark JSON — reusable for graphing or regression tracking. | +| [`reports/benchmarks/bench_20260423_162008.txt`](../reports/benchmarks/bench_20260423_162008.txt) | Console output as produced. | + +This page is the canonical narrative version of that data. If the benchmarks are re-run, update the numbers here (and commit the new raw outputs alongside) rather than maintaining a parallel per-run markdown report. diff --git a/reports/benchmarks/bench_20260423_162008.json b/reports/benchmarks/bench_20260423_162008.json new file mode 100644 index 0000000..a8dd3a2 --- /dev/null +++ b/reports/benchmarks/bench_20260423_162008.json @@ -0,0 +1,1049 @@ +{ + "context": { + "date": "2026-04-23T16:20:08+02:00", + "host_name": "ALEJANDROVTX", + "executable": "D:\\VTX\\build-bench\\bin\\Release\\vtx_benchmarks.exe", + "num_cpus": 20, + "mhz_per_cpu": 2995, + "caches": [ + { + "type": "Data", + "level": 1, + "size": 49152, + "num_sharing": 2 + }, + { + "type": "Instruction", + "level": 1, + "size": 32768, + "num_sharing": 2 + }, + { + "type": "Unified", + "level": 2, + "size": 1310720, + "num_sharing": 2 + }, + { + "type": "Unified", + "level": 3, + "size": 25165824, + "num_sharing": 20 + } + ], + "load_avg": [], + "library_version": "v1.9.0", + "library_build_type": "release", + "json_schema_version": 1 + }, + "benchmarks": [ + { + "name": "BM_ReaderSequentialScan", + "family_index": 0, + "per_family_instance_index": 0, + "run_name": "BM_ReaderSequentialScan", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 34, + "real_time": 2.9203788235249437e+01, + "cpu_time": 1.8841911764705884e+01, + "time_unit": "ms", + "items_per_second": 5.3073170731707313e+05 + }, + { + "name": "BM_ReaderRandomAccess", + "family_index": 1, + "per_family_instance_index": 0, + "run_name": "BM_ReaderRandomAccess", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 37, + "real_time": 1.6992321621620323e+05, + "cpu_time": 2.2804054054054053e+04, + "time_unit": "us", + "items_per_second": 4.3851851851851852e+03 + }, + { + "name": "BM_WriterThroughput", + "family_index": 2, + "per_family_instance_index": 0, + "run_name": "BM_WriterThroughput", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 64, + "real_time": 1.3305864062431283e+01, + "cpu_time": 1.2207031250000000e+01, + "time_unit": "ms", + "items_per_second": 8.1920000000000000e+04 + }, + { + "name": "BM_DifferConsecutiveFrames", + "family_index": 3, + "per_family_instance_index": 0, + "run_name": "BM_DifferConsecutiveFrames", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 154483, + "real_time": 4.1162891709626903e+00, + "cpu_time": 3.7423211615517564e+00, + "time_unit": "us", + "items_per_second": 2.6721383783783781e+05 + }, + { + "name": "BM_PropertyAddressCacheLookup", + "family_index": 4, + "per_family_instance_index": 0, + "run_name": "BM_PropertyAddressCacheLookup", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 560000, + "real_time": 9.9014375001778332e-01, + "cpu_time": 9.7656250000000000e-01, + "time_unit": "us", + "items_per_second": 2.3552000000000000e+07, + "keys_per_iter": 2.3000000000000000e+01 + }, + { + "name": "BM_AccessorSequentialScan", + "family_index": 5, + "per_family_instance_index": 0, + "run_name": "BM_AccessorSequentialScan", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 25, + "real_time": 8.3722676000325009e+01, + "cpu_time": 2.3125000000000000e+01, + "time_unit": "ms", + "items_per_second": 1.5567567567567568e+05 + }, + { + "name": "BM_AccessorHotLoopPreloaded", + "family_index": 6, + "per_family_instance_index": 0, + "run_name": "BM_AccessorHotLoopPreloaded", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 236, + "real_time": 2.8118673729033494e+00, + "cpu_time": 2.7807203389830510e+00, + "time_unit": "ms", + "items_per_second": 1.2946285714285715e+07 + }, + { + "name": "BM_AccessorRandomWithinBucket", + "family_index": 7, + "per_family_instance_index": 0, + "run_name": "BM_AccessorRandomWithinBucket", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 448, + "real_time": 1.1599430803731334e+00, + "cpu_time": 1.1858258928571428e+00, + "time_unit": "ms", + "items_per_second": 6.0717176470588237e+07 + }, + { + "name": "BM_FrameAccessor_Creation", + "family_index": 8, + "per_family_instance_index": 0, + "run_name": "BM_FrameAccessor_Creation", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 89600, + "real_time": 6.7697075892933105e+00, + "cpu_time": 6.8010602678571432e+00, + "time_unit": "us" + }, + { + "name": "BM_EntityView_SingleGet", + "family_index": 9, + "per_family_instance_index": 0, + "run_name": "BM_EntityView_SingleGet", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 320000000, + "real_time": 1.6983325000182956e+00, + "cpu_time": 1.7089843750000000e+00, + "time_unit": "ns", + "items_per_second": 5.8514285714285719e+08 + }, + { + "name": "BM_AccessorKeyResolution", + "family_index": 10, + "per_family_instance_index": 0, + "run_name": "BM_AccessorKeyResolution", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 1120000, + "real_time": 6.6229714285717434e-01, + "cpu_time": 6.6964285714285710e-01, + "time_unit": "us", + "items_per_second": 1.3440000000000000e+07, + "props_per_iter": 9.0000000000000000e+00 + }, + { + "name": "BM_CS_ReaderSequentialScan_FBS/repeats:5_mean", + "family_index": 11, + "per_family_instance_index": 0, + "run_name": "BM_CS_ReaderSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 5.7536638399993544e+03, + "cpu_time": 2.6531250000000000e+03, + "time_unit": "ms", + "items_per_second": 4.0593497008686204e+03, + "ns_per_frame": 2.4897944819819820e-04 + }, + { + "name": "BM_CS_ReaderSequentialScan_FBS/repeats:5_median", + "family_index": 11, + "per_family_instance_index": 0, + "run_name": "BM_CS_ReaderSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 5.5604609000001801e+03, + "cpu_time": 2.5781250000000000e+03, + "time_unit": "ms", + "items_per_second": 4.1332363636363634e+03, + "ns_per_frame": 2.4194115990990993e-04 + }, + { + "name": "BM_CS_ReaderSequentialScan_FBS/repeats:5_stddev", + "family_index": 11, + "per_family_instance_index": 0, + "run_name": "BM_CS_ReaderSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 3.9197380735124250e+02, + "cpu_time": 3.1972125310573057e+02, + "time_unit": "ms", + "items_per_second": 4.4779895020362540e+02, + "ns_per_frame": 3.0003871350012303e-05 + }, + { + "name": "BM_CS_ReaderSequentialScan_FBS/repeats:5_cv", + "family_index": 11, + "per_family_instance_index": 0, + "run_name": "BM_CS_ReaderSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 5, + "real_time": 6.8125948656619209e-02, + "cpu_time": 1.2050742166529302e-01, + "time_unit": "ms", + "items_per_second": 1.1031297700412589e-01, + "ns_per_frame": 1.2050742166529323e-01 + }, + { + "name": "BM_CS_ReaderSequentialScan_Proto/repeats:5_mean", + "family_index": 12, + "per_family_instance_index": 0, + "run_name": "BM_CS_ReaderSequentialScan_Proto/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 3.8251596999965841e+03, + "cpu_time": 1.1531250000000000e+03, + "time_unit": "ms", + "items_per_second": 1.0334791369239749e+04, + "ns_per_frame": 1.0821368243243244e-04 + }, + { + "name": "BM_CS_ReaderSequentialScan_Proto/repeats:5_median", + "family_index": 12, + "per_family_instance_index": 0, + "run_name": "BM_CS_ReaderSequentialScan_Proto/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 2.9343731999979354e+03, + "cpu_time": 9.2187500000000000e+02, + "time_unit": "ms", + "items_per_second": 1.1559050847457627e+04, + "ns_per_frame": 8.6512293543543545e-05 + }, + { + "name": "BM_CS_ReaderSequentialScan_Proto/repeats:5_stddev", + "family_index": 12, + "per_family_instance_index": 0, + "run_name": "BM_CS_ReaderSequentialScan_Proto/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 1.8827516338170044e+03, + "cpu_time": 4.9279476426551071e+02, + "time_unit": "ms", + "items_per_second": 3.2852700651712257e+03, + "ns_per_frame": 4.6245754904796370e-05 + }, + { + "name": "BM_CS_ReaderSequentialScan_Proto/repeats:5_cv", + "family_index": 12, + "per_family_instance_index": 0, + "run_name": "BM_CS_ReaderSequentialScan_Proto/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 5, + "real_time": 4.9220209912247198e-01, + "cpu_time": 4.2735589312998223e-01, + "time_unit": "ms", + "items_per_second": 3.1788450756242964e-01, + "ns_per_frame": 4.2735589312998168e-01 + }, + { + "name": "BM_CS_AccessorSequentialScan_FBS/repeats:5_mean", + "family_index": 13, + "per_family_instance_index": 0, + "run_name": "BM_CS_AccessorSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 5.6180635199998505e+03, + "cpu_time": 2.9781250000000005e+03, + "time_unit": "ms", + "items_per_second": 4.4790702941747468e+03, + "ns_per_frame": 2.7947869744744745e-04 + }, + { + "name": "BM_CS_AccessorSequentialScan_FBS/repeats:5_median", + "family_index": 13, + "per_family_instance_index": 0, + "run_name": "BM_CS_AccessorSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 6.1266414999990957e+03, + "cpu_time": 3.2031250000000000e+03, + "time_unit": "ms", + "items_per_second": 3.3267512195121953e+03, + "ns_per_frame": 3.0059356231231231e-04 + }, + { + "name": "BM_CS_AccessorSequentialScan_FBS/repeats:5_stddev", + "family_index": 13, + "per_family_instance_index": 0, + "run_name": "BM_CS_AccessorSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 2.5042867254499824e+03, + "cpu_time": 1.4204405539083637e+03, + "time_unit": "ms", + "items_per_second": 2.4044193400037416e+03, + "ns_per_frame": 1.3329960153043958e-04 + }, + { + "name": "BM_CS_AccessorSequentialScan_FBS/repeats:5_cv", + "family_index": 13, + "per_family_instance_index": 0, + "run_name": "BM_CS_AccessorSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 5, + "real_time": 4.4575621413587169e-01, + "cpu_time": 4.7695800341099293e-01, + "time_unit": "ms", + "items_per_second": 5.3681214673741739e-01, + "ns_per_frame": 4.7695800341099320e-01 + }, + { + "name": "BM_CS_AccessorRandomAccess_FBS", + "family_index": 14, + "per_family_instance_index": 0, + "run_name": "BM_CS_AccessorRandomAccess_FBS", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 1, + "real_time": 2.1999363800001446e+07, + "cpu_time": 5.7968750000000000e+06, + "time_unit": "us", + "items_per_second": 8.6253369272237190e+00 + }, + { + "name": "BM_CS_DifferConsecutiveFrames_FBS", + "family_index": 15, + "per_family_instance_index": 0, + "run_name": "BM_CS_DifferConsecutiveFrames_FBS", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 2987, + "real_time": 3.8331044526391258e+02, + "cpu_time": 1.9877803816538332e+02, + "time_unit": "us", + "items_per_second": 5.0307368421052633e+03 + }, + { + "name": "BM_RL_ReaderSequentialScan_FBS/repeats:5_mean", + "family_index": 16, + "per_family_instance_index": 0, + "run_name": "BM_RL_ReaderSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 7.3210921999998391e+02, + "cpu_time": 3.1406250000000000e+02, + "time_unit": "ms", + "items_per_second": 2.8680611096220855e+04, + "ns_per_frame": 3.4895833333333339e-05 + }, + { + "name": "BM_RL_ReaderSequentialScan_FBS/repeats:5_median", + "family_index": 16, + "per_family_instance_index": 0, + "run_name": "BM_RL_ReaderSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 7.2252170000137994e+02, + "cpu_time": 3.1250000000000000e+02, + "time_unit": "ms", + "items_per_second": 2.8800000000000000e+04, + "ns_per_frame": 3.4722222222222222e-05 + }, + { + "name": "BM_RL_ReaderSequentialScan_FBS/repeats:5_stddev", + "family_index": 16, + "per_family_instance_index": 0, + "run_name": "BM_RL_ReaderSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 1.8572353990622297e+01, + "cpu_time": 1.0186253758128762e+01, + "time_unit": "ms", + "items_per_second": 9.2108892694493431e+02, + "ns_per_frame": 1.1318059731253093e-06 + }, + { + "name": "BM_RL_ReaderSequentialScan_FBS/repeats:5_cv", + "family_index": 16, + "per_family_instance_index": 0, + "run_name": "BM_RL_ReaderSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 5, + "real_time": 2.5368283151279952e-02, + "cpu_time": 3.2433842811952281e-02, + "time_unit": "ms", + "items_per_second": 3.2115387076473524e-02, + "ns_per_frame": 3.2433842811949158e-02 + }, + { + "name": "BM_RL_ReaderSequentialScan_Proto/repeats:5_mean", + "family_index": 17, + "per_family_instance_index": 0, + "run_name": "BM_RL_ReaderSequentialScan_Proto/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 2.5656514400005112e+03, + "cpu_time": 9.6562500000000000e+02, + "time_unit": "ms", + "items_per_second": 2.1165772757046187e+04, + "ns_per_frame": 4.7418238067177373e-05 + }, + { + "name": "BM_RL_ReaderSequentialScan_Proto/repeats:5_median", + "family_index": 17, + "per_family_instance_index": 0, + "run_name": "BM_RL_ReaderSequentialScan_Proto/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 2.5559199999988778e+03, + "cpu_time": 9.6875000000000000e+02, + "time_unit": "ms", + "items_per_second": 2.1020903225806451e+04, + "ns_per_frame": 4.7571695148300924e-05 + }, + { + "name": "BM_RL_ReaderSequentialScan_Proto/repeats:5_stddev", + "family_index": 17, + "per_family_instance_index": 0, + "run_name": "BM_RL_ReaderSequentialScan_Proto/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 5.0571660578198241e+01, + "cpu_time": 6.5736512399881818e+01, + "time_unit": "ms", + "items_per_second": 1.4132584025212118e+03, + "ns_per_frame": 3.2280746611611022e-06 + }, + { + "name": "BM_RL_ReaderSequentialScan_Proto/repeats:5_cv", + "family_index": 17, + "per_family_instance_index": 0, + "run_name": "BM_RL_ReaderSequentialScan_Proto/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 5, + "real_time": 1.9711040942563953e-02, + "cpu_time": 6.8076647145508679e-02, + "time_unit": "ms", + "items_per_second": 6.6770933371697067e-02, + "ns_per_frame": 6.8076647145511648e-02 + }, + { + "name": "BM_RL_AccessorSequentialScan_FBS/repeats:5_mean", + "family_index": 18, + "per_family_instance_index": 0, + "run_name": "BM_RL_AccessorSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 7.5543203999986872e+02, + "cpu_time": 3.2187500000000000e+02, + "time_unit": "ms", + "items_per_second": 2.8128179076845398e+04, + "ns_per_frame": 3.5763888888888889e-05 + }, + { + "name": "BM_RL_AccessorSequentialScan_FBS/repeats:5_median", + "family_index": 18, + "per_family_instance_index": 0, + "run_name": "BM_RL_AccessorSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 7.3500529999728315e+02, + "cpu_time": 3.2031250000000000e+02, + "time_unit": "ms", + "items_per_second": 2.8097560975609755e+04, + "ns_per_frame": 3.5590277777777779e-05 + }, + { + "name": "BM_RL_AccessorSequentialScan_FBS/repeats:5_stddev", + "family_index": 18, + "per_family_instance_index": 0, + "run_name": "BM_RL_AccessorSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 4.5325897418990856e+01, + "cpu_time": 2.8384222069663604e+01, + "time_unit": "ms", + "items_per_second": 2.3760052774064648e+03, + "ns_per_frame": 3.1538024521848795e-06 + }, + { + "name": "BM_RL_AccessorSequentialScan_FBS/repeats:5_cv", + "family_index": 18, + "per_family_instance_index": 0, + "run_name": "BM_RL_AccessorSequentialScan_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 5, + "real_time": 5.9999966931504167e-02, + "cpu_time": 8.8183990896042258e-02, + "time_unit": "ms", + "items_per_second": 8.4470639600070979e-02, + "ns_per_frame": 8.8183990896043229e-02 + }, + { + "name": "BM_RL_AccessorRandomAccess_FBS", + "family_index": 19, + "per_family_instance_index": 0, + "run_name": "BM_RL_AccessorRandomAccess_FBS", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 1, + "real_time": 6.3368482999940170e+06, + "cpu_time": 1.9062500000000000e+06, + "time_unit": "us", + "items_per_second": 2.6229508196721312e+01 + }, + { + "name": "BM_RL_DifferConsecutiveFrames_FBS", + "family_index": 20, + "per_family_instance_index": 0, + "run_name": "BM_RL_DifferConsecutiveFrames_FBS", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 6400, + "real_time": 1.4795528124977864e+02, + "cpu_time": 1.2695312500000000e+02, + "time_unit": "us", + "items_per_second": 7.8769230769230771e+03 + }, + { + "name": "BM_CS_PreviewFirst1000Frames_FBS/repeats:5_mean", + "family_index": 21, + "per_family_instance_index": 0, + "run_name": "BM_CS_PreviewFirst1000Frames_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 9.5331159000197658e+02, + "cpu_time": 4.0156250000000000e+02, + "time_unit": "ms", + "items_per_second": 2.4912481288596719e+03, + "ns_per_frame": 4.0156250000000001e-04 + }, + { + "name": "BM_CS_PreviewFirst1000Frames_FBS/repeats:5_median", + "family_index": 21, + "per_family_instance_index": 0, + "run_name": "BM_CS_PreviewFirst1000Frames_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 9.4858604999899399e+02, + "cpu_time": 3.9843750000000000e+02, + "time_unit": "ms", + "items_per_second": 2.5098039215686276e+03, + "ns_per_frame": 3.9843749999999997e-04 + }, + { + "name": "BM_CS_PreviewFirst1000Frames_FBS/repeats:5_stddev", + "family_index": 21, + "per_family_instance_index": 0, + "run_name": "BM_CS_PreviewFirst1000Frames_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 1.3510164244042002e+01, + "cpu_time": 8.9076205085849125e+00, + "time_unit": "ms", + "items_per_second": 5.4994360208360867e+01, + "ns_per_frame": 8.9076205085884231e-06 + }, + { + "name": "BM_CS_PreviewFirst1000Frames_FBS/repeats:5_cv", + "family_index": 21, + "per_family_instance_index": 0, + "run_name": "BM_CS_PreviewFirst1000Frames_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 5, + "real_time": 1.4171824181864807e-02, + "cpu_time": 2.2182401266514953e-02, + "time_unit": "ms", + "items_per_second": 2.2075023186684192e-02, + "ns_per_frame": 2.2182401266523700e-02 + }, + { + "name": "BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5_mean", + "family_index": 22, + "per_family_instance_index": 0, + "run_name": "BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 9.0934604999783915e+02, + "cpu_time": 3.2812500000000000e+02, + "time_unit": "ms", + "items_per_second": 9.5157618392543191e+02, + "ns_per_frame": 1.0937499999999999e-03 + }, + { + "name": "BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5_median", + "family_index": 22, + "per_family_instance_index": 0, + "run_name": "BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 9.0271560000110185e+02, + "cpu_time": 3.3593750000000000e+02, + "time_unit": "ms", + "items_per_second": 8.9302325581395348e+02, + "ns_per_frame": 1.1197916666666667e-03 + }, + { + "name": "BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5_stddev", + "family_index": 22, + "per_family_instance_index": 0, + "run_name": "BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 6.2393239440926301e+01, + "cpu_time": 6.9439018885278060e+01, + "time_unit": "ms", + "items_per_second": 2.2566973770305447e+02, + "ns_per_frame": 2.3146339628426067e-04 + }, + { + "name": "BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5_cv", + "family_index": 22, + "per_family_instance_index": 0, + "run_name": "BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 5, + "real_time": 6.8613306717585185e-02, + "cpu_time": 2.1162367660275219e-01, + "time_unit": "ms", + "items_per_second": 2.3715362102918977e-01, + "ns_per_frame": 2.1162367660275264e-01 + }, + { + "name": "BM_CS_StridedScan_Every100th_FBS/repeats:5_mean", + "family_index": 23, + "per_family_instance_index": 0, + "run_name": "BM_CS_StridedScan_Every100th_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "mean", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 2.8393745800014585e+03, + "cpu_time": 1.3156250000000000e+03, + "time_unit": "ms", + "items_per_second": 8.1647330447330447e+01, + "ns_per_frame": 1.2295560747663553e-02 + }, + { + "name": "BM_CS_StridedScan_Every100th_FBS/repeats:5_median", + "family_index": 23, + "per_family_instance_index": 0, + "run_name": "BM_CS_StridedScan_Every100th_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "median", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 2.8270245000021532e+03, + "cpu_time": 1.3125000000000000e+03, + "time_unit": "ms", + "items_per_second": 8.1523809523809518e+01, + "ns_per_frame": 1.2266355140186917e-02 + }, + { + "name": "BM_CS_StridedScan_Every100th_FBS/repeats:5_stddev", + "family_index": 23, + "per_family_instance_index": 0, + "run_name": "BM_CS_StridedScan_Every100th_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "stddev", + "aggregate_unit": "time", + "iterations": 5, + "real_time": 4.1100799235245951e+01, + "cpu_time": 9.1376196982583480e+01, + "time_unit": "ms", + "items_per_second": 5.7127592521495734e+00, + "ns_per_frame": 8.5398314936992496e-04 + }, + { + "name": "BM_CS_StridedScan_Every100th_FBS/repeats:5_cv", + "family_index": 23, + "per_family_instance_index": 0, + "run_name": "BM_CS_StridedScan_Every100th_FBS/repeats:5", + "run_type": "aggregate", + "repetitions": 5, + "threads": 1, + "aggregate_name": "cv", + "aggregate_unit": "percentage", + "iterations": 5, + "real_time": 1.4475300132899278e-02, + "cpu_time": 6.9454591530704796e-02, + "time_unit": "ms", + "items_per_second": 6.9968720604218590e-02, + "ns_per_frame": 6.9454591530703630e-02 + }, + { + "name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/0", + "family_index": 24, + "per_family_instance_index": 0, + "run_name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/0", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 1, + "real_time": 1.4559074699995108e+07, + "cpu_time": 1.9843750000000000e+06, + "time_unit": "us", + "cache_window": 0.0000000000000000e+00, + "items_per_second": 2.5196850393700789e+01 + }, + { + "name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/2", + "family_index": 24, + "per_family_instance_index": 1, + "run_name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/2", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 1, + "real_time": 2.3196362200003933e+07, + "cpu_time": 6.1250000000000000e+06, + "time_unit": "us", + "cache_window": 2.0000000000000000e+00, + "items_per_second": 8.1632653061224492e+00 + }, + { + "name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/5", + "family_index": 24, + "per_family_instance_index": 2, + "run_name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/5", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 1, + "real_time": 1.6871882499995992e+07, + "cpu_time": 7.4218750000000000e+06, + "time_unit": "us", + "cache_window": 5.0000000000000000e+00, + "items_per_second": 6.7368421052631575e+00 + }, + { + "name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/10", + "family_index": 24, + "per_family_instance_index": 3, + "run_name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/10", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 1, + "real_time": 3.2683790999872144e+06, + "cpu_time": 2.8281250000000000e+06, + "time_unit": "us", + "cache_window": 1.0000000000000000e+01, + "items_per_second": 1.7679558011049725e+01 + }, + { + "name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/20", + "family_index": 24, + "per_family_instance_index": 4, + "run_name": "BM_CS_AccessorRandomAccess_CacheSweep_FBS/20", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 1, + "real_time": 3.0937867000029655e+06, + "cpu_time": 2.6406250000000000e+06, + "time_unit": "us", + "cache_window": 2.0000000000000000e+01, + "items_per_second": 1.8934911242603551e+01 + }, + { + "name": "BM_Arena_DifferIdenticalFrames_FBS", + "family_index": 25, + "per_family_instance_index": 0, + "run_name": "BM_Arena_DifferIdenticalFrames_FBS", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 112000, + "real_time": 6.2998500000373624e+03, + "cpu_time": 6.2779017857142853e+03, + "time_unit": "ns", + "items_per_second": 1.5928888888888888e+05 + }, + { + "name": "BM_Arena_DifferFirstVsLast_FBS", + "family_index": 26, + "per_family_instance_index": 0, + "run_name": "BM_Arena_DifferFirstVsLast_FBS", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 11200, + "real_time": 5.9296982141989119e+01, + "cpu_time": 5.8593750000000000e+01, + "time_unit": "us", + "items_per_second": 1.7066666666666668e+04 + }, + { + "name": "BM_CS_DifferIdenticalFrames_FBS", + "family_index": 27, + "per_family_instance_index": 0, + "run_name": "BM_CS_DifferIdenticalFrames_FBS", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 9292, + "real_time": 6.6008351269541720e+01, + "cpu_time": 6.5580606973740856e+01, + "time_unit": "us", + "items_per_second": 1.5248410256410256e+04 + }, + { + "name": "BM_CS_DifferFirstVsLast_FBS", + "family_index": 28, + "per_family_instance_index": 0, + "run_name": "BM_CS_DifferFirstVsLast_FBS", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 4073, + "real_time": 1.3127532531338679e+02, + "cpu_time": 1.3043211392094278e+02, + "time_unit": "us", + "items_per_second": 7.6668235294117649e+03 + }, + { + "name": "BM_Schema_LoadArena_Both", + "family_index": 29, + "per_family_instance_index": 0, + "run_name": "BM_Schema_LoadArena_Both", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 3733, + "real_time": 2.0089568711292475e+02, + "cpu_time": 2.0509643718189125e+02, + "time_unit": "us", + "items_per_second": 4.8757551020408164e+03 + }, + { + "name": "BM_Schema_LoadArena_BufferOnly", + "family_index": 30, + "per_family_instance_index": 0, + "run_name": "BM_Schema_LoadArena_BufferOnly", + "run_type": "iteration", + "repetitions": 1, + "repetition_index": 0, + "threads": 1, + "iterations": 3446, + "real_time": 2.0335504933368080e+02, + "cpu_time": 2.0404091700522343e+02, + "time_unit": "us", + "items_per_second": 4.9009777777777781e+03 + } + ] +} diff --git a/reports/benchmarks/bench_20260423_162008.txt b/reports/benchmarks/bench_20260423_162008.txt new file mode 100644 index 0000000..d52df7e --- /dev/null +++ b/reports/benchmarks/bench_20260423_162008.txt @@ -0,0 +1,109 @@ +2026-04-23T16:20:08+02:00 +Running D:\VTX\build-bench\bin\Release\vtx_benchmarks.exe +Run on (20 X 2995 MHz CPU s) +CPU Caches: + L1 Data 48 KiB (x10) + L1 Instruction 32 KiB (x10) + L2 Unified 1280 KiB (x10) + L3 Unified 24576 KiB (x1) +--------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second +--------------------------------------------------------------------------------------------------------------- +BM_ReaderSequentialScan 29.2 ms 18.8 ms 34 530.732k/s +BM_ReaderRandomAccess 169923 us 22804 us 37 4.38519k/s +BM_WriterThroughput 13.3 ms 12.2 ms 64 81.92k/s +BM_DifferConsecutiveFrames 4.12 us 3.74 us 154483 267.214k/s +----------------------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second keys_per_iter +----------------------------------------------------------------------------------------------------------------------------- +BM_PropertyAddressCacheLookup 0.990 us 0.977 us 560000 23.552M/s 23 +--------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second +--------------------------------------------------------------------------------------------------------------- +BM_AccessorSequentialScan 83.7 ms 23.1 ms 25 155.676k/s +BM_AccessorHotLoopPreloaded 2.81 ms 2.78 ms 236 12.9463M/s +BM_AccessorRandomWithinBucket 1.16 ms 1.19 ms 448 60.7172M/s +---------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations +---------------------------------------------------------------------------------------------- +BM_FrameAccessor_Creation 6.77 us 6.80 us 89600 +--------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second +--------------------------------------------------------------------------------------------------------------- +BM_EntityView_SingleGet 1.70 ns 1.71 ns 320000000 585.143M/s +------------------------------------------------------------------------------------------------------------------------------ +Benchmark Time CPU Iterations items_per_second props_per_iter +------------------------------------------------------------------------------------------------------------------------------ +BM_AccessorKeyResolution 0.662 us 0.670 us 1120000 13.44M/s 9 +---------------------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second ns_per_frame +---------------------------------------------------------------------------------------------------------------------------- +BM_CS_ReaderSequentialScan_FBS/repeats:5_mean 5754 ms 2653 ms 5 4.05935k/s 248.979us +BM_CS_ReaderSequentialScan_FBS/repeats:5_median 5560 ms 2578 ms 5 4.13324k/s 241.941us +BM_CS_ReaderSequentialScan_FBS/repeats:5_stddev 392 ms 320 ms 5 447.799/s 30.0039us +BM_CS_ReaderSequentialScan_FBS/repeats:5_cv 6.81 % 12.05 % 5 11.03% 12.05% +BM_CS_ReaderSequentialScan_Proto/repeats:5_mean 3825 ms 1153 ms 5 10.3348k/s 108.214us +BM_CS_ReaderSequentialScan_Proto/repeats:5_median 2934 ms 922 ms 5 11.5591k/s 86.5123us +BM_CS_ReaderSequentialScan_Proto/repeats:5_stddev 1883 ms 493 ms 5 3.28527k/s 46.2458us +BM_CS_ReaderSequentialScan_Proto/repeats:5_cv 49.22 % 42.74 % 5 31.79% 42.74% +BM_CS_AccessorSequentialScan_FBS/repeats:5_mean 5618 ms 2978 ms 5 4.47907k/s 279.479us +BM_CS_AccessorSequentialScan_FBS/repeats:5_median 6127 ms 3203 ms 5 3.32675k/s 300.594us +BM_CS_AccessorSequentialScan_FBS/repeats:5_stddev 2504 ms 1420 ms 5 2.40442k/s 133.3us +BM_CS_AccessorSequentialScan_FBS/repeats:5_cv 44.58 % 47.70 % 5 53.68% 47.70% +--------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second +--------------------------------------------------------------------------------------------------------------- +BM_CS_AccessorRandomAccess_FBS 21999364 us 5796875 us 1 8.62534/s +BM_CS_DifferConsecutiveFrames_FBS 383 us 199 us 2987 5.03074k/s +---------------------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second ns_per_frame +---------------------------------------------------------------------------------------------------------------------------- +BM_RL_ReaderSequentialScan_FBS/repeats:5_mean 732 ms 314 ms 5 28.6806k/s 34.8958us +BM_RL_ReaderSequentialScan_FBS/repeats:5_median 723 ms 312 ms 5 28.8k/s 34.7222us +BM_RL_ReaderSequentialScan_FBS/repeats:5_stddev 18.6 ms 10.2 ms 5 921.089/s 1.13181us +BM_RL_ReaderSequentialScan_FBS/repeats:5_cv 2.54 % 3.24 % 5 3.21% 3.24% +BM_RL_ReaderSequentialScan_Proto/repeats:5_mean 2566 ms 966 ms 5 21.1658k/s 47.4182us +BM_RL_ReaderSequentialScan_Proto/repeats:5_median 2556 ms 969 ms 5 21.0209k/s 47.5717us +BM_RL_ReaderSequentialScan_Proto/repeats:5_stddev 50.6 ms 65.7 ms 5 1.41326k/s 3.22807us +BM_RL_ReaderSequentialScan_Proto/repeats:5_cv 1.97 % 6.81 % 5 6.68% 6.81% +BM_RL_AccessorSequentialScan_FBS/repeats:5_mean 755 ms 322 ms 5 28.1282k/s 35.7639us +BM_RL_AccessorSequentialScan_FBS/repeats:5_median 735 ms 320 ms 5 28.0976k/s 35.5903us +BM_RL_AccessorSequentialScan_FBS/repeats:5_stddev 45.3 ms 28.4 ms 5 2.37601k/s 3.1538us +BM_RL_AccessorSequentialScan_FBS/repeats:5_cv 6.00 % 8.82 % 5 8.45% 8.82% +--------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second +--------------------------------------------------------------------------------------------------------------- +BM_RL_AccessorRandomAccess_FBS 6336848 us 1906250 us 1 26.2295/s +BM_RL_DifferConsecutiveFrames_FBS 148 us 127 us 6400 7.87692k/s +---------------------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second ns_per_frame +---------------------------------------------------------------------------------------------------------------------------- +BM_CS_PreviewFirst1000Frames_FBS/repeats:5_mean 953 ms 402 ms 5 2.49125k/s 401.562us +BM_CS_PreviewFirst1000Frames_FBS/repeats:5_median 949 ms 398 ms 5 2.5098k/s 398.438us +BM_CS_PreviewFirst1000Frames_FBS/repeats:5_stddev 13.5 ms 8.91 ms 5 54.9944/s 8.90762us +BM_CS_PreviewFirst1000Frames_FBS/repeats:5_cv 1.42 % 2.22 % 5 2.21% 2.22% +BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5_mean 909 ms 328 ms 5 951.576/s 1.09375ms +BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5_median 903 ms 336 ms 5 893.023/s 1.11979ms +BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5_stddev 62.4 ms 69.4 ms 5 225.67/s 231.463us +BM_CS_SeekMiddlePlay300Frames_FBS/repeats:5_cv 6.86 % 21.16 % 5 23.72% 21.16% +BM_CS_StridedScan_Every100th_FBS/repeats:5_mean 2839 ms 1316 ms 5 81.6473/s 0.0122956s +BM_CS_StridedScan_Every100th_FBS/repeats:5_median 2827 ms 1312 ms 5 81.5238/s 0.0122664s +BM_CS_StridedScan_Every100th_FBS/repeats:5_stddev 41.1 ms 91.4 ms 5 5.71276/s 853.983us +BM_CS_StridedScan_Every100th_FBS/repeats:5_cv 1.45 % 6.95 % 5 7.00% 6.95% +---------------------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations cache_window items_per_second +---------------------------------------------------------------------------------------------------------------------------- +BM_CS_AccessorRandomAccess_CacheSweep_FBS/0 14559075 us 1984375 us 1 0 25.1969/s +BM_CS_AccessorRandomAccess_CacheSweep_FBS/2 23196362 us 6125000 us 1 2 8.16327/s +BM_CS_AccessorRandomAccess_CacheSweep_FBS/5 16871882 us 7421875 us 1 5 6.73684/s +BM_CS_AccessorRandomAccess_CacheSweep_FBS/10 3268379 us 2828125 us 1 10 17.6796/s +BM_CS_AccessorRandomAccess_CacheSweep_FBS/20 3093787 us 2640625 us 1 20 18.9349/s +--------------------------------------------------------------------------------------------------------------- +Benchmark Time CPU Iterations items_per_second +--------------------------------------------------------------------------------------------------------------- +BM_Arena_DifferIdenticalFrames_FBS 6300 ns 6278 ns 112000 159.289k/s +BM_Arena_DifferFirstVsLast_FBS 59.3 us 58.6 us 11200 17.0667k/s +BM_CS_DifferIdenticalFrames_FBS 66.0 us 65.6 us 9292 15.2484k/s +BM_CS_DifferFirstVsLast_FBS 131 us 130 us 4073 7.66682k/s +BM_Schema_LoadArena_Both 201 us 205 us 3733 4.87576k/s +BM_Schema_LoadArena_BufferOnly 203 us 204 us 3446 4.90098k/s