From ef633b252f61a1562b7355554ae015ee1ffd635a Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Sat, 17 Oct 2026 02:37:44 +0100 Subject: [PATCH] test: run parity from worktrees and document startup profiles --- .../shared-json-buffer-lifetime-20261017.json | 379 ++++++++++++ .../shared-json-five-way-final-20261017.json | 582 ++++++++++++++++++ .../src/random_tick_sections.rs | 9 +- tools/PROFILE_SHARED_JSON.md | 85 +++ tools/baseline_loader_profile.rs | 23 + 5 files changed, 1077 insertions(+), 1 deletion(-) create mode 100644 benchmarks/shared-json-buffer-lifetime-20261017.json create mode 100644 benchmarks/shared-json-five-way-final-20261017.json create mode 100644 tools/PROFILE_SHARED_JSON.md create mode 100644 tools/baseline_loader_profile.rs diff --git a/benchmarks/shared-json-buffer-lifetime-20261017.json b/benchmarks/shared-json-buffer-lifetime-20261017.json new file mode 100644 index 000000000..d618906ed --- /dev/null +++ b/benchmarks/shared-json-buffer-lifetime-20261017.json @@ -0,0 +1,379 @@ +{ + "scope": "Assets + BlockFacts + Behaviours loader only; no full startup or first frame", + "resources": "/srv/bob-data/horizon/.local/horizon-client/26.3", + "repeats": 10, + "ordering": [ + [ + "released", + "retained" + ], + [ + "retained", + "released" + ], + [ + "released", + "retained" + ], + [ + "retained", + "released" + ], + [ + "released", + "retained" + ], + [ + "retained", + "released" + ], + [ + "released", + "retained" + ], + [ + "retained", + "released" + ], + [ + "released", + "retained" + ], + [ + "retained", + "released" + ] + ], + "load_average_before": [ + 8.2421875, + 6.56396484375, + 6.39208984375 + ], + "load_average_after": [ + 7.98095703125, + 6.6455078125, + 6.4248046875 + ], + "executables": { + "released": { + "path": "/srv/bob-data/horizon/.worktrees/shared-block-json-20261017/target/release/examples/shared_json_startup_profile-integrated", + "mode": "deferred", + "sha256": "a52d6a7efc7b3198ef0dd8150325f56a3fe5d0c5883fd6d14c4b0c281866ce7c" + }, + "retained": { + "path": "/srv/bob-data/horizon/.worktrees/shared-block-json-20261017/target/release/examples/shared_json_startup_profile-integrated", + "mode": "deferred-held", + "sha256": "a52d6a7efc7b3198ef0dd8150325f56a3fe5d0c5883fd6d14c4b0c281866ce7c" + } + }, + "metrics": { + "released": { + "phase_ms": { + "median": 482.591, + "p25": 444.276, + "p75": 586.92, + "min": 430.128, + "max": 736.543, + "samples": [ + 529.244, + 606.146, + 449.23, + 442.624, + 669.108, + 511.519, + 736.543, + 432.616, + 430.128, + 453.663 + ] + }, + "total_ms": { + "median": 987.004, + "p25": 932.885, + "p75": 1134.876, + "min": 914.242, + "max": 1201.759, + "samples": [ + 1055.119, + 1161.462, + 968.629, + 914.242, + 1201.759, + 1005.379, + 1200.01, + 928.249, + 935.775, + 931.921 + ] + }, + "cpu_ms": { + "median": 1004.675, + "p25": 936.465, + "p75": 1116.791, + "min": 908.327, + "max": 1241.168, + "samples": [ + 1074.425, + 1130.913, + 984.832, + 931.205, + 1186.169, + 1024.519, + 1241.168, + 908.327, + 952.245, + 927.15 + ] + }, + "peak_rss_kib": { + "median": 268124.0, + "p25": 267753.0, + "p75": 268455.0, + "min": 267708, + "max": 268700, + "samples": [ + 268268, + 268500, + 267744, + 267724, + 267708, + 267780, + 268700, + 268496, + 268332, + 267980 + ] + }, + "behaviour_json_ms": { + "median": 24.371, + "p25": 22.469, + "p75": 28.486, + "min": 20.662, + "max": 35.297, + "samples": [ + 33.387, + 35.297, + 24.732, + 24.011, + 27.699, + 28.748, + 23.623, + 22.084, + 20.662, + 21.266 + ] + }, + "facts_ms": { + "median": 292.77, + "p25": 270.649, + "p75": 383.193, + "min": 264.691, + "max": 443.291, + "samples": [ + 346.613, + 398.468, + 274.673, + 264.691, + 443.291, + 292.926, + 395.387, + 267.232, + 269.308, + 292.615 + ] + }, + "behaviours_ms": { + "median": 148.635, + "p25": 141.329, + "p75": 181.741, + "min": 136.361, + "max": 307.004, + "samples": [ + 145.009, + 168.982, + 146.535, + 150.736, + 194.604, + 185.994, + 307.004, + 140.102, + 136.785, + 136.361 + ] + }, + "post_rss_kib": { + "median": 268668.0, + "p25": 268246.0, + "p75": 268922.0, + "min": 268048.0, + "max": 269012.0, + "samples": [ + 268668.0, + 268936.0, + 268108.0, + 268088.0, + 268048.0, + 268668.0, + 268880.0, + 269012.0, + 268960.0, + 268660.0 + ] + } + }, + "retained": { + "phase_ms": { + "median": 487.954, + "p25": 471.456, + "p75": 531.586, + "min": 401.516, + "max": 834.154, + "samples": [ + 486.974, + 613.755, + 540.535, + 470.333, + 488.934, + 474.825, + 834.154, + 504.74, + 401.516, + 440.381 + ] + }, + "total_ms": { + "median": 1038.875, + "p25": 989.724, + "p75": 1079.197, + "min": 880.933, + "max": 1746.386, + "samples": [ + 996.407, + 1067.467, + 1082.69, + 1103.131, + 1010.283, + 1068.719, + 1746.386, + 987.496, + 890.46, + 880.933 + ] + }, + "cpu_ms": { + "median": 1035.537, + "p25": 982.276, + "p75": 1082.698, + "min": 908.774, + "max": 1660.068, + "samples": [ + 1011.712, + 1087.688, + 1076.523, + 1084.757, + 998.654, + 1059.363, + 1660.068, + 976.817, + 912.849, + 908.774 + ] + }, + "peak_rss_kib": { + "median": 268150.0, + "p25": 267537.0, + "p75": 268614.0, + "min": 267268, + "max": 268848, + "samples": [ + 268748, + 267968, + 267268, + 268332, + 267540, + 268560, + 267492, + 268632, + 267536, + 268848 + ] + }, + "behaviour_json_ms": { + "median": 23.208, + "p25": 22.305, + "p75": 26.544, + "min": 20.059, + "max": 32.669, + "samples": [ + 32.669, + 22.62, + 22.2, + 27.331, + 25.088, + 27.029, + 23.488, + 20.977, + 22.928, + 20.059 + ] + }, + "facts_ms": { + "median": 304.44, + "p25": 291.562, + "p75": 330.991, + "min": 244.758, + "max": 384.634, + "samples": [ + 307.936, + 374.145, + 336.931, + 300.944, + 290.81, + 293.817, + 384.634, + 313.171, + 244.758, + 279.303 + ] + }, + "behaviours_ms": { + "median": 162.285, + "p25": 143.135, + "p75": 179.31, + "min": 133.83, + "max": 426.031, + "samples": [ + 146.367, + 216.988, + 181.402, + 142.058, + 173.036, + 153.978, + 426.031, + 170.592, + 133.83, + 141.017 + ] + }, + "post_rss_kib": { + "median": 268694.0, + "p25": 268116.0, + "p75": 269056.0, + "min": 267988.0, + "max": 269212.0, + "samples": [ + 269212.0, + 268564.0, + 268096.0, + 268824.0, + 268176.0, + 269032.0, + 267988.0, + 269064.0, + 268044.0, + 269120.0 + ] + } + } + } +} diff --git a/benchmarks/shared-json-five-way-final-20261017.json b/benchmarks/shared-json-five-way-final-20261017.json new file mode 100644 index 000000000..ce92b7b61 --- /dev/null +++ b/benchmarks/shared-json-five-way-final-20261017.json @@ -0,0 +1,582 @@ +{ + "scope": "Assets + BlockFacts + Behaviours loader only; no full startup or first frame", + "resources": "/srv/bob-data/horizon/.local/horizon-client/26.3", + "repeats": 10, + "ordering": [ + [ + "baseline", + "a01d47f2", + "cf837118", + "cd61e11b", + "current" + ], + [ + "current", + "cd61e11b", + "cf837118", + "a01d47f2", + "baseline" + ], + [ + "baseline", + "a01d47f2", + "cf837118", + "cd61e11b", + "current" + ], + [ + "current", + "cd61e11b", + "cf837118", + "a01d47f2", + "baseline" + ], + [ + "baseline", + "a01d47f2", + "cf837118", + "cd61e11b", + "current" + ], + [ + "current", + "cd61e11b", + "cf837118", + "a01d47f2", + "baseline" + ], + [ + "baseline", + "a01d47f2", + "cf837118", + "cd61e11b", + "current" + ], + [ + "current", + "cd61e11b", + "cf837118", + "a01d47f2", + "baseline" + ], + [ + "baseline", + "a01d47f2", + "cf837118", + "cd61e11b", + "current" + ], + [ + "current", + "cd61e11b", + "cf837118", + "a01d47f2", + "baseline" + ] + ], + "load_average_before": [ + 11.4921875, + 7.46875, + 6.69677734375 + ], + "load_average_after": [ + 17.763671875, + 11.39013671875, + 8.20556640625 + ], + "executables": { + "baseline": { + "path": "/srv/bob-data/horizon/.worktrees/shared-block-json-20261017/target/release/examples/shared_json_startup_profile-e422bd13", + "mode": "baseline", + "sha256": "bf61f2e6c92e001be3c3bc93cf8072cc6af6fd1d7bcfa7273045960948ec89e7" + }, + "a01d47f2": { + "path": "/srv/bob-data/horizon/.worktrees/shared-block-json-20261017/target/release/examples/shared_json_startup_profile-a01d47f2", + "mode": "shared", + "sha256": "88be56f8dbd28d0b4abd6c672486ba758df96ba18f68da45b94db14231dd3eea" + }, + "cf837118": { + "path": "/srv/bob-data/horizon/.worktrees/shared-block-json-20261017/target/release/examples/shared_json_startup_profile-cf837118", + "mode": "deferred", + "sha256": "f1b044cd9ac2f67c644fb40bd7ecbe38128ec739a8112d57fc36f05fe9036a52" + }, + "cd61e11b": { + "path": "/srv/bob-data/horizon/.worktrees/shared-block-json-20261017/target/release/examples/shared_json_startup_profile-cd61e11b", + "mode": "deferred", + "sha256": "fb2d3725b09ee38f85b49901f7053a6fe339b980a2b2dac6930a8ded22c139e8" + }, + "current": { + "path": "/srv/bob-data/horizon/.worktrees/shared-block-json-20261017/target/release/examples/shared_json_startup_profile-integrated", + "mode": "deferred", + "sha256": "a52d6a7efc7b3198ef0dd8150325f56a3fe5d0c5883fd6d14c4b0c281866ce7c" + } + }, + "metrics": { + "baseline": { + "phase_ms": { + "median": 1506.588, + "p25": 1388.314, + "p75": 2119.85, + "min": 1319.319, + "max": 3143.124, + "samples": [ + 3143.124, + 2483.307, + 2124.952, + 2104.544, + 1525.153, + 1396.75, + 1381.771, + 1488.022, + 1385.502, + 1319.319 + ] + }, + "total_ms": { + "median": 1962.122, + "p25": 1858.188, + "p75": 3152.608, + "min": 1804.713, + "max": 4136.912, + "samples": [ + 4136.912, + 3250.285, + 3134.13, + 3158.767, + 2001.229, + 1883.076, + 1849.892, + 1923.016, + 1818.34, + 1804.713 + ] + }, + "cpu_ms": { + "median": 1969.296, + "p25": 1893.348, + "p75": 2694.824, + "min": 1842.049, + "max": 3059.824, + "samples": [ + 3059.824, + 2765.392, + 2698.837, + 2682.786, + 2026.89, + 1911.703, + 1888.282, + 1908.545, + 1859.233, + 1842.049 + ] + }, + "peak_rss_kib": { + "median": 819952.0, + "p25": 819778.0, + "p75": 820164.0, + "min": 818944, + "max": 820304, + "samples": [ + 819956, + 819744, + 818944, + 818984, + 820128, + 820176, + 819948, + 820236, + 819880, + 820304 + ] + } + }, + "a01d47f2": { + "phase_ms": { + "median": 666.765, + "p25": 520.278, + "p75": 1156.022, + "min": 450.677, + "max": 1882.249, + "samples": [ + 1001.208, + 1309.911, + 1207.627, + 1882.249, + 747.233, + 544.933, + 512.06, + 450.677, + 466.596, + 586.298 + ] + }, + "total_ms": { + "median": 1141.968, + "p25": 974.723, + "p75": 2326.553, + "min": 922.496, + "max": 3158.114, + "samples": [ + 2374.699, + 2275.18, + 2343.677, + 3158.114, + 1267.594, + 1006.411, + 964.16, + 922.496, + 936.687, + 1016.342 + ] + }, + "cpu_ms": { + "median": 1106.901, + "p25": 973.629, + "p75": 1525.998, + "min": 929.573, + "max": 1568.573, + "samples": [ + 1545.278, + 1568.573, + 1468.158, + 1563.377, + 1196.236, + 1017.565, + 960.219, + 929.573, + 946.096, + 1013.861 + ] + }, + "peak_rss_kib": { + "median": 351564.0, + "p25": 351148.0, + "p75": 352106.0, + "min": 350416, + "max": 353368, + "samples": [ + 351572, + 351268, + 351108, + 350416, + 351656, + 353368, + 352256, + 351556, + 350964, + 352308 + ] + } + }, + "cf837118": { + "phase_ms": { + "median": 505.124, + "p25": 435.315, + "p75": 1103.87, + "min": 417.056, + "max": 1875.147, + "samples": [ + 1875.147, + 1129.722, + 1066.305, + 1116.391, + 461.019, + 423.38, + 417.056, + 445.353, + 549.229, + 431.969 + ] + }, + "total_ms": { + "median": 1209.375, + "p25": 895.862, + "p75": 2133.144, + "min": 872.434, + "max": 2936.234, + "samples": [ + 2936.234, + 2215.538, + 1885.964, + 2695.131, + 1378.495, + 879.351, + 897.968, + 895.16, + 1040.255, + 872.434 + ] + }, + "cpu_ms": { + "median": 1068.41, + "p25": 896.926, + "p75": 1488.578, + "min": 882.398, + "max": 1570.652, + "samples": [ + 1530.601, + 1520.851, + 1391.76, + 1570.652, + 1116.403, + 900.779, + 894.039, + 895.642, + 1020.417, + 882.398 + ] + }, + "peak_rss_kib": { + "median": 273832.0, + "p25": 273592.0, + "p75": 274131.0, + "min": 272732, + "max": 274976, + "samples": [ + 274080, + 272732, + 273560, + 273468, + 274200, + 274148, + 273728, + 273936, + 274976, + 273688 + ] + } + }, + "cd61e11b": { + "phase_ms": { + "median": 429.481, + "p25": 410.043, + "p75": 1178.091, + "min": 399.576, + "max": 1644.881, + "samples": [ + 1194.624, + 1128.491, + 1644.881, + 1428.78, + 405.544, + 434.62, + 424.341, + 414.829, + 408.447, + 399.576 + ] + }, + "total_ms": { + "median": 902.865, + "p25": 868.889, + "p75": 2443.447, + "min": 827.16, + "max": 2961.261, + "samples": [ + 2682.056, + 2199.278, + 2524.837, + 2961.261, + 884.838, + 885.282, + 848.79, + 863.573, + 920.448, + 827.16 + ] + }, + "cpu_ms": { + "median": 920.917, + "p25": 869.777, + "p75": 1475.629, + "min": 840.036, + "max": 1626.459, + "samples": [ + 1518.201, + 1496.456, + 1413.149, + 1626.459, + 893.762, + 899.049, + 861.782, + 861.417, + 942.785, + 840.036 + ] + }, + "peak_rss_kib": { + "median": 267762.0, + "p25": 267612.0, + "p75": 267966.0, + "min": 266300, + "max": 268636, + "samples": [ + 266672, + 268636, + 266300, + 267596, + 267660, + 268280, + 267968, + 267680, + 267960, + 267844 + ] + } + }, + "current": { + "phase_ms": { + "median": 460.489, + "p25": 429.004, + "p75": 986.935, + "min": 404.103, + "max": 1300.033, + "samples": [ + 992.891, + 1126.098, + 1300.033, + 969.067, + 443.604, + 408.397, + 472.429, + 424.137, + 448.549, + 404.103 + ] + }, + "total_ms": { + "median": 935.623, + "p25": 874.18, + "p75": 2282.679, + "min": 839.642, + "max": 2965.198, + "samples": [ + 2320.566, + 2169.019, + 2965.198, + 2531.591, + 924.347, + 839.642, + 946.899, + 873.617, + 875.87, + 854.328 + ] + }, + "cpu_ms": { + "median": 950.702, + "p25": 892.992, + "p75": 1540.918, + "min": 861.669, + "max": 1586.478, + "samples": [ + 1557.765, + 1503.564, + 1553.369, + 1586.478, + 931.391, + 861.669, + 970.013, + 888.14, + 907.549, + 868.73 + ] + }, + "peak_rss_kib": { + "median": 268010.0, + "p25": 267013.0, + "p75": 268385.0, + "min": 266144, + "max": 268876, + "samples": [ + 266824, + 267580, + 266516, + 266144, + 267976, + 268304, + 268044, + 268480, + 268412, + 268876 + ] + }, + "behaviour_json_ms": { + "median": 34.288, + "p25": 23.085, + "p75": 37.474, + "min": 20.137, + "max": 70.397, + "samples": [ + 37.07, + 70.397, + 37.609, + 38.225, + 34.568, + 21.094, + 23.469, + 22.957, + 34.008, + 20.137 + ] + }, + "facts_ms": { + "median": 272.839, + "p25": 256.553, + "p75": 618.472, + "min": 248.146, + "max": 780.388, + "samples": [ + 625.908, + 693.735, + 780.388, + 596.165, + 272.718, + 249.954, + 272.959, + 264.913, + 253.767, + 248.146 + ] + }, + "behaviours_ms": { + "median": 162.633, + "p25": 133.345, + "p75": 326.117, + "min": 132.828, + "max": 476.9, + "samples": [ + 325.198, + 356.28, + 476.9, + 326.424, + 132.828, + 133.946, + 167.929, + 133.144, + 157.337, + 132.934 + ] + }, + "post_rss_kib": { + "median": 268408.0, + "p25": 267369.0, + "p75": 268861.0, + "min": 267052.0, + "max": 269072.0, + "samples": [ + 267084.0, + 268056.0, + 267052.0, + 267140.0, + 268184.0, + 268632.0, + 268660.0, + 269072.0, + 268928.0, + 268960.0 + ] + } + } + } +} diff --git a/crates/horizon-client/src/random_tick_sections.rs b/crates/horizon-client/src/random_tick_sections.rs index 647636fd6..97a1f02fa 100644 --- a/crates/horizon-client/src/random_tick_sections.rs +++ b/crates/horizon-client/src/random_tick_sections.rs @@ -208,7 +208,14 @@ mod tick_parity { let root = std::env::var_os("HORIZON_RESOURCES") .map(PathBuf::from) .unwrap_or_else(|| { - PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3") + let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + let local = manifest.join("../../.local/horizon-client/26.3"); + if local.join("gameplay-facts.json").exists() { + local + } else { + // The branch worktree lives below the main checkout. + manifest.join("../../../../.local/horizon-client/26.3") + } }); if !root.join("gameplay-facts.json").exists() { eprintln!( diff --git a/tools/PROFILE_SHARED_JSON.md b/tools/PROFILE_SHARED_JSON.md new file mode 100644 index 000000000..7712dda32 --- /dev/null +++ b/tools/PROFILE_SHARED_JSON.md @@ -0,0 +1,85 @@ +# Reproducing PR #607 block-facts startup profiles + +These are loader-only measurements. They include `Assets::load`, `BlockFacts`, and +`Behaviours` and exclude content root preparation, graphics, input setup, first +frame, and the rest of the client startup sequence. No full-client startup gain +has been measured. The prepared `26.3` resource root must match the revision. + +## Historical release builds + +From the PR branch checkout, use an absolute prepared resource-root path and a +single, explicit Cargo release profile for each detached historical worktree: + +```sh +PR_ROOT="$(pwd)" +BENCH_ROOT="$(mktemp -d)" +mkdir -p "$BENCH_ROOT/bin" +CARGO_TARGET_DIR="$BENCH_ROOT/target" +export CARGO_TARGET_DIR + +for entry in baseline:e422bd13 a01:a01d47f2 cf:cf837118 cd:cd61e11b; do + name="${entry%%:*}" + revision="${entry#*:}" + git worktree add --detach "$BENCH_ROOT/$name" "$revision" +done + +# e422bd13 predates the profiler; add the same baseline example source used +# for the benchmark, without changing any production implementation. +cp "$PR_ROOT/tools/baseline_loader_profile.rs" \ + "$BENCH_ROOT/baseline/crates/horizon-client/examples/shared_json_startup_profile.rs" + +for name in baseline a01 cf cd; do + (cd "$BENCH_ROOT/$name" && \ + cargo build --offline --release -p horizon-client --example shared_json_startup_profile) + cp "$CARGO_TARGET_DIR/release/examples/shared_json_startup_profile" \ + "$BENCH_ROOT/bin/$name" +done + +cargo build --offline --release -p horizon-client --example shared_json_startup_profile +cp "$CARGO_TARGET_DIR/release/examples/shared_json_startup_profile" "$BENCH_ROOT/bin/current" + +python3 tools/profile_client_startup.py \ + --resources /absolute/path/to/.local/horizon-client/26.3 \ + --baseline-binary "$BENCH_ROOT/bin/baseline" \ + --a01-binary "$BENCH_ROOT/bin/a01" \ + --cf-binary "$BENCH_ROOT/bin/cf" \ + --cd-binary "$BENCH_ROOT/bin/cd" \ + --binary "$BENCH_ROOT/bin/current" \ + --repeats 10 --output "$BENCH_ROOT/five-way.json" +``` + +The source tree of each historical revision is exact. The baseline profiler is +an added standalone measurement example, and therefore does not alter its +historical loader logic. Comparisons use alternating forward/reverse process +order, separate processes, Linux `wait4` CPU time and peak RSS, and saved raw +samples with 25th/75th percentiles, extrema, build hashes and system load. +Keep concurrent compilation and other CPU-intensive jobs idle if possible. +`ru_maxrss` records process peak residency and cannot establish the real game's +memory usage after rendering begins. If system load rises, preserve rather than +discard outliers and report the uncertainty. + +## Decoding passes and buffer lifetime + +```sh +cargo build --offline --release -p horizon-client --example gameplay_decode_profile +python3 tools/profile_gameplay_decode.py \ + --resources /absolute/path/to/.local/horizon-client/26.3 \ + --repeats 10 --output "$BENCH_ROOT/decode.json" + +python3 tools/profile_client_startup.py \ + --resources /absolute/path/to/.local/horizon-client/26.3 \ + --variant released="$BENCH_ROOT/bin/current"@deferred \ + --variant retained="$BENCH_ROOT/bin/current"@deferred-held \ + --repeats 10 --output "$BENCH_ROOT/lifetime.json" +``` + +The decoder profile measures the `Validate` pass and typed `Gameplay` pass +separately, including the JSON read in `total_ms`. The primary facts loader +continues both passes to preserve JSON validation, error precedence and useful +diagnostics, including overwritten fields and raw geometry. The lifetime +comparison measures current process `VmRSS` after materialisation, plus peak +RSS across the process. An explicit `drop` releases owned Rust values, but the +allocator may retain physical pages, so immediate RSS savings are not implied. + +When finished, `git worktree remove` each temporary historical worktree. Do +not `git clean` or reset the active PR working tree. diff --git a/tools/baseline_loader_profile.rs b/tools/baseline_loader_profile.rs new file mode 100644 index 000000000..f966301b8 --- /dev/null +++ b/tools/baseline_loader_profile.rs @@ -0,0 +1,23 @@ +//! Historical baseline comparator for PR #607; one normal independent loading sequence. +use horizon_client::{assets::Assets, blocks::BlockFacts}; +use horizon_world::level::Behaviours; +use std::{path::Path, time::Instant}; + +fn main() -> Result<(), Box> { + let mut args = std::env::args().skip(1); + let root = args.next().ok_or("expected prepared resource directory")?; + if args.next().as_deref() != Some("baseline") { + return Err("expected baseline".into()); + } + let root = Path::new(&root); + let total = Instant::now(); + let assets = Assets::load(root)?; + let started = Instant::now(); + let facts = BlockFacts::load(root, assets.registry)?; + let behaviours = Behaviours::load(assets.registry, root)?; + println!("phase_ms={:.3}", started.elapsed().as_secs_f64() * 1000.0); + println!("total_ms={:.3}", total.elapsed().as_secs_f64() * 1000.0); + println!("states={}", facts.states.len()); + std::hint::black_box((facts, behaviours)); + Ok(()) +}