WP40 RAID: paper sections (setup, micro/end-to-end/applications, threats, reproducibility, conclusion, appendices), E1–E3 reruns, parallel realized post-processing

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Simon-Pierre Boucher committed 21 h ago (Nov 2, 2026) parent a9731b7 Browse files

32 changed files +1,943 −11

modified backends/metal/host/metal_backend.mm +3 −3

				`@@ -237,9 +237,9 @@ void regression_stats(std::span<const f64> x, std::span<const f64> y, std::span<`
237	};	237	};
238		238
239	std::shared_ptr<Backend> make_metal_backend(const PrecisionPolicy& policy) {	239	std::shared_ptr<Backend> make_metal_backend(const PrecisionPolicy& policy) {
240	− static std::mutex m; static std::weak_ptr<MetalBackend> cached; std::lock_guard<std::mutex> lk(m);	240	+ static std::mutex m; static std::shared_ptr<MetalBackend> cached; std::lock_guard<std::mutex> lk(m);
241	− if (auto p = cached.lock()) return p; // one device/queue/library per process (pipelines and buffers are reused)	241	+ if (cached) return cached->available() ? cached : nullptr; // one device/queue/library/pipeline cache/buffer pool per process
242	− auto p = std::make_shared<MetalBackend>(policy); cached = p; if (!p->available()) return nullptr; return p;	242	+ cached = std::make_shared<MetalBackend>(policy); return cached->available() ? cached : nullptr;
243	}	243	}
244		244
245	/// Fused realized accumulators when the backend is Metal (falls back to the four generic calls otherwise).	245	/// Fused realized accumulators when the backend is Metal (falls back to the four generic calls otherwise).

modified benchmarks/end_to_end/bench_e3_garch.cpp +1 −1

				`@@ -44,7 +44,7 @@ int main(int argc, char** argv) {`
44	ThreadPool::global().parallel_for(S, [&](usize a, usize b) { for (usize i = a; i < b; ++i) { auto& r = ret[syms[i]]; std::vector<f64> train(r.begin(), r.end() - static_cast<long>(test)); models::GarchFitOptions o; o.model = sp.m; o.dist = sp.d; o.forecast_horizon = 1; json row = {{"symbol", syms[i]}, {"model", sp.name}, {"n_train", train.size()}};	44	ThreadPool::global().parallel_for(S, [&](usize a, usize b) { for (usize i = a; i < b; ++i) { auto& r = ret[syms[i]]; std::vector<f64> train(r.begin(), r.end() - static_cast<long>(test)); models::GarchFitOptions o; o.model = sp.m; o.dist = sp.d; o.forecast_horizon = 1; json row = {{"symbol", syms[i]}, {"model", sp.name}, {"n_train", train.size()}};
45	try { const f64 f0 = now(); auto e = models::garch_fit(train, o); row["seconds"] = now() - f0; row["converged"] = e.ok(); row["iterations"] = e.convergence.iterations; row["fevals"] = e.convergence.function_evaluations; row["loglik"] = -e.loss; row["coef"] = e.coefficients; row["se"] = e.inference ? e.inference->std_errors : std::vector<f64>{}; row["persistence"] = e.extra.value("persistence", 0.0); row["warnings"] = e.warnings;	45	try { const f64 f0 = now(); auto e = models::garch_fit(train, o); row["seconds"] = now() - f0; row["converged"] = e.ok(); row["iterations"] = e.convergence.iterations; row["fevals"] = e.convergence.function_evaluations; row["loglik"] = -e.loss; row["coef"] = e.coefficients; row["se"] = e.inference ? e.inference->std_errors : std::vector<f64>{}; row["persistence"] = e.extra.value("persistence", 0.0); row["warnings"] = e.warnings;
46	// rolling 1-step forecasts over the test window WITHOUT refitting (parameters fixed at the training estimate; variance path updated with realized returns): QLIKE vs next-day RV	46	// rolling 1-step forecasts over the test window WITHOUT refitting (parameters fixed at the training estimate; variance path updated with realized returns): QLIKE vs next-day RV
47	− if (e.ok()) { std::vector<f64> fc, act; for (usize k = 0; k < test; ++k) { std::vector<f64> hist(r.begin(), r.end() - static_cast<long>(test - k)); auto f = models::garch_forecast(e, hist, 1); fc.push_back(f[0]); act.push_back(rvd[syms[i]][r.size() - test + k]); } auto l = est::forecast_loss(act, fc); row["qlike_vs_rv"] = l.qlike; row["mse_vs_rv"] = l.mse; row["n_forecasts"] = l.n; std::vector<f64> naive; for (usize k = 0; k < test; ++k) naive.push_back(rvd[syms[i]][r.size() - test + k - 1]); auto ln = est::forecast_loss(act, naive); row["qlike_rw_rv"] = ln.qlike; } }	47	+ if (e.ok()) { std::vector<f64> fc, act; for (usize k = 0; k < test; ++k) { std::vector<f64> hist(r.begin(), r.end() - static_cast<long>(test - k)); auto f = models::garch_forecast(e, hist, 1); fc.push_back(f[0]); act.push_back(rvd[syms[i]][rvd[syms[i]].size() - test + k]); } auto l = est::forecast_loss(act, fc); row["qlike_vs_rv"] = l.qlike; row["mse_vs_rv"] = l.mse; row["n_forecasts"] = l.n; std::vector<f64> naive; for (usize k = 0; k < test; ++k) naive.push_back(rvd[syms[i]][rvd[syms[i]].size() - test + k - 1]); auto ln = est::forecast_loss(act, naive); row["qlike_rw_rv"] = ln.qlike; } }
48	catch (const RaidError& ex) { row["error"] = ex.what(); row["converged"] = false; } rows[i] = row; } });	48	catch (const RaidError& ex) { row["error"] = ex.what(); row["converged"] = false; } rows[i] = row; } });
49	usize conv = 0; for (auto& r : rows) { conv += r.value("converged", false); r["kind"] = "fit"; r["experiment"] = "E3"; out << r.dump() << "\n"; }	49	usize conv = 0; for (auto& r : rows) { conv += r.value("converged", false); r["kind"] = "fit"; r["experiment"] = "E3"; out << r.dump() << "\n"; }
50	out << json({{"kind", "fit_summary"}, {"experiment", "E3"}, {"model", sp.name}, {"S", S}, {"converged", conv}, {"wall_seconds_all", now() - t0}, {"threads", ThreadPool::global().size()}}).dump() << "\n"; out.flush();	50	out << json({{"kind", "fit_summary"}, {"experiment", "E3"}, {"model", sp.name}, {"S", S}, {"converged", conv}, {"wall_seconds_all", now() - t0}, {"threads", ThreadPool::global().size()}}).dump() << "\n"; out.flush();

added experiments/manifests/paper_assets.json +28 −0

++{
++ "inputs": {
++  "bench_primitives.jsonl": "f3de95928ef0d92f2fb1a89f81ed33118ff01f66ae3b2feb25f6e37d8ace292a",
++  "e1_batched_rv.jsonl": "853960fae2a0aebe19ee97df2a255d044e105ce6911c7f5683fbdf871e0b7f12",
++  "e2_har.jsonl": "b9ae608a015b33bea38aa9dfc8a282e9544f70a584d144e7160497c379da75a5",
++  "e3_garch.jsonl": "679ac18132f6b16ce5618dfe15e9c5c6f416cf40d90f3515d893deb7a4131f91",
++  "e4_connectedness.jsonl": "27f92310d6950ed7a60e5e9bfe1e361b7ac7f7a8636816475a2f02da8bad7673",
++  "e5_inference.jsonl": "d4dcc2baa0a227334ac454d928a4ab8c27e209edbad6a4681f5d50a8a0ddff5b",
++  "e6_pipeline.jsonl": "0816f1510693c4c028fe45b78482d7a8b009c6c9b4929f9a149d079401f935b0",
++  "e6_baselines.jsonl": "cdbd901b0fa99cd2db9240b5fba13b9f00a852b40d010a9d64f4efcff218cdb8",
++  "e7_summary.json": "1cbaa525a98b098eb26264d922033ee4d4f2df32049a6cf4b6fcb2a2f80a42cf"
++ },
++ "outputs": {
++  "tables/tab_primitives.tex": "dfccbd67b68adc9c451a2f7f196a70de42cb612ecc9826285e2bc7fadb1db0ff",
++  "figures/fig_primitives_throughput.pdf": "e9ce50655262712762064350c514e8dfd09fc2fce5c8db2027ed0e74b32b09eb",
++  "tables/tab_e1.tex": "c5a0de42b79895abd2dc0cffba23b92f9a2048093579fa3529335e24c1a90a97",
++  "figures/fig_e1.pdf": "53e26cdf3689df17adaebf18f1f95441f2bac33685ffe6e496efe223014a521d",
++  "tables/tab_e2_accuracy.tex": "a337d1e20c1b1298f83e55984296b06ebfc41834c723e0270236e78022bb6f65",
++  "tables/tab_e2_runtime.tex": "c43af1813c748886e5dc5c5f26257d3b14a4cc1dab5ea9cee5672e996f739abf",
++  "tables/tab_e3_fits.tex": "d5d6adfb8f9644524e5deac5a37ce775df6cf32b7df9cbcad3ffb15a1a63587e",
++  "tables/tab_e4.tex": "645ce562f6fce8f0a07495473237badb1190efe21f99e2dedb444f1b155208ef",
++  "tables/tab_e5.tex": "69b53b60302201eed7a2ffba95827f88fa44b7ba8b3e642f820ee696652495d7",
++  "tables/tab_e6.tex": "d06f84a429329af2a4f1e7831cff4cd4371a4189806fea8ba226e73890c47aee",
++  "tables/tab_e7.tex": "26125ba7860235e8ec9bc7cbf9094525ae3badfa7684b0fdeceff0c444db27bb",
++  "figures/fig_e7.pdf": "9e32e7a7c8d4fb0e1688ba282d05650b48cc53349a14aee834f4b19d5b306819"
++ },
++ "key_numbers_sha256": "4424672bebb9b3b34b9c9465c2afa92a10901aedfd967a1d7dc843855a0db242"
++}
+ \ No newline at end of file

added experiments/results/key_numbers.json +1230 −0

++{
++ "primitives": {
++  "realized_fused@1x390": {
++   "cpu1_ms": 0.0014998950064182281,
++   "cpuMT_ms": 0.0014998950064182281,
++   "metal_ms": 0.2344171516597271,
++   "speedup": 0.006398401293585508,
++   "verdict": "CPU"
++  },
++  "realized_fused@1x3900": {
++   "cpu1_ms": 0.011624768376350403,
++   "cpuMT_ms": 0.01116609200835228,
++   "metal_ms": 0.6333747878670692,
++   "speedup": 0.017629517660396336,
++   "verdict": "CPU"
++  },
++  "realized_fused@10x390": {
++   "cpu1_ms": 0.011292286217212677,
++   "cpuMT_ms": 0.14200014993548393,
++   "metal_ms": 0.2327919937670231,
++   "speedup": 0.6099872578848089,
++   "verdict": "CPU"
++  },
++  "realized_fused@1x39000": {
++   "cpu1_ms": 0.18258299678564072,
++   "cpuMT_ms": 0.1671668142080307,
++   "metal_ms": 0.206624623388052,
++   "speedup": 0.8090362681222294,
++   "verdict": "CPU"
++  },
++  "realized_fused@10x3900": {
++   "cpu1_ms": 0.18791621550917625,
++   "cpuMT_ms": 0.135000329464674,
++   "metal_ms": 0.16404176130890846,
++   "speedup": 0.8229631795433707,
++   "verdict": "CPU"
++  },
++  "realized_fused@100x390": {
++   "cpu1_ms": 0.1871250569820404,
++   "cpuMT_ms": 0.5520828999578953,
++   "metal_ms": 0.22633420303463936,
++   "speedup": 2.4392376077309077,
++   "verdict": "Metal"
++  },
++  "realized_fused@1x390000": {
++   "cpu1_ms": 2.032375428825617,
++   "cpuMT_ms": 2.0858747884631157,
++   "metal_ms": 0.9353337809443474,
++   "speedup": 2.2300860195139536,
++   "verdict": "Metal"
++  },
++  "realized_fused@10x39000": {
++   "cpu1_ms": 2.572625409811735,
++   "cpuMT_ms": 0.36349985748529434,
++   "metal_ms": 0.7184999994933605,
++   "speedup": 0.5059149029110798,
++   "verdict": "tie"
++  },
++  "realized_fused@100x3900": {
++   "cpu1_ms": 2.043417189270258,
++   "cpuMT_ms": 0.6015831604599953,
++   "metal_ms": 0.6413329392671585,
++   "speedup": 0.9380200573315559,
++   "verdict": "tie"
++  },
++  "realized_fused@1000x390": {
++   "cpu1_ms": 2.235791180282831,
++   "cpuMT_ms": 0.8399169892072678,
++   "metal_ms": 0.33845799043774605,
++   "speedup": 2.4815989367571367,
++   "verdict": "Metal"
++  },
++  "realized_fused@10x390000": {
++   "cpu1_ms": 20.89220890775323,
++   "cpuMT_ms": 2.5267917662858963,
++   "metal_ms": 1.0219174437224865,
++   "speedup": 2.4725987229278337,
++   "verdict": "Metal"
++  },
++  "realized_fused@100x39000": {
++   "cpu1_ms": 20.590624772012234,
++   "cpuMT_ms": 2.1904585883021355,
++   "metal_ms": 1.1692089028656483,
++   "speedup": 1.8734535658542084,
++   "verdict": "Metal"
++  },
++  "realized_fused@1000x3900": {
++   "cpu1_ms": 21.244540810585022,
++   "cpuMT_ms": 1.7422502860426903,
++   "metal_ms": 0.8750832639634609,
++   "speedup": 1.9909537272506195,
++   "verdict": "Metal"
++  },
++  "realized_fused@10000x390": {
++   "cpu1_ms": 21.238334011286497,
++   "cpuMT_ms": 2.125917002558708,
++   "metal_ms": 2.2132499143481255,
++   "speedup": 0.9605408719443508,
++   "verdict": "tie"
++  },
++  "realized_fused@100x390000": {
++   "cpu1_ms": 232.5868341140449,
++   "cpuMT_ms": 18.79258267581463,
++   "metal_ms": 8.720249868929386,
++   "speedup": 2.1550509398559075,
++   "verdict": "Metal"
++  },
++  "realized_fused@1000x39000": {
++   "cpu1_ms": 238.77166723832488,
++   "cpuMT_ms": 20.24729223921895,
++   "metal_ms": 5.891874898225069,
++   "speedup": 3.4364769430726474,
++   "verdict": "Metal"
++  },
++  "realized_fused@10000x3900": {
++   "cpu1_ms": 233.6724577471614,
++   "cpuMT_ms": 15.69391693919897,
++   "metal_ms": 7.8027499839663506,
++   "speedup": 2.0113315140749037,
++   "verdict": "Metal"
++  },
++  "regression_stats@1x390": {
++   "cpu1_ms": 0.0031669624149799347,
++   "cpuMT_ms": 0.0032088719308376312,
++   "metal_ms": 0.894167460501194,
++   "speedup": 0.003588669989219929,
++   "verdict": "CPU"
++  },
++  "regression_stats@1x3900": {
++   "cpu1_ms": 0.029958784580230713,
++   "cpuMT_ms": 0.030207913368940353,
++   "metal_ms": 0.3482499159872532,
++   "speedup": 0.0867420550075482,
++   "verdict": "CPU"
++  },
++  "regression_stats@10x390": {
++   "cpu1_ms": 0.031250063329935074,
++   "cpuMT_ms": 0.04133302718400955,
++   "metal_ms": 0.6523327901959419,
++   "speedup": 0.06336187265949686,
++   "verdict": "CPU"
++  },
++  "regression_stats@1x39000": {
++   "cpu1_ms": 0.30233291909098625,
++   "cpuMT_ms": 0.3838753327727318,
++   "metal_ms": 0.4085828550159931,
++   "speedup": 0.9395287346496851,
++   "verdict": "tie"
++  },
++  "regression_stats@10x3900": {
++   "cpu1_ms": 0.2997498959302902,
++   "cpuMT_ms": 0.07625017315149307,
++   "metal_ms": 0.36174990236759186,
++   "speedup": 0.2107814615911396,
++   "verdict": "CPU"
++  },
++  "regression_stats@100x390": {
++   "cpu1_ms": 0.36137504503130913,
++   "cpuMT_ms": 0.17625000327825546,
++   "metal_ms": 0.3363746218383312,
++   "speedup": 0.5239693836444206,
++   "verdict": "CPU"
++  },
++  "regression_stats@1x390000": {
++   "cpu1_ms": 2.9733749106526375,
++   "cpuMT_ms": 3.0428748577833176,
++   "metal_ms": 0.7901252247393131,
++   "speedup": 3.851129874745179,
++   "verdict": "Metal"
++  },
++  "regression_stats@10x39000": {
++   "cpu1_ms": 3.083667252212763,
++   "cpuMT_ms": 0.5624173209071159,
++   "metal_ms": 0.6961673498153687,
++   "speedup": 0.8078766133692931,
++   "verdict": "CPU"
++  },
++  "regression_stats@100x3900": {
++   "cpu1_ms": 2.9982919804751873,
++   "cpuMT_ms": 0.4399162717163563,
++   "metal_ms": 0.5946666933596134,
++   "speedup": 0.739769482011876,
++   "verdict": "CPU"
++  },
++  "regression_stats@1000x390": {
++   "cpu1_ms": 3.1211250461637974,
++   "cpuMT_ms": 0.6971252150833607,
++   "metal_ms": 0.5814996547996998,
++   "speedup": 1.1988402904959397,
++   "verdict": "tie"
++  },
++  "regression_stats@10x390000": {
++   "cpu1_ms": 32.662583980709314,
++   "cpuMT_ms": 6.654791999608278,
++   "metal_ms": 4.117042291909456,
++   "speedup": 1.6164011753500427,
++   "verdict": "Metal"
++  },
++  "regression_stats@100x39000": {
++   "cpu1_ms": 32.19050029292703,
++   "cpuMT_ms": 3.1737093813717365,
++   "metal_ms": 4.4694580137729645,
++   "speedup": 0.7100881967325159,
++   "verdict": "tie"
++  },
++  "regression_stats@1000x3900": {
++   "cpu1_ms": 34.39616598188877,
++   "cpuMT_ms": 3.421790897846222,
++   "metal_ms": 3.796167206019163,
++   "speedup": 0.9013804482638873,
++   "verdict": "tie"
++  },
++  "regression_stats@10000x390": {
++   "cpu1_ms": 30.644499696791172,
++   "cpuMT_ms": 3.9592497050762177,
++   "metal_ms": 4.190749954432249,
++   "speedup": 0.944759231194123,
++   "verdict": "tie"
++  },
++  "regression_stats@100x390000": {
++   "cpu1_ms": 301.3692502863705,
++   "cpuMT_ms": 33.760249614715576,
++   "metal_ms": 30.70899983868003,
++   "speedup": 1.0993601156685116,
++   "verdict": "Metal"
++  },
++  "regression_stats@1000x39000": {
++   "cpu1_ms": 324.0363751538098,
++   "cpuMT_ms": 31.240916810929775,
++   "metal_ms": 26.743208058178425,
++   "speedup": 1.1681813469411308,
++   "verdict": "Metal"
++  },
++  "regression_stats@10000x3900": {
++   "cpu1_ms": 356.9141672924161,
++   "cpuMT_ms": 37.49012481421232,
++   "metal_ms": 26.574499905109406,
++   "speedup": 1.4107556096287706,
++   "verdict": "Metal"
++  },
++  "rolling_sumsq@1x390": {
++   "cpu1_ms": 0.0009578652679920197,
++   "cpuMT_ms": 0.0007920898497104645,
++   "metal_ms": 0.2839169465005398,
++   "speedup": 0.0027898646399008046,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@1x3900": {
++   "cpu1_ms": 0.0074999406933784485,
++   "cpuMT_ms": 0.0074999406933784485,
++   "metal_ms": 0.2416251227259636,
++   "speedup": 0.031039573239594054,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@10x390": {
++   "cpu1_ms": 0.0071660615503787994,
++   "cpuMT_ms": 0.01800013706088066,
++   "metal_ms": 0.2032076008617878,
++   "speedup": 0.08858003826895974,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@1x39000": {
++   "cpu1_ms": 0.0693327747285366,
++   "cpuMT_ms": 0.07025012746453285,
++   "metal_ms": 0.16458332538604736,
++   "speedup": 0.42683623811679494,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@10x3900": {
++   "cpu1_ms": 0.06929086521267891,
++   "cpuMT_ms": 0.04487484693527222,
++   "metal_ms": 0.16070762649178505,
++   "speedup": 0.2792328398774908,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@100x390": {
++   "cpu1_ms": 0.06991717964410782,
++   "cpuMT_ms": 0.17983326688408852,
++   "metal_ms": 0.2676667645573616,
++   "speedup": 0.6718550477549103,
++   "verdict": "tie"
++  },
++  "rolling_sumsq@1x390000": {
++   "cpu1_ms": 0.6914162077009678,
++   "cpuMT_ms": 0.718916766345501,
++   "metal_ms": 0.7903752848505974,
++   "speedup": 0.909589128259996,
++   "verdict": "tie"
++  },
++  "rolling_sumsq@10x39000": {
++   "cpu1_ms": 0.7095411419868469,
++   "cpuMT_ms": 0.132707878947258,
++   "metal_ms": 0.7357923313975334,
++   "speedup": 0.18036050837224432,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@100x3900": {
++   "cpu1_ms": 0.806666910648346,
++   "cpuMT_ms": 0.20312517881393433,
++   "metal_ms": 0.6820829585194588,
++   "speedup": 0.2978012810272249,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@1000x390": {
++   "cpu1_ms": 0.7188748568296432,
++   "cpuMT_ms": 0.2710837870836258,
++   "metal_ms": 0.9075421839952469,
++   "speedup": 0.29870103215504695,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@10x390000": {
++   "cpu1_ms": 6.913874763995409,
++   "cpuMT_ms": 1.7658751457929611,
++   "metal_ms": 2.544207964092493,
++   "speedup": 0.6940765734230536,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@100x39000": {
++   "cpu1_ms": 7.338124793022871,
++   "cpuMT_ms": 1.0874588042497635,
++   "metal_ms": 2.226833254098892,
++   "speedup": 0.4883431672524638,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@1000x3900": {
++   "cpu1_ms": 6.95441709831357,
++   "cpuMT_ms": 1.0273326188325882,
++   "metal_ms": 2.144791651517153,
++   "speedup": 0.47898947112456725,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@10000x390": {
++   "cpu1_ms": 7.047916762530804,
++   "cpuMT_ms": 1.07216602191329,
++   "metal_ms": 2.1627498790621758,
++   "speedup": 0.49574203299838304,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@100x390000": {
++   "cpu1_ms": 69.62170917540789,
++   "cpuMT_ms": 9.413291700184345,
++   "metal_ms": 14.852333813905716,
++   "speedup": 0.6337920907333103,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@1000x39000": {
++   "cpu1_ms": 70.26320835575461,
++   "cpuMT_ms": 8.31229193136096,
++   "metal_ms": 14.728832989931107,
++   "speedup": 0.5643550943271196,
++   "verdict": "CPU"
++  },
++  "rolling_sumsq@10000x3900": {
++   "cpu1_ms": 69.22604190185666,
++   "cpuMT_ms": 6.54304213821888,
++   "metal_ms": 14.753291849046946,
++   "speedup": 0.4434970991671636,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@1x390": {
++   "cpu1_ms": 0.0017909333109855652,
++   "cpuMT_ms": 0.0017499551177024841,
++   "metal_ms": 0.9180000051856041,
++   "speedup": 0.0019062691806288963,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@1x3900": {
++   "cpu1_ms": 0.016250181943178177,
++   "cpuMT_ms": 0.01695798709988594,
++   "metal_ms": 1.348957885056734,
++   "speedup": 0.012571176081729732,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@10x390": {
++   "cpu1_ms": 0.021916814148426056,
++   "cpuMT_ms": 0.02929195761680603,
++   "metal_ms": 0.3432091325521469,
++   "speedup": 0.08534725576498299,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@10x3900": {
++   "cpu1_ms": 0.2155420370399952,
++   "cpuMT_ms": 0.06916606798768044,
++   "metal_ms": 1.4300826005637646,
++   "speedup": 0.04836508601699924,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@100x390": {
++   "cpu1_ms": 0.1916671171784401,
++   "cpuMT_ms": 0.16116676852107048,
++   "metal_ms": 0.6238752976059914,
++   "speedup": 0.2583317036906555,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@100x3900": {
++   "cpu1_ms": 1.6154590994119644,
++   "cpuMT_ms": 0.20695803686976433,
++   "metal_ms": 1.6493331640958786,
++   "speedup": 0.12547982504384633,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@1000x390": {
++   "cpu1_ms": 1.6390001401305199,
++   "cpuMT_ms": 0.2765827812254429,
++   "metal_ms": 1.1531668715178967,
++   "speedup": 0.23984627728802252,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@1000x3900": {
++   "cpu1_ms": 18.310166895389557,
++   "cpuMT_ms": 1.4978330582380295,
++   "metal_ms": 7.2068748995661736,
++   "speedup": 0.20783391957146272,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@10000x390": {
++   "cpu1_ms": 17.741417046636343,
++   "cpuMT_ms": 2.2433330304920673,
++   "metal_ms": 6.75466563552618,
++   "speedup": 0.33211607376881125,
++   "verdict": "CPU"
++  },
++  "garch_nll_P1@10000x3900": {
++   "cpu1_ms": 162.26391727104783,
++   "cpuMT_ms": 13.83341709151864,
++   "metal_ms": 61.06641702353954,
++   "speedup": 0.22653068193252948,
++   "verdict": "CPU"
++  },
++  "garch_nll_P64@1x390": {
++   "cpu1_ms": 0.08287513628602028,
++   "cpuMT_ms": 0.17224997282028198,
++   "metal_ms": 0.5012080073356628,
++   "speedup": 0.3436696347608925,
++   "verdict": "CPU"
++  },
++  "garch_nll_P64@1x3900": {
++   "cpu1_ms": 0.8078329265117645,
++   "cpuMT_ms": 0.14187488704919815,
++   "metal_ms": 1.4235423877835274,
++   "speedup": 0.09966326838366861,
++   "verdict": "CPU"
++  },
++  "garch_nll_P64@10x390": {
++   "cpu1_ms": 0.8257082663476467,
++   "cpuMT_ms": 0.2438751980662346,
++   "metal_ms": 1.0179998353123665,
++   "speedup": 0.23956310168891443,
++   "verdict": "CPU"
++  },
++  "garch_nll_P64@10x3900": {
++   "cpu1_ms": 8.083874825388193,
++   "cpuMT_ms": 0.775500200688839,
++   "metal_ms": 1.3822498731315136,
++   "speedup": 0.5610419763916696,
++   "verdict": "CPU"
++  },
++  "garch_nll_P64@100x390": {
++   "cpu1_ms": 8.346542250365019,
++   "cpuMT_ms": 1.005750149488449,
++   "metal_ms": 0.5332920700311661,
++   "speedup": 1.8859274420294159,
++   "verdict": "Metal"
++  },
++  "garch_nll_P64@100x3900": {
++   "cpu1_ms": 80.1338329911232,
++   "cpuMT_ms": 6.173874717205763,
++   "metal_ms": 2.1704169921576977,
++   "speedup": 2.84455693975565,
++   "verdict": "Metal"
++  },
++  "garch_nll_P64@1000x390": {
++   "cpu1_ms": 96.79854195564985,
++   "cpuMT_ms": 8.48708301782608,
++   "metal_ms": 2.336665987968445,
++   "speedup": 3.632133587567199,
++   "verdict": "Metal"
++  },
++  "garch_nll_P64@1000x3900": {
++   "cpu1_ms": 856.1791670508683,
++   "cpuMT_ms": 81.50566695258021,
++   "metal_ms": 10.272707790136337,
++   "speedup": 7.934195016316967,
++   "verdict": "Metal"
++  }
++ },
++ "breakeven": {
++  "realized_fused": {
++   "smallest_metal_win": 39000,
++   "largest_cpu_win": 39000,
++   "max_speedup": 3.4364769430726474,
++   "min_speedup": 0.006398401293585508
++  },
++  "regression_stats": {
++   "smallest_metal_win": 390000,
++   "largest_cpu_win": 390000,
++   "max_speedup": 3.851129874745179,
++   "min_speedup": 0.003588669989219929
++  },
++  "rolling_sumsq": {
++   "smallest_metal_win": null,
++   "largest_cpu_win": 39000000,
++   "max_speedup": 0.909589128259996,
++   "min_speedup": 0.0027898646399008046
++  },
++  "garch_nll_P1": {
++   "smallest_metal_win": null,
++   "largest_cpu_win": 39000000,
++   "max_speedup": 0.33211607376881125,
++   "min_speedup": 0.0019062691806288963
++  },
++  "garch_nll_P64": {
++   "smallest_metal_win": 39000,
++   "largest_cpu_win": 39000,
++   "max_speedup": 7.934195016316967,
++   "min_speedup": 0.09966326838366861
++  }
++ },
++ "E1": {
++  "real_S1_day": {
++   "elements": 88350,
++   "cpu1_ms": 0.7735420949757099,
++   "cpuMT_ms": 0.9354581125080585,
++   "metal_ms": 0.9417501278221607,
++   "metal_unfused_ms": 2.271167002618313,
++   "speedup_MT": 0.993318805988747,
++   "fusion_gain": 2.4116450165719523,
++   "max_rel_err": 3.216772293576152e-08,
++   "metal_wins": false,
++   "cpu_wins": false
++  },
++  "real_S1_week": {
++   "elements": 87732,
++   "cpu1_ms": 0.8084997534751892,
++   "cpuMT_ms": 0.9053335525095463,
++   "metal_ms": 0.7747076451778412,
++   "metal_unfused_ms": 1.9873343408107758,
++   "speedup_MT": 1.1686131641333148,
++   "fusion_gain": 2.5652700772748473,
++   "max_rel_err": 1.5355137638729577e-08,
++   "metal_wins": true,
++   "cpu_wins": false
++  },
++  "real_S1_month": {
++   "elements": 85202,
++   "cpu1_ms": 0.5944999866187572,
++   "cpuMT_ms": 0.263875350356102,
++   "metal_ms": 0.32645929604768753,
++   "metal_unfused_ms": 1.0339580476284027,
++   "speedup_MT": 0.8082947967809022,
++   "fusion_gain": 3.167188253317091,
++   "max_rel_err": 5.502644725750323e-09,
++   "metal_wins": false,
++   "cpu_wins": true
++  },
++  "real_S1_year": {
++   "elements": 88350,
++   "cpu1_ms": 0.8845417760312557,
++   "cpuMT_ms": 0.7403329946100712,
++   "metal_ms": 0.5079996772110462,
++   "metal_unfused_ms": 1.289083156734705,
++   "speedup_MT": 1.4573493406030318,
++   "fusion_gain": 2.537566881561543,
++   "max_rel_err": 1.1553520565395228e-09,
++   "metal_wins": true,
++   "cpu_wins": false
++  },
++  "real_S10_day": {
++   "elements": 660818,
++   "cpu1_ms": 4.591624718159437,
++   "cpuMT_ms": 1.333874650299549,
++   "metal_ms": 1.396208070218563,
++   "metal_unfused_ms": 1.9492078572511673,
++   "speedup_MT": 0.9553552072584308,
++   "fusion_gain": 1.3960726189944148,
++   "max_rel_err": 1.1707127776091667e-07,
++   "metal_wins": false,
++   "cpu_wins": false
++  },
++  "real_S10_week": {
++   "elements": 655478,
++   "cpu1_ms": 4.3206666596233845,
++   "cpuMT_ms": 1.0201670229434967,
++   "metal_ms": 0.8149999193847179,
++   "metal_unfused_ms": 1.9696662202477455,
++   "speedup_MT": 1.2517388022733416,
++   "fusion_gain": 2.416768607455495,
++   "max_rel_err": 4.3164647273400464e-08,
++   "metal_wins": false,
++   "cpu_wins": false
++  },
++  "real_S10_month": {
++   "elements": 634608,
++   "cpu1_ms": 4.162374883890152,
++   "cpuMT_ms": 0.9038751013576984,
++   "metal_ms": 1.0571670718491077,
++   "metal_unfused_ms": 1.4940421096980572,
++   "speedup_MT": 0.8549974033685291,
++   "fusion_gain": 1.413250705098868,
++   "max_rel_err": 1.5374929954074983e-08,
++   "metal_wins": false,
++   "cpu_wins": false
++  },
++  "real_S10_year": {
++   "elements": 660818,
++   "cpu1_ms": 4.490583203732967,
++   "cpuMT_ms": 1.3055838644504547,
++   "metal_ms": 1.4134589582681656,
++   "metal_unfused_ms": 2.377707976847887,
++   "speedup_MT": 0.9236800664167254,
++   "fusion_gain": 1.6821910271531078,
++   "max_rel_err": 3.180737515032068e-09,
++   "metal_wins": false,
++   "cpu_wins": false
++  },
++  "real_S100_day": {
++   "elements": 4857139,
++   "cpu1_ms": 29.412207659333944,
++   "cpuMT_ms": 3.8021672517061234,
++   "metal_ms": 4.112166818231344,
++   "metal_unfused_ms": 7.726917043328285,
++   "speedup_MT": 0.9246140586634681,
++   "fusion_gain": 1.8790378369551788,
++   "max_rel_err": 1.463952514147405e-07,
++   "metal_wins": false,
++   "cpu_wins": false
++  },
++  "real_S100_week": {
++   "elements": 4814500,
++   "cpu1_ms": 28.37820863351226,
++   "cpuMT_ms": 3.745041787624359,
++   "metal_ms": 3.630833700299263,
++   "metal_unfused_ms": 6.0623749159276485,
++   "speedup_MT": 1.031455058741931,
++   "fusion_gain": 1.6696922570229453,
++   "max_rel_err": 1.3949921298073233e-07,
++   "metal_wins": false,
++   "cpu_wins": false
++  },
++  "real_S100_month": {
++   "elements": 4656568,
++   "cpu1_ms": 27.86025032401085,
++   "cpuMT_ms": 3.613583743572235,
++   "metal_ms": 3.4282919950783253,
++   "metal_unfused_ms": 5.321166943758726,
++   "speedup_MT": 1.054047831619919,
++   "fusion_gain": 1.552133526373431,
++   "max_rel_err": 6.515494931810648e-08,
++   "metal_wins": true,
++   "cpu_wins": false
++  },
++  "real_S100_year": {
++   "elements": 4817403,
++   "cpu1_ms": 29.63858423754573,
++   "cpuMT_ms": 3.890958148986101,
++   "metal_ms": 3.2545411959290504,
++   "metal_unfused_ms": 5.527874920517206,
++   "speedup_MT": 1.1955473643575671,
++   "fusion_gain": 1.6985112763150025,
++   "max_rel_err": 1.220912079679724e-08,
++   "metal_wins": true,
++   "cpu_wins": false
++  },
++  "real_S926_day": {
++   "elements": 40408948,
++   "cpu1_ms": 240.89466594159603,
++   "cpuMT_ms": 29.765665996819735,
++   "metal_ms": 27.769084088504314,
++   "metal_unfused_ms": 51.85075011104345,
++   "speedup_MT": 1.0718994512729338,
++   "fusion_gain": 1.8672113904004608,
++   "max_rel_err": 1.6198392060671777e-07,
++   "metal_wins": false,
++   "cpu_wins": false
++  },
++  "real_S926_week": {
++   "elements": 40062893,
++   "cpu1_ms": 235.06820807233453,
++   "cpuMT_ms": 29.190624598413706,
++   "metal_ms": 24.931750260293484,
++   "metal_unfused_ms": 44.04070833697915,
++   "speedup_MT": 1.1708213139332997,
++   "fusion_gain": 1.7664507255681425,
++   "max_rel_err": 1.3949921298073233e-07,
++   "metal_wins": true,
++   "cpu_wins": false
++  },
++  "real_S926_month": {
++   "elements": 38769255,
++   "cpu1_ms": 231.19533294811845,
++   "cpuMT_ms": 28.66779128089547,
++   "metal_ms": 20.429750438779593,
++   "metal_unfused_ms": 38.208582904189825,
++   "speedup_MT": 1.4032374681620434,
++   "fusion_gain": 1.8702422733301036,
++   "max_rel_err": 6.515494931810648e-08,
++   "metal_wins": true,
++   "cpu_wins": false
++  },
++  "real_S926_year": {
++   "elements": 39917613,
++   "cpu1_ms": 241.63200007751584,
++   "cpuMT_ms": 28.705624863505363,
++   "metal_ms": 20.413792226463556,
++   "metal_unfused_ms": 39.6507503464818,
++   "speedup_MT": 1.406187764872645,
++   "fusion_gain": 1.9423510294711575,
++   "max_rel_err": 1.4314531656643865e-08,
++   "metal_wins": true,
++   "cpu_wins": false
++  },
++  "synthetic_S10000_day": {
++   "elements": 3900000,
++   "cpu1_ms": 21.742417011409998,
++   "cpuMT_ms": 2.6805000379681587,
++   "metal_ms": 3.3537917770445347,
++   "metal_unfused_ms": null,
++   "speedup_MT": 0.7992446210629983,
++   "fusion_gain": null,
++   "max_rel_err": 4.9499305589440414e-08,
++   "metal_wins": false,
++   "cpu_wins": true
++  },
++  "synthetic_S10000_week": {
++   "elements": 19500000,
++   "cpu1_ms": 106.63599986582994,
++   "cpuMT_ms": 12.074083089828491,
++   "metal_ms": 9.116541128605604,
++   "metal_unfused_ms": null,
++   "speedup_MT": 1.3244149200339592,
++   "fusion_gain": null,
++   "max_rel_err": 3.356929504238224e-08,
++   "metal_wins": true,
++   "cpu_wins": false
++  },
++  "synthetic_S10000_month": {
++   "elements": 85800000,
++   "cpu1_ms": 483.16720919683576,
++   "cpuMT_ms": 54.07591676339507,
++   "metal_ms": 35.40699975565076,
++   "metal_unfused_ms": null,
++   "speedup_MT": 1.5272662788878308,
++   "fusion_gain": null,
++   "max_rel_err": 2.7721528772327113e-08,
++   "metal_wins": true,
++   "cpu_wins": false
++  }
++ },
++ "E2": {
++  "accuracy": {
++   "h1": {
++    "n": 100,
++    "har": 0.19596646955954006,
++    "loghar": 0.20549043426692812,
++    "harq": 0.20287854864925106,
++    "rw": 0.2509836820568328,
++    "har_beats_rw_pct": 84.0,
++    "fits_per_symbol": 132.0
++   },
++   "h5": {
++    "n": 100,
++    "har": 0.14599330475845337,
++    "loghar": 0.13780663128811915,
++    "harq": 0.15032513333481387,
++    "rw": 0.2392329633290453,
++    "har_beats_rw_pct": 86.0,
++    "fits_per_symbol": 128.0
++   },
++   "h22": {
++    "n": 100,
++    "har": 0.13380122970874658,
++    "loghar": 0.11202433356845258,
++    "harq": 0.1317067007400809,
++    "rw": 0.30092923731362164,
++    "har_beats_rw_pct": 78.0,
++    "fits_per_symbol": 111.0
++   }
++  },
++  "runtime": {
++   "10": {
++    "per_series_cpu1": 0.07679173722863197,
++    "per_series_cpuMT": 0.053416937589645386,
++    "batched_cpu": 0.10233419016003609,
++    "batched_metal": 0.3199586644768715,
++    "T": 252
++   },
++   "100": {
++    "per_series_cpu1": 0.7653338834643364,
++    "per_series_cpuMT": 0.14466699212789536,
++    "batched_cpu": 0.6509590893983841,
++    "batched_metal": 0.7528341375291348,
++    "T": 252
++   },
++   "781": {
++    "per_series_cpu1": 6.033665966242552,
++    "per_series_cpuMT": 0.6839591078460217,
++    "batched_cpu": 3.8614580407738686,
++    "batched_metal": 4.703125450760126,
++    "T": 251
++   }
++  }
++ },
++ "E3": {
++  "symbols": 888,
++  "daily_history": 845,
++  "garch.n": {
++   "n": 888,
++   "converged_pct": 100.0,
++   "median_iter": 14.0,
++   "median_ms": 2.8645414859056473,
++   "median_persistence": 0.962240963021934,
++   "qlike": 0.4032196350815048,
++   "qlike_rw": 0.27550123596742626,
++   "n_train": 2458.5,
++   "n_eval": 888
++  },
++  "gjr.n": {
++   "n": 888,
++   "converged_pct": 98.42342342342343,
++   "median_iter": 18.0,
++   "median_ms": 3.9954171516001225,
++   "median_persistence": 0.9710634836054904,
++   "qlike": 0.39931764172261175,
++   "qlike_rw": 0.2734243088287934,
++   "n_train": 2458.5,
++   "n_eval": 874
++  },
++  "egarch.n": {
++   "n": 888,
++   "converged_pct": 92.7927927927928,
++   "median_iter": 17.0,
++   "median_ms": 18.152124946936965,
++   "median_persistence": 0.9561998303082433,
++   "qlike": 0.39635306701502293,
++   "qlike_rw": 0.27241123059255185,
++   "n_train": 2458.5,
++   "n_eval": 824
++  },
++  "garch.t": {
++   "n": 888,
++   "converged_pct": 100.0,
++   "median_iter": 18.0,
++   "median_ms": 6.74610398709774,
++   "median_persistence": 0.9727760170446753,
++   "qlike": 0.3908846216118549,
++   "qlike_rw": 0.27550123596742626,
++   "n_train": 2458.5,
++   "n_eval": 888
++  },
++  "grid": {
++   "S": 888,
++   "P": 256,
++   "cpuMT_ms": 117.02079232782125,
++   "metal_ms": 22.934832610189915,
++   "max_rel_err_nll": 0.001696265571243037,
++   "argmin_agreement": 888,
++   "argmin_total": 888
++  }
++ },
++ "E4": {
++  "10": {
++   "days_ok": 182,
++   "days_skipped": 70,
++   "cond_median": 80.51310121584409,
++   "cond_max": 1114.4148164242238,
++   "lw": 0.15825066990879552,
++   "dy_windows": 133,
++   "dy_total": 37.15801851010236,
++   "dy_ms": 0.5304999649524689,
++   "dy_failures": 0
++  },
++  "30": {
++   "days_ok": 129,
++   "days_skipped": 123,
++   "cond_median": 421.7546397917854,
++   "cond_max": 1982.0116043100866,
++   "lw": 0.26298332837244776,
++   "dy_windows": 133,
++   "dy_total": 69.67433187119195,
++   "dy_ms": 2.2807088680565357,
++   "dy_failures": 0
++  },
++  "60": {
++   "days_ok": 95,
++   "days_skipped": 157,
++   "cond_median": 5918.2160036330415,
++   "cond_max": 4.004356648938842e+297,
++   "lw": 0.3264154734521777,
++   "dy_windows": 133,
++   "dy_total": 87.50466794156553,
++   "dy_ms": 8.867499884217978,
++   "dy_failures": 0
++  },
++  "100": {
++   "days_ok": 88,
++   "days_skipped": 164,
++   "cond_median": 1.3073204915206876e+298,
++   "cond_max": 4.628848885035562e+298,
++   "lw": 0.3323406895220246,
++   "dy_windows": 133,
++   "dy_total": 97.24027926801519,
++   "dy_ms": 28.755417093634605,
++   "dy_failures": 0
++  }
++ },
++ "E5": {
++  "garch_n500": {
++   "mu": {
++    "bias": -0.00048301580401779385,
++    "coverage95": 0.95,
++    "rmse": 0.03830937699585465
++   },
++   "omega": {
++    "bias": 0.020140386483790382,
++    "coverage95": 0.954,
++    "rmse": 0.04874063710909834
++   },
++   "alpha": {
++    "bias": 0.0021013443234158386,
++    "coverage95": 0.896,
++    "rmse": 0.030365422987920495
++   },
++   "beta": {
++    "bias": -0.025611816484074457,
++    "coverage95": 0.916,
++    "rmse": 0.07085785700063447
++   },
++   "converged": 1000,
++   "R": 1000
++  },
++  "garch_n2000": {
++   "mu": {
++    "bias": 0.0001115840803594372,
++    "coverage95": 0.961,
++    "rmse": 0.018994072598395778
++   },
++   "omega": {
++    "bias": 0.0034273370897326973,
++    "coverage95": 0.972,
++    "rmse": 0.009288147787445019
++   },
++   "alpha": {
++    "bias": 0.0007353540065208454,
++    "coverage95": 0.932,
++    "rmse": 0.013671869751518313
++   },
++   "beta": {
++    "bias": -0.004814929382042228,
++    "coverage95": 0.936,
++    "rmse": 0.019568746480840227
++   },
++   "converged": 1000,
++   "R": 1000
++  },
++  "har_h1": [
++   0.945,
++   0.939,
++   0.946,
++   0.941
++  ],
++  "har_h5": [
++   0.909,
++   0.936,
++   0.931,
++   0.9
++  ],
++  "repro_bootstrap": {
++   "bitwise_identical_across_threads": true,
++   "replicas": 2000,
++   "threads": [
++    1,
++    4,
++    18
++   ]
++  },
++  "repro_realized": {
++   "cpu_threads_vs_1_identical": true,
++   "metal_backend_used": "metal",
++   "metal_runs_identical": true,
++   "metal_vs_cpu_max_rel_rv": 3.6599268443269906e-08
++  }
++ },
++ "E6": {
++  "bars_per_file": 2367760.5,
++  "read_s": 0.06473202048800886,
++  "prep_s": 0.02098981267772615,
++  "est_cpu_s": 0.03066229191608727,
++  "est_metal_s": 0.03653329168446362,
++  "RAID cpu": {
++   "median_s": 0.1182449993211776,
++   "ci": [
++    0.09712429158389568,
++    0.12820672919042408
++   ],
++   "bars_per_s": 20024191.412684422
++  },
++  "RAID metal": {
++   "median_s": 0.12477712496183813,
++   "ci": [
++    0.10097172926180065,
++    0.134304832899943
++   ],
++   "bars_per_s": 18975918.067707974
++  },
++  "polars": {
++   "median_s": 0.16476131248055026,
++   "ci": [
++    0.14585839601932094,
++    0.17225766699993983
++   ],
++   "bars_per_s": 14370852.38247
++  },
++  "duckdb": {
++   "median_s": 0.1637031040736474,
++   "ci": [
++    0.15818560402840376,
++    0.16537331248400733
++   ],
++   "bars_per_s": 14463748.341233544
++  },
++  "pandas": {
++   "median_s": 2.5584507705061696,
++   "ci": [
++    2.355445542023517,
++    2.6337175624794327
++   ],
++   "bars_per_s": 925466.5078161957
++  }
++ },
++ "E7": {
++  "m2m8a": {
++   "chip": "Apple M2",
++   "gpu_cores": 10,
++   "cpu_threads": "8",
++   "mem_gb": 8,
++   "macos": "26.5.1",
++   "cold_compile_s": 0.109846416,
++   "warm_compile_s": 0.000537584,
++   "realized_fused@1000x3900_speedup_MT": 3.990399191000979,
++   "regression_stats@1000x3900_speedup_MT": 1.6134322509601442,
++   "garch_nll_P64@1000x390_speedup_MT": 6.670422238065105,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.6518314749487951,
++   "realized_fused@1000x3900_cpuMT_ms": 5.524458014406264,
++   "realized_fused@1000x3900_metal_ms": 1.3844374334439635,
++   "tests": "pass / pass"
++  },
++  "M2M32c": {
++   "chip": "Apple M2 Max",
++   "gpu_cores": 30,
++   "cpu_threads": "12",
++   "mem_gb": 32,
++   "macos": "26.5.1",
++   "cold_compile_s": 0.048325125,
++   "warm_compile_s": 0.000524916,
++   "realized_fused@1000x3900_speedup_MT": 3.6053646941003636,
++   "regression_stats@1000x3900_speedup_MT": 1.35476806903387,
++   "garch_nll_P64@1000x390_speedup_MT": 7.836957668549106,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.5173055981132895,
++   "realized_fused@1000x3900_cpuMT_ms": 3.611000021919608,
++   "realized_fused@1000x3900_metal_ms": 1.0015630396082997,
++   "tests": "pass / pass"
++  },
++  "M2U64": {
++   "chip": "Apple M2 Ultra",
++   "gpu_cores": 60,
++   "cpu_threads": "24",
++   "mem_gb": 64,
++   "macos": "26.5",
++   "cold_compile_s": 0.049152792,
++   "warm_compile_s": 0.000613,
++   "realized_fused@1000x3900_speedup_MT": 2.1845461259882226,
++   "regression_stats@1000x3900_speedup_MT": 1.0830287027429175,
++   "garch_nll_P64@1000x390_speedup_MT": 4.924931422444954,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.32161785435813445,
++   "realized_fused@1000x3900_cpuMT_ms": 2.279437379911542,
++   "realized_fused@1000x3900_metal_ms": 1.0434375144541264,
++   "tests": "pass / pass"
++  },
++  "M3BA24": {
++   "chip": "Apple M3",
++   "gpu_cores": 10,
++   "cpu_threads": "8",
++   "mem_gb": 24,
++   "macos": "26.5.1",
++   "cold_compile_s": 0.043905667,
++   "warm_compile_s": 0.000421292,
++   "realized_fused@1000x3900_speedup_MT": 2.687471016852494,
++   "regression_stats@1000x3900_speedup_MT": 1.6792771365359433,
++   "garch_nll_P64@1000x390_speedup_MT": 6.207505979251421,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.3554353915980856,
++   "realized_fused@1000x3900_cpuMT_ms": 4.603916313499212,
++   "realized_fused@1000x3900_metal_ms": 1.7131036147475243,
++   "tests": "pass / pass"
++  },
++  "M3U96b": {
++   "chip": "Apple M3 Ultra",
++   "gpu_cores": 60,
++   "cpu_threads": "28",
++   "mem_gb": 96,
++   "macos": "26.4",
++   "cold_compile_s": 0.047089167,
++   "warm_compile_s": 0.000531084,
++   "realized_fused@1000x3900_speedup_MT": 1.6817560971796317,
++   "regression_stats@1000x3900_speedup_MT": 0.7767583073146588,
++   "garch_nll_P64@1000x390_speedup_MT": 3.179140922934574,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.24312350847240793,
++   "realized_fused@1000x3900_cpuMT_ms": 2.304041408933699,
++   "realized_fused@1000x3900_metal_ms": 1.370021142065525,
++   "tests": "pass / pass"
++  },
++  "m4md": {
++   "chip": "Apple M4",
++   "gpu_cores": 10,
++   "cpu_threads": "10",
++   "mem_gb": 16,
++   "macos": "26.6.2",
++   "cold_compile_s": 0.042053541,
++   "warm_compile_s": 0.000386541,
++   "realized_fused@1000x3900_speedup_MT": 2.548863991558486,
++   "regression_stats@1000x3900_speedup_MT": 1.338401514661036,
++   "garch_nll_P64@1000x390_speedup_MT": 4.206244849053445,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.37666800739402895,
++   "realized_fused@1000x3900_cpuMT_ms": 3.558958414942026,
++   "realized_fused@1000x3900_metal_ms": 1.3962920056656003,
++   "tests": "pass / pass"
++  },
++  "m4mm": {
++   "chip": "Apple M4 Pro",
++   "gpu_cores": 16,
++   "cpu_threads": "12",
++   "mem_gb": 48,
++   "macos": "26.5.1",
++   "cold_compile_s": 0.038549083,
++   "warm_compile_s": 0.000449708,
++   "realized_fused@1000x3900_speedup_MT": 1.6260083182113196,
++   "regression_stats@1000x3900_speedup_MT": 0.91166043986465,
++   "garch_nll_P64@1000x390_speedup_MT": 2.1391683174192333,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.23880014056164212,
++   "realized_fused@1000x3900_cpuMT_ms": 2.68670788500458,
++   "realized_fused@1000x3900_metal_ms": 1.6523334197700024,
++   "tests": "pass / pass"
++  },
++  "M4M64c": {
++   "chip": "Apple M4 Max",
++   "gpu_cores": 40,
++   "cpu_threads": "16",
++   "mem_gb": 64,
++   "macos": "26.4",
++   "cold_compile_s": 0.040168875,
++   "warm_compile_s": 0.0004675,
++   "realized_fused@1000x3900_speedup_MT": 2.79582771769825,
++   "regression_stats@1000x3900_speedup_MT": 1.1902389066688093,
++   "garch_nll_P64@1000x390_speedup_MT": 4.8188331984067,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.4781437102048132,
++   "realized_fused@1000x3900_cpuMT_ms": 2.066000597551465,
++   "realized_fused@1000x3900_metal_ms": 0.7389584789052606,
++   "tests": "pass / pass"
++  },
++  "m5ma": {
++   "chip": "Apple M5 Pro",
++   "gpu_cores": 16,
++   "cpu_threads": "15",
++   "mem_gb": 24,
++   "macos": "27.0",
++   "cold_compile_s": 0.043711542,
++   "warm_compile_s": 0.000386292,
++   "realized_fused@1000x3900_speedup_MT": 1.1284910996519257,
++   "regression_stats@1000x3900_speedup_MT": 0.5487957656812417,
++   "garch_nll_P64@1000x390_speedup_MT": 1.8287923928070076,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.19530880040350074,
++   "realized_fused@1000x3900_cpuMT_ms": 2.040499937720597,
++   "realized_fused@1000x3900_metal_ms": 1.8081666203215718,
++   "tests": "pass / pass"
++  },
++  "M5M36": {
++   "chip": "Apple M5 Max",
++   "gpu_cores": 32,
++   "cpu_threads": "18",
++   "mem_gb": 36,
++   "macos": "27.0",
++   "cold_compile_s": 0.037059042,
++   "warm_compile_s": 0.000456708,
++   "realized_fused@1000x3900_speedup_MT": 1.1217974525711423,
++   "regression_stats@1000x3900_speedup_MT": 0.6015969625826116,
++   "garch_nll_P64@1000x390_speedup_MT": 2.1447918847693943,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.22944356711535452,
++   "realized_fused@1000x3900_cpuMT_ms": 1.6108546406030655,
++   "realized_fused@1000x3900_metal_ms": 1.4359585475176573,
++   "tests": "pass / pass"
++  },
++  "m6ma": {
++   "chip": "Apple M6",
++   "gpu_cores": 12,
++   "cpu_threads": "12",
++   "mem_gb": 24,
++   "macos": "27.0",
++   "cold_compile_s": 0.039953334,
++   "warm_compile_s": 0.000306458,
++   "realized_fused@1000x3900_speedup_MT": 1.6330551240965197,
++   "regression_stats@1000x3900_speedup_MT": 0.7851066834472289,
++   "garch_nll_P64@1000x390_speedup_MT": 3.7206830701585027,
++   "rolling_sumsq@1000x3900_speedup_MT": 0.34461349554716936,
++   "realized_fused@1000x3900_cpuMT_ms": 2.4681249633431435,
++   "realized_fused@1000x3900_metal_ms": 1.5113543486222625,
++   "tests": "pass / pass"
++  }
++ },
++ "laptop": {
++  "chip": "Apple M5 Max",
++  "os": "27.0",
++  "xcode": "Xcode 27.2 Build version 27B52",
++  "clang": "Apple clang version 21.0.0 (clang-2100.4.1.1)",
++  "cmake": "cmake version 4.3.2",
++  "metal_toolchain": "Apple metal version 32023.922 (metalfe-32023.922.4)",
++  "brew": {
++   "eigen": "eigen 5.0.1",
++   "apache-arrow": "apache-arrow 26.0.0_3",
++   "catch2": "catch2 3.16.1",
++   "nlohmann-json": "nlohmann-json 3.12.0",
++   "openblas": "openblas 0.3.33",
++   "libomp": "libomp 22.1.8"
++  },
++  "load_avg": "{ 3,67 3,00 2,56 }",
++  "thermal": "Note: No thermal warning level has been recorded;Note: No performance warning level has been recorded;Note: No CPU power status has been recorded;",
++  "ncpu": "18",
++  "perf_cores": "6",
++  "eff_cores": "12"
++ },
++ "generated_at": "2026-11-02T21:05:20.158901+00:00"
++}
+ \ No newline at end of file

added experiments/scripts/make_paper_assets.py +166 −0

++#!/usr/bin/env python3
++"""Generates every paper table (paper/tables/*.tex) and figure (paper/figures/*.pdf) from the tracked artifacts under
++experiments/results/, and writes experiments/results/key_numbers.json (the only source of numbers quoted in the prose)
++and experiments/manifests/paper_assets.json (SHA-256 of every input and output). No number is typed by hand."""
++import os, sys, json, glob, hashlib, collections, statistics, csv
++import numpy as np
++ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".."); RES = os.path.join(ROOT, "experiments", "results"); RAW = os.path.join(RES, "raw")
++TAB = os.path.join(ROOT, "paper", "tables"); FIG = os.path.join(ROOT, "paper", "figures"); os.makedirs(TAB, exist_ok=True); os.makedirs(FIG, exist_ok=True)
++import matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt
++plt.rcParams.update({"font.size": 8, "axes.titlesize": 9, "legend.fontsize": 7, "figure.dpi": 150})
++COL = {"cpu1": "#9aa0a6", "cpuN": "#1f4e79", "metal": "#c0392b", "metal_unfused": "#e67e22", "pandas": "#7f8c8d", "polars": "#2980b9", "duckdb": "#27ae60", "raid_cpu": "#1f4e79", "raid_metal": "#c0392b"}
++rng = np.random.default_rng(20261102); key = {}; inputs = {}; outputs = {}
++def sha(p): return hashlib.sha256(open(p, "rb").read()).hexdigest()
++def load(name):
++    p = os.path.join(RAW, name);
++    if not os.path.exists(p): return []
++    inputs[name] = sha(p); return [json.loads(l) for l in open(p) if l.strip()]
++def ci(x, n=2000): x = np.asarray(x, float); m = [np.median(rng.choice(x, x.size, replace=True)) for _ in range(n)]; return float(np.median(x)), float(np.percentile(m, 2.5)), float(np.percentile(m, 97.5))
++def med(it):
++    v = [x for x in it if x is not None and np.isfinite(x)]; return statistics.median(v) if v else None
++def fmt(x, d=2): return "--" if x is None or (isinstance(x, float) and not np.isfinite(x)) else f"{x:.{d}f}"
++def write(name, s): p = os.path.join(TAB, name); open(p, "w").write(s); outputs["tables/" + name] = sha(p)
++def savefig(fig, name): p = os.path.join(FIG, name); fig.savefig(p, bbox_inches="tight"); plt.close(fig); outputs["figures/" + name] = sha(p)
++
++# ---------------------------------------------------------------- primitives (laptop)
++prim = [r for r in load("bench_primitives.jsonl") if r.get("kernel") != "shader_library_load"]
++g = collections.defaultdict(list)
++for r in prim: g[(r["kernel"], r["S"], r["n"], r["backend"], r["threads"] == 1)].append(r["wall_seconds"])
++rows = {k: ci(v) for k, v in g.items()}
++def spd(k, S, n):
++    c = rows.get((k, S, n, "cpu", False)); m = rows.get((k, S, n, "metal", False)); c1 = rows.get((k, S, n, "cpu", True))
++    if not c or not m: return None
++    verdict = "Metal" if m[2] < c[1] else ("CPU" if c[2] < m[1] else "tie"); return (c1[0] if c1 else None, c[0], m[0], c[0] / m[0], verdict)
++lines = [r"\begin{tabular}{llrrrrrl}", r"\toprule", r"Kernel & $S\times n$ & elements & CPU 1T (ms) & CPU MT (ms) & Metal (ms) & speedup & verdict \\", r"\midrule"]
++prim_key = {}
++for k in ["realized_fused", "regression_stats", "rolling_sumsq", "garch_nll_P1", "garch_nll_P64"]:
++    for (S, n) in sorted({(r["S"], r["n"]) for r in prim if r["kernel"] == k}, key=lambda t: (t[0] * t[1], t[0])):
++        s = spd(k, S, n)
++        if not s: continue
++        prim_key[f"{k}@{S}x{n}"] = {"cpu1_ms": None if s[0] is None else 1e3 * s[0], "cpuMT_ms": 1e3 * s[1], "metal_ms": 1e3 * s[2], "speedup": s[3], "verdict": s[4]}
++        lines.append(f"{k.replace('_', r'\_')} & ${S}\\times{n}$ & {S * n:,} & {fmt(None if s[0] is None else 1e3 * s[0], 3)} & {fmt(1e3 * s[1], 3)} & {fmt(1e3 * s[2], 3)} & {fmt(s[3])} & {s[4]} \\\\")
++lines += [r"\bottomrule", r"\end{tabular}"]; write("tab_primitives.tex", "\n".join(lines)); key["primitives"] = prim_key
++# break-even summary
++be = {}
++for k in ["realized_fused", "regression_stats", "rolling_sumsq", "garch_nll_P1", "garch_nll_P64"]:
++    wins = sorted(v["cpuMT_ms"] and (int(t.split("@")[1].split("x")[0]) * int(t.split("x")[1])) for t, v in prim_key.items() if t.startswith(k + "@") and v["verdict"] == "Metal")
++    losses = sorted((int(t.split("@")[1].split("x")[0]) * int(t.split("x")[1])) for t, v in prim_key.items() if t.startswith(k + "@") and v["verdict"] == "CPU")
++    be[k] = {"smallest_metal_win": wins[0] if wins else None, "largest_cpu_win": losses[-1] if losses else None, "max_speedup": max(v["speedup"] for t, v in prim_key.items() if t.startswith(k + "@")), "min_speedup": min(v["speedup"] for t, v in prim_key.items() if t.startswith(k + "@"))}
++key["breakeven"] = be
++# figure: throughput
++kernels = ["realized_fused", "regression_stats", "rolling_sumsq", "garch_nll_P64"]; fig, axes = plt.subplots(1, 4, figsize=(10, 2.6))
++for ax, k in zip(axes, kernels):
++    for be_, one, lab in [("cpu", True, "CPU 1 thread"), ("cpu", False, "CPU 18 threads"), ("metal", False, "Metal")]:
++        pts = sorted([(S * n, S * n / rows[(k, S, n, be_, one)][0]) for (kk, S, n, b, o) in rows if kk == k and b == be_ and o == one])
++        if pts: ax.plot([p[0] for p in pts], [p[1] for p in pts], "o-", ms=2.5, lw=1, color=COL["cpu1" if one else ("cpuN" if be_ == "cpu" else "metal")], label=lab)
++    ax.set_xscale("log"); ax.set_yscale("log"); ax.set_title(k.replace("_", " ")); ax.set_xlabel("elements"); ax.grid(alpha=.3)
++axes[0].set_ylabel("elements / s (median)"); axes[0].legend(); savefig(fig, "fig_primitives_throughput.pdf")
++
++# ---------------------------------------------------------------- E1
++e1 = [r for r in load("e1_batched_rv.jsonl") if r.get("kind") == "bench"]
++g1 = collections.defaultdict(list)
++for r in e1: g1[(r["source"], r["S"], r["segment"], r["backend"])].append(r["wall_seconds"])
++r1 = {k: ci(v) for k, v in g1.items()}; err = collections.defaultdict(list)
++for r in e1:
++    if r["backend"].startswith("metal"): err[(r["source"], r["S"], r["segment"])].append(r["max_rel_err_rv_vs_fp64"])
++lines = [r"\begin{tabular}{llrrrrrrl}", r"\toprule", r"Panel & $S$ & segment & elements & CPU 1T (ms) & CPU MT (ms) & Metal fused (ms) & Metal 4 kernels (ms) & max rel.\ err.\ RV \\", r"\midrule"]
++e1_key = {}
++for (src, S, seg) in sorted({(r["source"], r["S"], r["segment"]) for r in e1}, key=lambda t: (t[0] != "real", t[1], ["day", "week", "month", "year"].index(t[2]))):
++    el = next(r["elements"] for r in e1 if (r["source"], r["S"], r["segment"]) == (src, S, seg))
++    c1, cn, mt, mu = (r1.get((src, S, seg, b)) for b in ["cpu1", "cpuN", "metal", "metal_unfused"]); mx = max(err[(src, S, seg)]) if err[(src, S, seg)] else None
++    e1_key[f"{src}_S{S}_{seg}"] = {"elements": el, "cpu1_ms": c1 and 1e3 * c1[0], "cpuMT_ms": cn and 1e3 * cn[0], "metal_ms": mt and 1e3 * mt[0], "metal_unfused_ms": mu and 1e3 * mu[0], "speedup_MT": (cn and mt) and cn[0] / mt[0], "fusion_gain": (mu and mt) and mu[0] / mt[0], "max_rel_err": mx, "metal_wins": bool(cn and mt and mt[2] < cn[1]), "cpu_wins": bool(cn and mt and cn[2] < mt[1])}
++    lines.append(f"{src} & {S} & {seg} & {el:,} & {fmt(c1 and 1e3 * c1[0], 2)} & {fmt(cn and 1e3 * cn[0], 2)} & {fmt(mt and 1e3 * mt[0], 2)} & {fmt(mu and 1e3 * mu[0], 2)} & {('%.1e' % mx) if mx is not None else '--'} \\\\")
++lines += [r"\bottomrule", r"\end{tabular}"]; write("tab_e1.tex", "\n".join(lines)); key["E1"] = e1_key
++fig, axes = plt.subplots(1, 2, figsize=(7, 2.6))
++for ax, src in zip(axes, ["real", "synthetic"]):
++    for b, lab in [("cpu1", "CPU 1T"), ("cpuN", "CPU 18T"), ("metal", "Metal fused"), ("metal_unfused", "Metal 4 kernels")]:
++        pts = sorted([(e1_key[k]["elements"], e1_key[k]["elements"] / (e1_key[k][{"cpu1": "cpu1_ms", "cpuN": "cpuMT_ms", "metal": "metal_ms", "metal_unfused": "metal_unfused_ms"}[b]] / 1e3)) for k in e1_key if k.startswith(src + "_") and e1_key[k][{"cpu1": "cpu1_ms", "cpuN": "cpuMT_ms", "metal": "metal_ms", "metal_unfused": "metal_unfused_ms"}[b]]])
++        if pts: ax.plot([p[0] for p in pts], [p[1] for p in pts], "o", ms=3, color=COL[b], label=lab)
++    ax.set_xscale("log"); ax.set_yscale("log"); ax.set_title(f"E1 — {src} panel"); ax.set_xlabel("elements (returns)"); ax.grid(alpha=.3)
++axes[0].set_ylabel("returns / s"); axes[0].legend(); savefig(fig, "fig_e1.pdf")
++
++# ---------------------------------------------------------------- E2
++e2 = load("e2_har.jsonl"); acc = [r for r in e2 if r.get("kind") == "accuracy"]; rt = [r for r in e2 if r.get("kind") == "runtime"]
++lines = [r"\begin{tabular}{lrrrrrr}", r"\toprule", r"$h$ & symbols & HAR QLIKE & log-HAR QLIKE & HARQ QLIKE & RW QLIKE & HAR beats RW (\%) \\", r"\midrule"]; e2_key = {}
++for h in [1, 5, 22]:
++    rs = [r for r in acc if r["h"] == h and "qlike" in r.get("har", {})]
++    medq = lambda m: med(r[m]["qlike"] for r in rs if "qlike" in r.get(m, {}))
++    beats = 100 * np.mean([r["har"]["qlike"] < r["random_walk"]["qlike"] for r in rs])
++    e2_key[f"h{h}"] = {"n": len(rs), "har": medq("har"), "loghar": medq("loghar"), "harq": medq("harq"), "rw": medq("random_walk"), "har_beats_rw_pct": beats, "fits_per_symbol": med(r["har"]["fits"] for r in rs)}
++    lines.append(f"{h} & {len(rs)} & {fmt(medq('har'), 3)} & {fmt(medq('loghar'), 3)} & {fmt(medq('harq'), 3)} & {fmt(medq('random_walk'), 3)} & {fmt(beats, 1)} \\\\")
++lines += [r"\bottomrule", r"\end{tabular}"]; write("tab_e2_accuracy.tex", "\n".join(lines))
++g2 = collections.defaultdict(list)
++for r in rt: g2[(r["S"], r["mode"])].append(r["wall_seconds"])
++lines = [r"\begin{tabular}{rrrrrr}", r"\toprule", r"$S$ & $T$ & per-series 1T (ms) & per-series 18T (ms) & batched CPU (ms) & batched Metal (ms) \\", r"\midrule"]; e2_rt = {}
++for S in sorted({r["S"] for r in rt}):
++    T = next(r["T_per_series"] for r in rt if r["S"] == S); v = {m: ci(g2[(S, m)])[0] for m in ["per_series_cpu1", "per_series_cpuMT", "batched_cpu", "batched_metal"] if g2[(S, m)]}
++    e2_rt[str(S)] = {**{k: 1e3 * x for k, x in v.items()}, "T": T}; lines.append(f"{S} & {T} & " + " & ".join(fmt(1e3 * v.get(m), 3) if v.get(m) else "--" for m in ["per_series_cpu1", "per_series_cpuMT", "batched_cpu", "batched_metal"]) + r" \\")
++lines += [r"\bottomrule", r"\end{tabular}"]; write("tab_e2_runtime.tex", "\n".join(lines)); key["E2"] = {"accuracy": e2_key, "runtime": e2_rt}
++
++# ---------------------------------------------------------------- E3
++e3 = load("e3_garch.jsonl"); fits = [r for r in e3 if r.get("kind") == "fit"]; grid = [r for r in e3 if r.get("kind") == "grid"]; loadrec = next((r for r in e3 if r.get("kind") == "load"), {})
++lines = [r"\begin{tabular}{lrrrrrrr}", r"\toprule", r"Model & fits & converged (\%) & median iterations & median time (ms) & median persistence & QLIKE vs RV & QLIKE RW \\", r"\midrule"]; e3_key = {"symbols": loadrec.get("symbols"), "daily_history": loadrec.get("daily_history_replaced")}
++for m in ["garch.n", "gjr.n", "egarch.n", "garch.t"]:
++    rs = [r for r in fits if r["model"] == m]; ok = [r for r in rs if r.get("converged")]
++    e3_key[m] = {"n": len(rs), "converged_pct": 100 * len(ok) / len(rs), "median_iter": med(r["iterations"] for r in ok), "median_ms": 1e3 * med(r["seconds"] for r in ok), "median_persistence": med(r["persistence"] for r in ok), "qlike": med(r.get("qlike_vs_rv") for r in ok), "qlike_rw": med(r.get("qlike_rw_rv") for r in ok), "n_train": med(r["n_train"] for r in rs), "n_eval": sum(1 for r in ok if r.get("qlike_vs_rv") is not None)}
++    k3 = e3_key[m]; lines.append(f"{m} & {k3['n']} & {fmt(k3['converged_pct'], 1)} & {fmt(k3['median_iter'], 0)} & {fmt(k3['median_ms'], 2)} & {fmt(k3['median_persistence'], 3)} & {fmt(k3['qlike'], 3)} & {fmt(k3['qlike_rw'], 3)} \\\\")
++lines += [r"\bottomrule", r"\end{tabular}"]; write("tab_e3_fits.tex", "\n".join(lines))
++gm = [r for r in grid if r["backend"] == "metal"]; gc = [r for r in grid if r["backend"] == "cpuMT"]
++if gm and gc: e3_key["grid"] = {"S": gm[0]["S"], "P": gm[0]["P"], "cpuMT_ms": 1e3 * statistics.median(r["wall_seconds"] for r in gc), "metal_ms": 1e3 * statistics.median(r["wall_seconds"] for r in gm), "max_rel_err_nll": max(r["max_rel_err_nll"] for r in gm), "argmin_agreement": gm[0]["argmin_agreement"], "argmin_total": gm[0]["S_total"]}
++key["E3"] = e3_key
++
++# ---------------------------------------------------------------- E4
++e4 = load("e4_connectedness.jsonl"); lines = [r"\begin{tabular}{rrrrrrrr}", r"\toprule", r"$N$ & days used & cond.\ median & cond.\ max & LW shrinkage & DY windows (120 d) & mean total (\%) & time (ms) \\", r"\midrule"]; e4_key = {}
++for N in sorted({r["N"] for r in e4}):
++    rc = next((r for r in e4 if r["kind"] == "rcov" and r["N"] == N), None); dy = [r for r in e4 if r["kind"] == "dy" and r["N"] == N and r.get("window") == 120 and "wall_seconds" in r]
++    if rc: e4_key[str(N)] = {"days_ok": rc["days_ok"], "days_skipped": rc["days_skipped"], "cond_median": rc["cond_median"], "cond_max": rc["cond_max"], "lw": rc["ledoit_wolf_shrinkage_mean"], "dy_windows": dy[0]["n_windows"] if dy else None, "dy_total": dy[0]["mean_total"] if dy else None, "dy_ms": 1e3 * statistics.median(r["wall_seconds"] for r in dy) if dy else None, "dy_failures": dy[0]["failures"] if dy else None}
++    k4 = e4_key.get(str(N), {}); lines.append(f"{N} & {k4.get('days_ok', '--')} & {fmt(k4.get('cond_median'), 0)} & {fmt(k4.get('cond_max'), 0)} & {fmt(k4.get('lw'), 2)} & {k4.get('dy_windows', '--')} & {fmt(k4.get('dy_total'), 1)} & {fmt(k4.get('dy_ms'), 1)} \\\\")
++lines += [r"\bottomrule", r"\end{tabular}"]; write("tab_e4.tex", "\n".join(lines)); key["E4"] = e4_key
++
++# ---------------------------------------------------------------- E5
++e5 = load("e5_inference.jsonl"); lines = [r"\begin{tabular}{llrrrr}", r"\toprule", r"DGP & parameter & bias & RMSE & coverage 95\% & converged \\", r"\midrule"]; e5_key = {}
++for r in e5:
++    if r["kind"] == "garch_mc":
++        e5_key[f"garch_n{r['n']}"] = {p: r[p] for p in ["mu", "omega", "alpha", "beta"]} | {"converged": r["converged"], "R": r["R"]}
++        for p in ["mu", "omega", "alpha", "beta"]: lines.append(f"GARCH(1,1) $n={r['n']}$ & $\\{p}$ & {r[p]['bias']:+.4f} & {fmt(r[p]['rmse'], 4)} & {fmt(r[p]['coverage95'], 3)} & {r['converged']}/{r['R']} \\\\")
++    elif r["kind"] == "har_mc":
++        e5_key[f"har_h{r['h']}"] = r["coverage95"]; lines.append(f"HAR $h={r['h']}$ (HAC) & $\\beta_0,\\beta_d,\\beta_w,\\beta_m$ & -- & -- & {', '.join(fmt(c, 3) for c in r['coverage95'])} & {r['R']}/{r['R']} \\\\")
++    elif r["kind"] in ("repro_bootstrap", "repro_realized"): e5_key[r["kind"]] = {k: v for k, v in r.items() if k not in ("kind", "experiment")}
++lines += [r"\bottomrule", r"\end{tabular}"]; write("tab_e5.tex", "\n".join(lines)); key["E5"] = e5_key
++
++# ---------------------------------------------------------------- E6
++e6 = load("e6_pipeline.jsonl"); e6b = load("e6_baselines.jsonl"); g6 = collections.defaultdict(list); st6 = collections.defaultdict(list)
++for r in e6: g6["RAID " + r["backend_used"]].append(r["total_seconds"]); st6["read"].append(r["read_seconds"]); st6["prep"].append(r["prep_seconds"]); st6["est_" + r["backend_used"]].append(r["estimate_seconds"]); st6["rss_" + r["backend_used"]].append(r["peak_rss_after"]); st6["bars"].append(r["bars"])
++for r in e6b: g6[r["engine"]].append(r["total_seconds"]); st6["rss_" + r["engine"]].append(r["peak_rss"])
++lines = [r"\begin{tabular}{lrrrl}", r"\toprule", r"Engine & median total (s) & 95\% CI & bars / s & notes \\", r"\midrule"]; e6_key = {"bars_per_file": statistics.median(st6["bars"]), "read_s": statistics.median(st6["read"]), "prep_s": statistics.median(st6["prep"]), "est_cpu_s": statistics.median(st6["est_cpu"]), "est_metal_s": statistics.median(st6["est_metal"]) if st6["est_metal"] else None}
++notes = {"RAID cpu": "Arrow projection, exact calendar, 5 measures", "RAID metal": "same, fused Metal kernel", "pandas": "approximate early-close rule, groupby.apply", "polars": "approximate early-close rule, lazy scan", "duckdb": "approximate early-close rule, SQL window"}
++for eng in ["RAID cpu", "RAID metal", "polars", "duckdb", "pandas"]:
++    if not g6[eng]: continue
++    m, lo, hi = ci(g6[eng]); e6_key[eng] = {"median_s": m, "ci": [lo, hi], "bars_per_s": e6_key["bars_per_file"] / m}; lines.append(f"{eng} & {fmt(m, 3)} & [{fmt(lo, 3)}, {fmt(hi, 3)}] & {e6_key['bars_per_file'] / m / 1e6:.1f}M & {notes[eng]} \\\\")
++lines += [r"\bottomrule", r"\end{tabular}"]; write("tab_e6.tex", "\n".join(lines)); key["E6"] = e6_key
++
++# ---------------------------------------------------------------- E7
++e7 = json.load(open(os.path.join(RES, "e7_summary.json"))) if os.path.exists(os.path.join(RES, "e7_summary.json")) else []
++inputs["e7_summary.json"] = sha(os.path.join(RES, "e7_summary.json")) if e7 else None
++lines = [r"\begin{tabular}{llrrrllrrrr}", r"\toprule", r"Node & chip & GPU cores & CPU thr. & GB & tests (metallib / runtime) & cold / warm compile (ms) & RV fused $1000\times3900$ speedup & regression speedup & GARCH P=64 speedup & rolling speedup \\", r"\midrule"]; e7_key = {}
++order = ["m2m8a", "M2M32c", "M2U64", "M3BA24", "M3U96b", "m4md", "m4mm", "M4M64c", "m5ma", "M5M36", "m6ma"]
++for n in order:
++    r = next((x for x in e7 if x.get("node") == n), None)
++    if not r: continue
++    t = ("pass" if r["tests_metallib"].startswith("All tests passed") else "FAIL") + " / " + ("pass" if r["tests_runtime_msl"].startswith("All tests passed") else "FAIL")
++    e7_key[n] = {k: r.get(k) for k in ["chip", "gpu_cores", "cpu_threads", "mem_gb", "macos", "cold_compile_s", "warm_compile_s", "realized_fused@1000x3900_speedup_MT", "regression_stats@1000x3900_speedup_MT", "garch_nll_P64@1000x390_speedup_MT", "rolling_sumsq@1000x3900_speedup_MT", "realized_fused@1000x3900_cpuMT_ms", "realized_fused@1000x3900_metal_ms"]} | {"tests": t}
++    lines.append(f"{n} & {r['chip']} & {r['gpu_cores']} & {r['cpu_threads']} & {r['mem_gb']} & {t} & {fmt(1e3 * (r['cold_compile_s'] or 0), 0)} / {fmt(1e3 * (r['warm_compile_s'] or 0), 0)} & {fmt(r['realized_fused@1000x3900_speedup_MT'])} & {fmt(r['regression_stats@1000x3900_speedup_MT'])} & {fmt(r['garch_nll_P64@1000x390_speedup_MT'])} & {fmt(r['rolling_sumsq@1000x3900_speedup_MT'])} \\\\")
++lines += [r"\bottomrule", r"\end{tabular}"]; write("tab_e7.tex", "\n".join(lines)); key["E7"] = e7_key
++fig, ax = plt.subplots(figsize=(6, 2.8)); xs = [e7_key[n]["gpu_cores"] for n in e7_key];
++for k, lab, c in [("realized_fused@1000x3900_speedup_MT", "RV fused 1000×3900", COL["metal"]), ("garch_nll_P64@1000x390_speedup_MT", "GARCH NLL P=64 1000×390", COL["cpuN"]), ("rolling_sumsq@1000x3900_speedup_MT", "rolling sumsq 1000×3900", COL["cpu1"])]:
++    ax.scatter([e7_key[n]["gpu_cores"] for n in e7_key], [e7_key[n][k] for n in e7_key], label=lab, color=c, s=18)
++for n in e7_key: ax.annotate(e7_key[n]["chip"].replace("Apple ", ""), (e7_key[n]["gpu_cores"], e7_key[n]["realized_fused@1000x3900_speedup_MT"]), fontsize=6, xytext=(2, 2), textcoords="offset points")
++ax.axhline(1, color="k", lw=.6, ls="--"); ax.set_xlabel("GPU cores"); ax.set_ylabel("Metal / CPU-MT speedup"); ax.set_yscale("log"); ax.grid(alpha=.3); ax.legend(); savefig(fig, "fig_e7.pdf")
++
++# ---------------------------------------------------------------- hardware inventory + manifest
++env = glob.glob(os.path.join(ROOT, "experiments", "manifests", "environment_*.json")); envj = json.load(open(env[0])) if env else {}
++key["laptop"] = {k: envj.get(k) for k in ["chip", "os", "xcode", "clang", "cmake", "metal_toolchain", "brew", "load_avg", "thermal", "ncpu", "perf_cores", "eff_cores"]}
++key["generated_at"] = __import__("datetime").datetime.now(__import__("datetime").timezone.utc).isoformat()
++json.dump(key, open(os.path.join(RES, "key_numbers.json"), "w"), indent=1)
++json.dump({"inputs": inputs, "outputs": outputs, "key_numbers_sha256": sha(os.path.join(RES, "key_numbers.json"))}, open(os.path.join(ROOT, "experiments", "manifests", "paper_assets.json"), "w"), indent=1)
++print("tables:", sorted(outputs)); print(json.dumps({k: key[k] for k in ["breakeven", "E6"]}, indent=1)[:1500])

added experiments/scripts/run_e1_e2_e3.sh +7 −0

++#!/bin/bash
++set -uo pipefail; cd "$(dirname "$0")/../.."; R=experiments/results/raw; E0=experiments/results/e0_universe.json
++rm -f $R/e1_batched_rv.jsonl $R/e2_har.jsonl $R/e3_garch.jsonl
++echo "== E1 $(date)"; ./build/macos-release/bench_bench_e1_batched_rv $E0 $R/e1_batched_rv.jsonl 5 2> $R/e1.log; echo "E1 exit=$?"
++echo "== E2 $(date)"; ./build/macos-release/bench_bench_e2_har $E0 $R/e2_har.jsonl 5 2> $R/e2.log; echo "E2 exit=$?"
++echo "== E3 $(date)"; ./build/macos-release/bench_bench_e3_garch $E0 $R/e3_garch.jsonl 1000 experiments/results/e0_daily.json 2> $R/e3.log; echo "E3 exit=$?"
++echo "== done $(date)"

modified include/raid/estimators/realized.hpp +1 −0

				`@@ -25,6 +25,7 @@ namespace raid::est {`
25	struct RealizedOptions {	25	struct RealizedOptions {
26	bool bpv_finite_sample{true};	26	bool bpv_finite_sample{true};
27	bool fuse_kernels{true}; // Metal: one fused pass for all accumulators (ablation: false → 4 kernels)	27	bool fuse_kernels{true}; // Metal: one fused pass for all accumulators (ablation: false → 4 kernels)
		28	+ bool tripower{true}; // tripower quarticity (CPU FP64, parallel over segments; \|x\|^{4/3} computed once per element)
28	bool annualize{false}; // multiply variances by `periods_per_year`	29	bool annualize{false}; // multiply variances by `periods_per_year`
29	f64 periods_per_year{252.0};	30	f64 periods_per_year{252.0};
30	ExecutionPlan plan{};	31	ExecutionPlan plan{};

added paper/appendices/appendix.tex +46 −0

++\begin{appendices}
++\section{Kernel pseudocode}
++\label{app:kernels}
++\begin{lstlisting}[basicstyle=\ttfamily\scriptsize]
++df two_sum(float a, float b): s = a + b; bb = s - a; e = (a - (s - bb)) + (b - bb); return (s, e)
++df df_add_f(df a, float v): (h, l) = two_sum(a.hi, v); l += a.lo; h2 = h + l; return (h2, l - (h2 - h))
++kernel realized_fused(x, chunks, out):   // one threadgroup (256 threads) per (segment, chunk)
++  c = chunks[gid]; s2 = adj = neg = pos = s4 = (0, 0)
++  for i in c.begin + lid .. c.end step 256:
++    v = x[i]; q = v*v; s2 += q; s4 += q*q; if v < 0: neg += q elif v > 0: pos += q
++    if i > c.begin: adj += |v| * |x[i-1]|
++  tree-reduce each df over the threadgroup in fixed order; thread 0 writes 5 float2
++host: for each chunk c of segment s: acc[s] += (double)hi + (double)lo (fixed order);
++      adj[s] += |x[c.begin]| * |x[c.begin-1]| in FP64 when c.begin > segment begin
++kernel garch_nll(r, seg, params[8], var0, jobs, out, model):   // one thread per (segment, parameter vector)
++  (mu, omega, alpha, gamma, beta, nu, kconst, Eabs) = params[job]; s2 = var0[seg]
++  validity checks -> +inf; nll = (0, 0); e_prev = r[b] - mu
++  for i in 0..n-1: if i > 0: s2 = recursion(model); if !(s2 > 0): return +inf
++    e = r[b+i] - mu; ll = kconst - 0.5 log s2 - (student ? 0.5 (nu+1) log(1 + e^2/((nu-2) s2)) : 0.5 e^2/s2)
++    nll += -ll
++  out[job] = nll.hi + nll.lo   // host adds n log(sd) for the per-series scaling
++\end{lstlisting}
++
++\section{Optimiser details}
++GARCH-family QML: parameters are transformed to an unconstrained space ($\omega = e^{u}$; persistence $p = \sigma(u_p)(1-10^{-9})$ and share $s = \sigma(u_s)$ so that $\alpha = sp$, $\beta = (1-s)p$ for GARCH; for GJR $\alpha+\gamma = e^{u_g}$ and $\beta = p - \alpha - \gamma/2 \ge 0$; for EGARCH $\omega$ free and $\beta = \tanh(u)$; $\nu = 2.05 + 497.95\,\sigma(u_\nu)$). BFGS with Armijo backtracking (factor 0.5, up to 60 halvings), central-difference gradients with step $10^{-5}\max(1,|u|)$, convergence when $\|g\| < 10^{-5}$, or when the relative change of the negative log-likelihood is below $10^{-8}$ (or the step below $10^{-9}$) with $\|g\| < 10^{-2}$ in the transformed space; at most 500 iterations; up to three starting variants (persistence 0.95, 0.80, 0.985; opposite EGARCH $\gamma$ sign). Covariance from the numerical Hessian (central differences, step $10^{-4}\max(1,|\theta|)$) and the OPG of per-observation scores. Returns are scaled to unit variance before optimisation and the estimates un-scaled (EGARCH: $\omega \to \omega + (1-\beta)\log s^{-2}$).
++
++\section{Finite-sample conventions}
++Regular session = 09:30 to 16:00 ET inclusive of the 16:00 closing print (391 one-minute bars; 211 on 13:00 early closes); extended session 04:00--19:59 ET (17:00 on early closes). Intraday returns are close-to-close within the session ($M = $ bars $-1$). BPV factor $M/(M-1)$ on by default; TriPV factor $M/(M-2)$; RQ $= (M/3)\sum r^4$. HAR windows of 1, 5 and 22 trading days; targets averaged over $h$ sessions; HAC lags $\max(h-1, \lfloor 4(n/100)^{2/9}\rfloor)$. HARQ regressor $(\sqrt{\RQ_t} - \sqrt{\overline{\RQ}})\RV_t$ with $\overline{\RQ}$ over the estimation sample. GARCH $\sigma_0^2$ = sample variance of $\varepsilon$. Stationary bootstrap mean block $n^{1/3}$ unless stated.
++
++\section{Benchmark configuration}
++Laptop: Apple M5 Max (6P+12E cores reported by \texttt{hw.perflevel}, 18 hardware threads), 40-core GPU, 48\,GB, macOS 27.0 (26A5425a), Xcode 27.2 (27B52), Apple clang 21.0.0 (clang-2100.4.1.1), Metal toolchain 32023.922, CMake 4.3.2, \texttt{-O3 -mcpu=native -ffp-model=precise}, Eigen 5.0.1 + Accelerate, Arrow 26.0.0. Metal: 256-thread threadgroups for reductions, 4\,096-element chunks, 64-thread threadgroups for GARCH jobs, shared storage mode, \texttt{fastMathEnabled = NO}. Repetitions: 5 (laptop), 3 (nodes); 2 warm-ups; shuffled order with seed 20261102; medians and 2\,000-draw bootstrap 95\,\% CIs. Cluster bundle: \texttt{-mcpu=apple-m1}, deployment target macOS 26.0, Arrow disabled, Metal enabled, prebuilt metallib plus embedded MSL.
++
++\section{Hardware inventory (E7)}
++\begin{center}\scriptsize
++\begin{tabular}{llrrrl}
++\toprule Node & Chip & GPU cores & CPU threads & RAM (GB) & macOS \\ \midrule
++m2m8a & Apple M2 & 10 & 8 & 8 & 26.5.1 \\ M2M32c & Apple M2 Max & 30 & 12 & 32 & 26.5.1 \\ M2U64 & Apple M2 Ultra & 60 & 24 & 64 & 26.5 \\ M3BA24 & Apple M3 & 10 & 8 & 24 & 26.5.1 \\ M3U96b & Apple M3 Ultra & 60 & 28 & 96 & 26.4 \\ m4md & Apple M4 & 10 & 10 & 16 & 26.6.2 \\ m4mm & Apple M4 Pro & 16 & 12 & 48 & 26.5.1 \\ M4M64c & Apple M4 Max & 40 & 16 & 64 & 26.4 \\ m5ma & Apple M5 Pro & 16 & 15 & 24 & 27.0 \\ M5M36 & Apple M5 Max & 32 & 18 & 36 & 27.0 \\ m6ma & Apple M6 & 12 & 12 & 24 & 27.0 \\ \bottomrule
++\end{tabular}
++\end{center}
++
++\section{API provenance}
++FinData OS API \texttt{https://findata.spboucher.ai/api/v1} (OpenAPI 3.1 snapshot of 2026-11-02 in \texttt{docs/evidence/}); datasets \texttt{market\_bars.stock.1m.raw} (version 17\,375 at export time; 6.70 billion rows, 16\,195 symbols, 2000--2026) and \texttt{market\_bars.stock.1d.raw}; bars schema v1 (\texttt{timestamp\_utc} = bar open, UTC); exports as Parquet with the dataset version in the job record; request identifiers of every exchange are kept in the cache manifests; API key identified by a SHA-256 fingerprint only. Data © FirstRate Data, private-use licence, no redistribution.
++
++\section{Numerical tolerance tables}
++See Table~\ref{tab:validation} for the reference tolerances. GPU/CPU tolerances by primitive: realized accumulators $10^{-6}$ relative ($\Sigma x^4$: $10^{-5}$); rolling sums $10^{-5}$; regression statistics $10^{-6}$ absolute on $\max(1,|\cdot|)$ and $10^{-5}$ on the solved coefficients; batched GARCH NLL $2\times10^{-5}$ relative (Student-$t$: $5\times10^{-5}$) on simulated series with $n = 2\,000$; on the E3 real-data grid the maximum relative difference is $2\times10^{-3}$ at boundary grid points and the argmin agrees for 888/888 series.
++\end{appendices}

added paper/figures/fig_e1.pdf +0 −0

Binary file not shown.

added paper/figures/fig_e7.pdf +0 −0

Binary file not shown.

added paper/figures/fig_primitives_throughput.pdf +0 −0

Binary file not shown.

added paper/sections/applications.tex +37 −0

Large diff (37 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/architecture.tex +34 −0

Large diff (34 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/conclusion.tex +6 −0

Large diff (6 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/correctness.tex +41 −0

Large diff (41 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/endtoend.tex +26 −0

Large diff (26 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/estimators.tex +38 −0

Large diff (38 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/metal.tex +16 −0

Large diff (16 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/microbenchmarks.tex +36 −0

Large diff (36 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/reproducibility.tex +8 −0

Large diff (8 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/setup.tex +12 −0

Large diff (12 lines) is not loaded by default to keep the page fast.Load diff

added paper/sections/threats.tex +12 −0

Large diff (12 lines) is not loaded by default to keep the page fast.Load diff

added paper/tables/tab_e1.tex +25 −0

Large diff (26 lines) is not loaded by default to keep the page fast.Load diff

added paper/tables/tab_e2_accuracy.tex +9 −0

Large diff (10 lines) is not loaded by default to keep the page fast.Load diff

added paper/tables/tab_e2_runtime.tex +9 −0

Large diff (10 lines) is not loaded by default to keep the page fast.Load diff

added paper/tables/tab_e3_fits.tex +10 −0

Large diff (11 lines) is not loaded by default to keep the page fast.Load diff

added paper/tables/tab_e4.tex +10 −0

Large diff (11 lines) is not loaded by default to keep the page fast.Load diff

added paper/tables/tab_e5.tex +16 −0

Large diff (17 lines) is not loaded by default to keep the page fast.Load diff

added paper/tables/tab_e6.tex +11 −0

Large diff (12 lines) is not loaded by default to keep the page fast.Load diff

added paper/tables/tab_e7.tex +17 −0

Large diff (18 lines) is not loaded by default to keep the page fast.Load diff

added paper/tables/tab_primitives.tex +75 −0

Large diff (76 lines) is not loaded by default to keep the page fast.Load diff

modified src/estimators/realized.cpp +13 −7

Large diff (40 lines) is not loaded by default to keep the page fast.Load diff

spb/wp40_uqo

WP40 RAID: paper sections (setup, micro/end-to-end/applications, threats, reproducibility, conclusion, appendices), E1–E3 reruns, parallel realized post-processing

Theme