diff --git a/README.md b/README.md index 086ef29..7ba71e1 100644 --- a/README.md +++ b/README.md @@ -110,6 +110,7 @@ external data or GPU. It checks integration, not representative compression. | [Structural contribution controls](docs/structural_native_evidence_20261030/README.md) | Trained SGNS/GRU references measure DATrie and approximate joint sharing separately; exact mode finds no identical rows to merge | | [FP16/INT8 + structural controls](docs/quantized_structural_evidence_20261031/README.md) | Same trained tables retain additional approximate savings after quantization; 4-order GRU INT8 regresses; quality failures and fixed-default audit are separate | | [1.85M trained-row capacity](docs/cpu_capacity_evidence_20261030/README.md) / [sparse blocks](docs/sparse_blocks_evidence_20261030/README.md) | Smaller blocks lower native miss latency 16–27× relative to the previous native layout; raw mmap remains faster | +| [Large FP16/INT8 capacity and CPU controls](docs/quantized_capacity_evidence_20261031/README.md) | 54 fresh query workers; FP16 native saves 52.29% backend bytes versus raw FP32; INT8 native expands versus raw INT8, prompting an optional raw fallback; quantization is lossy | | [TinyEngram/Qwen trained integration](docs/tinyengram_qwen_evidence_20261030/README.md) / [CUDA controls](docs/qwen_cuda_performance_20261030/README.md) | Preserved trained outputs and measured CPU/device costs; native lookup remains slower than dense offload on these traces | Official DeepSeek Engram verification uses its small demonstration, not a diff --git a/docs/index.md b/docs/index.md index 2a475ce..4b38393 100644 --- a/docs/index.md +++ b/docs/index.md @@ -17,6 +17,7 @@ - [Original DATrie / mark-compact contribution ablations](structural_native_evidence_20261030/README.md) - [Same-trained-table FP16/INT8 and structural-sharing controls](quantized_structural_evidence_20261031/README.md) - [1.85M trained-row CPU capacity](cpu_capacity_evidence_20261030/README.md) +- [Large FP16/INT8 capacity, construction RSS and fresh CPU traces](quantized_capacity_evidence_20261031/README.md) - [Sparse-block native miss latency](sparse_blocks_evidence_20261030/README.md) - [Native query/cache controls](native_query_evidence_20261030/README.md) - [Causal language-model quality controls](causal_lm_evidence_20261024/README.md) diff --git a/docs/native_ngram_memory.md b/docs/native_ngram_memory.md index 9ae5f22..d85c3a9 100644 --- a/docs/native_ngram_memory.md +++ b/docs/native_ngram_memory.md @@ -207,6 +207,49 @@ the PyTorch adapter does. Use trusted, immutable artifacts and external checksum for archival provenance. Structural checks and sanitizers are not a production artifact-security guarantee. +### Frozen quantized row files + +`tools.quantized_memory.pack_quantized_file` reads a headerless little-endian +FP32 table in chunks, encodes FP32/FP16/per-row INT8, then packs the encoded +rows with the same native format. The original source and decoded-original-ID +hashes are computed incrementally. Use this file path for large exports to +avoid accumulating resident source mmap pages: + +```python +import numpy as np +from tools.quantized_memory import pack_quantized_file, QuantizedRows + +pack_quantized_file("trained.f32", "int8-bundle", 256, "int8", + native="auto", chunk_rows=4096, max_block_bytes=8192) +ids = np.array([2, 0, 2], dtype=" checks-clone.log 2>&1 +cd checks-source +nice -n 19 "$PY" -m unittest discover -s tests > "$ROOT/final-tests.log" 2>&1 +tail -8 "$ROOT/final-tests.log" diff --git a/docs/quantized_capacity_evidence_20261031/compiler.txt b/docs/quantized_capacity_evidence_20261031/compiler.txt new file mode 100644 index 0000000..533f9fc --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/compiler.txt @@ -0,0 +1,5 @@ +cc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0 +Copyright (C) 2021 Free Software Foundation, Inc. +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + diff --git a/docs/quantized_capacity_evidence_20261031/local-tests.txt b/docs/quantized_capacity_evidence_20261031/local-tests.txt new file mode 100644 index 0000000..634ef77 --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/local-tests.txt @@ -0,0 +1,5 @@ +...................ss.s.........ss...............................................................................sssssssssssssssssssss....... +---------------------------------------------------------------------- +Ran 141 tests in 11.724s + +OK (skipped=26) diff --git a/docs/quantized_capacity_evidence_20261031/old-build.json b/docs/quantized_capacity_evidence_20261031/old-build.json new file mode 100644 index 0000000..15d848b --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/old-build.json @@ -0,0 +1,340 @@ +{ + "status": "passed", + "python": "3.11.15 (main, Mar 11 2026, 17:20:07) [GCC 14.3.0]", + "numpy": "2.2.6", + "os": "Linux-5.4.0-42-generic-x86_64-with-glibc2.35", + "cpu": "AMD EPYC 7742 64-Core Processor", + "command": "/llm-align/duyimin/miniconda3/envs/gemma4/bin/python /llm-align/duyimin/ngram-scale-20261031/old-build.py", + "source_commit": "13348839cc414cceba4477af2e07b04da23374da", + "cuda_visible_devices": "", + "cpu_affinity": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254 + ], + "memory_before": { + "peak_rss_bytes": 29913088, + "VmSize_bytes": 129892352, + "VmRSS_bytes": 29913088, + "Rss_bytes": 30007296, + "Pss_bytes": 20105216, + "Shared_Clean_bytes": 10424320, + "Shared_Dirty_bytes": 0, + "Private_Clean_bytes": 856064, + "Private_Dirty_bytes": 18726912, + "Anonymous_bytes": 18726912 + }, + "label": "pre-streaming main INT8 native export", + "shape": [ + 1855907, + 256 + ], + "metadata": { + "schema_version": 1, + "shape": [ + 1855907, + 256 + ], + "encoding": "int8", + "byteorder": "little", + "backend": "native", + "table_file": "table.men", + "row_bytes": 260, + "storage": { + "format": "MEFTNAT1", + "format_version": 2, + "input_bytes": 482535820, + "artifact_bytes": 488715334, + "unique_rows": 1855907, + "row_map_bytes": 14847256, + "n_rows": 1855907, + "row_bytes": 260, + "block_rows": 31, + "blocks": 59868, + "max_block_bytes": 8192, + "raw_blocks": 30, + "compressed_blocks": 59838, + "zlib_blocks": 59799, + "xor_blocks": 39, + "deduplicate": false, + "predictor": "xor", + "reordered": false, + "external_representatives": false, + "marked_rows": 1855907 + }, + "source_float32_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "decoded_float32_sha256": "035d3a5223898f4bf0552b1564a724a0c7f6458e4840887c6f6220d1d2dde286", + "table_sha256": "c2fe87dd534c414adecbe640d94b551da9717e701ef88bb0409c94e002bd42d5", + "source_bytes_preserved": false, + "int8_scale_bytes_per_physical_row": 4, + "rounding": "nearest-even; symmetric [-127,127] per-row scale", + "contract": "frozen original IDs; exact encoded representative bytes; quantization/sharing may change float32 rows" + }, + "wall_seconds": 45.10139607009478, + "cpu_seconds": 44.842845452, + "memory_after": { + "peak_rss_bytes": 9560866816, + "VmSize_bytes": 2052505600, + "VmRSS_bytes": 1955495936, + "Rss_bytes": 1955495936, + "Pss_bytes": 1945308160, + "Shared_Clean_bytes": 10739712, + "Shared_Dirty_bytes": 0, + "Private_Clean_bytes": 1901379584, + "Private_Dirty_bytes": 43376640, + "Anonymous_bytes": 43376640 + }, + "old_new_source_decoded_and_table_hashes_equal": true +} diff --git a/docs/quantized_capacity_evidence_20261031/old-build.py b/docs/quantized_capacity_evidence_20261031/old-build.py new file mode 100644 index 0000000..1131105 --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/old-build.py @@ -0,0 +1,22 @@ +import json,sys,time +from pathlib import Path +root=Path('/llm-align/duyimin/ngram-scale-20261031') +sys.path.insert(0,str(root/'source-old')) +import numpy as np +from tools.benchmark_memory_capacity import environment,memory +from tools.quantized_memory import pack_quantized +source=Path('/llm-align/duyimin/meft-cpu-capacity-20261030/training2/trained.f32') +shape=(1855907,256) +report=dict(status='running',**environment(),memory_before=memory(), + label='pre-streaming main INT8 native export',shape=list(shape)) +rows=np.memmap(source,mode='r',dtype=' "$ROOT/status" +trap 'echo failed > "$ROOT/status"' ERR +nice -n 19 "$PY" -m tools.benchmark_quantized_capacity \ + --training-dir /llm-align/duyimin/meft-cpu-capacity-20261030/training2 \ + --query-manifest /llm-align/duyimin/meft-cpu-capacity-20261030/capacity/queries-ordinary.json \ + --output-dir "$ROOT/results" --native-library "$ROOT/source/build/libmeft_rows.so" \ + --chunk-rows 4096 --max-block-bytes 8192 --cache-bytes 4194304 \ + --repeat 20 --process-repeats 3 --seed 42 --scale-rows 100000 500000 \ + --int8-extra-block-rows 1 4 +echo completed > "$ROOT/status" diff --git a/docs/quantized_capacity_evidence_20261031/scale-performance.png b/docs/quantized_capacity_evidence_20261031/scale-performance.png new file mode 100644 index 0000000..683b0f7 Binary files /dev/null and b/docs/quantized_capacity_evidence_20261031/scale-performance.png differ diff --git a/docs/quantized_capacity_evidence_20261031/scale-performance.svg b/docs/quantized_capacity_evidence_20261031/scale-performance.svg new file mode 100644 index 0000000..80c81d0 --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/scale-performance.svg @@ -0,0 +1,3043 @@ + + + + + + + + 2026-10-31T19:35:15.325440 + image/svg+xml + + + Matplotlib v3.11.2, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/quantized_capacity_evidence_20261031/setup.sh b/docs/quantized_capacity_evidence_20261031/setup.sh new file mode 100644 index 0000000..b328abf --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/setup.sh @@ -0,0 +1,38 @@ +#!/bin/bash +set -eu +ROOT=/llm-align/duyimin/ngram-scale-20261031 +PY=/llm-align/duyimin/miniconda3/envs/gemma4/bin/python +export CUDA_VISIBLE_DEVICES="" +export OMP_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 MKL_NUM_THREADS=1 +test -x "$PY" +cd "$ROOT" +git clone source.bundle source > clone.log 2>&1 +cd source +test "$(git rev-parse --short=7 HEAD)" = 20d111c +mkdir build +cc -std=c11 -O2 -fPIC -shared native/meft_rows.c -lz -o build/libmeft_rows.so > "$ROOT/build.log" 2>&1 +cc --version > "$ROOT/compiler.txt" +nice -n 19 "$PY" -m unittest tests.test_quantized_capacity tests.test_quantized_memory > "$ROOT/tests.log" 2>&1 +cat > "$ROOT/run.sh" <<'RUN' +#!/bin/bash +set -eu +ROOT=/llm-align/duyimin/ngram-scale-20261031 +PY=/llm-align/duyimin/miniconda3/envs/gemma4/bin/python +export CUDA_VISIBLE_DEVICES="" +export OMP_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 MKL_NUM_THREADS=1 +cd "$ROOT/source" +echo running > "$ROOT/status" +trap 'echo failed > "$ROOT/status"' ERR +nice -n 19 "$PY" -m tools.benchmark_quantized_capacity \ + --training-dir /llm-align/duyimin/meft-cpu-capacity-20261030/training2 \ + --query-manifest /llm-align/duyimin/meft-cpu-capacity-20261030/capacity/queries-ordinary.json \ + --output-dir "$ROOT/results" --native-library "$ROOT/source/build/libmeft_rows.so" \ + --chunk-rows 4096 --max-block-bytes 8192 --cache-bytes 4194304 \ + --repeat 20 --process-repeats 3 --seed 42 --scale-rows 100000 500000 \ + --int8-extra-block-rows 1 4 +echo completed > "$ROOT/status" +RUN +nohup bash "$ROOT/run.sh" > "$ROOT/run.log" 2>&1 < /dev/null & +echo "$!" > "$ROOT/run.pid" +cat "$ROOT/tests.log" +cat "$ROOT/run.pid" diff --git a/docs/quantized_capacity_evidence_20261031/summary.json b/docs/quantized_capacity_evidence_20261031/summary.json new file mode 100644 index 0000000..f10f247 --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/summary.json @@ -0,0 +1,6430 @@ +{ + "status": "passed", + "source_commit": "20d111c0830239b7b19ba787479a00fdffb90b07", + "command": "/llm-align/duyimin/miniconda3/envs/gemma4/bin/python -m tools.benchmark_quantized_capacity --training-dir /llm-align/duyimin/meft-cpu-capacity-20261030/training2 --query-manifest /llm-align/duyimin/meft-cpu-capacity-20261030/capacity/queries-ordinary.json --output-dir /llm-align/duyimin/ngram-scale-20261031/results --native-library /llm-align/duyimin/ngram-scale-20261031/source/build/libmeft_rows.so --chunk-rows 4096 --max-block-bytes 8192 --cache-bytes 4194304 --repeat 20 --process-repeats 3 --seed 42 --scale-rows 100000 500000 --int8-extra-block-rows 1 4", + "shape": [ + 1855907, + 256 + ], + "source_bytes": 1900448768, + "source_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "python": "3.11.15 (main, Mar 11 2026, 17:20:07) [GCC 14.3.0]", + "numpy": "2.2.6", + "os": "Linux-5.4.0-42-generic-x86_64-with-glibc2.35", + "cpu": "AMD EPYC 7742 64-Core Processor", + "settings": { + "chunk_rows": 4096, + "max_block_bytes": 8192, + "cache_bytes": 4194304, + "repeat": 20, + "process_repeats": 3, + "seed": 42, + "scale_rows": [ + 100000, + 500000 + ], + "int8_extra_block_rows": [ + 1, + 4 + ] + }, + "limitations": [ + "Shared CPU and filesystem; timing rounds randomize variant/trace order, no isolation guarantee.", + "Filesystem warmed by build/verification; first trace means fresh process/empty application cache, not disk-cold.", + "Uniform IDs are synthetic accesses on genuine vectors; original held-out lexical trace is reused.", + "FP16/INT8 are lossy relative to FP32; byte-exact claims apply to their encoded rows only.", + "No downstream task quality, GPU, cgroup memory cap, physical disk I/O or monetary cost measured.", + "Smaller prefixes reuse original trained rows without retraining and are storage scaling controls.", + "Chunking bounds codec working buffers, not native O(block count) descriptors or arbitrary optional planner indexes.", + "Complete bundle is table + codec metadata + common key registry; training source-ID provenance is separate." + ], + "native_library_sha256": "49aa8e7e82c83e3ec0b103af62eeb3638d98a18a780a35bb5c80e435fc791c51", + "keys_bytes": 21429556, + "keys_sha256": "addcb6e8300c27a5d8d43028d334f9d9e6f62dcf39f7590c0952a060ede8acc8", + "training_report_sha256": "2d6f5cbe67e7922ff0e28055be0cf1cf045c5f7f8cddd89b69b594e5408c0245", + "training": { + "status": "passed", + "category": "public-text finite CPU SGNS storage reference", + "source_commit": "3104f50470067049f5a57a574270d0b9d17c4fbf", + "command": "/llm-align/duyimin/meft-cuda-20261030/compat/bin/python /llm-align/duyimin/meft-cpu-capacity-20261030/source/tools/train_capacity_memory.py --corpus-zip /llm-align/duyimin/meft-cpu-capacity-20261030/enwik8.zip --output-dir /llm-align/duyimin/meft-cpu-capacity-20261030/training2 --order 12 --dim 256 --min-count 2 --epochs 3 --random-pairs 262144 --batch-size 128 --threads 4 --seed 42 --exclude-untrained", + "settings": { + "corpus_zip": "/llm-align/duyimin/meft-cpu-capacity-20261030/enwik8.zip", + "output_dir": "/llm-align/duyimin/meft-cpu-capacity-20261030/training2", + "order": 12, + "dim": 256, + "min_count": 2, + "epochs": 3, + "random_pairs": 262144, + "batch_size": 128, + "negatives": 5, + "lr": 0.02, + "threads": 4, + "seed": 42, + "exclude_untrained": true + }, + "python": "3.11.15 (main, Mar 11 2026, 17:20:07) [GCC 14.3.0]", + "torch": "2.11.0+cu130", + "numpy": "2.2.6", + "os": "Linux-5.4.0-42-generic-x86_64-with-glibc2.35", + "cuda_visible_devices": "", + "corpus_source": "https://mattmahoney.net/dc/enwik8.zip", + "corpus_license_note": "Wikipedia-derived benchmark XML; publish aggregates/hashes only, no text or weights.", + "zip_sha256": "547994d9980ebed1288380d652999f38a14fe291a6247c157c3d33d4932534bc", + "loss_samples": [ + { + "pair": 128, + "loss_per_pair": 4.1588826179504395 + }, + { + "pair": 25728, + "loss_per_pair": 4.15886926651001 + }, + { + "pair": 51328, + "loss_per_pair": 4.1541571617126465 + }, + { + "pair": 76928, + "loss_per_pair": 4.104265213012695 + }, + { + "pair": 102528, + "loss_per_pair": 4.097651481628418 + }, + { + "pair": 128128, + "loss_per_pair": 4.011539459228516 + }, + { + "pair": 153728, + "loss_per_pair": 3.821012020111084 + }, + { + "pair": 179328, + "loss_per_pair": 3.7390387058258057 + }, + { + "pair": 204928, + "loss_per_pair": 3.499899387359619 + }, + { + "pair": 230528, + "loss_per_pair": 3.392859935760498 + }, + { + "pair": 256128, + "loss_per_pair": 3.1507654190063477 + }, + { + "pair": 281728, + "loss_per_pair": 3.030824899673462 + }, + { + "pair": 307328, + "loss_per_pair": 2.8885982036590576 + }, + { + "pair": 332928, + "loss_per_pair": 2.884829521179199 + }, + { + "pair": 358528, + "loss_per_pair": 2.5694169998168945 + }, + { + "pair": 384128, + "loss_per_pair": 2.682878017425537 + }, + { + "pair": 404170, + "loss_per_pair": 2.451352119445801 + }, + { + "pair": 429770, + "loss_per_pair": 2.7473137378692627 + }, + { + "pair": 455370, + "loss_per_pair": 2.586317777633667 + }, + { + "pair": 480970, + "loss_per_pair": 2.6172497272491455 + }, + { + "pair": 506570, + "loss_per_pair": 2.568492889404297 + }, + { + "pair": 532170, + "loss_per_pair": 2.551452875137329 + }, + { + "pair": 557770, + "loss_per_pair": 2.3971922397613525 + }, + { + "pair": 583370, + "loss_per_pair": 2.339668035507202 + }, + { + "pair": 608970, + "loss_per_pair": 2.3867764472961426 + }, + { + "pair": 634570, + "loss_per_pair": 2.358508348464966 + }, + { + "pair": 660170, + "loss_per_pair": 2.0983707904815674 + }, + { + "pair": 685770, + "loss_per_pair": 2.401175022125244 + }, + { + "pair": 711370, + "loss_per_pair": 2.5801897048950195 + }, + { + "pair": 736970, + "loss_per_pair": 2.0772454738616943 + }, + { + "pair": 762570, + "loss_per_pair": 2.13584566116333 + }, + { + "pair": 788170, + "loss_per_pair": 2.2601511478424072 + }, + { + "pair": 808212, + "loss_per_pair": 1.954177737236023 + }, + { + "pair": 833812, + "loss_per_pair": 2.157029151916504 + }, + { + "pair": 859412, + "loss_per_pair": 2.305432081222534 + }, + { + "pair": 885012, + "loss_per_pair": 2.092989921569824 + }, + { + "pair": 910612, + "loss_per_pair": 1.9835753440856934 + }, + { + "pair": 936212, + "loss_per_pair": 2.4388372898101807 + }, + { + "pair": 961812, + "loss_per_pair": 2.010632038116455 + }, + { + "pair": 987412, + "loss_per_pair": 2.254207134246826 + }, + { + "pair": 1013012, + "loss_per_pair": 2.1635193824768066 + }, + { + "pair": 1038612, + "loss_per_pair": 2.1499266624450684 + }, + { + "pair": 1064212, + "loss_per_pair": 1.9153399467468262 + }, + { + "pair": 1089812, + "loss_per_pair": 1.9550358057022095 + }, + { + "pair": 1115412, + "loss_per_pair": 2.0913519859313965 + }, + { + "pair": 1141012, + "loss_per_pair": 2.1659600734710693 + }, + { + "pair": 1166612, + "loss_per_pair": 2.104854106903076 + }, + { + "pair": 1192212, + "loss_per_pair": 2.1347568035125732 + } + ], + "limitations": [ + "Finite reference training, not convergence or task quality.", + "ASCII word tokenization of XML-tag-stripped Wikipedia benchmark text.", + "No trained DeepSeek weights, no whole-model inference or GPU memory result.", + "Coverage sampling overweights rare words; it is recorded, not claimed as standard full-corpus SGNS.", + "Shared CPU host, monetary/energy cost unmeasured." + ], + "corpus_raw_bytes": 100000000, + "corpus_raw_sha256": "2b49720ec4d78c3c9fabaee6e4179a5e997302b3a70029f30f2d582218c024a8", + "train_raw_sha256": "f8978bd9ca51fbea387d5145d310652ab39904bcbc8ab2647932c8c2e0539e64", + "heldout_raw_sha256": "10c136c4dc9db600c9c8e640271ea9d9628348c90e40309927ea1bbd481dcfe1", + "vocabulary": 142308, + "ngram_rows": 1855907, + "dim": 256, + "raw_table_bytes": 1900448768, + "training_tokens": 12186524, + "valid_adjacent_pair_pool": 11917115, + "coverage_centers": 141898, + "preparation_seconds": 22.897388527169824, + "completed_epochs": 3, + "sampled_training_pairs": 1212126, + "registered_ngram_rows": 1860921, + "excluded_untrained_rows": 5014, + "changed_rows": 1855907, + "all_rows_changed": true, + "source_row_ids_sha256": "16c6ef210b5975bdb4146f0400163eecfb424c11e590012dc9ada47aa399bc0a", + "all_finite": true, + "center_coverage": 141898, + "training_seconds": 38.3484745179303, + "trained_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "keys_sha256": "addcb6e8300c27a5d8d43028d334f9d9e6f62dcf39f7590c0952a060ede8acc8", + "query_ids_sha256": "ed786a9c6d4139ea202af21a5ae2933383aa2353aaa0caf6b8774b2caca2596d", + "query_rows": 65536, + "initial_sha256": "ffb05f7f554c416f64d07a1a59118c5c939533ac5762186aa9697a32b2357a1d" + }, + "software": { + "pytorch_installed_not_used": "2.11.0", + "thread_environment": { + "OMP_NUM_THREADS": "1", + "MKL_NUM_THREADS": "1", + "OPENBLAS_NUM_THREADS": "1" + }, + "cpu_affinity": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254 + ] + }, + "builds": { + "fp32-raw": { + "rows": 1855907, + "encoding": "fp32", + "backend": "raw_mmap", + "wall_seconds": 10.370393085991964, + "cpu_seconds": 10.355446356000002, + "peak_rss_bytes": 62156800, + "table_bytes": 1900448768, + "bundle_bytes": 1900449610, + "bundle_with_keys_bytes": 1921879166, + "storage": { + "artifact_bytes": 1900448768, + "unique_rows": 1855907, + "row_map_bytes": 0, + "deduplicate": false + }, + "source_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "table_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "source_bytes_preserved": true, + "verification": { + "rows_verified": 1855907, + "all_original_ids_encoded_byte_exact": true, + "all_decoded_rows_oracle_byte_exact": true, + "encoded_original_id_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "decoded_original_id_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "relative_frobenius": 0.0, + "row_relative_l2": { + "p50": 0.0, + "p99": 0.0, + "max": 0.0 + }, + "cosine_distance": { + "p50": 0.0, + "p99": 0.0, + "max": 0.0 + } + }, + "table_saving_vs_raw_fp32": 0.0, + "bundle_saving_vs_raw_fp32": 0.0, + "bundle_added_saving_vs_same_encoding_raw": 0.0 + }, + "fp32-native": { + "rows": 1855907, + "encoding": "fp32", + "backend": "native", + "wall_seconds": 148.345714968862, + "cpu_seconds": 147.13892236200002, + "peak_rss_bytes": 90267648, + "table_bytes": 1788494457, + "bundle_bytes": 1788495722, + "bundle_with_keys_bytes": 1809925278, + "storage": { + "format": "MEFTNAT1", + "format_version": 2, + "input_bytes": 1900448768, + "artifact_bytes": 1788494457, + "unique_rows": 1855907, + "row_map_bytes": 14847256, + "n_rows": 1855907, + "row_bytes": 1024, + "block_rows": 8, + "blocks": 231989, + "max_block_bytes": 8192, + "raw_blocks": 0, + "compressed_blocks": 231989, + "zlib_blocks": 231776, + "xor_blocks": 213, + "deduplicate": false, + "predictor": "xor", + "reordered": false, + "external_representatives": false, + "marked_rows": 1855907 + }, + "source_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "table_sha256": "ff7abc982b7f2ea28ec65bf542dced85fcad65bdf5a43d6c4d888d7831f5d42e", + "source_bytes_preserved": true, + "verification": { + "rows_verified": 1855907, + "all_original_ids_encoded_byte_exact": true, + "all_decoded_rows_oracle_byte_exact": true, + "encoded_original_id_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "decoded_original_id_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "relative_frobenius": 0.0, + "row_relative_l2": { + "p50": 0.0, + "p99": 0.0, + "max": 0.0 + }, + "cosine_distance": { + "p50": 0.0, + "p99": 0.0, + "max": 0.0 + } + }, + "table_saving_vs_raw_fp32": 0.05890940754894369, + "bundle_saving_vs_raw_fp32": 0.058252303256405624, + "bundle_added_saving_vs_same_encoding_raw": 0.058252303256405624 + }, + "fp16-raw": { + "rows": 1855907, + "encoding": "fp16", + "backend": "raw_mmap", + "wall_seconds": 14.220760132186115, + "cpu_seconds": 14.203124190999999, + "peak_rss_bytes": 61788160, + "table_bytes": 950224384, + "bundle_bytes": 950225225, + "bundle_with_keys_bytes": 971654781, + "storage": { + "artifact_bytes": 950224384, + "unique_rows": 1855907, + "row_map_bytes": 0, + "deduplicate": false + }, + "source_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "table_sha256": "9a834bae821d8f47e500137f2cb6e177897f8384c95dc6f0f7c0d81e44d6cda0", + "source_bytes_preserved": false, + "verification": { + "rows_verified": 1855907, + "all_original_ids_encoded_byte_exact": true, + "all_decoded_rows_oracle_byte_exact": true, + "encoded_original_id_sha256": "9a834bae821d8f47e500137f2cb6e177897f8384c95dc6f0f7c0d81e44d6cda0", + "decoded_original_id_sha256": "617abd12e13be288874a291b647275a5c9f4387c39e7b293768496a8c9d63f90", + "relative_frobenius": 0.00020674881637380336, + "row_relative_l2": { + "p50": 0.00020555812572555036, + "p99": 0.00023194982570116276, + "max": 0.00026330016850603243 + }, + "cosine_distance": { + "p50": 2.09291917130372e-08, + "p99": 2.665040440330557e-08, + "max": 3.421355421195926e-08 + } + }, + "table_saving_vs_raw_fp32": 0.5, + "bundle_saving_vs_raw_fp32": 0.4944246245083652, + "bundle_added_saving_vs_same_encoding_raw": 0.0 + }, + "fp16-native": { + "rows": 1855907, + "encoding": "fp16", + "backend": "native", + "wall_seconds": 80.87081305100583, + "cpu_seconds": 80.48362037, + "peak_rss_bytes": 68276224, + "table_bytes": 895590970, + "bundle_bytes": 895592233, + "bundle_with_keys_bytes": 917021789, + "storage": { + "format": "MEFTNAT1", + "format_version": 2, + "input_bytes": 950224384, + "artifact_bytes": 895590970, + "unique_rows": 1855907, + "row_map_bytes": 14847256, + "n_rows": 1855907, + "row_bytes": 512, + "block_rows": 16, + "blocks": 115995, + "max_block_bytes": 8192, + "raw_blocks": 0, + "compressed_blocks": 115995, + "zlib_blocks": 115853, + "xor_blocks": 142, + "deduplicate": false, + "predictor": "xor", + "reordered": false, + "external_representatives": false, + "marked_rows": 1855907 + }, + "source_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "table_sha256": "baf61ef2961c4224e97741694f223d31152578a9da18c4109bf15c6835052bd0", + "source_bytes_preserved": false, + "verification": { + "rows_verified": 1855907, + "all_original_ids_encoded_byte_exact": true, + "all_decoded_rows_oracle_byte_exact": true, + "encoded_original_id_sha256": "9a834bae821d8f47e500137f2cb6e177897f8384c95dc6f0f7c0d81e44d6cda0", + "decoded_original_id_sha256": "617abd12e13be288874a291b647275a5c9f4387c39e7b293768496a8c9d63f90", + "relative_frobenius": 0.00020674881637380336, + "row_relative_l2": { + "p50": 0.00020555812572555036, + "p99": 0.00023194982570116276, + "max": 0.00026330016850603243 + }, + "cosine_distance": { + "p50": 2.09291917130372e-08, + "p99": 2.665040440330557e-08, + "max": 3.421355421195926e-08 + } + }, + "table_saving_vs_raw_fp32": 0.5287476384104242, + "bundle_saving_vs_raw_fp32": 0.5228514855548416, + "bundle_added_saving_vs_same_encoding_raw": 0.056226751587403534 + }, + "int8-raw": { + "rows": 1855907, + "encoding": "int8", + "backend": "raw_mmap", + "wall_seconds": 12.3611105249729, + "cpu_seconds": 12.340051010000002, + "peak_rss_bytes": 63176704, + "table_bytes": 482535820, + "bundle_bytes": 482536705, + "bundle_with_keys_bytes": 503966261, + "storage": { + "artifact_bytes": 482535820, + "unique_rows": 1855907, + "row_map_bytes": 0, + "deduplicate": false + }, + "source_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "table_sha256": "52fb9be46af385ca15a8174ceb87840a85c8532c5e2bfa9a1dd80cc27123893a", + "source_bytes_preserved": false, + "verification": { + "rows_verified": 1855907, + "all_original_ids_encoded_byte_exact": true, + "all_decoded_rows_oracle_byte_exact": true, + "encoded_original_id_sha256": "52fb9be46af385ca15a8174ceb87840a85c8532c5e2bfa9a1dd80cc27123893a", + "decoded_original_id_sha256": "035d3a5223898f4bf0552b1564a724a0c7f6458e4840887c6f6220d1d2dde286", + "relative_frobenius": 0.007792033224643991, + "row_relative_l2": { + "p50": 0.005593181978794904, + "p99": 0.00904459455787198, + "max": 0.011602407628381531 + }, + "cosine_distance": { + "p50": 1.5581723388335966e-05, + "p99": 4.074664666232847e-05, + "max": 6.695415484603284e-05 + } + }, + "table_saving_vs_raw_fp32": 0.74609375, + "bundle_saving_vs_raw_fp32": 0.7377742212332199, + "bundle_added_saving_vs_same_encoding_raw": 0.0 + }, + "int8-native": { + "rows": 1855907, + "encoding": "int8", + "backend": "native", + "wall_seconds": 43.67581850197166, + "cpu_seconds": 43.395281255, + "peak_rss_bytes": 64651264, + "table_bytes": 488715334, + "bundle_bytes": 488716638, + "bundle_with_keys_bytes": 510146194, + "storage": { + "format": "MEFTNAT1", + "format_version": 2, + "input_bytes": 482535820, + "artifact_bytes": 488715334, + "unique_rows": 1855907, + "row_map_bytes": 14847256, + "n_rows": 1855907, + "row_bytes": 260, + "block_rows": 31, + "blocks": 59868, + "max_block_bytes": 8192, + "raw_blocks": 30, + "compressed_blocks": 59838, + "zlib_blocks": 59799, + "xor_blocks": 39, + "deduplicate": false, + "predictor": "xor", + "reordered": false, + "external_representatives": false, + "marked_rows": 1855907 + }, + "source_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "table_sha256": "c2fe87dd534c414adecbe640d94b551da9717e701ef88bb0409c94e002bd42d5", + "source_bytes_preserved": false, + "verification": { + "rows_verified": 1855907, + "all_original_ids_encoded_byte_exact": true, + "all_decoded_rows_oracle_byte_exact": true, + "encoded_original_id_sha256": "52fb9be46af385ca15a8174ceb87840a85c8532c5e2bfa9a1dd80cc27123893a", + "decoded_original_id_sha256": "035d3a5223898f4bf0552b1564a724a0c7f6458e4840887c6f6220d1d2dde286", + "relative_frobenius": 0.007792033224643991, + "row_relative_l2": { + "p50": 0.005593181978794904, + "p99": 0.00904459455787198, + "max": 0.011602407628381531 + }, + "cosine_distance": { + "p50": 1.5581723388335966e-05, + "p99": 4.074664666232847e-05, + "max": 6.695415484603284e-05 + } + }, + "table_saving_vs_raw_fp32": 0.7428421422197475, + "bundle_saving_vs_raw_fp32": 0.7345586533092164, + "bundle_added_saving_vs_same_encoding_raw": -0.012262592713522924 + }, + "int8-native-rows-1": { + "rows": 1855907, + "encoding": "int8", + "backend": "native", + "wall_seconds": 84.57163161505014, + "cpu_seconds": 84.282680844, + "peak_rss_bytes": 398155776, + "table_bytes": 556772156, + "bundle_bytes": 556773456, + "bundle_with_keys_bytes": 578203012, + "storage": { + "format": "MEFTNAT1", + "format_version": 2, + "input_bytes": 482535820, + "artifact_bytes": 556772156, + "unique_rows": 1855907, + "row_map_bytes": 14847256, + "n_rows": 1855907, + "row_bytes": 260, + "block_rows": 1, + "blocks": 1855907, + "max_block_bytes": 260, + "raw_blocks": 1855907, + "compressed_blocks": 0, + "zlib_blocks": 0, + "xor_blocks": 0, + "deduplicate": false, + "predictor": "xor", + "reordered": false, + "external_representatives": false, + "marked_rows": 1855907 + }, + "source_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "table_sha256": "4cee7fcc39e8e2301f4e9d0a6c90279b79a14d8c4ca93f501c9de9efd99f0a8f", + "source_bytes_preserved": false, + "verification": { + "rows_verified": 1855907, + "all_original_ids_encoded_byte_exact": true, + "all_decoded_rows_oracle_byte_exact": true, + "encoded_original_id_sha256": "52fb9be46af385ca15a8174ceb87840a85c8532c5e2bfa9a1dd80cc27123893a", + "decoded_original_id_sha256": "035d3a5223898f4bf0552b1564a724a0c7f6458e4840887c6f6220d1d2dde286", + "relative_frobenius": 0.007792033224643991, + "row_relative_l2": { + "p50": 0.005593181978794904, + "p99": 0.00904459455787198, + "max": 0.011602407628381531 + }, + "cosine_distance": { + "p50": 1.5581723388335966e-05, + "p99": 4.074664666232847e-05, + "max": 6.695415484603284e-05 + } + }, + "table_saving_vs_raw_fp32": 0.7070312205332756, + "bundle_saving_vs_raw_fp32": 0.6991470524115146, + "bundle_added_saving_vs_same_encoding_raw": -0.1473050018322557 + }, + "int8-native-rows-4": { + "rows": 1855907, + "encoding": "int8", + "backend": "native", + "wall_seconds": 81.07962489011697, + "cpu_seconds": 80.826415181, + "peak_rss_bytes": 132521984, + "table_bytes": 511695058, + "bundle_bytes": 511696368, + "bundle_with_keys_bytes": 533125924, + "storage": { + "format": "MEFTNAT1", + "format_version": 2, + "input_bytes": 482535820, + "artifact_bytes": 511695058, + "unique_rows": 1855907, + "row_map_bytes": 14847256, + "n_rows": 1855907, + "row_bytes": 260, + "block_rows": 4, + "blocks": 463977, + "max_block_bytes": 1040, + "raw_blocks": 432294, + "compressed_blocks": 31683, + "zlib_blocks": 25208, + "xor_blocks": 6475, + "deduplicate": false, + "predictor": "xor", + "reordered": false, + "external_representatives": false, + "marked_rows": 1855907 + }, + "source_sha256": "0e5d4be0b156c5e9f0d745292876e48f78772c599d97902619123512955d82fc", + "table_sha256": "99a345e4984fcf504467e2cb5dd79d2450c8985e2d0ae974d37b489778740a3a", + "source_bytes_preserved": false, + "verification": { + "rows_verified": 1855907, + "all_original_ids_encoded_byte_exact": true, + "all_decoded_rows_oracle_byte_exact": true, + "encoded_original_id_sha256": "52fb9be46af385ca15a8174ceb87840a85c8532c5e2bfa9a1dd80cc27123893a", + "decoded_original_id_sha256": "035d3a5223898f4bf0552b1564a724a0c7f6458e4840887c6f6220d1d2dde286", + "relative_frobenius": 0.007792033224643991, + "row_relative_l2": { + "p50": 0.005593181978794904, + "p99": 0.00904459455787198, + "max": 0.011602407628381531 + }, + "cosine_distance": { + "p50": 1.5581723388335966e-05, + "p99": 4.074664666232847e-05, + "max": 6.695415484603284e-05 + } + }, + "table_saving_vs_raw_fp32": 0.7307504066323771, + "bundle_saving_vs_raw_fp32": 0.722601746544975, + "bundle_added_saving_vs_same_encoding_raw": -0.05786034752036695 + }, + "int8-native-prefix-100000": { + "rows": 100000, + "encoding": "int8", + "backend": "native", + "wall_seconds": 2.3831364430952817, + "cpu_seconds": 2.349497259, + "peak_rss_bytes": 66666496, + "table_bytes": 26390162, + "bundle_bytes": 26391453, + "bundle_with_keys_bytes": null, + "storage": { + "format": "MEFTNAT1", + "format_version": 2, + "input_bytes": 26000000, + "artifact_bytes": 26390162, + "unique_rows": 100000, + "row_map_bytes": 800000, + "n_rows": 100000, + "row_bytes": 260, + "block_rows": 31, + "blocks": 3226, + "max_block_bytes": 8192, + "raw_blocks": 4, + "compressed_blocks": 3222, + "zlib_blocks": 3214, + "xor_blocks": 8, + "deduplicate": false, + "predictor": "xor", + "reordered": false, + "external_representatives": false, + "marked_rows": 100000 + }, + "source_sha256": "e1ea759def4b1fb8a20ae3c2ead78a58c05503cbb4ece23a7f7aa2c439bc66af", + "table_sha256": "54768b16c5d27e35fa7a9e7e289354847dd53654f830f0839bd4f551fe37a787", + "source_bytes_preserved": false + }, + "int8-native-prefix-500000": { + "rows": 500000, + "encoding": "int8", + "backend": "native", + "wall_seconds": 11.73707849602215, + "cpu_seconds": 11.623225424000001, + "peak_rss_bytes": 65036288, + "table_bytes": 131959408, + "bundle_bytes": 131960707, + "bundle_with_keys_bytes": null, + "storage": { + "format": "MEFTNAT1", + "format_version": 2, + "input_bytes": 130000000, + "artifact_bytes": 131959408, + "unique_rows": 500000, + "row_map_bytes": 4000000, + "n_rows": 500000, + "row_bytes": 260, + "block_rows": 31, + "blocks": 16130, + "max_block_bytes": 8192, + "raw_blocks": 20, + "compressed_blocks": 16110, + "zlib_blocks": 16094, + "xor_blocks": 16, + "deduplicate": false, + "predictor": "xor", + "reordered": false, + "external_representatives": false, + "marked_rows": 500000 + }, + "source_sha256": "253dccf006cda19887a7874b564d840577af97979aa943a70ee530180e6e45b4", + "table_sha256": "bd94fdd73cce4dfd7430b59f8d1d732ea4765d8aeb3c0eaffb6213a4934d1f54", + "source_bytes_preserved": false + } + }, + "queries": { + "int8-native-rows-1": { + "uniform-id-stress": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 65536, + "batch_rows": 512, + "query_buffer_bytes": 657408, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 0.7700705, + "min": 0.7612005, + "max": 0.7720959999999999, + "values": [ + 0.7612005, + 0.7720959999999999, + 0.7700705 + ] + }, + "wall_p95_ms": { + "median": 1.0908454, + "min": 1.0879464499999998, + "max": 1.0973891999999998, + "values": [ + 1.0879464499999998, + 1.0908454, + 1.0973891999999998 + ] + }, + "wall_p99_ms": { + "median": 1.3638068300000004, + "min": 1.3514532000000004, + "max": 1.3820030700000001, + "values": [ + 1.3514532000000004, + 1.3638068300000004, + 1.3820030700000001 + ] + }, + "rows_per_second": { + "median": 631366.7015875959, + "min": 625960.8892690603, + "max": 639697.3619267723, + "values": [ + 639697.3619267723, + 631366.7015875959, + 625960.8892690603 + ] + }, + "cpu_p50_ms": { + "median": 0.7714455, + "min": 0.7622705000000001, + "max": 0.77237, + "values": [ + 0.7622705000000001, + 0.77237, + 0.7714455 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.36094, + "min": 0.35748250000000004, + "max": 0.36520050000000004, + "values": [ + 0.36094, + 0.36520050000000004, + 0.35748250000000004 + ] + }, + "wall_p95_ms": { + "median": 0.38179789999999997, + "min": 0.3779817, + "max": 0.3893416, + "values": [ + 0.38179789999999997, + 0.3893416, + 0.3779817 + ] + }, + "wall_p99_ms": { + "median": 0.39904909, + "min": 0.38730885, + "max": 0.40987605000000005, + "values": [ + 0.40987605000000005, + 0.39904909, + 0.38730885 + ] + }, + "rows_per_second": { + "median": 1401308.7834024276, + "min": 1386909.9244371539, + "max": 1418859.2363945358, + "values": [ + 1401308.7834024276, + 1386909.9244371539, + 1418859.2363945358 + ] + }, + "cpu_p50_ms": { + "median": 0.36174, + "min": 0.35827050000000005, + "max": 0.3662355, + "values": [ + 0.36174, + 0.3662355, + 0.35827050000000005 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.27489549999999996, + "min": 0.272521, + "max": 0.2765375, + "values": [ + 0.27489549999999996, + 0.2765375, + 0.272521 + ] + }, + "wall_p95_ms": { + "median": 0.28735114999999994, + "min": 0.28721245, + "max": 0.3399184999999999, + "values": [ + 0.3399184999999999, + 0.28721245, + 0.28735114999999994 + ] + }, + "wall_p99_ms": { + "median": 0.29975635999999994, + "min": 0.29856734, + "max": 0.36243514, + "values": [ + 0.36243514, + 0.29975635999999994, + 0.29856734 + ] + }, + "rows_per_second": { + "median": 1843976.078822234, + "min": 1823547.8797961418, + "max": 1866806.7987134713, + "values": [ + 1823547.8797961418, + 1843976.078822234, + 1866806.7987134713 + ] + }, + "cpu_p50_ms": { + "median": 0.2759595, + "min": 0.273345, + "max": 0.27757449999999995, + "values": [ + 0.2759595, + 0.27757449999999995, + 0.273345 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 331341824.0, + "min": 331292672.0, + "max": 331370496.0, + "values": [ + 331292672, + 331370496, + 331341824 + ] + }, + "VmRSS_bytes": { + "median": 331341824.0, + "min": 331292672.0, + "max": 331370496.0, + "values": [ + 331292672, + 331370496, + 331341824 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 331882496.0, + "min": 331833344.0, + "max": 331911168.0, + "values": [ + 331833344, + 331911168, + 331882496 + ] + }, + "VmRSS_bytes": { + "median": 331882496.0, + "min": 331833344.0, + "max": 331911168.0, + "values": [ + 331833344, + 331911168, + 331882496 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 331882496.0, + "min": 331833344.0, + "max": 331911168.0, + "values": [ + 331833344, + 331911168, + 331882496 + ] + }, + "VmRSS_bytes": { + "median": 331882496.0, + "min": 331833344.0, + "max": 331911168.0, + "values": [ + 331833344, + 331911168, + 331882496 + ] + } + } + }, + "heldout-lexical": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 17677, + "batch_rows": 512, + "query_buffer_bytes": 657408, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 0.3460985, + "min": 0.342083, + "max": 0.348682, + "values": [ + 0.342083, + 0.348682, + 0.3460985 + ] + }, + "wall_p95_ms": { + "median": 0.5134807, + "min": 0.51019805, + "max": 0.52430585, + "values": [ + 0.51019805, + 0.5134807, + 0.52430585 + ] + }, + "wall_p99_ms": { + "median": 0.7309658300000006, + "min": 0.7307545100000006, + "max": 0.7355493600000005, + "values": [ + 0.7355493600000005, + 0.7309658300000006, + 0.7307545100000006 + ] + }, + "rows_per_second": { + "median": 1387049.2949607018, + "min": 1383325.673989214, + "max": 1396250.032383729, + "values": [ + 1396250.032383729, + 1383325.673989214, + 1387049.2949607018 + ] + }, + "cpu_p50_ms": { + "median": 0.346725, + "min": 0.342955, + "max": 0.3498555, + "values": [ + 0.342955, + 0.3498555, + 0.346725 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.2592855, + "min": 0.25788900000000003, + "max": 0.26019349999999997, + "values": [ + 0.26019349999999997, + 0.2592855, + 0.25788900000000003 + ] + }, + "wall_p95_ms": { + "median": 0.28087019999999996, + "min": 0.2806991, + "max": 0.2820017999999999, + "values": [ + 0.2806991, + 0.2820017999999999, + 0.28087019999999996 + ] + }, + "wall_p99_ms": { + "median": 0.30379110000000004, + "min": 0.29983925, + "max": 0.31067655000000005, + "values": [ + 0.29983925, + 0.30379110000000004, + 0.31067655000000005 + ] + }, + "rows_per_second": { + "median": 1949825.2622033888, + "min": 1946387.675721287, + "max": 1956044.0465685087, + "values": [ + 1946387.675721287, + 1949825.2622033888, + 1956044.0465685087 + ] + }, + "cpu_p50_ms": { + "median": 0.26073, + "min": 0.258895, + "max": 0.260775, + "values": [ + 0.260775, + 0.26073, + 0.258895 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.2396605, + "min": 0.238438, + "max": 0.240324, + "values": [ + 0.240324, + 0.2396605, + 0.238438 + ] + }, + "wall_p95_ms": { + "median": 0.25321689999999997, + "min": 0.25132744999999995, + "max": 0.2850502999999994, + "values": [ + 0.25132744999999995, + 0.2850502999999994, + 0.25321689999999997 + ] + }, + "wall_p99_ms": { + "median": 0.26333789, + "min": 0.25917133, + "max": 0.51240549, + "values": [ + 0.25917133, + 0.51240549, + 0.26333789 + ] + }, + "rows_per_second": { + "median": 2125765.387121288, + "min": 2020290.6530409504, + "max": 2138364.559885966, + "values": [ + 2125765.387121288, + 2020290.6530409504, + 2138364.559885966 + ] + }, + "cpu_p50_ms": { + "median": 0.24072, + "min": 0.239235, + "max": 0.2410755, + "values": [ + 0.2410755, + 0.24072, + 0.239235 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 146702336.0, + "min": 146571264.0, + "max": 146718720.0, + "values": [ + 146702336, + 146718720, + 146571264 + ] + }, + "VmRSS_bytes": { + "median": 146702336.0, + "min": 146571264.0, + "max": 146718720.0, + "values": [ + 146702336, + 146718720, + 146571264 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 147243008.0, + "min": 147111936.0, + "max": 147259392.0, + "values": [ + 147243008, + 147259392, + 147111936 + ] + }, + "VmRSS_bytes": { + "median": 147243008.0, + "min": 147111936.0, + "max": 147259392.0, + "values": [ + 147243008, + 147259392, + 147111936 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 147243008.0, + "min": 147111936.0, + "max": 147259392.0, + "values": [ + 147243008, + 147259392, + 147111936 + ] + }, + "VmRSS_bytes": { + "median": 147243008.0, + "min": 147111936.0, + "max": 147259392.0, + "values": [ + 147243008, + 147259392, + 147111936 + ] + } + } + } + }, + "fp16-raw": { + "heldout-lexical": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 17677, + "batch_rows": 512, + "query_buffer_bytes": 786432, + "cache_budget_bytes": 0, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 0.4962925, + "min": 0.4960825, + "max": 0.49863250000000003, + "values": [ + 0.4962925, + 0.4960825, + 0.49863250000000003 + ] + }, + "wall_p95_ms": { + "median": 0.6055247, + "min": 0.6038551, + "max": 0.6096835, + "values": [ + 0.6038551, + 0.6096835, + 0.6055247 + ] + }, + "wall_p99_ms": { + "median": 0.7605827900000006, + "min": 0.7554019000000005, + "max": 0.7681003400000006, + "values": [ + 0.7605827900000006, + 0.7681003400000006, + 0.7554019000000005 + ] + }, + "rows_per_second": { + "median": 997764.3021472557, + "min": 995254.242765526, + "max": 1000713.9798625245, + "values": [ + 1000713.9798625245, + 995254.242765526, + 997764.3021472557 + ] + }, + "cpu_p50_ms": { + "median": 0.4971105, + "min": 0.496405, + "max": 0.4988, + "values": [ + 0.4971105, + 0.496405, + 0.4988 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.415346, + "min": 0.4149275, + "max": 0.4173015, + "values": [ + 0.4149275, + 0.4173015, + 0.415346 + ] + }, + "wall_p95_ms": { + "median": 0.436229, + "min": 0.42702785, + "max": 0.43647684999999997, + "values": [ + 0.436229, + 0.43647684999999997, + 0.42702785 + ] + }, + "wall_p99_ms": { + "median": 0.44128386999999997, + "min": 0.43760578, + "max": 0.45321257000000004, + "values": [ + 0.44128386999999997, + 0.45321257000000004, + 0.43760578 + ] + }, + "rows_per_second": { + "median": 1227571.2242215145, + "min": 1221174.5889846382, + "max": 1230307.357195194, + "values": [ + 1227571.2242215145, + 1221174.5889846382, + 1230307.357195194 + ] + }, + "cpu_p50_ms": { + "median": 0.415865, + "min": 0.41559, + "max": 0.418025, + "values": [ + 0.41559, + 0.418025, + 0.415865 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.407803, + "min": 0.407803, + "max": 0.4092355, + "values": [ + 0.407803, + 0.4092355, + 0.407803 + ] + }, + "wall_p95_ms": { + "median": 0.42163285, + "min": 0.421492, + "max": 0.42255745, + "values": [ + 0.421492, + 0.42163285, + 0.42255745 + ] + }, + "wall_p99_ms": { + "median": 0.43141601999999996, + "min": 0.42773669999999997, + "max": 0.43418498, + "values": [ + 0.42773669999999997, + 0.43418498, + 0.43141601999999996 + ] + }, + "rows_per_second": { + "median": 1252845.666420298, + "min": 1246672.414163324, + "max": 1253356.0589797653, + "values": [ + 1253356.0589797653, + 1246672.414163324, + 1252845.666420298 + ] + }, + "cpu_p50_ms": { + "median": 0.40833050000000004, + "min": 0.40825, + "max": 0.40984, + "values": [ + 0.40833050000000004, + 0.40984, + 0.40825 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 80941056.0, + "min": 80830464.0, + "max": 80945152.0, + "values": [ + 80941056, + 80830464, + 80945152 + ] + }, + "VmRSS_bytes": { + "median": 80941056.0, + "min": 80830464.0, + "max": 80945152.0, + "values": [ + 80941056, + 80830464, + 80945152 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 81481728.0, + "min": 81371136.0, + "max": 81485824.0, + "values": [ + 81481728, + 81371136, + 81485824 + ] + }, + "VmRSS_bytes": { + "median": 81481728.0, + "min": 81371136.0, + "max": 81485824.0, + "values": [ + 81481728, + 81371136, + 81485824 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 81481728.0, + "min": 81371136.0, + "max": 81485824.0, + "values": [ + 81481728, + 81371136, + 81485824 + ] + }, + "VmRSS_bytes": { + "median": 81481728.0, + "min": 81371136.0, + "max": 81485824.0, + "values": [ + 81481728, + 81371136, + 81485824 + ] + } + } + }, + "uniform-id-stress": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 65536, + "batch_rows": 512, + "query_buffer_bytes": 786432, + "cache_budget_bytes": 0, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 0.9641949999999999, + "min": 0.9611565, + "max": 0.9705845, + "values": [ + 0.9641949999999999, + 0.9611565, + 0.9705845 + ] + }, + "wall_p95_ms": { + "median": 1.0678568499999999, + "min": 1.0501033, + "max": 1.1486944999999993, + "values": [ + 1.0678568499999999, + 1.0501033, + 1.1486944999999993 + ] + }, + "wall_p99_ms": { + "median": 1.1743823000000004, + "min": 1.1670374000000001, + "max": 1.3030107000000002, + "values": [ + 1.1743823000000004, + 1.1670374000000001, + 1.3030107000000002 + ] + }, + "rows_per_second": { + "median": 523112.7664890015, + "min": 516895.99851543823, + "max": 524957.9050821703, + "values": [ + 523112.7664890015, + 524957.9050821703, + 516895.99851543823 + ] + }, + "cpu_p50_ms": { + "median": 0.9645305, + "min": 0.9605755, + "max": 0.970515, + "values": [ + 0.9645305, + 0.9605755, + 0.970515 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.476388, + "min": 0.4757245, + "max": 0.4782735, + "values": [ + 0.476388, + 0.4757245, + 0.4782735 + ] + }, + "wall_p95_ms": { + "median": 0.50201965, + "min": 0.50190105, + "max": 0.5020268, + "values": [ + 0.50190105, + 0.5020268, + 0.50201965 + ] + }, + "wall_p99_ms": { + "median": 0.5553464600000002, + "min": 0.5526327500000002, + "max": 0.5752368700000001, + "values": [ + 0.5752368700000001, + 0.5526327500000002, + 0.5553464600000002 + ] + }, + "rows_per_second": { + "median": 1063267.0502535799, + "min": 1060954.023275067, + "max": 1067789.7750428484, + "values": [ + 1060954.023275067, + 1067789.7750428484, + 1063267.0502535799 + ] + }, + "cpu_p50_ms": { + "median": 0.47680500000000003, + "min": 0.47635, + "max": 0.478771, + "values": [ + 0.47680500000000003, + 0.47635, + 0.478771 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.448521, + "min": 0.446566, + "max": 0.44901, + "values": [ + 0.448521, + 0.446566, + 0.44901 + ] + }, + "wall_p95_ms": { + "median": 0.47082545000000003, + "min": 0.4698709, + "max": 0.47273235, + "values": [ + 0.47082545000000003, + 0.4698709, + 0.47273235 + ] + }, + "wall_p99_ms": { + "median": 0.55082701, + "min": 0.4933852599999998, + "max": 0.5774042399999999, + "values": [ + 0.4933852599999998, + 0.55082701, + 0.5774042399999999 + ] + }, + "rows_per_second": { + "median": 1133544.5556347598, + "min": 1125250.4891103446, + "max": 1134911.055502193, + "values": [ + 1133544.5556347598, + 1134911.055502193, + 1125250.4891103446 + ] + }, + "cpu_p50_ms": { + "median": 0.44920000000000004, + "min": 0.44699999999999995, + "max": 0.4495455, + "values": [ + 0.44920000000000004, + 0.44699999999999995, + 0.4495455 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 276910080.0, + "min": 276791296.0, + "max": 276967424.0, + "values": [ + 276910080, + 276967424, + 276791296 + ] + }, + "VmRSS_bytes": { + "median": 276910080.0, + "min": 276791296.0, + "max": 276967424.0, + "values": [ + 276910080, + 276967424, + 276791296 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 277450752.0, + "min": 277331968.0, + "max": 277508096.0, + "values": [ + 277450752, + 277508096, + 277331968 + ] + }, + "VmRSS_bytes": { + "median": 277450752.0, + "min": 277331968.0, + "max": 277508096.0, + "values": [ + 277450752, + 277508096, + 277331968 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 277450752.0, + "min": 277331968.0, + "max": 277508096.0, + "values": [ + 277450752, + 277508096, + 277331968 + ] + }, + "VmRSS_bytes": { + "median": 277450752.0, + "min": 277331968.0, + "max": 277508096.0, + "values": [ + 277450752, + 277508096, + 277331968 + ] + } + } + } + }, + "int8-raw": { + "uniform-id-stress": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 65536, + "batch_rows": 512, + "query_buffer_bytes": 657408, + "cache_budget_bytes": 0, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 0.6150225, + "min": 0.6084225, + "max": 0.617397, + "values": [ + 0.6084225, + 0.6150225, + 0.617397 + ] + }, + "wall_p95_ms": { + "median": 0.76563225, + "min": 0.75777135, + "max": 0.7742577499999999, + "values": [ + 0.75777135, + 0.76563225, + 0.7742577499999999 + ] + }, + "wall_p99_ms": { + "median": 0.8456747600000001, + "min": 0.8351091800000002, + "max": 0.8672943400000002, + "values": [ + 0.8351091800000002, + 0.8456747600000001, + 0.8672943400000002 + ] + }, + "rows_per_second": { + "median": 817674.0770792066, + "min": 813798.6555632951, + "max": 822159.6720494191, + "values": [ + 822159.6720494191, + 817674.0770792066, + 813798.6555632951 + ] + }, + "cpu_p50_ms": { + "median": 0.615695, + "min": 0.6094105, + "max": 0.6168899999999999, + "values": [ + 0.6094105, + 0.615695, + 0.6168899999999999 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.1833685, + "min": 0.183054, + "max": 0.18368250000000003, + "values": [ + 0.183054, + 0.18368250000000003, + 0.1833685 + ] + }, + "wall_p95_ms": { + "median": 0.1946862, + "min": 0.19257344999999998, + "max": 0.19622285, + "values": [ + 0.19257344999999998, + 0.19622285, + 0.1946862 + ] + }, + "wall_p99_ms": { + "median": 0.20942290000000002, + "min": 0.20518239000000002, + "max": 0.21856552, + "values": [ + 0.20518239000000002, + 0.21856552, + 0.20942290000000002 + ] + }, + "rows_per_second": { + "median": 2761331.366547654, + "min": 2751759.245251426, + "max": 2773770.2472932828, + "values": [ + 2773770.2472932828, + 2751759.245251426, + 2761331.366547654 + ] + }, + "cpu_p50_ms": { + "median": 0.1842895, + "min": 0.18366549999999998, + "max": 0.18481, + "values": [ + 0.18366549999999998, + 0.18481, + 0.1842895 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.165175, + "min": 0.165105, + "max": 0.165594, + "values": [ + 0.165594, + 0.165105, + 0.165175 + ] + }, + "wall_p95_ms": { + "median": 0.17602444999999997, + "min": 0.175665, + "max": 0.1787975, + "values": [ + 0.17602444999999997, + 0.175665, + 0.1787975 + ] + }, + "wall_p99_ms": { + "median": 0.19175688, + "min": 0.19033678, + "max": 0.19181620000000002, + "values": [ + 0.19181620000000002, + 0.19033678, + 0.19175688 + ] + }, + "rows_per_second": { + "median": 3074922.0215240046, + "min": 3071121.0067788484, + "max": 3080939.384134811, + "values": [ + 3074922.0215240046, + 3080939.384134811, + 3071121.0067788484 + ] + }, + "cpu_p50_ms": { + "median": 0.166185, + "min": 0.16593000000000002, + "max": 0.16638, + "values": [ + 0.16638, + 0.16593000000000002, + 0.166185 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 257048576.0, + "min": 256970752.0, + "max": 257114112.0, + "values": [ + 257114112, + 256970752, + 257048576 + ] + }, + "VmRSS_bytes": { + "median": 257048576.0, + "min": 256970752.0, + "max": 257114112.0, + "values": [ + 257114112, + 256970752, + 257048576 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 257589248.0, + "min": 257511424.0, + "max": 257654784.0, + "values": [ + 257654784, + 257511424, + 257589248 + ] + }, + "VmRSS_bytes": { + "median": 257589248.0, + "min": 257511424.0, + "max": 257654784.0, + "values": [ + 257654784, + 257511424, + 257589248 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 257589248.0, + "min": 257511424.0, + "max": 257654784.0, + "values": [ + 257654784, + 257511424, + 257589248 + ] + }, + "VmRSS_bytes": { + "median": 257589248.0, + "min": 257511424.0, + "max": 257654784.0, + "values": [ + 257654784, + 257511424, + 257589248 + ] + } + } + }, + "heldout-lexical": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 17677, + "batch_rows": 512, + "query_buffer_bytes": 657408, + "cache_budget_bytes": 0, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 0.2349465, + "min": 0.2329905, + "max": 0.2354, + "values": [ + 0.2349465, + 0.2329905, + 0.2354 + ] + }, + "wall_p95_ms": { + "median": 0.3494305, + "min": 0.3483829999999999, + "max": 0.35298519999999994, + "values": [ + 0.3494305, + 0.3483829999999999, + 0.35298519999999994 + ] + }, + "wall_p99_ms": { + "median": 0.4810112100000006, + "min": 0.4716401800000005, + "max": 0.5085719300000006, + "values": [ + 0.4810112100000006, + 0.4716401800000005, + 0.5085719300000006 + ] + }, + "rows_per_second": { + "median": 2046809.013005557, + "min": 2003085.6860125293, + "max": 2053810.8727749777, + "values": [ + 2053810.8727749777, + 2046809.013005557, + 2003085.6860125293 + ] + }, + "cpu_p50_ms": { + "median": 0.2344405, + "min": 0.23382, + "max": 0.236655, + "values": [ + 0.2344405, + 0.23382, + 0.236655 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.165594, + "min": 0.165594, + "max": 0.16657149999999998, + "values": [ + 0.16657149999999998, + 0.165594, + 0.165594 + ] + }, + "wall_p95_ms": { + "median": 0.18082569999999998, + "min": 0.1725462, + "max": 0.18339635, + "values": [ + 0.1725462, + 0.18339635, + 0.18082569999999998 + ] + }, + "wall_p99_ms": { + "median": 0.19860942000000004, + "min": 0.19545808, + "max": 0.19933493000000008, + "values": [ + 0.19933493000000008, + 0.19860942000000004, + 0.19545808 + ] + }, + "rows_per_second": { + "median": 3048379.7249629907, + "min": 3041394.965204903, + "max": 3051007.874026744, + "values": [ + 3041394.965204903, + 3048379.7249629907, + 3051007.874026744 + ] + }, + "cpu_p50_ms": { + "median": 0.1667255, + "min": 0.166435, + "max": 0.16732, + "values": [ + 0.16732, + 0.166435, + 0.1667255 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.161403, + "min": 0.161264, + "max": 0.161823, + "values": [ + 0.161403, + 0.161264, + 0.161823 + ] + }, + "wall_p95_ms": { + "median": 0.165594, + "min": 0.1654787999999999, + "max": 0.173137, + "values": [ + 0.165594, + 0.1654787999999999, + 0.173137 + ] + }, + "wall_p99_ms": { + "median": 0.1835717, + "min": 0.16993411, + "max": 0.18567665999999997, + "values": [ + 0.16993411, + 0.18567665999999997, + 0.1835717 + ] + }, + "rows_per_second": { + "median": 3158935.565195347, + "min": 3141262.9234382724, + "max": 3169005.6393755144, + "values": [ + 3169005.6393755144, + 3158935.565195347, + 3141262.9234382724 + ] + }, + "cpu_p50_ms": { + "median": 0.162051, + "min": 0.161895, + "max": 0.162815, + "values": [ + 0.162051, + 0.161895, + 0.162815 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 76124160.0, + "min": 76091392.0, + "max": 76214272.0, + "values": [ + 76091392, + 76214272, + 76124160 + ] + }, + "VmRSS_bytes": { + "median": 76124160.0, + "min": 76091392.0, + "max": 76214272.0, + "values": [ + 76091392, + 76214272, + 76124160 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 76664832.0, + "min": 76632064.0, + "max": 76754944.0, + "values": [ + 76632064, + 76754944, + 76664832 + ] + }, + "VmRSS_bytes": { + "median": 76664832.0, + "min": 76632064.0, + "max": 76754944.0, + "values": [ + 76632064, + 76754944, + 76664832 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 76664832.0, + "min": 76632064.0, + "max": 76754944.0, + "values": [ + 76632064, + 76754944, + 76664832 + ] + }, + "VmRSS_bytes": { + "median": 76664832.0, + "min": 76632064.0, + "max": 76754944.0, + "values": [ + 76632064, + 76754944, + 76664832 + ] + } + } + } + }, + "fp16-native": { + "uniform-id-stress": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 65536, + "batch_rows": 512, + "query_buffer_bytes": 786432, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 34.1499695, + "min": 34.0631215, + "max": 34.2317885, + "values": [ + 34.0631215, + 34.1499695, + 34.2317885 + ] + }, + "wall_p95_ms": { + "median": 35.3285249, + "min": 34.86448105, + "max": 36.13812195, + "values": [ + 35.3285249, + 34.86448105, + 36.13812195 + ] + }, + "wall_p99_ms": { + "median": 37.932198910000004, + "min": 36.50495449, + "max": 41.14803561, + "values": [ + 36.50495449, + 37.932198910000004, + 41.14803561 + ] + }, + "rows_per_second": { + "median": 14915.417924285177, + "min": 14805.674270236097, + "max": 14968.58831144965, + "values": [ + 14968.58831144965, + 14915.417924285177, + 14805.674270236097 + ] + }, + "cpu_p50_ms": { + "median": 34.1157245, + "min": 34.04069, + "max": 34.210854499999996, + "values": [ + 34.04069, + 34.1157245, + 34.210854499999996 + ] + }, + "logical_decoded_bytes": { + "median": 535756800.0, + "min": 535756800.0, + "max": 535756800.0, + "values": [ + 535756800, + 535756800, + 535756800 + ] + }, + "logical_compressed_bytes": { + "median": 494488732.0, + "min": 494488732.0, + "max": 494488732.0, + "values": [ + 494488732, + 494488732, + 494488732 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 15.966796875, + "min": 15.966796875, + "max": 15.966796875, + "values": [ + 15.966796875, + 15.966796875, + 15.966796875 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 33.12641, + "min": 32.9938505, + "max": 33.3846825, + "values": [ + 32.9938505, + 33.12641, + 33.3846825 + ] + }, + "wall_p95_ms": { + "median": 33.42217035, + "min": 33.30390095, + "max": 34.18008175, + "values": [ + 33.30390095, + 33.42217035, + 34.18008175 + ] + }, + "wall_p99_ms": { + "median": 33.673265199999996, + "min": 33.642200779999996, + "max": 38.460472, + "values": [ + 33.642200779999996, + 33.673265199999996, + 38.460472 + ] + }, + "rows_per_second": { + "median": 15452.375085365678, + "min": 15244.053792357121, + "max": 15508.582595048389, + "values": [ + 15508.582595048389, + 15452.375085365678, + 15244.053792357121 + ] + }, + "cpu_p50_ms": { + "median": 33.103149, + "min": 32.9728705, + "max": 33.363619, + "values": [ + 32.9728705, + 33.103149, + 33.363619 + ] + }, + "logical_decoded_bytes": { + "median": 535756800.0, + "min": 535756800.0, + "max": 535756800.0, + "values": [ + 535756800, + 535756800, + 535756800 + ] + }, + "logical_compressed_bytes": { + "median": 494488732.0, + "min": 494488732.0, + "max": 494488732.0, + "values": [ + 494488732, + 494488732, + 494488732 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 15.966796875, + "min": 15.966796875, + "max": 15.966796875, + "values": [ + 15.966796875, + 15.966796875, + 15.966796875 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.47666699999999995, + "min": 0.476423, + "max": 0.476877, + "values": [ + 0.476877, + 0.47666699999999995, + 0.476423 + ] + }, + "wall_p95_ms": { + "median": 0.50260215, + "min": 0.500553, + "max": 0.51103235, + "values": [ + 0.50260215, + 0.500553, + 0.51103235 + ] + }, + "wall_p99_ms": { + "median": 0.55930377, + "min": 0.52457901, + "max": 0.58837655, + "values": [ + 0.58837655, + 0.52457901, + 0.55930377 + ] + }, + "rows_per_second": { + "median": 1065629.9946121417, + "min": 1064304.451251991, + "max": 1069421.1362549963, + "values": [ + 1064304.451251991, + 1069421.1362549963, + 1065629.9946121417 + ] + }, + "cpu_p50_ms": { + "median": 0.4773305, + "min": 0.4770705, + "max": 0.477385, + "values": [ + 0.477385, + 0.4773305, + 0.4770705 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 81920.0, + "min": 81920.0, + "max": 81920.0, + "values": [ + 81920, + 81920, + 81920 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 561995776.0, + "min": 561967104.0, + "max": 562188288.0, + "values": [ + 561995776, + 561967104, + 562188288 + ] + }, + "VmRSS_bytes": { + "median": 561995776.0, + "min": 561971200.0, + "max": 562192384.0, + "values": [ + 561995776, + 561971200, + 562192384 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 562536448.0, + "min": 562499584.0, + "max": 562753536.0, + "values": [ + 562536448, + 562499584, + 562753536 + ] + }, + "VmRSS_bytes": { + "median": 562536448.0, + "min": 562499584.0, + "max": 562757632.0, + "values": [ + 562536448, + 562499584, + 562757632 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 562556928.0, + "min": 562536448.0, + "max": 562757632.0, + "values": [ + 562536448, + 562556928, + 562757632 + ] + }, + "VmRSS_bytes": { + "median": 562556928.0, + "min": 562536448.0, + "max": 562757632.0, + "values": [ + 562536448, + 562556928, + 562757632 + ] + } + } + }, + "heldout-lexical": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 17677, + "batch_rows": 512, + "query_buffer_bytes": 786432, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 5.8316815, + "min": 5.828609, + "max": 5.875158, + "values": [ + 5.8316815, + 5.828609, + 5.875158 + ] + }, + "wall_p95_ms": { + "median": 10.3957464, + "min": 10.39566635, + "max": 10.44647645, + "values": [ + 10.39566635, + 10.3957464, + 10.44647645 + ] + }, + "wall_p99_ms": { + "median": 15.395507590000019, + "min": 15.34446719000002, + "max": 15.40235262000002, + "values": [ + 15.395507590000019, + 15.34446719000002, + 15.40235262000002 + ] + }, + "rows_per_second": { + "median": 83658.14071972766, + "min": 83134.32162894621, + "max": 83752.7531212776, + "values": [ + 83752.7531212776, + 83658.14071972766, + 83134.32162894621 + ] + }, + "cpu_p50_ms": { + "median": 5.8297025, + "min": 5.828328, + "max": 5.872253, + "values": [ + 5.828328, + 5.8297025, + 5.872253 + ] + }, + "logical_decoded_bytes": { + "median": 90193920.0, + "min": 90193920.0, + "max": 90193920.0, + "values": [ + 90193920, + 90193920, + 90193920 + ] + }, + "logical_compressed_bytes": { + "median": 84125527.0, + "min": 84125527.0, + "max": 84125527.0, + "values": [ + 84125527, + 84125527, + 84125527 + ] + }, + "row_cache_hits": { + "median": 34722.0, + "min": 34722.0, + "max": 34722.0, + "values": [ + 34722, + 34722, + 34722 + ] + }, + "decoded_over_encoded_output": { + "median": 2.68798828125, + "min": 2.68798828125, + "max": 2.68798828125, + "values": [ + 2.68798828125, + 2.68798828125, + 2.68798828125 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 5.2461675, + "min": 5.242151, + "max": 5.2516145, + "values": [ + 5.242151, + 5.2461675, + 5.2516145 + ] + }, + "wall_p95_ms": { + "median": 7.352120350000001, + "min": 7.32059125, + "max": 7.35991165, + "values": [ + 7.32059125, + 7.352120350000001, + 7.35991165 + ] + }, + "wall_p99_ms": { + "median": 8.599477250000003, + "min": 8.582062020000004, + "max": 8.661745620000003, + "values": [ + 8.582062020000004, + 8.599477250000003, + 8.661745620000003 + ] + }, + "rows_per_second": { + "median": 98554.96904601608, + "min": 98212.13394130544, + "max": 98676.35180921791, + "values": [ + 98676.35180921791, + 98554.96904601608, + 98212.13394130544 + ] + }, + "cpu_p50_ms": { + "median": 5.237707, + "min": 5.235412, + "max": 5.2448525, + "values": [ + 5.235412, + 5.237707, + 5.2448525 + ] + }, + "logical_decoded_bytes": { + "median": 78413824.0, + "min": 78413824.0, + "max": 78413824.0, + "values": [ + 78413824, + 78413824, + 78413824 + ] + }, + "logical_compressed_bytes": { + "median": 73084685.0, + "min": 73084685.0, + "max": 73084685.0, + "values": [ + 73084685, + 73084685, + 73084685 + ] + }, + "row_cache_hits": { + "median": 36907.0, + "min": 36907.0, + "max": 36907.0, + "values": [ + 36907, + 36907, + 36907 + ] + }, + "decoded_over_encoded_output": { + "median": 2.3369140625, + "min": 2.3369140625, + "max": 2.3369140625, + "values": [ + 2.3369140625, + 2.3369140625, + 2.3369140625 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.441467, + "min": 0.44021, + "max": 0.4421305, + "values": [ + 0.441467, + 0.4421305, + 0.44021 + ] + }, + "wall_p95_ms": { + "median": 0.4590223, + "min": 0.45602544999999983, + "max": 0.4626569, + "values": [ + 0.4590223, + 0.4626569, + 0.45602544999999983 + ] + }, + "wall_p99_ms": { + "median": 0.47484192999999997, + "min": 0.47076746, + "max": 0.4848843199999999, + "values": [ + 0.4848843199999999, + 0.47076746, + 0.47484192999999997 + ] + }, + "rows_per_second": { + "median": 1154325.0433058601, + "min": 1153037.0865961951, + "max": 1157108.1697260723, + "values": [ + 1154325.0433058601, + 1153037.0865961951, + 1157108.1697260723 + ] + }, + "cpu_p50_ms": { + "median": 0.442245, + "min": 0.44101, + "max": 0.44284, + "values": [ + 0.442245, + 0.44284, + 0.44101 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 62360.0, + "min": 62360.0, + "max": 62360.0, + "values": [ + 62360, + 62360, + 62360 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 148606976.0, + "min": 148578304.0, + "max": 148766720.0, + "values": [ + 148606976, + 148578304, + 148766720 + ] + }, + "VmRSS_bytes": { + "median": 148606976.0, + "min": 148578304.0, + "max": 148766720.0, + "values": [ + 148606976, + 148578304, + 148766720 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 149147648.0, + "min": 149118976.0, + "max": 149307392.0, + "values": [ + 149147648, + 149118976, + 149307392 + ] + }, + "VmRSS_bytes": { + "median": 149147648.0, + "min": 149118976.0, + "max": 149307392.0, + "values": [ + 149147648, + 149118976, + 149307392 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 149147648.0, + "min": 149118976.0, + "max": 149307392.0, + "values": [ + 149147648, + 149118976, + 149307392 + ] + }, + "VmRSS_bytes": { + "median": 149147648.0, + "min": 149118976.0, + "max": 149307392.0, + "values": [ + 149147648, + 149118976, + 149307392 + ] + } + } + } + }, + "fp32-direct": { + "heldout-lexical": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 17677, + "batch_rows": 512, + "query_buffer_bytes": 1048576, + "cache_budget_bytes": 0, + "all_query_bytes_exact": true, + "buffer_accounting_note": "Corrected allocated bytes: frozen raw worker field omitted unused FP32 scratch; RSS is unchanged.", + "first_trace": { + "wall_p50_ms": { + "median": 0.14621250000000002, + "min": 0.1459685, + "max": 0.1476445, + "values": [ + 0.14621250000000002, + 0.1476445, + 0.1459685 + ] + }, + "wall_p95_ms": { + "median": 0.27707435, + "min": 0.27563979999999993, + "max": 0.28264414999999987, + "values": [ + 0.27707435, + 0.28264414999999987, + 0.27563979999999993 + ] + }, + "wall_p99_ms": { + "median": 0.45538477000000066, + "min": 0.43638749000000054, + "max": 0.4858961500000005, + "values": [ + 0.45538477000000066, + 0.43638749000000054, + 0.4858961500000005 + ] + }, + "rows_per_second": { + "median": 3165051.8314907383, + "min": 3151053.431549885, + "max": 3171268.1249712682, + "values": [ + 3165051.8314907383, + 3171268.1249712682, + 3151053.431549885 + ] + }, + "cpu_p50_ms": { + "median": 0.146475, + "min": 0.146465, + "max": 0.14732, + "values": [ + 0.146465, + 0.14732, + 0.146475 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.047772, + "min": 0.047318, + "max": 0.04847, + "values": [ + 0.047318, + 0.047772, + 0.04847 + ] + }, + "wall_p95_ms": { + "median": 0.052566499999999995, + "min": 0.051612, + "max": 0.05384739999999999, + "values": [ + 0.051612, + 0.052566499999999995, + 0.05384739999999999 + ] + }, + "wall_p99_ms": { + "median": 0.06256179000000002, + "min": 0.06093083000000001, + "max": 0.06270370000000001, + "values": [ + 0.06256179000000002, + 0.06093083000000001, + 0.06270370000000001 + ] + }, + "rows_per_second": { + "median": 10628353.390155407, + "min": 10470613.629148616, + "max": 10760958.161389407, + "values": [ + 10760958.161389407, + 10628353.390155407, + 10470613.629148616 + ] + }, + "cpu_p50_ms": { + "median": 0.048265, + "min": 0.047689999999999996, + "max": 0.04888, + "values": [ + 0.047689999999999996, + 0.048265, + 0.04888 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.038343, + "min": 0.0380985, + "max": 0.03974, + "values": [ + 0.0380985, + 0.038343, + 0.03974 + ] + }, + "wall_p95_ms": { + "median": 0.040717050000000005, + "min": 0.03925355, + "max": 0.041206, + "values": [ + 0.03925355, + 0.040717050000000005, + 0.041206 + ] + }, + "wall_p99_ms": { + "median": 0.04496073999999999, + "min": 0.04035849, + "max": 0.04695788999999997, + "values": [ + 0.04035849, + 0.04496073999999999, + 0.04695788999999997 + ] + }, + "rows_per_second": { + "median": 13438410.59298462, + "min": 13015661.37418183, + "max": 13727164.889692534, + "values": [ + 13727164.889692534, + 13438410.59298462, + 13015661.37418183 + ] + }, + "cpu_p50_ms": { + "median": 0.038720000000000004, + "min": 0.038430000000000006, + "max": 0.039834999999999995, + "values": [ + 0.038430000000000006, + 0.038720000000000004, + 0.039834999999999995 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 89518080.0, + "min": 89501696.0, + "max": 89559040.0, + "values": [ + 89518080, + 89559040, + 89501696 + ] + }, + "VmRSS_bytes": { + "median": 89518080.0, + "min": 89501696.0, + "max": 89559040.0, + "values": [ + 89518080, + 89559040, + 89501696 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 90058752.0, + "min": 90042368.0, + "max": 90099712.0, + "values": [ + 90058752, + 90099712, + 90042368 + ] + }, + "VmRSS_bytes": { + "median": 90058752.0, + "min": 90042368.0, + "max": 90099712.0, + "values": [ + 90058752, + 90099712, + 90042368 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 90058752.0, + "min": 90042368.0, + "max": 90099712.0, + "values": [ + 90058752, + 90099712, + 90042368 + ] + }, + "VmRSS_bytes": { + "median": 90058752.0, + "min": 90042368.0, + "max": 90099712.0, + "values": [ + 90058752, + 90099712, + 90042368 + ] + } + } + }, + "uniform-id-stress": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 65536, + "batch_rows": 512, + "query_buffer_bytes": 1048576, + "cache_budget_bytes": 0, + "all_query_bytes_exact": true, + "buffer_accounting_note": "Corrected allocated bytes: frozen raw worker field omitted unused FP32 scratch; RSS is unchanged.", + "first_trace": { + "wall_p50_ms": { + "median": 0.6285725, + "min": 0.6240675, + "max": 0.634718, + "values": [ + 0.634718, + 0.6285725, + 0.6240675 + ] + }, + "wall_p95_ms": { + "median": 0.69374795, + "min": 0.6841976999999999, + "max": 0.7080235999999999, + "values": [ + 0.7080235999999999, + 0.69374795, + 0.6841976999999999 + ] + }, + "wall_p99_ms": { + "median": 0.8597316400000004, + "min": 0.8440083400000004, + "max": 0.8736247200000005, + "values": [ + 0.8736247200000005, + 0.8440083400000004, + 0.8597316400000004 + ] + }, + "rows_per_second": { + "median": 801371.3800341262, + "min": 790554.1994108555, + "max": 805476.7304783119, + "values": [ + 790554.1994108555, + 801371.3800341262, + 805476.7304783119 + ] + }, + "cpu_p50_ms": { + "median": 0.6287210000000001, + "min": 0.62439, + "max": 0.635085, + "values": [ + 0.635085, + 0.6287210000000001, + 0.62439 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.08852399999999999, + "min": 0.088489, + "max": 0.0886635, + "values": [ + 0.088489, + 0.08852399999999999, + 0.0886635 + ] + }, + "wall_p95_ms": { + "median": 0.09208985, + "min": 0.0918175, + "max": 0.10009679999999997, + "values": [ + 0.0918175, + 0.10009679999999997, + 0.09208985 + ] + }, + "wall_p99_ms": { + "median": 0.11657525000000006, + "min": 0.11480079000000007, + "max": 0.11995708000000005, + "values": [ + 0.11480079000000007, + 0.11995708000000005, + 0.11657525000000006 + ] + }, + "rows_per_second": { + "median": 5736122.270711782, + "min": 5702623.2014517635, + "max": 5744658.955579347, + "values": [ + 5744658.955579347, + 5702623.2014517635, + 5736122.270711782 + ] + }, + "cpu_p50_ms": { + "median": 0.089035, + "min": 0.08901, + "max": 0.08914, + "values": [ + 0.089035, + 0.08914, + 0.08901 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.0407525, + "min": 0.040718, + "max": 0.043057, + "values": [ + 0.0407525, + 0.040718, + 0.043057 + ] + }, + "wall_p95_ms": { + "median": 0.04502334999999998, + "min": 0.0444225, + "max": 0.04828189999999999, + "values": [ + 0.0444225, + 0.04502334999999998, + 0.04828189999999999 + ] + }, + "wall_p99_ms": { + "median": 0.05974679, + "min": 0.057256839999999976, + "max": 0.06250375, + "values": [ + 0.057256839999999976, + 0.05974679, + 0.06250375 + ] + }, + "rows_per_second": { + "median": 12213083.116202757, + "min": 11807491.761276502, + "max": 12280990.010901773, + "values": [ + 12280990.010901773, + 12213083.116202757, + 11807491.761276502 + ] + }, + "cpu_p50_ms": { + "median": 0.041139999999999996, + "min": 0.040955000000000005, + "max": 0.043399999999999994, + "values": [ + 0.041139999999999996, + 0.040955000000000005, + 0.043399999999999994 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 293699584.0, + "min": 293597184.0, + "max": 294080512.0, + "values": [ + 293597184, + 293699584, + 294080512 + ] + }, + "VmRSS_bytes": { + "median": 293699584.0, + "min": 293597184.0, + "max": 294080512.0, + "values": [ + 293597184, + 293699584, + 294080512 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 294240256.0, + "min": 294137856.0, + "max": 294621184.0, + "values": [ + 294137856, + 294240256, + 294621184 + ] + }, + "VmRSS_bytes": { + "median": 294240256.0, + "min": 294137856.0, + "max": 294621184.0, + "values": [ + 294137856, + 294240256, + 294621184 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 294240256.0, + "min": 294137856.0, + "max": 294621184.0, + "values": [ + 294137856, + 294240256, + 294621184 + ] + }, + "VmRSS_bytes": { + "median": 294240256.0, + "min": 294137856.0, + "max": 294621184.0, + "values": [ + 294137856, + 294240256, + 294621184 + ] + } + } + } + }, + "int8-native": { + "heldout-lexical": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 17677, + "batch_rows": 512, + "query_buffer_bytes": 657408, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 3.9457915000000003, + "min": 3.933534, + "max": 3.9484105, + "values": [ + 3.9457915000000003, + 3.933534, + 3.9484105 + ] + }, + "wall_p95_ms": { + "median": 8.540170799999999, + "min": 8.506133349999997, + "max": 8.568271399999999, + "values": [ + 8.540170799999999, + 8.506133349999997, + 8.568271399999999 + ] + }, + "wall_p99_ms": { + "median": 13.519929490000017, + "min": 13.516299410000016, + "max": 13.601833460000018, + "values": [ + 13.516299410000016, + 13.601833460000018, + 13.519929490000017 + ] + }, + "rows_per_second": { + "median": 115905.87934659913, + "min": 115368.37335851822, + "max": 116071.963101046, + "values": [ + 115905.87934659913, + 116071.963101046, + 115368.37335851822 + ] + }, + "cpu_p50_ms": { + "median": 3.939267, + "min": 3.9309075, + "max": 3.9424764999999997, + "values": [ + 3.9424764999999997, + 3.9309075, + 3.939267 + ] + }, + "logical_decoded_bytes": { + "median": 68437460.0, + "min": 68437460.0, + "max": 68437460.0, + "values": [ + 68437460, + 68437460, + 68437460 + ] + }, + "logical_compressed_bytes": { + "median": 66774939.0, + "min": 66774939.0, + "max": 66774939.0, + "values": [ + 66774939, + 66774939, + 66774939 + ] + }, + "row_cache_hits": { + "median": 37299.0, + "min": 37299.0, + "max": 37299.0, + "values": [ + 37299, + 37299, + 37299 + ] + }, + "decoded_over_encoded_output": { + "median": 4.0164337158203125, + "min": 4.0164337158203125, + "max": 4.0164337158203125, + "values": [ + 4.0164337158203125, + 4.0164337158203125, + 4.0164337158203125 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 2.5874815, + "min": 2.58413, + "max": 2.5971900000000003, + "values": [ + 2.5971900000000003, + 2.58413, + 2.5874815 + ] + }, + "wall_p95_ms": { + "median": 4.29978165, + "min": 4.295274299999999, + "max": 4.459844449999999, + "values": [ + 4.29978165, + 4.295274299999999, + 4.459844449999999 + ] + }, + "wall_p99_ms": { + "median": 5.087034660000002, + "min": 5.0676550900000015, + "max": 5.25017796, + "values": [ + 5.0676550900000015, + 5.087034660000002, + 5.25017796 + ] + }, + "rows_per_second": { + "median": 190767.67417193286, + "min": 186878.83962110511, + "max": 191133.39595642983, + "values": [ + 190767.67417193286, + 191133.39595642983, + 186878.83962110511 + ] + }, + "cpu_p50_ms": { + "median": 2.594816, + "min": 2.583906, + "max": 2.5979409999999996, + "values": [ + 2.5979409999999996, + 2.583906, + 2.594816 + ] + }, + "logical_decoded_bytes": { + "median": 41984540.0, + "min": 41984540.0, + "max": 41984540.0, + "values": [ + 41984540, + 41984540, + 41984540 + ] + }, + "logical_compressed_bytes": { + "median": 40957951.0, + "min": 40957951.0, + "max": 40957951.0, + "values": [ + 40957951, + 40957951, + 40957951 + ] + }, + "row_cache_hits": { + "median": 43255.0, + "min": 43255.0, + "max": 43255.0, + "values": [ + 43255, + 43255, + 43255 + ] + }, + "decoded_over_encoded_output": { + "median": 2.4639739990234375, + "min": 2.4639739990234375, + "max": 2.4639739990234375, + "values": [ + 2.4639739990234375, + 2.4639739990234375, + 2.4639739990234375 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.195905, + "min": 0.19545099999999999, + "max": 0.19656849999999998, + "values": [ + 0.19656849999999998, + 0.195905, + 0.19545099999999999 + ] + }, + "wall_p95_ms": { + "median": 0.20724439999999997, + "min": 0.20680079999999998, + "max": 0.21146234999999997, + "values": [ + 0.20680079999999998, + 0.21146234999999997, + 0.20724439999999997 + ] + }, + "wall_p99_ms": { + "median": 0.22555155, + "min": 0.22492079, + "max": 0.23047861999999997, + "values": [ + 0.22555155, + 0.23047861999999997, + 0.22492079 + ] + }, + "rows_per_second": { + "median": 2588491.7716011163, + "min": 2587955.581432303, + "max": 2601962.9955886686, + "values": [ + 2588491.7716011163, + 2587955.581432303, + 2601962.9955886686 + ] + }, + "cpu_p50_ms": { + "median": 0.19690000000000002, + "min": 0.19639, + "max": 0.19729999999999998, + "values": [ + 0.19729999999999998, + 0.19690000000000002, + 0.19639 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 62360.0, + "min": 62360.0, + "max": 62360.0, + "values": [ + 62360, + 62360, + 62360 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 135462912.0, + "min": 135409664.0, + "max": 135557120.0, + "values": [ + 135557120, + 135409664, + 135462912 + ] + }, + "VmRSS_bytes": { + "median": 135462912.0, + "min": 135409664.0, + "max": 135557120.0, + "values": [ + 135557120, + 135409664, + 135462912 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 136003584.0, + "min": 135950336.0, + "max": 136097792.0, + "values": [ + 136097792, + 135950336, + 136003584 + ] + }, + "VmRSS_bytes": { + "median": 136003584.0, + "min": 135950336.0, + "max": 136097792.0, + "values": [ + 136097792, + 135950336, + 136003584 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 136003584.0, + "min": 135950336.0, + "max": 136097792.0, + "values": [ + 136097792, + 135950336, + 136003584 + ] + }, + "VmRSS_bytes": { + "median": 136003584.0, + "min": 135950336.0, + "max": 136097792.0, + "values": [ + 136097792, + 135950336, + 136003584 + ] + } + } + }, + "uniform-id-stress": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 65536, + "batch_rows": 512, + "query_buffer_bytes": 657408, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 31.5501955, + "min": 31.445224, + "max": 31.5535135, + "values": [ + 31.445224, + 31.5501955, + 31.5535135 + ] + }, + "wall_p95_ms": { + "median": 32.3860987, + "min": 32.37926055, + "max": 32.61270885, + "values": [ + 32.3860987, + 32.37926055, + 32.61270885 + ] + }, + "wall_p99_ms": { + "median": 32.84768555, + "min": 32.77391381, + "max": 34.27476526, + "values": [ + 32.84768555, + 32.77391381, + 34.27476526 + ] + }, + "rows_per_second": { + "median": 16204.508456984888, + "min": 16148.352513578711, + "max": 16216.672830446601, + "values": [ + 16216.672830446601, + 16204.508456984888, + 16148.352513578711 + ] + }, + "cpu_p50_ms": { + "median": 31.5288435, + "min": 31.421439, + "max": 31.531354, + "values": [ + 31.421439, + 31.531354, + 31.5288435 + ] + }, + "logical_decoded_bytes": { + "median": 525810220.0, + "min": 525810220.0, + "max": 525810220.0, + "values": [ + 525810220, + 525810220, + 525810220 + ] + }, + "logical_compressed_bytes": { + "median": 514269018.0, + "min": 514269018.0, + "max": 514269018.0, + "values": [ + 514269018, + 514269018, + 514269018 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 30.858566284179688, + "min": 30.858566284179688, + "max": 30.858566284179688, + "values": [ + 30.858566284179688, + 30.858566284179688, + 30.858566284179688 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 30.702392000000003, + "min": 30.664956500000002, + "max": 30.750826, + "values": [ + 30.702392000000003, + 30.664956500000002, + 30.750826 + ] + }, + "wall_p95_ms": { + "median": 31.0492374, + "min": 30.86886555, + "max": 31.06966195, + "values": [ + 31.0492374, + 30.86886555, + 31.06966195 + ] + }, + "wall_p99_ms": { + "median": 31.40166418, + "min": 31.257682650000003, + "max": 31.565465730000003, + "values": [ + 31.40166418, + 31.257682650000003, + 31.565465730000003 + ] + }, + "rows_per_second": { + "median": 16646.177702483936, + "min": 16623.159469019934, + "max": 16684.948442274534, + "values": [ + 16646.177702483936, + 16684.948442274534, + 16623.159469019934 + ] + }, + "cpu_p50_ms": { + "median": 30.680798, + "min": 30.643379, + "max": 30.7297835, + "values": [ + 30.680798, + 30.643379, + 30.7297835 + ] + }, + "logical_decoded_bytes": { + "median": 525810220.0, + "min": 525810220.0, + "max": 525810220.0, + "values": [ + 525810220, + 525810220, + 525810220 + ] + }, + "logical_compressed_bytes": { + "median": 514269018.0, + "min": 514269018.0, + "max": 514269018.0, + "values": [ + 514269018, + 514269018, + 514269018 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 30.858566284179688, + "min": 30.858566284179688, + "max": 30.858566284179688, + "values": [ + 30.858566284179688, + 30.858566284179688, + 30.858566284179688 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.1850095, + "min": 0.184102, + "max": 0.187384, + "values": [ + 0.184102, + 0.187384, + 0.1850095 + ] + }, + "wall_p95_ms": { + "median": 0.2081759, + "min": 0.20563684999999987, + "max": 0.21392384999999997, + "values": [ + 0.21392384999999997, + 0.20563684999999987, + 0.2081759 + ] + }, + "wall_p99_ms": { + "median": 0.23176874999999997, + "min": 0.22685952999999998, + "max": 0.24184842999999998, + "values": [ + 0.24184842999999998, + 0.23176874999999997, + 0.22685952999999998 + ] + }, + "rows_per_second": { + "median": 2723717.1930392017, + "min": 2695860.3241594336, + "max": 2731729.491554182, + "values": [ + 2723717.1930392017, + 2695860.3241594336, + 2731729.491554182 + ] + }, + "cpu_p50_ms": { + "median": 0.1857355, + "min": 0.18516, + "max": 0.18838, + "values": [ + 0.18516, + 0.18838, + 0.1857355 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 81880.0, + "min": 81880.0, + "max": 81880.0, + "values": [ + 81880, + 81880, + 81880 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 431804416.0, + "min": 431706112.0, + "max": 431947776.0, + "values": [ + 431706112, + 431804416, + 431947776 + ] + }, + "VmRSS_bytes": { + "median": 431804416.0, + "min": 431706112.0, + "max": 431976448.0, + "values": [ + 431706112, + 431804416, + 431976448 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 432345088.0, + "min": 432246784.0, + "max": 432504832.0, + "values": [ + 432246784, + 432345088, + 432504832 + ] + }, + "VmRSS_bytes": { + "median": 432345088.0, + "min": 432246784.0, + "max": 432504832.0, + "values": [ + 432246784, + 432345088, + 432504832 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 432345088.0, + "min": 432246784.0, + "max": 432529408.0, + "values": [ + 432246784, + 432345088, + 432529408 + ] + }, + "VmRSS_bytes": { + "median": 432345088.0, + "min": 432246784.0, + "max": 432529408.0, + "values": [ + 432246784, + 432345088, + 432529408 + ] + } + } + } + }, + "int8-native-rows-4": { + "uniform-id-stress": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 65536, + "batch_rows": 512, + "query_buffer_bytes": 657408, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 1.3022960000000001, + "min": 1.2944740000000001, + "max": 1.309595, + "values": [ + 1.2944740000000001, + 1.3022960000000001, + 1.309595 + ] + }, + "wall_p95_ms": { + "median": 1.6440926999999999, + "min": 1.6406635999999999, + "max": 1.66551375, + "values": [ + 1.6406635999999999, + 1.6440926999999999, + 1.66551375 + ] + }, + "wall_p99_ms": { + "median": 1.9736764400000009, + "min": 1.9585167700000006, + "max": 2.005813690000001, + "values": [ + 1.9585167700000006, + 1.9736764400000009, + 2.005813690000001 + ] + }, + "rows_per_second": { + "median": 382308.7645894346, + "min": 380560.4169073745, + "max": 382958.1496385012, + "values": [ + 382958.1496385012, + 382308.7645894346, + 380560.4169073745 + ] + }, + "cpu_p50_ms": { + "median": 1.3036355, + "min": 1.2944149999999999, + "max": 1.3104, + "values": [ + 1.2944149999999999, + 1.3036355, + 1.3104 + ] + }, + "logical_decoded_bytes": { + "median": 4652960.0, + "min": 4652960.0, + "max": 4652960.0, + "values": [ + 4652960, + 4652960, + 4652960 + ] + }, + "logical_compressed_bytes": { + "median": 4575227.0, + "min": 4575227.0, + "max": 4575227.0, + "values": [ + 4575227, + 4575227, + 4575227 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 0.2730712890625, + "min": 0.2730712890625, + "max": 0.2730712890625, + "values": [ + 0.2730712890625, + 0.2730712890625, + 0.2730712890625 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.3669115, + "min": 0.363594, + "max": 0.368099, + "values": [ + 0.363594, + 0.368099, + 0.3669115 + ] + }, + "wall_p95_ms": { + "median": 0.39198825, + "min": 0.3797969499999999, + "max": 0.3947568999999999, + "values": [ + 0.3797969499999999, + 0.3947568999999999, + 0.39198825 + ] + }, + "wall_p99_ms": { + "median": 0.40718165, + "min": 0.3934937, + "max": 0.42199763000000007, + "values": [ + 0.3934937, + 0.42199763000000007, + 0.40718165 + ] + }, + "rows_per_second": { + "median": 1379087.0547230267, + "min": 1374314.0749716677, + "max": 1397378.929416607, + "values": [ + 1397378.929416607, + 1374314.0749716677, + 1379087.0547230267 + ] + }, + "cpu_p50_ms": { + "median": 0.36799, + "min": 0.36464050000000003, + "max": 0.3692705, + "values": [ + 0.36464050000000003, + 0.3692705, + 0.36799 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 4476.0, + "min": 4476.0, + "max": 4476.0, + "values": [ + 4476, + 4476, + 4476 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.280483, + "min": 0.279156, + "max": 0.28195, + "values": [ + 0.279156, + 0.28195, + 0.280483 + ] + }, + "wall_p95_ms": { + "median": 0.30473895, + "min": 0.2956904, + "max": 0.3071661499999999, + "values": [ + 0.30473895, + 0.3071661499999999, + 0.2956904 + ] + }, + "wall_p99_ms": { + "median": 0.31151218999999997, + "min": 0.31012779, + "max": 0.31936642, + "values": [ + 0.31012779, + 0.31936642, + 0.31151218999999997 + ] + }, + "rows_per_second": { + "median": 1810364.6558830931, + "min": 1792790.8056268329, + "max": 1813925.7997620343, + "values": [ + 1810364.6558830931, + 1792790.8056268329, + 1813925.7997620343 + ] + }, + "cpu_p50_ms": { + "median": 0.281385, + "min": 0.28025500000000003, + "max": 0.28283499999999995, + "values": [ + 0.28025500000000003, + 0.28283499999999995, + 0.281385 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 5680.0, + "min": 5680.0, + "max": 5680.0, + "values": [ + 5680, + 5680, + 5680 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 290435072.0, + "min": 290271232.0, + "max": 290447360.0, + "values": [ + 290435072, + 290447360, + 290271232 + ] + }, + "VmRSS_bytes": { + "median": 290435072.0, + "min": 290271232.0, + "max": 290447360.0, + "values": [ + 290435072, + 290447360, + 290271232 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 290975744.0, + "min": 290811904.0, + "max": 290988032.0, + "values": [ + 290975744, + 290988032, + 290811904 + ] + }, + "VmRSS_bytes": { + "median": 290975744.0, + "min": 290811904.0, + "max": 290988032.0, + "values": [ + 290975744, + 290988032, + 290811904 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 290975744.0, + "min": 290811904.0, + "max": 290988032.0, + "values": [ + 290975744, + 290988032, + 290811904 + ] + }, + "VmRSS_bytes": { + "median": 290975744.0, + "min": 290811904.0, + "max": 290988032.0, + "values": [ + 290975744, + 290988032, + 290811904 + ] + } + } + }, + "heldout-lexical": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 17677, + "batch_rows": 512, + "query_buffer_bytes": 657408, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 0.5635494999999999, + "min": 0.5599179999999999, + "max": 0.5679845, + "values": [ + 0.5635494999999999, + 0.5599179999999999, + 0.5679845 + ] + }, + "wall_p95_ms": { + "median": 1.0928673999999998, + "min": 1.0916726999999997, + "max": 1.1003534999999995, + "values": [ + 1.0928673999999998, + 1.0916726999999997, + 1.1003534999999995 + ] + }, + "wall_p99_ms": { + "median": 1.426608770000001, + "min": 1.411642360000001, + "max": 1.4792992200000012, + "values": [ + 1.4792992200000012, + 1.426608770000001, + 1.411642360000001 + ] + }, + "rows_per_second": { + "median": 809344.3008279018, + "min": 806489.612809796, + "max": 818223.1540597359, + "values": [ + 809344.3008279018, + 818223.1540597359, + 806489.612809796 + ] + }, + "cpu_p50_ms": { + "median": 0.5642705, + "min": 0.561545, + "max": 0.5683499999999999, + "values": [ + 0.5642705, + 0.561545, + 0.5683499999999999 + ] + }, + "logical_decoded_bytes": { + "median": 2233920.0, + "min": 2233920.0, + "max": 2233920.0, + "values": [ + 2233920, + 2233920, + 2233920 + ] + }, + "logical_compressed_bytes": { + "median": 2178394.0, + "min": 2178394.0, + "max": 2178394.0, + "values": [ + 2178394, + 2178394, + 2178394 + ] + }, + "row_cache_hits": { + "median": 7387.0, + "min": 7387.0, + "max": 7387.0, + "values": [ + 7387, + 7387, + 7387 + ] + }, + "decoded_over_encoded_output": { + "median": 0.131103515625, + "min": 0.131103515625, + "max": 0.131103515625, + "values": [ + 0.131103515625, + 0.131103515625, + 0.131103515625 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.264978, + "min": 0.260718, + "max": 0.265886, + "values": [ + 0.265886, + 0.260718, + 0.264978 + ] + }, + "wall_p95_ms": { + "median": 0.284813, + "min": 0.281925, + "max": 0.28593704999999997, + "values": [ + 0.284813, + 0.281925, + 0.28593704999999997 + ] + }, + "wall_p99_ms": { + "median": 0.31044997, + "min": 0.30535762000000005, + "max": 0.3133580100000001, + "values": [ + 0.3133580100000001, + 0.30535762000000005, + 0.31044997 + ] + }, + "rows_per_second": { + "median": 1908277.5849712894, + "min": 1901156.4575528014, + "max": 1939019.4708491133, + "values": [ + 1901156.4575528014, + 1939019.4708491133, + 1908277.5849712894 + ] + }, + "cpu_p50_ms": { + "median": 0.2662, + "min": 0.26165499999999997, + "max": 0.266616, + "values": [ + 0.266616, + 0.26165499999999997, + 0.2662 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 11102.0, + "min": 11102.0, + "max": 11102.0, + "values": [ + 11102, + 11102, + 11102 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.247483, + "min": 0.24367650000000002, + "max": 0.247937, + "values": [ + 0.247483, + 0.24367650000000002, + 0.247937 + ] + }, + "wall_p95_ms": { + "median": 0.25848269999999995, + "min": 0.25515174999999995, + "max": 0.262051, + "values": [ + 0.262051, + 0.25515174999999995, + 0.25848269999999995 + ] + }, + "wall_p99_ms": { + "median": 0.27524135, + "min": 0.26555723, + "max": 0.27788524, + "values": [ + 0.27524135, + 0.26555723, + 0.27788524 + ] + }, + "rows_per_second": { + "median": 2068590.386705955, + "min": 2061602.193572919, + "max": 2101000.7914145794, + "values": [ + 2068590.386705955, + 2101000.7914145794, + 2061602.193572919 + ] + }, + "cpu_p50_ms": { + "median": 0.248415, + "min": 0.2444705, + "max": 0.249285, + "values": [ + 0.248415, + 0.2444705, + 0.249285 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 12300.0, + "min": 12300.0, + "max": 12300.0, + "values": [ + 12300, + 12300, + 12300 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 103890944.0, + "min": 103829504.0, + "max": 103923712.0, + "values": [ + 103829504, + 103923712, + 103890944 + ] + }, + "VmRSS_bytes": { + "median": 103890944.0, + "min": 103829504.0, + "max": 103923712.0, + "values": [ + 103829504, + 103923712, + 103890944 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 104431616.0, + "min": 104370176.0, + "max": 104464384.0, + "values": [ + 104370176, + 104464384, + 104431616 + ] + }, + "VmRSS_bytes": { + "median": 104431616.0, + "min": 104370176.0, + "max": 104464384.0, + "values": [ + 104370176, + 104464384, + 104431616 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 104431616.0, + "min": 104370176.0, + "max": 104464384.0, + "values": [ + 104370176, + 104464384, + 104431616 + ] + }, + "VmRSS_bytes": { + "median": 104431616.0, + "min": 104370176.0, + "max": 104464384.0, + "values": [ + 104370176, + 104464384, + 104431616 + ] + } + } + } + }, + "fp32-raw": { + "uniform-id-stress": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 65536, + "batch_rows": 512, + "query_buffer_bytes": 1048576, + "cache_budget_bytes": 0, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 0.691918, + "min": 0.6871695, + "max": 0.6985535, + "values": [ + 0.6871695, + 0.691918, + 0.6985535 + ] + }, + "wall_p95_ms": { + "median": 0.7793211999999999, + "min": 0.7555716499999999, + "max": 0.99588835, + "values": [ + 0.7555716499999999, + 0.99588835, + 0.7793211999999999 + ] + }, + "wall_p99_ms": { + "median": 1.0807080300000003, + "min": 0.9130438600000004, + "max": 1.1000451200000003, + "values": [ + 0.9130438600000004, + 1.1000451200000003, + 1.0807080300000003 + ] + }, + "rows_per_second": { + "median": 713493.7124999644, + "min": 704503.9026082695, + "max": 730185.4307327488, + "values": [ + 730185.4307327488, + 704503.9026082695, + 713493.7124999644 + ] + }, + "cpu_p50_ms": { + "median": 0.692725, + "min": 0.6875249999999999, + "max": 0.6995855, + "values": [ + 0.6875249999999999, + 0.692725, + 0.6995855 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.140032, + "min": 0.1392985, + "max": 0.14101, + "values": [ + 0.140032, + 0.1392985, + 0.14101 + ] + }, + "wall_p95_ms": { + "median": 0.14901755, + "min": 0.1483602, + "max": 0.15486955, + "values": [ + 0.1483602, + 0.14901755, + 0.15486955 + ] + }, + "wall_p99_ms": { + "median": 0.16563745000000002, + "min": 0.15921842000000005, + "max": 0.21462428000000006, + "values": [ + 0.15921842000000005, + 0.16563745000000002, + 0.21462428000000006 + ] + }, + "rows_per_second": { + "median": 3609809.43240076, + "min": 3544414.8397493004, + "max": 3621134.3937263153, + "values": [ + 3609809.43240076, + 3621134.3937263153, + 3544414.8397493004 + ] + }, + "cpu_p50_ms": { + "median": 0.140925, + "min": 0.13985, + "max": 0.141745, + "values": [ + 0.140925, + 0.13985, + 0.141745 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.089886, + "min": 0.089397, + "max": 0.090794, + "values": [ + 0.089886, + 0.089397, + 0.090794 + ] + }, + "wall_p95_ms": { + "median": 0.1036475, + "min": 0.09891944999999999, + "max": 0.13262869999999996, + "values": [ + 0.09891944999999999, + 0.1036475, + 0.13262869999999996 + ] + }, + "wall_p99_ms": { + "median": 0.11819648999999996, + "min": 0.10144179, + "max": 0.19525256, + "values": [ + 0.10144179, + 0.11819648999999996, + 0.19525256 + ] + }, + "rows_per_second": { + "median": 5532549.042278753, + "min": 5254630.867954437, + "max": 5573533.770090101, + "values": [ + 5573533.770090101, + 5532549.042278753, + 5254630.867954437 + ] + }, + "cpu_p50_ms": { + "median": 0.0905305, + "min": 0.08993, + "max": 0.091515, + "values": [ + 0.0905305, + 0.08993, + 0.091515 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 294309888.0, + "min": 294227968.0, + "max": 294363136.0, + "values": [ + 294227968, + 294363136, + 294309888 + ] + }, + "VmRSS_bytes": { + "median": 294309888.0, + "min": 294227968.0, + "max": 294363136.0, + "values": [ + 294227968, + 294363136, + 294309888 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 294850560.0, + "min": 294768640.0, + "max": 294903808.0, + "values": [ + 294768640, + 294903808, + 294850560 + ] + }, + "VmRSS_bytes": { + "median": 294850560.0, + "min": 294768640.0, + "max": 294903808.0, + "values": [ + 294768640, + 294903808, + 294850560 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 294850560.0, + "min": 294768640.0, + "max": 294903808.0, + "values": [ + 294768640, + 294903808, + 294850560 + ] + }, + "VmRSS_bytes": { + "median": 294850560.0, + "min": 294768640.0, + "max": 294903808.0, + "values": [ + 294768640, + 294903808, + 294850560 + ] + } + } + }, + "heldout-lexical": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 17677, + "batch_rows": 512, + "query_buffer_bytes": 1048576, + "cache_budget_bytes": 0, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 0.199467, + "min": 0.199152, + "max": 0.20606649999999999, + "values": [ + 0.199152, + 0.20606649999999999, + 0.199467 + ] + }, + "wall_p95_ms": { + "median": 0.33527735, + "min": 0.33444494999999996, + "max": 0.34749594999999994, + "values": [ + 0.33444494999999996, + 0.34749594999999994, + 0.33527735 + ] + }, + "wall_p99_ms": { + "median": 0.5099254800000006, + "min": 0.5069357400000006, + "max": 0.5217706100000006, + "values": [ + 0.5069357400000006, + 0.5217706100000006, + 0.5099254800000006 + ] + }, + "rows_per_second": { + "median": 2352445.2278270833, + "min": 2292411.786779959, + "max": 2379232.9442441324, + "values": [ + 2379232.9442441324, + 2292411.786779959, + 2352445.2278270833 + ] + }, + "cpu_p50_ms": { + "median": 0.20083499999999999, + "min": 0.20000050000000003, + "max": 0.20660499999999998, + "values": [ + 0.20000050000000003, + 0.20660499999999998, + 0.20083499999999999 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 0.097464, + "min": 0.0943905, + "max": 0.098407, + "values": [ + 0.0943905, + 0.098407, + 0.097464 + ] + }, + "wall_p95_ms": { + "median": 0.1101082, + "min": 0.10986769999999998, + "max": 0.11344354999999995, + "values": [ + 0.1101082, + 0.10986769999999998, + 0.11344354999999995 + ] + }, + "wall_p99_ms": { + "median": 0.12611141, + "min": 0.12325702000000001, + "max": 0.12668408000000003, + "values": [ + 0.12668408000000003, + 0.12325702000000001, + 0.12611141 + ] + }, + "rows_per_second": { + "median": 5197345.845156747, + "min": 5129921.588973171, + "max": 5274832.402776466, + "values": [ + 5274832.402776466, + 5129921.588973171, + 5197345.845156747 + ] + }, + "cpu_p50_ms": { + "median": 0.0979905, + "min": 0.09503500000000001, + "max": 0.09931, + "values": [ + 0.09503500000000001, + 0.09931, + 0.0979905 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.081365, + "min": 0.080946, + "max": 0.081435, + "values": [ + 0.080946, + 0.081365, + 0.081435 + ] + }, + "wall_p95_ms": { + "median": 0.094146, + "min": 0.093238, + "max": 0.09647894999999998, + "values": [ + 0.09647894999999998, + 0.093238, + 0.094146 + ] + }, + "wall_p99_ms": { + "median": 0.10126208999999999, + "min": 0.09502029, + "max": 0.10539159999999999, + "values": [ + 0.10539159999999999, + 0.09502029, + 0.10126208999999999 + ] + }, + "rows_per_second": { + "median": 6081305.3902101675, + "min": 6073245.625643271, + "max": 6083863.895230991, + "values": [ + 6083863.895230991, + 6073245.625643271, + 6081305.3902101675 + ] + }, + "cpu_p50_ms": { + "median": 0.08196, + "min": 0.08112549999999999, + "max": 0.08216100000000001, + "values": [ + 0.08112549999999999, + 0.08216100000000001, + 0.08196 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 89952256.0, + "min": 89931776.0, + "max": 90046464.0, + "values": [ + 89952256, + 90046464, + 89931776 + ] + }, + "VmRSS_bytes": { + "median": 89952256.0, + "min": 89931776.0, + "max": 90046464.0, + "values": [ + 89952256, + 90046464, + 89931776 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 90492928.0, + "min": 90472448.0, + "max": 90587136.0, + "values": [ + 90492928, + 90587136, + 90472448 + ] + }, + "VmRSS_bytes": { + "median": 90492928.0, + "min": 90472448.0, + "max": 90587136.0, + "values": [ + 90492928, + 90587136, + 90472448 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 90492928.0, + "min": 90472448.0, + "max": 90587136.0, + "values": [ + 90492928, + 90587136, + 90472448 + ] + }, + "VmRSS_bytes": { + "median": 90492928.0, + "min": 90472448.0, + "max": 90587136.0, + "values": [ + 90492928, + 90587136, + 90472448 + ] + } + } + } + }, + "fp32-native": { + "heldout-lexical": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 17677, + "batch_rows": 512, + "query_buffer_bytes": 1048576, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 8.1645225, + "min": 8.1404615, + "max": 8.169376, + "values": [ + 8.1404615, + 8.169376, + 8.1645225 + ] + }, + "wall_p95_ms": { + "median": 11.19768315, + "min": 11.170465649999999, + "max": 11.3455821, + "values": [ + 11.170465649999999, + 11.19768315, + 11.3455821 + ] + }, + "wall_p99_ms": { + "median": 15.97162655000002, + "min": 15.971114770000021, + "max": 16.05014178000002, + "values": [ + 15.97162655000002, + 16.05014178000002, + 15.971114770000021 + ] + }, + "rows_per_second": { + "median": 61282.84590609152, + "min": 61135.61933490193, + "max": 61579.78833253849, + "values": [ + 61579.78833253849, + 61282.84590609152, + 61135.61933490193 + ] + }, + "cpu_p50_ms": { + "median": 8.157663, + "min": 8.132978000000001, + "max": 8.1616485, + "values": [ + 8.132978000000001, + 8.1616485, + 8.157663 + ] + }, + "logical_decoded_bytes": { + "median": 139190272.0, + "min": 139190272.0, + "max": 139190272.0, + "values": [ + 139190272, + 139190272, + 139190272 + ] + }, + "logical_compressed_bytes": { + "median": 130538259.0, + "min": 130538259.0, + "max": 130538259.0, + "values": [ + 130538259, + 130538259, + 130538259 + ] + }, + "row_cache_hits": { + "median": 28615.0, + "min": 28615.0, + "max": 28615.0, + "values": [ + 28615, + 28615, + 28615 + ] + }, + "decoded_over_encoded_output": { + "median": 2.0740966796875, + "min": 2.0740966796875, + "max": 2.0740966796875, + "values": [ + 2.0740966796875, + 2.0740966796875, + 2.0740966796875 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 7.7825595, + "min": 7.764785, + "max": 7.9140715, + "values": [ + 7.764785, + 7.9140715, + 7.7825595 + ] + }, + "wall_p95_ms": { + "median": 10.714311149999999, + "min": 10.640093599999998, + "max": 10.74537975, + "values": [ + 10.640093599999998, + 10.74537975, + 10.714311149999999 + ] + }, + "wall_p99_ms": { + "median": 11.04761118, + "min": 11.001303440000001, + "max": 11.04822083, + "values": [ + 11.001303440000001, + 11.04761118, + 11.04822083 + ] + }, + "rows_per_second": { + "median": 65941.80149423664, + "min": 65011.324802951305, + "max": 66086.89920218526, + "values": [ + 66086.89920218526, + 65011.324802951305, + 65941.80149423664 + ] + }, + "cpu_p50_ms": { + "median": 7.7792535, + "min": 7.761739, + "max": 7.906979, + "values": [ + 7.761739, + 7.906979, + 7.7792535 + ] + }, + "logical_decoded_bytes": { + "median": 133808128.0, + "min": 133808128.0, + "max": 133808128.0, + "values": [ + 133808128, + 133808128, + 133808128 + ] + }, + "logical_compressed_bytes": { + "median": 125461062.0, + "min": 125461062.0, + "max": 125461062.0, + "values": [ + 125461062, + 125461062, + 125461062 + ] + }, + "row_cache_hits": { + "median": 29437.0, + "min": 29437.0, + "max": 29437.0, + "values": [ + 29437, + 29437, + 29437 + ] + }, + "decoded_over_encoded_output": { + "median": 1.993896484375, + "min": 1.993896484375, + "max": 1.993896484375, + "values": [ + 1.993896484375, + 1.993896484375, + 1.993896484375 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.116844, + "min": 0.11447, + "max": 0.1197425, + "values": [ + 0.11447, + 0.1197425, + 0.116844 + ] + }, + "wall_p95_ms": { + "median": 0.13202095, + "min": 0.1297125, + "max": 0.13340049999999998, + "values": [ + 0.1297125, + 0.13202095, + 0.13340049999999998 + ] + }, + "wall_p99_ms": { + "median": 0.14425905, + "min": 0.14140631999999997, + "max": 0.14579780999999997, + "values": [ + 0.14140631999999997, + 0.14579780999999997, + 0.14425905 + ] + }, + "rows_per_second": { + "median": 4310025.523432397, + "min": 4239721.689597409, + "max": 4380988.328933714, + "values": [ + 4380988.328933714, + 4239721.689597409, + 4310025.523432397 + ] + }, + "cpu_p50_ms": { + "median": 0.11726500000000001, + "min": 0.11496500000000001, + "max": 0.120585, + "values": [ + 0.11496500000000001, + 0.120585, + 0.11726500000000001 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 62360.0, + "min": 62360.0, + "max": 62360.0, + "values": [ + 62360, + 62360, + 62360 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 168972288.0, + "min": 168931328.0, + "max": 168988672.0, + "values": [ + 168972288, + 168988672, + 168931328 + ] + }, + "VmRSS_bytes": { + "median": 168972288.0, + "min": 168931328.0, + "max": 168988672.0, + "values": [ + 168972288, + 168988672, + 168931328 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 169512960.0, + "min": 169472000.0, + "max": 169697280.0, + "values": [ + 169512960, + 169697280, + 169472000 + ] + }, + "VmRSS_bytes": { + "median": 169512960.0, + "min": 169472000.0, + "max": 169697280.0, + "values": [ + 169512960, + 169697280, + 169472000 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 169512960.0, + "min": 169472000.0, + "max": 169734144.0, + "values": [ + 169512960, + 169734144, + 169472000 + ] + }, + "VmRSS_bytes": { + "median": 169512960.0, + "min": 169472000.0, + "max": 169734144.0, + "values": [ + 169512960, + 169734144, + 169472000 + ] + } + } + }, + "uniform-id-stress": { + "processes": 3, + "query_rows": 65536, + "distinct_rows": 65536, + "batch_rows": 512, + "query_buffer_bytes": 1048576, + "cache_budget_bytes": 4194304, + "all_query_bytes_exact": true, + "first_trace": { + "wall_p50_ms": { + "median": 32.2792345, + "min": 32.210196499999995, + "max": 32.297498000000004, + "values": [ + 32.2792345, + 32.210196499999995, + 32.297498000000004 + ] + }, + "wall_p95_ms": { + "median": 32.7242913, + "min": 32.7206565, + "max": 32.822209, + "values": [ + 32.7242913, + 32.822209, + 32.7206565 + ] + }, + "wall_p99_ms": { + "median": 33.63448117, + "min": 33.52078385, + "max": 33.70249114000001, + "values": [ + 33.52078385, + 33.70249114000001, + 33.63448117 + ] + }, + "rows_per_second": { + "median": 15841.002071586408, + "min": 15837.219471170298, + "max": 15843.8521988725, + "values": [ + 15843.8521988725, + 15841.002071586408, + 15837.219471170298 + ] + }, + "cpu_p50_ms": { + "median": 32.2474785, + "min": 32.1851295, + "max": 32.270305500000006, + "values": [ + 32.2474785, + 32.1851295, + 32.270305500000006 + ] + }, + "logical_decoded_bytes": { + "median": 536313856.0, + "min": 536313856.0, + "max": 536313856.0, + "values": [ + 536313856, + 536313856, + 536313856 + ] + }, + "logical_compressed_bytes": { + "median": 498432318.0, + "min": 498432318.0, + "max": 498432318.0, + "values": [ + 498432318, + 498432318, + 498432318 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 7.99169921875, + "min": 7.99169921875, + "max": 7.99169921875, + "values": [ + 7.99169921875, + 7.99169921875, + 7.99169921875 + ] + } + }, + "second_trace": { + "wall_p50_ms": { + "median": 30.8198645, + "min": 30.774258, + "max": 30.893722, + "values": [ + 30.774258, + 30.893722, + 30.8198645 + ] + }, + "wall_p95_ms": { + "median": 31.019624699999998, + "min": 30.9754015, + "max": 32.08307085, + "values": [ + 30.9754015, + 32.08307085, + 31.019624699999998 + ] + }, + "wall_p99_ms": { + "median": 31.36066058, + "min": 31.191405760000002, + "max": 35.62775690000001, + "values": [ + 31.191405760000002, + 35.62775690000001, + 31.36066058 + ] + }, + "rows_per_second": { + "median": 16600.373064001622, + "min": 16434.14781189058, + "max": 16634.629825558874, + "values": [ + 16634.629825558874, + 16434.14781189058, + 16600.373064001622 + ] + }, + "cpu_p50_ms": { + "median": 30.800839, + "min": 30.755043, + "max": 30.873967999999998, + "values": [ + 30.755043, + 30.873967999999998, + 30.800839 + ] + }, + "logical_decoded_bytes": { + "median": 536313856.0, + "min": 536313856.0, + "max": 536313856.0, + "values": [ + 536313856, + 536313856, + 536313856 + ] + }, + "logical_compressed_bytes": { + "median": 498432318.0, + "min": 498432318.0, + "max": 498432318.0, + "values": [ + 498432318, + 498432318, + 498432318 + ] + }, + "row_cache_hits": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "decoded_over_encoded_output": { + "median": 7.99169921875, + "min": 7.99169921875, + "max": 7.99169921875, + "values": [ + 7.99169921875, + 7.99169921875, + 7.99169921875 + ] + } + }, + "hot_repeated": { + "wall_p50_ms": { + "median": 0.121664, + "min": 0.1206505, + "max": 0.1220475, + "values": [ + 0.121664, + 0.1220475, + 0.1206505 + ] + }, + "wall_p95_ms": { + "median": 0.1475994, + "min": 0.14073749999999993, + "max": 0.17569274999999995, + "values": [ + 0.14073749999999993, + 0.17569274999999995, + 0.1475994 + ] + }, + "wall_p99_ms": { + "median": 0.19469166999999996, + "min": 0.19101880999999996, + "max": 0.29206107000000003, + "values": [ + 0.19101880999999996, + 0.29206107000000003, + 0.19469166999999996 + ] + }, + "rows_per_second": { + "median": 4141165.2041829005, + "min": 3947686.9792638477, + "max": 4174283.8940055957, + "values": [ + 4141165.2041829005, + 3947686.9792638477, + 4174283.8940055957 + ] + }, + "cpu_p50_ms": { + "median": 0.122135, + "min": 0.121465, + "max": 0.12281500000000001, + "values": [ + 0.122135, + 0.12281500000000001, + 0.121465 + ] + }, + "logical_decoded_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "logical_compressed_bytes": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0, + 0, + 0 + ] + }, + "row_cache_hits": { + "median": 81920.0, + "min": 81920.0, + "max": 81920.0, + "values": [ + 81920, + 81920, + 81920 + ] + }, + "decoded_over_encoded_output": { + "median": 0.0, + "min": 0.0, + "max": 0.0, + "values": [ + 0.0, + 0.0, + 0.0 + ] + } + }, + "memory_after_first_trace": { + "peak_rss_bytes": { + "median": 686002176.0, + "min": 685903872.0, + "max": 686030848.0, + "values": [ + 686030848, + 686002176, + 685903872 + ] + }, + "VmRSS_bytes": { + "median": 686002176.0, + "min": 685903872.0, + "max": 686030848.0, + "values": [ + 686030848, + 686002176, + 685903872 + ] + } + }, + "memory_after_second_trace": { + "peak_rss_bytes": { + "median": 686571520.0, + "min": 686444544.0, + "max": 686718976.0, + "values": [ + 686571520, + 686718976, + 686444544 + ] + }, + "VmRSS_bytes": { + "median": 686571520.0, + "min": 686444544.0, + "max": 686718976.0, + "values": [ + 686571520, + 686718976, + 686444544 + ] + } + }, + "memory_after_hot": { + "peak_rss_bytes": { + "median": 686571520.0, + "min": 686444544.0, + "max": 686723072.0, + "values": [ + 686571520, + 686723072, + 686444544 + ] + }, + "VmRSS_bytes": { + "median": 686571520.0, + "min": 686444544.0, + "max": 686723072.0, + "values": [ + 686571520, + 686723072, + 686444544 + ] + } + } + } + } + }, + "failures": [] +} diff --git a/docs/quantized_capacity_evidence_20261031/supplement-run.log b/docs/quantized_capacity_evidence_20261031/supplement-run.log new file mode 100644 index 0000000..e69de29 diff --git a/docs/quantized_capacity_evidence_20261031/supplement-run.sh b/docs/quantized_capacity_evidence_20261031/supplement-run.sh new file mode 100644 index 0000000..c166be8 --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/supplement-run.sh @@ -0,0 +1,19 @@ +#!/bin/bash +set -eu +ROOT=/llm-align/duyimin/ngram-scale-20261031 +PY=/llm-align/duyimin/miniconda3/envs/gemma4/bin/python +export CUDA_VISIBLE_DEVICES="" +export OMP_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 MKL_NUM_THREADS=1 +export TMPDIR="$ROOT/tmp" +echo running > "$ROOT/supplement-status" +trap 'echo failed > "$ROOT/supplement-status"' ERR +bash "$ROOT/old-run.sh" > "$ROOT/old-run.log" 2>&1 +cd "$ROOT/source-auto" +nice -n 19 "$PY" "$ROOT/auto-build.py" > "$ROOT/auto-run.log" 2>&1 +nice -n 19 "$PY" -m tools.benchmark_quantized_capacity --phase verify \ + --source /llm-align/duyimin/meft-cpu-capacity-20261030/training2/trained.f32 \ + --bundle "$ROOT/auto-int8" --dim 256 --encoding int8 --backend raw \ + --worker-report "$ROOT/auto-verify.json" \ + --native-library "$ROOT/source/build/libmeft_rows.so" --chunk-rows 4096 \ + --query-manifest "$ROOT/results/queries.json" > "$ROOT/auto-verify.log" 2>&1 +echo completed > "$ROOT/supplement-status" diff --git a/docs/quantized_capacity_evidence_20261031/supplement-setup.sh b/docs/quantized_capacity_evidence_20261031/supplement-setup.sh new file mode 100644 index 0000000..1c4e640 --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/supplement-setup.sh @@ -0,0 +1,61 @@ +#!/bin/bash +set -eu +ROOT=/llm-align/duyimin/ngram-scale-20261031 +PY=/llm-align/duyimin/miniconda3/envs/gemma4/bin/python +export CUDA_VISIBLE_DEVICES="" +export OMP_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 MKL_NUM_THREADS=1 +export TMPDIR="$ROOT/tmp" +test "$(cat "$ROOT/status")" = completed +cd "$ROOT" +git clone auto.bundle source-auto > auto-clone.log 2>&1 +cd source-auto +test "$(git rev-parse HEAD)" = 9485969066ee4be466673cde07823330da1a7658 +nice -n 19 "$PY" -m unittest tests.test_quantized_memory tests.test_quantized_capacity > "$ROOT/auto-tests.log" 2>&1 +cat > "$ROOT/auto-build.py" <<'PY' +import json,sys,time +from pathlib import Path +root=Path('/llm-align/duyimin/ngram-scale-20261031') +sys.path.insert(0,str(root/'source-auto')) +from tools.benchmark_quantized_capacity import software_environment, memory +from tools.quantized_memory import pack_quantized_file +source=Path('/llm-align/duyimin/meft-cpu-capacity-20261030/training2/trained.f32') +report=dict(status='running',**software_environment(),memory_before=memory(), + label='auto INT8 native/raw bundle selection',shape=[1855907,256]) +started,cpu=time.perf_counter(),time.process_time() +metadata=pack_quantized_file(source,root/'auto-int8',256,'int8',native='auto',chunk_rows=4096,max_block_bytes=8192) +report.update(status='passed',metadata=metadata,wall_seconds=time.perf_counter()-started, + cpu_seconds=time.process_time()-cpu,memory_after=memory(), + bundle_bytes=sum(p.stat().st_size for p in (root/'auto-int8').iterdir())) +current=json.loads((root/'results/build-int8-raw.json').read_text())['metadata'] +for key in ('source_float32_sha256','decoded_float32_sha256','table_sha256'): + if current[key] != metadata[key]: raise AssertionError('auto/raw differs: '+key) +if metadata['backend'] != 'raw_mmap': raise AssertionError('expected measured INT8 expansion to select raw') +report['auto_matches_verified_raw_source_decoded_and_table_hashes']=True +(root/'auto-build.json').write_text(json.dumps(report,indent=2)+'\n') +print(json.dumps({k:report[k] for k in ('status','wall_seconds','cpu_seconds','memory_after','bundle_bytes','auto_matches_verified_raw_source_decoded_and_table_hashes')})) +PY +cat > "$ROOT/supplement-run.sh" <<'RUN' +#!/bin/bash +set -eu +ROOT=/llm-align/duyimin/ngram-scale-20261031 +PY=/llm-align/duyimin/miniconda3/envs/gemma4/bin/python +export CUDA_VISIBLE_DEVICES="" +export OMP_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 MKL_NUM_THREADS=1 +export TMPDIR="$ROOT/tmp" +echo running > "$ROOT/supplement-status" +trap 'echo failed > "$ROOT/supplement-status"' ERR +bash "$ROOT/old-run.sh" > "$ROOT/old-run.log" 2>&1 +cd "$ROOT/source-auto" +nice -n 19 "$PY" "$ROOT/auto-build.py" > "$ROOT/auto-run.log" 2>&1 +nice -n 19 "$PY" -m tools.benchmark_quantized_capacity --phase verify \ + --source /llm-align/duyimin/meft-cpu-capacity-20261030/training2/trained.f32 \ + --bundle "$ROOT/auto-int8" --dim 256 --encoding int8 --backend raw \ + --worker-report "$ROOT/auto-verify.json" \ + --native-library "$ROOT/source/build/libmeft_rows.so" --chunk-rows 4096 \ + --query-manifest "$ROOT/results/queries.json" > "$ROOT/auto-verify.log" 2>&1 +echo completed > "$ROOT/supplement-status" +RUN +nohup bash "$ROOT/supplement-run.sh" > "$ROOT/supplement-run.log" 2>&1 < /dev/null & +echo "$!" > "$ROOT/supplement.pid" +cat "$ROOT/auto-tests.log" +cat "$ROOT/supplement.pid" diff --git a/docs/quantized_capacity_evidence_20261031/tests.log b/docs/quantized_capacity_evidence_20261031/tests.log new file mode 100644 index 0000000..b7ea89c --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/tests.log @@ -0,0 +1,5 @@ +.......... +---------------------------------------------------------------------- +Ran 10 tests in 2.115s + +OK diff --git a/docs/quantized_capacity_evidence_20261031/tests.txt b/docs/quantized_capacity_evidence_20261031/tests.txt new file mode 100644 index 0000000..f88bac0 --- /dev/null +++ b/docs/quantized_capacity_evidence_20261031/tests.txt @@ -0,0 +1,12 @@ +...................ss.ss......../llm-align/duyimin/ngram-scale-20261031/checks-source/src/ftindex.cc: In function ‘FTIndex* ftindex_map_from_buffer(void*, size_t*)’: +/llm-align/duyimin/ngram-scale-20261031/checks-source/mylib/include/pub/pub_malloc.h:16:82: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings] + 16 | #define pub_calloc(num, size) pub_calloc_detail((num), (size), __FILE__, __FUNCTION__, __LINE__) + | ^~~~~~~~ +/llm-align/duyimin/ngram-scale-20261031/checks-source/src/ftindex.cc:461:31: note: in expansion of macro ‘pub_calloc’ + 461 | if (!(fti = (FTIndex*)pub_calloc(1, sizeof(*fti)))) return NULL; + | ^~~~~~~~~~ +........................................................................................sssssssssssss....... +---------------------------------------------------------------------- +Ran 140 tests in 66.453s + +OK (skipped=17) diff --git a/tests/test_quantized_capacity.py b/tests/test_quantized_capacity.py new file mode 100644 index 0000000..391fe47 --- /dev/null +++ b/tests/test_quantized_capacity.py @@ -0,0 +1,84 @@ +"""Small deterministic correctness fixtures, never compression/quality evidence.""" +from argparse import Namespace +import hashlib +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +try: + import numpy as np +except ImportError: + np = None + + +@unittest.skipUnless(np is not None and shutil.which("cc"), "NumPy and C compiler required") +class CapacityTest(unittest.TestCase): + def test_fresh_worker_oracles_full_verification_and_direct_control(self): + from tools.benchmark_quantized_capacity import build, verify, query, prepare_oracle, software_environment + from tools.analyze_quantized_capacity import analyze + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + library = root / ("rows.dylib" if sys.platform == "darwin" else "rows.so") + native = Path(__file__).resolve().parents[1] / "native/meft_rows.c" + subprocess.run(["cc", "-std=c11", "-O2", "-fPIC", "-dynamiclib" if sys.platform == "darwin" else "-shared", + str(native), "-lz", "-o", str(library)], check=True, capture_output=True) + rows = np.array([[127., .5, -.5], [1., .3, -.2], [0., -0., 0.], [2., .6, -.4]], dtype="= 0: + decoded, compressed, hits = [], [], [] + for w in workers: + work = w[phase]["codec_work"] + decoded.append(sum(c["last_decoded_bytes"] for c in work)) + compressed.append(sum(c["last_compressed_bytes"] for c in work)) + hits.append(sum(c["last_row_cache_hits"] for c in work)) + target[phase]["logical_decoded_bytes"] = range_summary(decoded) + target[phase]["logical_compressed_bytes"] = range_summary(compressed) + target[phase]["row_cache_hits"] = range_summary(hits) + row_width = report["builds"][variant]["result"]["metadata"]["row_bytes"] + output_bytes = workers[0]["batch_rows"] * row_width * len(workers[0][phase]["wall"]["samples_ms"]) + target[phase]["decoded_over_encoded_output"] = range_summary([v / output_bytes for v in decoded]) + for phase in ("memory_after_first_trace", "memory_after_second_trace", "memory_after_hot"): + target[phase] = {key: range_summary([w[phase][key] for w in workers]) + for key in ("peak_rss_bytes", "VmRSS_bytes") if all(key in w[phase] for w in workers)} + summary["queries"].setdefault(variant, {})[case] = target + baseline = summary["builds"].get("fp32-raw") + if baseline: + for name, v in summary["builds"].items(): + if v["rows"] != report["shape"][0]: + continue + v["table_saving_vs_raw_fp32"] = 1 - v["table_bytes"] / baseline["table_bytes"] + v["bundle_saving_vs_raw_fp32"] = 1 - v["bundle_with_keys_bytes"] / baseline["bundle_with_keys_bytes"] + matched = summary["builds"].get(v["encoding"] + "-raw") + if matched: + v["bundle_added_saving_vs_same_encoding_raw"] = 1 - v["bundle_with_keys_bytes"] / matched["bundle_with_keys_bytes"] + return summary + + +def plot(summary, directory): + import matplotlib.pyplot as plt + names = ["fp32-raw", "fp32-native", "fp16-raw", "fp16-native", "int8-raw", "int8-native", + "int8-native-rows-4", "int8-native-rows-1"] + names = [n for n in names if n in summary["builds"]] + labels = [n.replace("-raw", " mmap").replace("-native-rows-", " native/").replace("-native", " native") for n in names] + fig, axes = plt.subplots(1, 3, figsize=(17, 5.4), constrained_layout=True) + colors = ["#4c78a8" if "fp32" in n else "#59a14f" if "fp16" in n else "#f28e2b" for n in names] + axes[0].barh(labels, [summary["builds"][n]["bundle_with_keys_bytes"] / 1e9 for n in names], color=colors) + axes[0].set(xlabel="Table + codec + common keys (GB)", + title=f"Same {summary['shape'][0]/1e6:.3f}M × {summary['shape'][1]} trained rows") + query_names = ["fp32-direct"] + names + for case, marker in (("heldout-lexical", "o"), ("uniform-id-stress", "s")): + values = [summary["queries"][n][case]["first_trace"]["wall_p50_ms"]["median"] for n in query_names] + low = [summary["queries"][n][case]["first_trace"]["wall_p50_ms"]["min"] for n in query_names] + high = [summary["queries"][n][case]["first_trace"]["wall_p50_ms"]["max"] for n in query_names] + axes[1].errorbar(values, list(range(len(query_names))), + xerr=[np.asarray(values) - low, np.asarray(high) - values], + fmt=marker, capsize=2, label=case) + axes[1].set_yticks(range(len(query_names)), [n.replace("fp32-direct", "FP32 direct mmap") for n in query_names]) + axes[1].set(xscale="log", xlabel="Fresh-process first-trace batch p50 (ms)", title="512-row CPU gather → FP32") + axes[1].legend(fontsize=8) + scale_names = ["int8-native-prefix-100000", "int8-native-prefix-500000", "int8-native"] + scale_names = [n for n in scale_names if n in summary["builds"]] + scale_x = [summary["builds"][n]["rows"] / 1e6 for n in scale_names] + scale_y = [summary["builds"][n]["peak_rss_bytes"] / 2**20 for n in scale_names] + axes[2].plot(scale_x, scale_y, "o-", color="#f28e2b") + axes[2].set_ylim(0, max(scale_y) * 1.3) + for x, y in zip(scale_x, scale_y): + axes[2].annotate(f"{y:.1f}", (x, y), xytext=(0, 7), textcoords="offset points", ha="center", fontsize=8) + axes[2].set(xlabel="Original trained rows (millions)", ylabel="Fresh builder peak RSS (MiB)", + title="INT8 streaming export, ≤8 KiB blocks") + for ax in axes[:2]: + ax.invert_yaxis() + fig.suptitle("Quantization is lossy; native preserves encoded bytes. Shared CPU, warmed filesystem, no GPU.", fontsize=11) + for ext in ("svg", "png"): + fig.savefig(directory / ("scale-performance." + ext), dpi=180) + plt.close(fig) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--report", type=Path, required=True) + parser.add_argument("--output-dir", type=Path, required=True) + parser.add_argument("--plots", action="store_true") + args = parser.parse_args() + opener = gzip.open if args.report.suffix == ".gz" else open + with opener(args.report, "rt") as stream: + summary = analyze(json.load(stream)) + args.output_dir.mkdir(parents=True, exist_ok=True) + (args.output_dir / "summary.json").write_text(json.dumps(summary, indent=2) + "\n") + if args.plots: + plot(summary, args.output_dir) + + +if __name__ == "__main__": + main() diff --git a/tools/benchmark_quantized_capacity.py b/tools/benchmark_quantized_capacity.py new file mode 100644 index 0000000..ccbca14 --- /dev/null +++ b/tools/benchmark_quantized_capacity.py @@ -0,0 +1,358 @@ +"""CPU scale/latency evidence on unchanged genuinely trained FP32 rows. + +No training, downloads or GPU calls. Construction, verification and each query +trace use separate processes. Uniform IDs are a synthetic access pattern on +real vectors. Prefix subsets are storage scaling controls, not new trained +models. Native compression is exact to encoded bytes; FP16/INT8 are lossy. +""" +import argparse +import hashlib +import importlib.metadata +import json +import os +from pathlib import Path +import random +import subprocess +import sys +import time + +import numpy as np + +from .benchmark_memory_capacity import environment, memory, samples +from .prepare_public_benchmark import file_sha256 +from .quantized_memory import QuantizedRows, encode_rows, decode_rows, pack_quantized_file + + +def software_environment(): + result = environment() + try: + result["pytorch_installed_not_used"] = importlib.metadata.version("torch") + except importlib.metadata.PackageNotFoundError: + result["pytorch_installed_not_used"] = None + result["thread_environment"] = {key: os.environ.get(key) for key in + ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS")} + return result + + +def write_json(path, value): + path.write_text(json.dumps(value, indent=2) + "\n") + + +def read_chunks(source, dim, chunk_rows): + with source.open("rb") as stream: + while True: + part = stream.read(chunk_rows * dim * 4) + if not part: + break + if len(part) % (dim * 4): + raise ValueError("partial FP32 source row") + yield np.frombuffer(part, dtype=" 0) + cosine[(norm == 0) & (other == 0)] = 1 + cosine_errors.append(1 - np.clip(cosine, -1, 1)) + row += len(chunk) + if row != table.nrows or source_digest.hexdigest() != table.metadata["source_float32_sha256"]: + raise AssertionError("source provenance differs from the full bundle") + if decoded_digest.hexdigest() != table.metadata["decoded_float32_sha256"]: + raise AssertionError("full original-ID decoded hash differs from export audit") + relative = np.concatenate(relative_errors) + cosine = np.concatenate(cosine_errors) + write_json(args.worker_report, dict(status="passed", **software_environment(), rows_verified=row, + all_original_ids_encoded_byte_exact=True, all_decoded_rows_oracle_byte_exact=True, + source_sha256=source_digest.hexdigest(), encoded_original_id_sha256=encoded_digest.hexdigest(), + decoded_original_id_sha256=decoded_digest.hexdigest(), verify_seconds=time.perf_counter() - started, + relative_frobenius=float(np.sqrt(square_error / max(square_source, np.finfo(np.float64).tiny))), + row_relative_l2=dict(p50=float(np.median(relative)), p99=float(np.percentile(relative, 99)), max=float(np.max(relative))), + cosine_distance=dict(p50=float(np.median(cosine)), p99=float(np.percentile(cosine, 99)), max=float(np.max(cosine))), + memory_after=memory())) + + +def query(args): + manifest = json.loads(args.query_manifest.read_text()) + case = next(c for c in manifest["cases"] if c["name"] == args.case) + report = dict(status="running", **software_environment(), variant=args.variant_label or args.backend + "-" + args.encoding, + case=args.case, cache_budget_bytes=args.cache_bytes if args.backend == "native" else 0, + memory_before_open=memory(), batch_rows=len(case["queries"][0]["ids"])) + started = time.perf_counter() + if args.backend == "direct": + table = np.memmap(args.source, mode="r", dtype=" 256 for n in args.int8_extra_block_rows) or len(set(args.int8_extra_block_rows)) != len(args.int8_extra_block_rows): + parser.error("distinct extra block rows between 1 and 256 required") + if args.phase: + if any(getattr(args, name) is None for name in ("source", "bundle", "dim", "encoding", "backend", "worker_report")): + parser.error("worker source/bundle/dim/encoding/backend/report are required") + if args.backend == "direct" and (args.phase != "query" or args.encoding != "fp32"): + parser.error("direct backend is the FP32 query control only") + {"build": build, "verify": verify, "query": query}[args.phase](args) + else: + if args.training_dir is None or args.output_dir is None: + parser.error("training-dir and output-dir required") + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/quantized_memory.py b/tools/quantized_memory.py index 24635f0..943ef89 100644 --- a/tools/quantized_memory.py +++ b/tools/quantized_memory.py @@ -6,6 +6,7 @@ """ import hashlib import json +import os from pathlib import Path import shutil @@ -59,39 +60,144 @@ def decode_rows(encoded, dim, encoding): def pack_quantized(rows, directory, encoding, *, native=True, representatives=None, - row_order=None, deduplicate=False, max_block_bytes=8192): - """Publish a new research bundle; include codec metadata in measured bytes.""" - rows = np.ascontiguousarray(rows, dtype="= self.nrows))): + raise ValueError("one-dimensional original row IDs out of range") + if (not isinstance(output, np.ndarray) or output.dtype != np.dtype("