diff --git a/openpilot/selfdrive/modeld/SConscript b/openpilot/selfdrive/modeld/SConscript index 5513394cd5..c5ba8f624e 100644 --- a/openpilot/selfdrive/modeld/SConscript +++ b/openpilot/selfdrive/modeld/SConscript @@ -6,7 +6,7 @@ from SCons.Script import Action, Value from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE, DM_INPUT_SIZE from openpilot.system.camerad.cameras.nv12_info import get_nv12_info -from tools.laptop_device_build.qcom_artifact_contract import import_artifact +from tools.laptop_device_build.qcom_artifact_contract import import_artifact, native_records, verify_native_defaults Import('env', 'arch') @@ -35,6 +35,31 @@ laptop_qcom_import = arch == 'comma_arm64' and os.getenv('COMMA_LAPTOP_CROSS_BUI qcom_package = Dir('#.cache/qcom-artifact-package').abspath +# Native defaults are release artifacts, not outputs of the legacy model compiler. +# Validate their current source/vendor/guard contract without regenerating them. +native_bundle = native_records(Path(Dir('#').abspath)) if arch == 'comma_arm64' else None +if native_bundle is not None: + native_root = Path(Dir('#').abspath) + native_bridge = native_root / 'openpilot/starpilot/models/runtime_bridge' + native_sources = [native_bridge / name for name in ( + 'native.py', 'native-policy.json', 'native_guards.py', 'bounded_wait.c', 'usb_guards.c', + 'libbounded_wait.so', 'libusb_guards.so')] + native_sources += [native_bridge.parent / 'catalog-native02e.json'] + for name in native_bundle: + base = native_root / 'openpilot/selfdrive/modeld/models' / name + native_sources += [path for path in (base, *base.parent.glob(base.name + '.chunk*')) if path.is_file()] + + def verify_native_bundle(target, source, env): + records = verify_native_defaults(native_root, prefer_regular=True) + stamp = Path(str(target[0])) + stamp.parent.mkdir(parents=True, exist_ok=True) + stamp.write_text(str({name: row['artifact_sha256'] for name, row in records.items()}) + '\n') + + native_node = lenv.Command('#.cache/native-model-defaults/verified', [File(str(path)) for path in native_sources], + Action(verify_native_bundle, ' [NATIVE MODEL VERIFY] $TARGET')) + lenv.AlwaysBuild(native_node) + + def model_action(command): if not laptop_qcom_import: return Action(command, " [ONNX] $TARGET") @@ -77,7 +102,8 @@ def compile_model(onnx_path, pkl_path): if laptop_qcom_import: lenv.AlwaysBuild(node) -compile_model('models/dmonitoring_model.onnx', 'models/dmonitoring_model_tinygrad.pkl') +if native_bundle is None: + compile_model('models/dmonitoring_model.onnx', 'models/dmonitoring_model_tinygrad.pkl') model_w, model_h = MEDMODEL_INPUT_SIZE for cam_w, cam_h in camera_configs: @@ -92,7 +118,7 @@ for cam_w, cam_h in camera_configs: lenv.AlwaysBuild(node) dm_w, dm_h = DM_INPUT_SIZE -for cam_w, cam_h in camera_configs: +for cam_w, cam_h in (() if native_bundle is not None else camera_configs): dm_pkl_path = File(f"models/dm_warp_{cam_w}x{cam_h}_tinygrad.pkl").abspath stride, y_height, uv_height, frame_size = get_nv12_info(cam_w, cam_h) cmd = (f'{tg_flags} {mac_brew_string} python3 "{compiler}/compile_warp.py" ' diff --git a/openpilot/selfdrive/modeld/dmonitoringmodeld.py b/openpilot/selfdrive/modeld/dmonitoringmodeld.py index fac5215f89..6fa5ef7ab4 100755 --- a/openpilot/selfdrive/modeld/dmonitoringmodeld.py +++ b/openpilot/selfdrive/modeld/dmonitoringmodeld.py @@ -47,8 +47,8 @@ class ModelState: self.model_run = jits['run'] self.outputs = {name: Tensor(np.zeros(shape, dtype=dtype), device=device).realize() for name, (shape, dtype, device) in jits['output_specs'].items()} warp_path = MODELS_DIR / f'dm_warp_{cam_w}x{cam_h}_tinygrad.pkl' - from openpilot.starpilot.models.runtime_bridge.runtime import selected_legacy, load_warp - if selected_legacy(): + from openpilot.starpilot.models.runtime_bridge.runtime import prepared, load_warp + if prepared(): self.image_warp = load_warp(warp_path) else: with warp_path.open('rb') as f: diff --git a/openpilot/selfdrive/modeld/helpers.py b/openpilot/selfdrive/modeld/helpers.py index eb15083db1..194ed242ff 100644 --- a/openpilot/selfdrive/modeld/helpers.py +++ b/openpilot/selfdrive/modeld/helpers.py @@ -15,9 +15,9 @@ def modeld_pkl_path(chestnut: bool): return materialize_file_chunked(path) if path.is_file() or Path(f'{path}.chunkmanifest').exists() else path def load_oob(path, chestnut=False): - from openpilot.starpilot.models.runtime_bridge.runtime import selected_legacy, load_oob as protected_load + from openpilot.starpilot.models.runtime_bridge.runtime import prepared, load_oob as protected_load if AGNOS: - if not selected_legacy(): + if not prepared(): raise RuntimeError('Prepare the model runtime before loading a device artifact') return protected_load(materialize_file_chunked(path), chestnut) from tinygrad import Context diff --git a/openpilot/selfdrive/modeld/modeld.py b/openpilot/selfdrive/modeld/modeld.py index e77e8ffccb..3c7df5c4e1 100755 --- a/openpilot/selfdrive/modeld/modeld.py +++ b/openpilot/selfdrive/modeld/modeld.py @@ -8,8 +8,9 @@ from functools import cached_property import os os.environ['GMMU'] = '0' # for chestnut fast loading, noop for qcom os.environ.setdefault('AM_POWER_LIMIT', '100') -from openpilot.starpilot.models.runtime_bridge.runtime import prepare as prepare_model_runtime, selected_legacy +from openpilot.starpilot.models.runtime_bridge.runtime import prepare as prepare_model_runtime, selected_legacy, selected_plan prepare_model_runtime('driving') +MODEL_RUNTIME_PLAN = selected_plan() from tinygrad.device import Buffer, Device from tinygrad.dtype import DType, dtypes from tinygrad.engine.realize import lower_and_compile @@ -50,7 +51,7 @@ from openpilot.starpilot.models.status import ModelVariant from openpilot.starpilot.models.startup import report_load_timeout, wait_for_chestnut_power from openpilot.starpilot.models.recovery import STARTUP_FALLBACK_EXIT from openpilot.starpilot.navigation.intent import TurnIntent, matching_turn_signal -from openpilot.starpilot.models.catalog import BUNDLED_CURRENT, BY_ID, DEFAULT_SMALL, DEFAULT_SMALL_SHA256 +from openpilot.starpilot.models.catalog import BUNDLED_CURRENT, DEFAULT_SMALL from openpilot.starpilot.models.runner import CatalogModelState, load_verified_model from openpilot.starpilot.models import jetlink_adapter import uuid @@ -290,8 +291,8 @@ def main(demo=False): # a Jetson, PC or phone on the port looks like a chestnut to cable_connected(): the cable counts with Jetlink off only chestnut_available = chestnut_present() or (cable_connected() and not jetlink_adapter.link_on()) recovery_small_only = os.getenv("STARPILOT_MODELD_RECOVERY_SMALL_ONLY") == "1" - selection = resolve_runtime(chestnut_available=chestnut_available and not recovery_small_only, randomize=not recovery_small_only) - requested_model_id = requested_runtime_id(chestnut_available) + selection = resolve_runtime(chestnut_available=chestnut_available and not recovery_small_only, plan=MODEL_RUNTIME_PLAN) + requested_model_id = requested_runtime_id(chestnut_available, plan=MODEL_RUNTIME_PLAN) CHESTNUT = selection.allow_big and selection.big_path is not None if CHESTNUT: from tinygrad.runtime.support.am import startup_trace @@ -350,13 +351,12 @@ def main(demo=False): return selected, prepared, False except Exception: cloudlog.exception("selected small model load failed, using shipped RDFv4") - from openpilot.starpilot.models.manager import shipped_default - path = shipped_default() + path = selection.fallback_path if path is None: raise RuntimeError("Shipped RDFv4 is missing or corrupt") fallback, prepared = load_verified_model(vipc_client_main.width, vipc_client_main.height, - path, BY_ID[DEFAULT_SMALL].version, False, - DEFAULT_SMALL, DEFAULT_SMALL_SHA256) + path, selection.fallback_version, False, + DEFAULT_SMALL, selection.fallback_sha256) return fallback, prepared, selection.small_id != DEFAULT_SMALL # Preload a custom fallback before the GPU worker takes the catalog lock. diff --git a/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunk01of03 b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunk01of03 new file mode 100644 index 0000000000..190e70cabe Binary files /dev/null and b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunk01of03 differ diff --git a/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunk02of03 b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunk02of03 new file mode 100644 index 0000000000..6b53962814 Binary files /dev/null and b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunk02of03 differ diff --git a/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunk03of03 b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunk03of03 new file mode 100644 index 0000000000..a6ae382b5d Binary files /dev/null and b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunk03of03 differ diff --git a/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunkmanifest b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunkmanifest new file mode 100644 index 0000000000..e440e5c842 --- /dev/null +++ b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunkmanifest @@ -0,0 +1 @@ +3 \ No newline at end of file diff --git a/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunksha256 b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunksha256 new file mode 100644 index 0000000000..0c861ade46 --- /dev/null +++ b/openpilot/selfdrive/modeld/models/compat9d/rdf43_driving_tinygrad.pkl.chunksha256 @@ -0,0 +1,18 @@ +{ + "bytes": 125895084, + "sha256": "e23f65b3790a2092348024603966717506c2ad1fae10b4312bdfe1f2b932df61", + "parts": [ + { + "bytes": 47185920, + "sha256": "268527c074b659a76c495d91afac8aee21e12100cc0191daa116f0db633b9165" + }, + { + "bytes": 47185920, + "sha256": "8622fdec72524dbc80c744fa17b92edea59d5889f0e1c4d02d3e4e8d44521d2b" + }, + { + "bytes": 31523244, + "sha256": "9cff2854787bf48fd7fd0f64a4a243a0011ed76cc3c09fb3399c0d3d9661d1d1" + } + ] +} diff --git a/openpilot/selfdrive/modeld/models/dm_warp_1344x760_tinygrad.pkl b/openpilot/selfdrive/modeld/models/dm_warp_1344x760_tinygrad.pkl index bba9ce80a5..ef78c1b6ad 100644 Binary files a/openpilot/selfdrive/modeld/models/dm_warp_1344x760_tinygrad.pkl and b/openpilot/selfdrive/modeld/models/dm_warp_1344x760_tinygrad.pkl differ diff --git a/openpilot/selfdrive/modeld/models/dm_warp_1928x1208_tinygrad.pkl b/openpilot/selfdrive/modeld/models/dm_warp_1928x1208_tinygrad.pkl index e59eed792c..db352f7255 100644 Binary files a/openpilot/selfdrive/modeld/models/dm_warp_1928x1208_tinygrad.pkl and b/openpilot/selfdrive/modeld/models/dm_warp_1928x1208_tinygrad.pkl differ diff --git a/openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl.chunk01of01 b/openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl.chunk01of01 index dc0264429c..8e4dc3a22d 100644 Binary files a/openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl.chunk01of01 and b/openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl.chunk01of01 differ diff --git a/openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl.chunksha256 b/openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl.chunksha256 index 2129ef43b9..2c99c909f6 100644 --- a/openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl.chunksha256 +++ b/openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl.chunksha256 @@ -1,10 +1,10 @@ { - "bytes": 20768359, - "sha256": "7f7198c63d2d9b0d015cc860fdd836db50a4b9a75ab5d56cffd4d4eee5eb7b97", + "bytes": 20778338, + "sha256": "2dfdf58712f29be92d37f0b6b06d6ae78626831c3b9e7a0c990d40e8ef84b3a2", "parts": [ { - "bytes": 20768359, - "sha256": "7f7198c63d2d9b0d015cc860fdd836db50a4b9a75ab5d56cffd4d4eee5eb7b97" + "bytes": 20778338, + "sha256": "2dfdf58712f29be92d37f0b6b06d6ae78626831c3b9e7a0c990d40e8ef84b3a2" } ] } diff --git a/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk01of03 b/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk01of03 index 190e70cabe..ce7f3e86e9 100644 Binary files a/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk01of03 and b/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk01of03 differ diff --git a/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk02of03 b/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk02of03 index 6b53962814..ecdc224f84 100644 Binary files a/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk02of03 and b/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk02of03 differ diff --git a/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk03of03 b/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk03of03 index a6ae382b5d..4a038f1f05 100644 Binary files a/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk03of03 and b/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunk03of03 differ diff --git a/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunksha256 b/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunksha256 index 0c861ade46..1a4ff569e3 100644 --- a/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunksha256 +++ b/openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl.chunksha256 @@ -1,18 +1,18 @@ { - "bytes": 125895084, - "sha256": "e23f65b3790a2092348024603966717506c2ad1fae10b4312bdfe1f2b932df61", + "bytes": 114218310, + "sha256": "efc9c780a824c798c629776601dc7b26aaa1e1270e048d9f90dd2f164de380a9", "parts": [ { "bytes": 47185920, - "sha256": "268527c074b659a76c495d91afac8aee21e12100cc0191daa116f0db633b9165" + "sha256": "3e6df8f84030d138d5fdee925b8eeb80bc33468c3406340fd2a026e86ec51b33" }, { "bytes": 47185920, - "sha256": "8622fdec72524dbc80c744fa17b92edea59d5889f0e1c4d02d3e4e8d44521d2b" + "sha256": "8a538d5122992ad2d137164a23df0be5fd322d4f6cbb1c9a4561b903ace1420d" }, { - "bytes": 31523244, - "sha256": "9cff2854787bf48fd7fd0f64a4a243a0011ed76cc3c09fb3399c0d3d9661d1d1" + "bytes": 19846470, + "sha256": "2021d5b79a036efb899ac7423f3c84ec5e59b8ab2859c01402bcba757200767e" } ] } diff --git a/openpilot/starpilot/models/catalog-native02e.json b/openpilot/starpilot/models/catalog-native02e.json new file mode 100644 index 0000000000..9865e715e0 --- /dev/null +++ b/openpilot/starpilot/models/catalog-native02e.json @@ -0,0 +1,188 @@ +{ + "artifact_abi": "tinygrad_single_v2_arena", + "compiler_revision": "02e698160eed1751738212144a7ea2cfb160b3f1", + "generation": "native02e-v1", + "models": [ + { + "artifact_chunk_count": 18, + "artifact_format": "tinygrad_single_v2_arena", + "artifact_sha256": "868b3e775ab92e223a1618e5b9f2690976cbdb61e27516e50a43db96375586b8", + "artifact_size": 804719273, + "community_favorite": false, + "id": "traintrack", + "name": "Train Track \ud83d\udc40\ud83d\udce1", + "qualification_scope": "Native ONNX compilation with original five-frame capture/reload checks; exact retained GPU kernels and weights during bounded-guard preparation; fresh final-source guarded CatalogModelState/Parser runner, four seeded frames at 1928x1208. No physical acceptance or startup speedup asserted.", + "qualification_sha256": "3d7f485199fa8532b41b2d1ce3e484718bffb4c17a587a18b86ceee24ebbf5ff", + "released": "2026-10-17", + "series": "OP Series", + "source_bytes": 792467570, + "source_sha256": "ceb38c593005b3338aee4ca057d5ad9ee64c58f8fdba0b41641a9d4cc6c36e36", + "uses_external_gpu": true, + "version": "v16" + }, + { + "artifact_chunk_count": 18, + "artifact_format": "tinygrad_single_v2_arena", + "artifact_sha256": "6a9ccfb1d9c6a518435cddc13e990bd1c89bc87f2d3a5591a8e1a69d4cd552e2", + "artifact_size": 804719273, + "community_favorite": false, + "id": "mountaindewv3", + "name": "Mountain Dew v3 \ud83d\udc40\ud83d\udce1", + "qualification_scope": "Native ONNX compilation with original five-frame capture/reload checks; exact retained GPU kernels and weights during bounded-guard preparation; fresh final-source guarded CatalogModelState/Parser runner, four seeded frames at 1344x760. No physical acceptance or startup speedup asserted.", + "qualification_sha256": "ac3637cb238f9599a43f77144bc332be6930627d77bad098acbcfd6f1d777748", + "released": "2026-10-14", + "series": "OP Series", + "source_bytes": 792542056, + "source_sha256": "1cfd2c45353d876b5b257b24d77537de58ab90a44ae595f15b1f64b6ea3fd770", + "uses_external_gpu": true, + "version": "v16" + }, + { + "artifact_chunk_count": 18, + "artifact_format": "tinygrad_single_v2_arena", + "artifact_sha256": "d4bd838f4cfe2465c2ecac3efa32aeeddd9d1a3c0ed80b1987ee87a1a3470358", + "artifact_size": 804718917, + "community_favorite": false, + "id": "mountaindewv2", + "name": "Mountain Dew v2 \ud83d\udc40\ud83d\udce1", + "qualification_scope": "Native ONNX compilation with original five-frame capture/reload checks; exact retained GPU kernels and weights during bounded-guard preparation; fresh final-source guarded CatalogModelState/Parser runner, four seeded frames at 1344x760. No physical acceptance or startup speedup asserted.", + "qualification_sha256": "5b79ede3cf0809fce8497bb7f8feca86be6f387c68c0e706177ed73068927683", + "released": "2026-10-10", + "series": "OP Series", + "source_bytes": 792430559, + "source_sha256": "87fe86ca0813c099efddf9173ba503be2e40ea4c5362c36812a44141f4cb07d4", + "uses_external_gpu": true, + "version": "v16" + }, + { + "artifact_chunk_count": 18, + "artifact_format": "tinygrad_single_v2_arena", + "artifact_sha256": "787b13a040362f4efcfca15bf95f7a36694ba21fb8175d8557ed579ceffde282", + "artifact_size": 804719273, + "community_favorite": false, + "id": "mountaindewv1", + "name": "Mountain Dew v1 \ud83d\udc40\ud83d\udce1", + "qualification_scope": "Native ONNX compilation with original five-frame capture/reload checks; exact retained GPU kernels and weights during bounded-guard preparation; fresh final-source guarded CatalogModelState/Parser runner, four seeded frames at 1344x760. No physical acceptance or startup speedup asserted.", + "qualification_sha256": "497a0f262de83a911ba4dbb1d63f9ffbf51567e155574e72170f94949cafa88d", + "released": "2026-10-08", + "series": "OP Series", + "source_bytes": 792487890, + "source_sha256": "c392ba1aa1b4b89e850366024fa6c1beac1f1fdc3a7182e3c3b0234c55e08eeb", + "uses_external_gpu": true, + "version": "v16" + }, + { + "artifact_chunk_count": 18, + "artifact_format": "tinygrad_single_v2_arena", + "artifact_sha256": "10aa579f2181154996afc04f30337a7b42c7768f92d2bbdc92d8685acbd725ca", + "artifact_size": 804718766, + "community_favorite": false, + "id": "resfit", + "name": "ResFit", + "qualification_scope": "Native ONNX compilation with original five-frame capture/reload checks; exact retained GPU kernels and weights during bounded-guard preparation; fresh final-source guarded CatalogModelState/Parser runner, four seeded frames at 1344x760. No physical acceptance or startup speedup asserted.", + "qualification_sha256": "cb84da0893e25cfec8f581c7c043949a0f6a830ab9e4745d2f7ab0e8b9e86d43", + "released": "2026-10-06", + "series": "OP Series", + "source_bytes": 792485215, + "source_sha256": "1563b85f6bd00d9e2edf50bdb69646f0d95d5ac0f218d5abe3fe54a13427d71b", + "uses_external_gpu": true, + "version": "v16" + }, + { + "artifact_chunk_count": 17, + "artifact_format": "tinygrad_single_v2_arena", + "artifact_sha256": "d4613485c31cc28ab9b75fc8c14072354586c83e3e799e94682dcf06026b8f80", + "artifact_size": 778866789, + "community_favorite": false, + "id": "cinquev3", + "name": "Cinque v3 \ud83d\udc40\ud83d\udce1", + "qualification_scope": "Native ONNX compilation with original five-frame capture/reload checks; exact retained GPU kernels and weights during bounded-guard preparation; fresh final-source guarded CatalogModelState/Parser runner, four seeded frames at 1344x760. No physical acceptance or startup speedup asserted.", + "qualification_sha256": "b169cef607dbb650f055ef87ace3c76f43013da3798ea3d3af384ae2b95026e5", + "released": "2026-09-18", + "series": "OP Series", + "source_bytes": 766354845, + "source_sha256": "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4", + "uses_external_gpu": true, + "version": "v16" + }, + { + "artifact_chunk_count": 3, + "artifact_format": "tinygrad_single_v2_arena", + "artifact_sha256": "efc9c780a824c798c629776601dc7b26aaa1e1270e048d9f90dd2f164de380a9", + "artifact_size": 114218310, + "community_favorite": false, + "id": "rdf43", + "model_lab_eligible": true, + "model_size": "small", + "name": "Regret Driven Framework V4 \ud83d\udc40\ud83d\udce1", + "qualification_scope": "Native ONNX compilation with original five-frame capture/reload checks; exact retained GPU kernels and weights during bounded-guard preparation; fresh final-source guarded CatalogModelState/Parser runner, four seeded frames at 1344x760. No physical acceptance or startup speedup asserted.", + "qualification_sha256": "0d0ff59d57da106f042ec79636c65dbcd805d4d15c81a79ae9a7551b46dc5ecd", + "released": "2026-08-10", + "series": "OP Series", + "source_bytes": 96636386, + "source_sha256": "b9550d192e32769f1fca82b2e2f2fae65e335b9f6fbbda2b455fcc8b2207bef6", + "version": "v15" + } + ], + "status": "QUALIFIED_NATIVE_RELEASE", + "stock": { + "dm_warp_1344x760_tinygrad.pkl": { + "artifact_sha256": "095467b3397526455aba3573e2458d960cbe195e23f8f91d46ef5e886074006c", + "artifact_size": 1397668, + "qualification_scope": "Actual four-frame driver-monitoring ModelState and both camera warps; 88 output arrays and state histories exact per camera against raw native captures. No road acceptance or speedup asserted.", + "qualification_sha256": "6d9b4ad05d673a352f152b2b6327bcff6de6dbc76c3c96204fb839b67b920fc0", + "source_geometry": { + "border_fill": 16, + "camera": [ + 1344, + 760 + ], + "layout": "luma", + "nv12": [ + 1408, + 768, + 384, + 2428928 + ], + "transform_device": "NPY", + "warp_to": [ + 1440, + 960 + ] + } + }, + "dm_warp_1928x1208_tinygrad.pkl": { + "artifact_sha256": "05021aae07d80fe8ccdd593581398e6432c52d7132384f706c0e2f75d69a7a3b", + "artifact_size": 1397620, + "qualification_scope": "Actual four-frame driver-monitoring ModelState and both camera warps; 88 output arrays and state histories exact per camera against raw native captures. No road acceptance or speedup asserted.", + "qualification_sha256": "6d9b4ad05d673a352f152b2b6327bcff6de6dbc76c3c96204fb839b67b920fc0", + "source_geometry": { + "border_fill": 16, + "camera": [ + 1928, + 1208 + ], + "layout": "luma", + "nv12": [ + 2048, + 1216, + 608, + 4804608 + ], + "transform_device": "NPY", + "warp_to": [ + 1440, + 960 + ] + } + }, + "dmonitoring_model_tinygrad.pkl": { + "artifact_sha256": "2dfdf58712f29be92d37f0b6b06d6ae78626831c3b9e7a0c990d40e8ef84b3a2", + "artifact_size": 20778338, + "qualification_scope": "Actual four-frame driver-monitoring ModelState and both camera warps; 88 output arrays and state histories exact per camera against raw native captures. No road acceptance or speedup asserted.", + "qualification_sha256": "6d9b4ad05d673a352f152b2b6327bcff6de6dbc76c3c96204fb839b67b920fc0", + "source_bytes": 7844499, + "source_sha256": "dee5a294e8afaacc9295ac5d100e00733ecac278e79264b96331e40a3ede1b04" + } + } +} diff --git a/openpilot/starpilot/models/catalog.py b/openpilot/starpilot/models/catalog.py index 6cc9cc06b8..4441b3daf3 100644 --- a/openpilot/starpilot/models/catalog.py +++ b/openpilot/starpilot/models/catalog.py @@ -1,10 +1,12 @@ """Reviewed local driving-model catalog. This module never loads model artifacts.""" -from dataclasses import dataclass, replace +from dataclasses import dataclass from functools import lru_cache import json from pathlib import Path +from openpilot.starpilot.models.runtime_selection import NATIVE_ABI, NATIVE_REVISION + BUNDLED_CURRENT = "bundled-current" DEFAULT_SMALL = "rdf43" @@ -14,6 +16,7 @@ GENERATION = "v26" COMPILER_REVISION = "9d0446a4ba8a532c8b674fb6ad795af015cd9dcf" ARTIFACT_ABI = "tinygrad_single_v1_arena" CATALOG_PATH = Path(__file__).with_name("catalog-v26.json") +NATIVE_CATALOG_PATH = Path(__file__).with_name("catalog-native02e.json") @dataclass(frozen=True) @@ -33,10 +36,10 @@ BUNDLED = ( ModelEntry( model_id=BUNDLED_CURRENT, name="Regret Driven Framework V4", - source_sha256=DEFAULT_SMALL_SHA256, + source_sha256="", source_path="openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl", - compiler_revision="9d0446a4ba8a532c8b674fb6ad795af015cd9dcf", - artifact_abi=ARTIFACT_ABI, + compiler_revision=NATIVE_REVISION, + artifact_abi=NATIVE_ABI, selectable=True, version="v15", ), @@ -44,9 +47,10 @@ BUNDLED = ( CATALOG = BUNDLED + tuple(ModelEntry( model_id=m["id"], name=m["name"], - source_sha256=DEFAULT_SMALL_SHA256 if m["id"] == DEFAULT_SMALL else "", + source_sha256="", source_path="openpilot/selfdrive/modeld/models/rdf43_driving_tinygrad.pkl" if m["id"] == DEFAULT_SMALL else "", - compiler_revision=COMPILER_REVISION, artifact_abi=ARTIFACT_ABI, selectable=True, + compiler_revision=NATIVE_REVISION if m["id"] == DEFAULT_SMALL else COMPILER_REVISION, + artifact_abi=NATIVE_ABI if m["id"] == DEFAULT_SMALL else ARTIFACT_ABI, selectable=True, version=m["version"], uses_external_gpu=bool(m.get("uses_external_gpu", False)), ) for m in json.loads(CATALOG_PATH.read_text())["models"]) @@ -66,9 +70,11 @@ def _cached_entries(root: Path, identities: tuple) -> tuple[ModelEntry, ...]: from openpilot.starpilot.models.manager import catalog entries = dict(BY_ID) for model_id, row in catalog(root).items(): - entries[model_id] = (replace(BY_ID[model_id], name=row["name"]) if model_id in BY_ID else - ModelEntry(model_id, row["name"], "", "", COMPILER_REVISION, ARTIFACT_ABI, - True, row["version"], row.get("uses_external_gpu", False))) + entries[model_id] = ModelEntry(model_id, row["name"], + row.get("artifact_sha256", "") if model_id == DEFAULT_SMALL else "", + BY_ID[model_id].source_path if model_id in BY_ID else "", + row.get("compiler_revision", COMPILER_REVISION), row.get("artifact_format", ARTIFACT_ABI), + True, row["version"], row.get("uses_external_gpu", False)) return tuple(entries.values()) @@ -76,7 +82,8 @@ def model_entries(root: Path | None = None) -> dict[str, ModelEntry]: """Resolve validated cached metadata without mutating the bundled catalog.""" from openpilot.starpilot.models.manager import ROOT root = ROOT if root is None else root - identities = (_document_identity(CATALOG_PATH), _document_identity(root / "catalog.json")) + identities = (_document_identity(CATALOG_PATH), _document_identity(root / "catalog.json"), + _document_identity(NATIVE_CATALOG_PATH), _document_identity(root / "native02e-v1/catalog.json")) return {entry.model_id: entry for entry in _cached_entries(root, identities)} diff --git a/openpilot/starpilot/models/compile_native.py b/openpilot/starpilot/models/compile_native.py new file mode 100644 index 0000000000..0aa95e8ac2 --- /dev/null +++ b/openpilot/starpilot/models/compile_native.py @@ -0,0 +1,753 @@ +"""Compile StarPilot unified driving artifacts against the vendored tinygrad runtime.""" +import argparse +import base64 +import hashlib +import json +import math +import os +from pathlib import Path +import pickle +import tempfile +import time +from collections import namedtuple +from functools import partial + +import numpy as np +from tinygrad import Device, TinyJit, Context, Tensor +from tinygrad.dtype import _to_np_dtype, dtypes +from tinygrad.device import Buffer, BufferSpec +from tinygrad.uop.ops import UOp +from tinygrad_repo.examples.openpilot.helpers import dump_pickle, load_pickle + +COMPILER_REVISION = "02e698160eed1751738212144a7ea2cfb160b3f1" +ARTIFACT_ABI = "tinygrad_single_v2_arena" +_PRE_HCQ_RECORDS = {} + + +def make_metadata_dict(path, runner): + from tinygrad.nn.onnx import OnnxPBParser + + parser = OnnxPBParser(path, load_external_data=False) + properties, output_shapes = {}, {} + for field, wire_type in parser._parse_message(parser.reader.len): + if field == 14: + entry = parser._parse_StringStringEntryProto() + properties[entry['key']] = entry['value'] + elif field == 7: + for field, wire_type in parser._parse_message(parser._decode_end_pos()): + if field == 12: + value = parser._parse_ValueInfoProto() + output_shapes[value['name']] = value['parsed_type'].shape if value['parsed_type'] is not None else () + else: + parser.reader.skip_field(wire_type) + else: + parser.reader.skip_field(wire_type) + if "output_slices" not in properties: + raise ValueError(f"Missing output_slices metadata: {path}") + return { + "model_checkpoint": properties.get("model_checkpoint"), + "output_slices": pickle.loads(base64.b64decode(properties["output_slices"])), + "input_shapes": {name: tuple(spec.shape) for name, spec in runner.graph_inputs.items()}, + "output_shapes": output_shapes, + } + + +ARTIFACT_FORMAT_VERSION = 1 +MODEL_TYPES = ("vision_policy", "vision_multi_policy", "supercombo") +NV12Frame = namedtuple("NV12Frame", ["width", "height", "stride", "y_height", "uv_height", "size"]) +IMAGE_HISTORY_IN_WARP = "warp" +IMAGE_HISTORY_IN_POLICY = "policy" +IMAGE_HISTORY_PIPELINES = (IMAGE_HISTORY_IN_WARP, IMAGE_HISTORY_IN_POLICY) +LEGACY_WARP_INPUTS = ("img_q", "big_img_q", "tfm", "big_tfm") +FAST_WARP_INPUTS = ("tfm", "big_tfm") +BASE_POLICY_INPUTS = ("feat_q", "desire_q", "packed_npy_inputs") +FAST_POLICY_INPUTS = ("img_q", "big_img_q", *BASE_POLICY_INPUTS) +WARP_INPUTS = LEGACY_WARP_INPUTS +SPLIT_POLICY_INPUTS = BASE_POLICY_INPUTS +SUPERCOMBO_POLICY_INPUTS = BASE_POLICY_INPUTS +WARP_DEV = os.getenv("WARP_DEV") + + + +def _detect_desire_key(input_shapes): + return next((key for key in input_shapes if key.startswith("desire")), None) + + +def _detect_vision_keys(input_shapes): + image_keys = sorted(key for key in input_shapes if "img" in key) + road_key = next((key for key in image_keys if "big" not in key), None) + wide_key = next((key for key in image_keys if "big" in key), None) + if road_key is None or wide_key is None: + raise ValueError(f"Cannot determine road/wide image keys from {list(input_shapes)}") + return road_key, wide_key + + +def derive_frame_skip(input_shapes): + features_shape = input_shapes.get("features_buffer") + if features_shape is None: + return 1 + return 1 if features_shape[1] >= 99 else 4 + + +def make_random_images(keys, shape, device=None, *, rng=None): + return {key: Tensor.randint(shape, low=0, high=256, dtype="uint8", device=device).realize() for key in keys} + + +def make_random_blob_images(keys, size, device=None): + keepalive: list[np.ndarray] = [] + + def make_inputs(*, rng): + nonlocal keepalive + keepalive = [] + tensors = {} + for key in keys: + frame = (32 * rng.standard_normal(size).astype(np.float32) + 128).clip(0, 255).astype(np.uint8) + keepalive.append(frame) + tensors[key] = Tensor.from_blob(frame.ctypes.data, (size,), dtype="uint8", device=device).realize() + return tensors + + return make_inputs + + +def warp_perspective_tinygrad(src_flat, matrix_inverse, dst_shape, src_shape, stride_pad, border_fill_val=None): + width_dst, height_dst = dst_shape + height_src, width_src = src_shape + + x = Tensor.arange(width_dst).reshape(1, width_dst).expand(height_dst, width_dst).reshape(-1) + y = Tensor.arange(height_dst).reshape(height_dst, 1).expand(height_dst, width_dst).reshape(-1) + + src_x = matrix_inverse[0, 0] * x + matrix_inverse[0, 1] * y + matrix_inverse[0, 2] + src_y = matrix_inverse[1, 0] * x + matrix_inverse[1, 1] * y + matrix_inverse[1, 2] + src_w = matrix_inverse[2, 0] * x + matrix_inverse[2, 1] * y + matrix_inverse[2, 2] + src_x = src_x / src_w + src_y = src_y / src_w + + x_round = Tensor.round(src_x) + y_round = Tensor.round(src_y) + x_nn_clipped = x_round.clip(0, width_src - 1).cast("int") + y_nn_clipped = y_round.clip(0, height_src - 1).cast("int") + sampled = src_flat[y_nn_clipped * (width_src + stride_pad) + x_nn_clipped] + + if border_fill_val is None: + return sampled + + in_bounds = ((x_round >= 0) & (x_round <= width_src - 1) & + (y_round >= 0) & (y_round <= height_src - 1)).cast(sampled.dtype) + return sampled * in_bounds + Tensor(border_fill_val, dtype=sampled.dtype) * (1 - in_bounds) + + +def frames_to_tensor(frames): + height = (frames.shape[0] * 2) // 3 + width = frames.shape[1] + return Tensor.cat( + frames[0:height:2, 0::2], + frames[1:height:2, 0::2], + frames[0:height:2, 1::2], + frames[1:height:2, 1::2], + frames[height:height + height // 4].reshape((height // 2, width // 2)), + frames[height + height // 4:height + height // 2].reshape((height // 2, width // 2)), + dim=0, + ).reshape((6, height // 2, width // 2)) + + +def make_frame_prepare(nv12: NV12Frame, model_w, model_h): + cam_w, cam_h, stride, y_height, uv_height, _ = nv12 + uv_offset = stride * y_height + stride_pad = stride - cam_w + + def frame_prepare(input_frame, matrix_inverse): + matrix_inverse_uv = matrix_inverse * Tensor( + [[1.0, 1.0, 0.5], [1.0, 1.0, 0.5], [2.0, 2.0, 1.0]], + device=WARP_DEV, + ) + uv = input_frame[uv_offset:uv_offset + uv_height * stride].reshape(uv_height, stride) + with Context(SPLIT_REDUCEOP=0): + y = warp_perspective_tinygrad( + input_frame[:cam_h * stride], matrix_inverse, (model_w, model_h), (cam_h, cam_w), stride_pad, + ).realize() + u = warp_perspective_tinygrad( + uv[:cam_h // 2, :cam_w:2].flatten(), matrix_inverse_uv, + (model_w // 2, model_h // 2), (cam_h // 2, cam_w // 2), 0, + ).realize() + v = warp_perspective_tinygrad( + uv[:cam_h // 2, 1:cam_w:2].flatten(), matrix_inverse_uv, + (model_w // 2, model_h // 2), (cam_h // 2, cam_w // 2), 0, + ).realize() + return frames_to_tensor(y.cat(u).cat(v).reshape((model_h * 3 // 2, model_w))) + + return frame_prepare + + +def make_warp_input_queues(vision_input_shapes, frame_skip, device): + road_key, _ = _detect_vision_keys(vision_input_shapes) + image_shape = vision_input_shapes[road_key] + frame_count = image_shape[1] // 6 + image_buffer_shape = (frame_skip * (frame_count - 1) + 1, 6, image_shape[2], image_shape[3]) + + npy = { + "tfm": np.zeros((3, 3), dtype=np.float32), + "big_tfm": np.zeros((3, 3), dtype=np.float32), + } + queues = { + "img_q": Tensor(np.zeros(image_buffer_shape, dtype=np.uint8), device=device).contiguous().realize(), + "big_img_q": Tensor(np.zeros(image_buffer_shape, dtype=np.uint8), device=device).contiguous().realize(), + **{key: Tensor(value, device="NPY").realize() for key, value in npy.items()}, + } + return queues, npy + + +def _packed_policy_shapes(input_shapes, include_prev_feature=False): + desire_key = _detect_desire_key(input_shapes) + if desire_key is None: + raise ValueError(f"No desire input found in {list(input_shapes)}") + + shapes = {"desire": (input_shapes[desire_key][2],)} + for key, shape in input_shapes.items(): + if key in ("features_buffer", desire_key) or "img" in key: + continue + shapes[key] = tuple(shape) + if include_prev_feature: + features_shape = input_shapes["features_buffer"] + shapes["prev_feat"] = (features_shape[0], math.prod(features_shape[2:])) + return shapes, [math.prod(shape) for shape in shapes.values()] + + +def make_split_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, device): + queues, npy = make_warp_input_queues(vision_input_shapes, frame_skip, device) + features_shape = policy_input_shapes["features_buffer"] + feature_dim = math.prod(features_shape[2:]) + desire_key = _detect_desire_key(policy_input_shapes) + desire_shape = policy_input_shapes[desire_key] + packed_shapes, packed_sizes = _packed_policy_shapes(policy_input_shapes) + + packed_inputs = np.zeros(sum(packed_sizes), dtype=np.float32) + npy.update({ + key: value.reshape(shape) + for (key, shape), value in zip( + packed_shapes.items(), np.split(packed_inputs, np.cumsum(packed_sizes[:-1])), strict=True, + ) + }) + queues.update({ + "feat_q": Tensor( + np.zeros((frame_skip * (features_shape[1] - 1) + 1, features_shape[0], feature_dim), dtype=np.float32), + device=device, + ).contiguous().realize(), + "desire_q": Tensor( + np.zeros((frame_skip * desire_shape[1], desire_shape[0], desire_shape[2]), dtype=np.float32), + device=device, + ).contiguous().realize(), + "packed_npy_inputs": Tensor(packed_inputs, device="NPY").realize(), + }) + return queues, npy + + +def make_supercombo_input_queues(input_shapes, frame_skip, device): + queues, npy = make_warp_input_queues(input_shapes, frame_skip, device) + features_shape = input_shapes["features_buffer"] + feature_dim = math.prod(features_shape[2:]) + desire_key = _detect_desire_key(input_shapes) + desire_shape = input_shapes[desire_key] + packed_shapes, packed_sizes = _packed_policy_shapes(input_shapes, include_prev_feature=True) + + packed_inputs = np.zeros(sum(packed_sizes), dtype=np.float32) + npy.update({ + key: value.reshape(shape) + for (key, shape), value in zip( + packed_shapes.items(), np.split(packed_inputs, np.cumsum(packed_sizes[:-1])), strict=True, + ) + }) + queues.update({ + "feat_q": Tensor( + np.zeros((frame_skip * features_shape[1], features_shape[0], feature_dim), dtype=np.float32), + device=device, + ).contiguous().realize(), + "desire_q": Tensor( + np.zeros((frame_skip * desire_shape[1], desire_shape[0], desire_shape[2]), dtype=np.float32), + device=device, + ).contiguous().realize(), + "packed_npy_inputs": Tensor(packed_inputs, device="NPY").realize(), + }) + return queues, npy + + +def shift_and_sample(buffer, new_value, sample_fn): + buffer.assign(buffer[1:].cat(new_value, dim=0).contiguous()) + return sample_fn(buffer) + + +def sample_skip(buffer, frame_skip): + return buffer[::frame_skip].contiguous().flatten(0, 1).unsqueeze(0) + + +def sample_desire(buffer, frame_skip): + return buffer.reshape(-1, frame_skip, *buffer.shape[1:]).max(1).flatten(0, 1).unsqueeze(0) + + +def make_warp(nv12, model_w, model_h, frame_skip, image_history_pipeline=IMAGE_HISTORY_IN_POLICY): + frame_prepare = make_frame_prepare(nv12, model_w, model_h) + + if image_history_pipeline == IMAGE_HISTORY_IN_POLICY: + def warp(tfm, big_tfm, frame, big_frame): + tfm = tfm.to(WARP_DEV) + big_tfm = big_tfm.to(WARP_DEV) + Tensor.realize(tfm, big_tfm) + + return Tensor.cat( + frame_prepare(frame, tfm).unsqueeze(0), + frame_prepare(big_frame, big_tfm).unsqueeze(0), + ) + + return warp + + sample_skip_fn = partial(sample_skip, frame_skip=frame_skip) + + def warp_enqueue(img_q, big_img_q, tfm, big_tfm, frame, big_frame): + tfm = tfm.to(WARP_DEV) + big_tfm = big_tfm.to(WARP_DEV) + Tensor.realize(tfm, big_tfm) + + warped = Tensor.cat( + frame_prepare(frame, tfm).unsqueeze(0), + frame_prepare(big_frame, big_tfm).unsqueeze(0), + ).to(Device.DEFAULT) + img = shift_and_sample(img_q, warped[0:1], sample_skip_fn) + big_img = shift_and_sample(big_img_q, warped[1:2], sample_skip_fn) + return img, big_img + + return warp_enqueue + + +def make_run_split_policy(vision_runner, policy_runners, metadata, policy_order, frame_skip, + image_history_pipeline=IMAGE_HISTORY_IN_POLICY): + sample_desire_fn = partial(sample_desire, frame_skip=frame_skip) + sample_skip_fn = partial(sample_skip, frame_skip=frame_skip) + vision_metadata = metadata["vision"] + policy_metadata = metadata[policy_order[0]] + vision_features_slice = vision_metadata["output_slices"]["hidden_state"] + desire_key = _detect_desire_key(policy_metadata["input_shapes"]) + packed_shapes, packed_sizes = _packed_policy_shapes(policy_metadata["input_shapes"]) + road_key, wide_key = _detect_vision_keys(vision_metadata["input_shapes"]) + + def run_model(img, big_img, feat_q, desire_q, packed_npy_inputs): + unpacked = { + key: tensor.reshape(shape) + for (key, shape), tensor in zip( + packed_shapes.items(), packed_npy_inputs.split(packed_sizes), strict=True, + ) + } + desire_buffer = shift_and_sample( + desire_q, unpacked.pop("desire").reshape(1, 1, -1), sample_desire_fn, + ) + vision_output = next(iter(vision_runner({road_key: img, wide_key: big_img}).values())).cast("float32") + new_feature = vision_output[:, vision_features_slice].reshape(1, -1).unsqueeze(0) + features_buffer = shift_and_sample(feat_q, new_feature, sample_skip_fn) + features_buffer = features_buffer.reshape(policy_metadata["input_shapes"]["features_buffer"]) + + policy_inputs = { + "features_buffer": features_buffer, + desire_key: desire_buffer, + **unpacked, + } + policy_outputs = [ + next(iter(policy_runners[key](policy_inputs).values())).cast("float32") + for key in policy_order + ] + return (vision_output, *policy_outputs) + + if image_history_pipeline == IMAGE_HISTORY_IN_POLICY: + def run_policy(warped, img_q, big_img_q, feat_q, desire_q, packed_npy_inputs): + packed_npy_inputs = packed_npy_inputs.to(Device.DEFAULT) + warped = warped.to(Device.DEFAULT) + Tensor.realize(packed_npy_inputs, warped) + img = shift_and_sample(img_q, warped[0:1], sample_skip_fn) + big_img = shift_and_sample(big_img_q, warped[1:2], sample_skip_fn) + return run_model(img, big_img, feat_q, desire_q, packed_npy_inputs) + + return run_policy + + def run_policy(img, big_img, feat_q, desire_q, packed_npy_inputs): + packed_npy_inputs = packed_npy_inputs.to(Device.DEFAULT).realize() + return run_model(img, big_img, feat_q, desire_q, packed_npy_inputs) + + return run_policy + + +def make_run_supercombo(model_runner, metadata, frame_skip, image_history_pipeline=IMAGE_HISTORY_IN_POLICY): + input_shapes = metadata["model"]["input_shapes"] + sample_desire_fn = partial(sample_desire, frame_skip=frame_skip) + sample_skip_fn = partial(sample_skip, frame_skip=frame_skip) + desire_key = _detect_desire_key(input_shapes) + packed_shapes, packed_sizes = _packed_policy_shapes(input_shapes, include_prev_feature=True) + road_key, wide_key = _detect_vision_keys(input_shapes) + + def run_model(img, big_img, feat_q, desire_q, packed_npy_inputs): + unpacked = { + key: tensor.reshape(shape) + for (key, shape), tensor in zip( + packed_shapes.items(), packed_npy_inputs.split(packed_sizes), strict=True, + ) + } + desire_buffer = shift_and_sample( + desire_q, unpacked.pop("desire").reshape(1, 1, -1), sample_desire_fn, + ) + previous_feature = unpacked.pop("prev_feat") + features_buffer = shift_and_sample( + feat_q, previous_feature.reshape(1, 1, -1), sample_skip_fn, + ) + features_buffer = features_buffer.reshape(input_shapes["features_buffer"]) + model_inputs = { + road_key: img, + wide_key: big_img, + "features_buffer": features_buffer, + desire_key: desire_buffer, + **unpacked, + } + model_output = next(iter(model_runner(model_inputs).values())).cast("float32") + return model_output, + + if image_history_pipeline == IMAGE_HISTORY_IN_POLICY: + def run_policy(warped, img_q, big_img_q, feat_q, desire_q, packed_npy_inputs): + packed_npy_inputs = packed_npy_inputs.to(Device.DEFAULT) + if (isinstance(warped.device, str) and warped.device.split(":")[0] == "QCOM" and + Device.DEFAULT.split(":")[0] == "AMD" and getattr(Device.default, "is_usb", False)): + warped = warped.to("CPU").realize() + warped = warped.to(Device.DEFAULT) + Tensor.realize(packed_npy_inputs, warped) + img = shift_and_sample(img_q, warped[0:1], sample_skip_fn) + big_img = shift_and_sample(big_img_q, warped[1:2], sample_skip_fn) + return run_model(img, big_img, feat_q, desire_q, packed_npy_inputs) + + return run_policy + + def run_policy(img, big_img, feat_q, desire_q, packed_npy_inputs): + packed_npy_inputs = packed_npy_inputs.to(Device.DEFAULT).realize() + return run_model(img, big_img, feat_q, desire_q, packed_npy_inputs) + + return run_policy + + +def stateful_image_shapes(metadata): + shape = tuple(metadata['input_shapes']['new_img']) + if len(shape) != 4 or shape[:2] != (2, 6): + raise ValueError(f"Unsupported stateful image shape: {shape}") + return dict.fromkeys(('img', 'big_img'), (1, *shape[1:])) + + +def stateful_host_shapes(metadata): + return {name: shape for name, shape in metadata['input_shapes'].items() + if name != 'new_img' and name not in metadata['state_pairs']} + + +def make_stateful_input_queues(metadata, device): + queues, npy = make_warp_input_queues(stateful_image_shapes(metadata), 1, device) + shapes = stateful_host_shapes(metadata) + sizes = [math.prod(shape) for shape in shapes.values()] + packed = np.zeros(sum(sizes), dtype=np.float32) + npy.update({name: value.reshape(shape) for (name, shape), value in + zip(shapes.items(), np.split(packed, np.cumsum(sizes[:-1])), strict=True)}) + queues['packed_npy_inputs'] = Tensor(packed, device='NPY').realize() + if metadata.get('mapped_image_input', False): + image_shape = tuple(metadata['input_shapes']['new_img']) + buffer = Buffer(device, math.prod(image_shape) * dtypes.uint8.itemsize, + options=BufferSpec(cpu_access=True), preallocate=True) + view = UOp.from_buffer(buffer, dtypes.uint8) + queues['mapped_gpu_image'] = Tensor(view).reshape(image_shape) + for name in metadata['state_pairs']: + queues[name] = Tensor(np.zeros(metadata['input_shapes'][name], dtype=metadata['input_dtypes'][name]), + device=device).contiguous().realize() + return queues, npy + + +def make_run_stateful_supercombo(model_runner, metadata): + shapes = stateful_host_shapes(metadata) + sizes = [math.prod(shape) for shape in shapes.values()] + + def run_policy(warped, packed_npy_inputs, mapped_gpu_image=None, **state): + packed = packed_npy_inputs.to(Device.DEFAULT).realize() + inputs = {name: value.reshape(shape).cast(model_runner.graph_inputs[name].dtype) + for (name, shape), value in zip(shapes.items(), packed.split(sizes), strict=True)} + if metadata.get('mapped_image_input', False): + if mapped_gpu_image is None: + raise ValueError('Mapped stateful image queue is missing') + image = warped.to('CPU').realize().to(Device.DEFAULT) + image = mapped_gpu_image.assign(image).realize() + else: + image = warped.to(Device.DEFAULT) + inputs['new_img'] = image.cast(model_runner.graph_inputs['new_img'].dtype) + outputs = {name: value.contiguous() for name, value in model_runner(inputs | state).items()} + for name, next_name in metadata['state_pairs'].items(): + if outputs[next_name].dtype != state[name].dtype: + raise ValueError(f'State dtype mismatch: {name} -> {next_name}') + Tensor.realize(*outputs.values()) + Tensor.realize(*(state[name].assign(outputs[next_name]) for name, next_name in metadata['state_pairs'].items())) + return outputs['outputs'].cast('float32'), + + return run_policy + + +def compile_jit(jit, make_random_inputs, input_keys, make_queues, validation_runs=1): + seed = 42 + + def random_inputs_run(fn, current_seed, test_values=None, test_buffers=None, expect_match=True): + input_queues, npy = make_queues(Device.DEFAULT) + rng = np.random.default_rng(current_seed) + Tensor.manual_seed(current_seed) + testing = test_values is not None or test_buffers is not None + run_count = validation_runs if testing else max(3, validation_runs) + values, buffers = [], [] + + for index in range(run_count): + for value in npy.values(): + value[:] = rng.standard_normal(value.shape).astype(value.dtype) + Device.default.synchronize() + random_inputs = make_random_inputs(rng=rng) + start = time.perf_counter() + outputs = fn(**{key: input_queues[key] for key in input_keys}, **random_inputs) + mid = time.perf_counter() + Device.default.synchronize() + end = time.perf_counter() + print(f" [{index + 1}/{run_count}] enqueue {(mid - start) * 1e3:6.2f} ms -- total {(end - start) * 1e3:6.2f} ms") + + if index < validation_runs: + values.extend(np.copy(value.numpy()) for value in outputs) + buffers.extend(np.copy(value.numpy()) for value in input_queues.values()) + if not all(np.isfinite(value).all() for value in values): + raise ValueError("Compiled JIT produced non-finite outputs") + + if test_values is not None: + match = all(np.array_equal(lhs, rhs) for lhs, rhs in zip(values, test_values, strict=True)) + assert match == expect_match, f"outputs {'differ from' if expect_match else 'match'} baseline (seed={current_seed})" + if test_buffers is not None: + match = all(np.array_equal(lhs, rhs) for lhs, rhs in zip(buffers, test_buffers, strict=True)) + assert match == expect_match, f"buffers {'differ from' if expect_match else 'match'} baseline (seed={current_seed})" + return values, buffers + + from tinygrad.engine import realize + from unittest.mock import patch + original_hcq_compile = realize.hcq_compile + schedules = [] + + def retain_schedule(linear, input_uops, profile, cache=False): + compiled = original_hcq_compile(linear, input_uops, profile, cache=cache) + schedules.append((linear, compiled)) + return compiled + + print("capture + replay") + with patch.object(realize, 'hcq_compile', retain_schedule): + test_values, test_buffers = random_inputs_run(jit, seed) + captured = jit.captured + matching = [linear for linear, compiled in schedules if compiled is captured._linear] + if len(matching) != 1: + raise ValueError("Missing or ambiguous pre-HCQ schedule for captured JIT") + _PRE_HCQ_RECORDS[id(jit)] = {'linear': matching[0], 'ret': captured.ret, + 'expected_names': captured.expected_names, + 'expected_input_info': captured.expected_input_info} + print("pickle round trip") + with tempfile.TemporaryDirectory(prefix="starpilot-jit-") as temporary: + path = Path(temporary) / "captured.pkl" + dump_pickle(jit, path) + loaded = load_pickle(path, out_of_band=True) + random_inputs_run(loaded, seed, test_values, test_buffers, expect_match=True) + random_inputs_run(loaded, seed + 1, test_values, test_buffers, expect_match=False) + return jit + + +def _parse_size(value): + width, height = value.lower().split("x") + return int(width), int(height) + + +def validate_metadata(metadata): + output_shapes = metadata.get("output_shapes", {}) + output_shape = output_shapes.get("outputs") + if not output_shape or len(output_shape) < 2: + raise ValueError(f"Invalid model output shape metadata: {output_shapes}") + output_size = output_shape[-1] + for name, output_slice in metadata.get("output_slices", {}).items(): + start, stop, step = output_slice.indices(output_size) + if step != 1 or start < 0 or stop < start or stop > output_size: + raise ValueError(f"Invalid output slice {name}={output_slice} for output size {output_size}") + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--model-type", choices=MODEL_TYPES, required=True) + parser.add_argument("--model-size", type=_parse_size, required=True) + parser.add_argument("--camera-resolutions", type=_parse_size, nargs="+", required=True) + parser.add_argument("--frame-skip", type=int) + parser.add_argument("--behavior-version") + parser.add_argument("--output", required=True) + parser.add_argument("--out-of-band", action="store_true", help="Compatibility flag; all artifacts use the current buffer arena format.") + parser.add_argument("--vision-onnx") + parser.add_argument("--policy-onnx") + parser.add_argument("--off-policy-onnx") + parser.add_argument("--on-policy-onnx") + parser.add_argument("--supercombo-onnx") + parser.add_argument( + "--image-history-pipeline", + choices=IMAGE_HISTORY_PIPELINES, + default=IMAGE_HISTORY_IN_POLICY, + help="Where img/big_img history queues are updated. 'policy' is the newer faster ABI; 'warp' reproduces legacy v22 artifacts.", + ) + args = parser.parse_args() + if args.frame_skip is not None and args.frame_skip < 1: + parser.error("--frame-skip must be positive") + + from tinygrad.nn.onnx import OnnxRunner + from openpilot.system.camerad.cameras.nv12_info import get_nv12_info + + output = { + "format_version": ARTIFACT_FORMAT_VERSION, + "artifact_abi": ARTIFACT_ABI, + "compiler_revision": COMPILER_REVISION, + "execution_device": Device.DEFAULT, + "warp_device": WARP_DEV or Device.DEFAULT, + "model_type": args.model_type, + "metadata": {}, + "image_history_pipeline": args.image_history_pipeline, + } + if args.behavior_version: + output["behavior_version"] = args.behavior_version + + if args.model_type == "supercombo": + if not args.supercombo_onnx: + parser.error("--supercombo-onnx is required for supercombo") + model_path = Path(args.supercombo_onnx) + model_runner = OnnxRunner(model_path) + output["metadata"]["model"] = make_metadata_dict(model_path, model_runner) + validate_metadata(output["metadata"]["model"]) + policy_shapes = output["metadata"]["model"]["input_shapes"] + if 'new_img' in policy_shapes: + if args.image_history_pipeline != IMAGE_HISTORY_IN_POLICY: + parser.error('ONNX-managed history requires --image-history-pipeline policy') + metadata = output['metadata']['model'] + metadata['state_pairs'] = {name: f'next_{name}' for name in policy_shapes + if f'next_{name}' in metadata['output_shapes']} + if not metadata['state_pairs']: + raise ValueError('Stateful supercombo is missing next-state outputs') + metadata['input_dtypes'] = {name: np.dtype(_to_np_dtype(spec.dtype)).name for name, spec in model_runner.graph_inputs.items()} + for name, next_name in metadata['state_pairs'].items(): + if policy_shapes[name] != metadata['output_shapes'][next_name]: + raise ValueError(f'State shape mismatch: {name} -> {next_name}') + metadata['mapped_image_input'] = True + frame_skip = 1 + make_policy_queues = partial(make_stateful_input_queues, metadata) + run_policy = make_run_stateful_supercombo(model_runner, metadata) + image_shapes = stateful_image_shapes(metadata) + policy_input_keys = ('packed_npy_inputs', 'mapped_gpu_image', *metadata['state_pairs']) + else: + frame_skip = args.frame_skip or derive_frame_skip(policy_shapes) + make_policy_queues = partial(make_supercombo_input_queues, policy_shapes, frame_skip) + run_policy = make_run_supercombo( + model_runner, output["metadata"], frame_skip, args.image_history_pipeline, + ) + image_shapes = policy_shapes + policy_input_keys = FAST_POLICY_INPUTS if args.image_history_pipeline == IMAGE_HISTORY_IN_POLICY else SUPERCOMBO_POLICY_INPUTS + else: + if not args.vision_onnx: + parser.error("--vision-onnx is required for split models") + policy_paths = {} + if args.policy_onnx: + policy_paths["policy"] = args.policy_onnx + if args.off_policy_onnx: + policy_paths["off_policy"] = args.off_policy_onnx + if args.on_policy_onnx: + policy_paths["on_policy"] = args.on_policy_onnx + if args.model_type == "vision_policy" and set(policy_paths) != {"policy"}: + parser.error("vision_policy requires --policy-onnx") + if args.model_type == "vision_multi_policy" and not policy_paths: + parser.error("vision_multi_policy requires at least one policy ONNX") + + vision_path = Path(args.vision_onnx) + resolved_policy_paths = {key: Path(path) for key, path in policy_paths.items()} + vision_runner = OnnxRunner(vision_path) + policy_runners = {key: OnnxRunner(path) for key, path in resolved_policy_paths.items()} + output["metadata"]["vision"] = make_metadata_dict(vision_path, vision_runner) + validate_metadata(output["metadata"]["vision"]) + for key, path in resolved_policy_paths.items(): + output["metadata"][key] = make_metadata_dict(path, policy_runners[key]) + validate_metadata(output["metadata"][key]) + + policy_order = [key for key in ("on_policy", "off_policy", "policy") if key in policy_runners] + output["policy_order"] = policy_order + first_policy_shapes = output["metadata"][policy_order[0]]["input_shapes"] + for key in policy_order[1:]: + if output["metadata"][key]["input_shapes"] != first_policy_shapes: + raise ValueError(f"Policy input shapes differ between {policy_order[0]} and {key}") + frame_skip = args.frame_skip or derive_frame_skip(first_policy_shapes) + make_policy_queues = partial( + make_split_input_queues, + output["metadata"]["vision"]["input_shapes"], + first_policy_shapes, + frame_skip, + ) + run_policy = make_run_split_policy( + vision_runner, policy_runners, output["metadata"], policy_order, frame_skip, + args.image_history_pipeline, + ) + image_shapes = output["metadata"]["vision"]["input_shapes"] + policy_input_keys = FAST_POLICY_INPUTS if args.image_history_pipeline == IMAGE_HISTORY_IN_POLICY else SPLIT_POLICY_INPUTS + + output["frame_skip"] = frame_skip + output["policy_input_keys"] = policy_input_keys + warp_input_keys = FAST_WARP_INPUTS if args.image_history_pipeline == IMAGE_HISTORY_IN_POLICY else LEGACY_WARP_INPUTS + output["warp_input_keys"] = warp_input_keys + run_policy_jit = TinyJit(run_policy, prune=True) + road_key, wide_key = _detect_vision_keys(image_shapes) + if args.image_history_pipeline == IMAGE_HISTORY_IN_POLICY: + make_random_model_inputs = partial( + make_random_images, + keys=["warped"], + shape=(2, 6, *image_shapes[road_key][2:]), + device=WARP_DEV, + ) + else: + make_random_model_inputs = partial( + make_random_images, + keys=[road_key, wide_key], + shape=image_shapes[road_key], + ) + output["run_policy"] = compile_jit( + run_policy_jit, make_random_model_inputs, policy_input_keys, make_policy_queues, + validation_runs=5 if output['metadata'].get('model', {}).get('state_pairs') else 1, + ) + + model_w, model_h = args.model_size + for cam_w, cam_h in args.camera_resolutions: + nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h)) + warp_enqueue = TinyJit( + make_warp(nv12, model_w, model_h, frame_skip, args.image_history_pipeline), + prune=True, + ) + make_random_warp_inputs = make_random_blob_images( + keys=["frame", "big_frame"], size=nv12.size, device=WARP_DEV, + ) + make_warp_queues = partial(make_warp_input_queues, image_shapes, frame_skip) + output[(cam_w, cam_h)] = compile_jit( + warp_enqueue, make_random_warp_inputs, warp_input_keys, make_warp_queues, + ) + + dump_pickle(output, args.output) + with open(args.output, 'rb') as native_file: + native_sha256 = hashlib.file_digest(native_file, 'sha256').hexdigest() + launch_path = Path(args.output).with_suffix('.launch.pkl') + launch = { + 'format': 'tinygrad_pre_hcq_v1', 'compiler_revision': COMPILER_REVISION, + 'artifact_abi': ARTIFACT_ABI, 'native_artifact_sha256': native_sha256, + 'native_artifact_name': Path(args.output).name, + 'captures': {key: _PRE_HCQ_RECORDS.pop(id(value)) for key, value in output.items() + if key == 'run_policy' or isinstance(key, tuple)}, + } + dump_pickle(launch, launch_path) + with launch_path.open('rb') as launch_file: + launch_sha256 = hashlib.file_digest(launch_file, 'sha256').hexdigest() + launch_path.with_suffix('.json').write_text(json.dumps({ + 'format': launch['format'], 'compiler_revision': COMPILER_REVISION, 'artifact_abi': ARTIFACT_ABI, + 'native_artifact_sha256': native_sha256, 'launch_sha256': launch_sha256, + }, indent=2) + '\n') + print(f"Saved JITs to {args.output} ({os.path.getsize(args.output) / 1e6:.2f} MB)") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/openpilot/starpilot/models/manager.py b/openpilot/starpilot/models/manager.py index 3605b42633..bb1c1e0c24 100644 --- a/openpilot/starpilot/models/manager.py +++ b/openpilot/starpilot/models/manager.py @@ -22,7 +22,11 @@ from urllib.request import urlopen from openpilot.starpilot.models.catalog import ( ARTIFACT_ABI, BUNDLED_CURRENT, BY_ID, CATALOG_PATH, COMPILER_REVISION, DEFAULT_SMALL, DEFAULT_SMALL_SHA256, - DEFAULT_SMALL_SIZE, GENERATION, model_entries, + DEFAULT_SMALL_SIZE, GENERATION, NATIVE_CATALOG_PATH, model_entries, +) + +from openpilot.starpilot.models.runtime_selection import ( + NATIVE_ABI, NATIVE_GENERATION, NATIVE_REVISION, RuntimePlan, freeze_plan, selection_family, ) RESOURCE_URL = "https://huggingface.co/buckets/StarPilot-Driving/StarPilot-Resources/resolve" @@ -74,9 +78,12 @@ def state_lock(root: Path): yield -def validate_manifest(data: object) -> dict[str, dict]: - if (not isinstance(data, dict) or data.get("generation") != GENERATION or data.get("compiler_revision") != COMPILER_REVISION or - data.get("artifact_abi") != ARTIFACT_ABI or not isinstance(data.get("models"), list)): +def validate_manifest(data: object, *, native: bool = False) -> dict[str, dict]: + generation = NATIVE_GENERATION if native else GENERATION + revision = NATIVE_REVISION if native else COMPILER_REVISION + abi = NATIVE_ABI if native else ARTIFACT_ABI + if (not isinstance(data, dict) or data.get("generation") != generation or data.get("compiler_revision") != revision or + data.get("artifact_abi") != abi or not isinstance(data.get("models"), list)): raise ModelError("The model catalog targets a different runtime") rows = {} for entry in data["models"]: @@ -107,7 +114,7 @@ def validate_manifest(data: object) -> dict[str, dict]: amd = variants.get("amd") if amd is not None and (not isinstance(amd, dict) or entry.get("uses_external_gpu", False) or entry.get("model_lab_eligible") is not True or amd.get("execution_device") != "AMD" or - amd.get("compiler_revision") != COMPILER_REVISION): + amd.get("compiler_revision") != revision): raise ModelError("Invalid laboratory artifact hardware or runtime") runtime_artifacts = entry.get("runtime_artifacts", []) if not isinstance(runtime_artifacts, list): @@ -127,7 +134,7 @@ def validate_manifest(data: object) -> dict[str, dict]: size, chunks = artifact.get("artifact_size"), artifact.get("artifact_chunk_count") if (not isinstance(artifact["artifact_sha256"], str) or not SHA.fullmatch(artifact["artifact_sha256"]) or type(size) is not int or not 0 < size <= MAX_ARTIFACT or type(chunks) is not int or not 0 <= chunks <= 99 or - artifact.get("artifact_format") != ARTIFACT_ABI): + artifact.get("artifact_format") != abi): raise ModelError("Invalid compiled artifact metadata") row = dict(entry) compatible = [artifact for artifact in runtime_artifacts if artifact["min_runner_revision"] <= MODEL_RUNNER_REVISION] @@ -136,19 +143,97 @@ def validate_manifest(data: object) -> dict[str, dict]: row.update({key: value for key, value in selected.items() if key != "min_runner_revision"}) if known is None and "artifact_sha256" not in row: raise ModelError("New models require a compatible compiled artifact") + if native and (model_id != DEFAULT_SMALL and row.get("uses_external_gpu") is not True or + "artifact_sha256" not in row or not isinstance(row.get("qualification_sha256"), str) or + not SHA.fullmatch(row["qualification_sha256"]) or variants or runtime_artifacts): + raise ModelError("Native rows require qualified RDF or Chestnut artifacts") + row.pop("_artifact_path", None) + row.update(compiler_revision=revision, _runtime_family="native02e" if native else "legacy9d", + _generation=generation) rows[model_id] = row return rows +def native_catalog(root: Path = ROOT) -> dict[str, dict]: + rows = {} + for path in (NATIVE_CATALOG_PATH, root / NATIVE_GENERATION / "catalog.json"): + try: + rows.update(validate_manifest(read_json(path), native=True)) + except FileNotFoundError: + continue + return rows + + +def native_stock(root: Path = ROOT) -> dict[str, dict]: + # Stock DM is release-pinned, never supplied by the downloadable model catalog. + document = read_json(NATIVE_CATALOG_PATH) + validate_manifest(document, native=True) + stock = document.get("stock") + required = {"dmonitoring_model_tinygrad.pkl", "dm_warp_1928x1208_tinygrad.pkl", "dm_warp_1344x760_tinygrad.pkl"} + if not isinstance(stock, dict) or set(stock) != required: + raise ModelError("Native monitoring release is not qualified") + for row in stock.values(): + if (not isinstance(row, dict) or not isinstance(row.get("artifact_sha256"), str) or + not SHA.fullmatch(row["artifact_sha256"]) or type(row.get("artifact_size")) is not int or + not 0 < row["artifact_size"] <= MAX_ARTIFACT or not isinstance(row.get("qualification_sha256"), str) or + not SHA.fullmatch(row["qualification_sha256"])): + raise ModelError("Invalid native monitoring artifact identity") + return stock + + def catalog(root: Path = ROOT) -> dict[str, dict]: base = validate_manifest(read_json(CATALOG_PATH)) try: base.update(validate_manifest(read_json(root / "catalog.json"))) except (OSError, ValueError, TypeError): pass + # Qualified native entries replace only matching IDs; all other v26 payloads remain usable. + try: + base.update(native_catalog(root)) + except (OSError, ValueError, TypeError): + pass return base +def default_record(family: str, root: Path = ROOT) -> dict: + if family == "legacy9d": + return {"path": str(SHIPPED_MODELS / "compat9d" / f"{DEFAULT_SMALL}_driving_tinygrad.pkl"), + "artifact_sha256": DEFAULT_SMALL_SHA256, "artifact_size": DEFAULT_SMALL_SIZE, + "version": BY_ID[DEFAULT_SMALL].version, "runtime_family": family} + if family != "native02e": + raise ModelError("Unknown default runtime") + row = native_catalog(root).get(DEFAULT_SMALL) + if row is None: + raise ModelError("Native RDF default is not qualified") + native_stock(root) + return {"path": str(SHIPPED_MODELS / f"{DEFAULT_SMALL}_driving_tinygrad.pkl"), + "artifact_sha256": row["artifact_sha256"], "artifact_size": row["artifact_size"], + "version": row["version"], "runtime_family": family} + + +def freeze_runtime(*, root: Path = ROOT, recovery_small_only: bool = False, + chestnut_available: bool | None = None, randomize: bool = True) -> RuntimePlan: + # All called modules are stdlib-only until prepare() chooses the family. + if chestnut_available is None: + from openpilot.selfdrive.modeld.helpers import chestnut_present + from openpilot.common.hardware.usb import cable_connected + from openpilot.starpilot.models.jetlink_adapter import link_on + chestnut_available = chestnut_present() or (cable_connected() and not link_on()) + if randomize and not recovery_small_only: + randomize_next_start(chestnut_available, root=root) + with state_lock(root): + prefs, entries = preferences(root), catalog(root) + family = selection_family(prefs, entries, recovery_small_only=recovery_small_only) + for mid, row in entries.items(): + directory = root / NATIVE_GENERATION if row.get("_runtime_family") == "native02e" else root + row["_artifact_path"] = str(directory / mid / f"{mid}_driving_tinygrad.pkl") + fallback = default_record(family, root) + plan = freeze_plan(prefs, entries, fallback, recovery_small_only=recovery_small_only) + if shipped_default(plan) is None: + raise ModelError("Selected runtime RDF fallback is missing or corrupt") + return plan + + def preferences(root: Path = ROOT) -> dict: default = {"small": DEFAULT_SMALL, "big": "", "userFavorites": [], "sortMode": "name", "randomizer": False, "blacklistedModels": []} @@ -172,14 +257,16 @@ def preferences(root: Path = ROOT) -> dict: return default -def artifact_path(model_id: str, root: Path = ROOT, variant: str = "standard") -> Path: +def artifact_path(model_id: str, root: Path = ROOT, variant: str = "standard", *, family: str | None = None) -> Path: entries = model_entries(root) if not isinstance(model_id, str) or model_id not in entries or model_id == BUNDLED_CURRENT: raise ModelError("Unknown downloadable model") if variant not in ("standard", "amd") or (variant == "amd" and entries[model_id].uses_external_gpu): raise ModelError("Unknown model artifact variant") suffix = "amd_" if variant == "amd" else "" - return root / model_id / f"{model_id}_driving_{suffix}tinygrad.pkl" + family = catalog(root).get(model_id, {}).get("_runtime_family") if family is None else family + directory = root / NATIVE_GENERATION if family == "native02e" else root + return directory / model_id / f"{model_id}_driving_{suffix}tinygrad.pkl" def artifact_entry(model_id: str, entries: dict[str, dict], variant: str = "standard") -> dict: @@ -195,7 +282,8 @@ def verified_artifact(model_id: str, entries: dict[str, dict], root: Path = ROOT row = artifact_entry(model_id, entries, variant) if "artifact_sha256" not in row: return None - path = artifact_path(model_id, root, variant) + path = Path(row["_artifact_path"]) if variant == "standard" and "_artifact_path" in row else artifact_path( + model_id, root, variant, family=row.get("_runtime_family")) try: if path.is_symlink() or not path.is_file() or path.stat().st_size != row["artifact_size"]: return None @@ -206,13 +294,13 @@ def verified_artifact(model_id: str, entries: dict[str, dict], root: Path = ROOT return None -def shipped_default() -> Path | None: +def shipped_default(plan: RuntimePlan | None = None) -> Path | None: from openpilot.common.file_chunker import materialize_file_chunked try: - path = materialize_file_chunked(SHIPPED_MODELS / f"{DEFAULT_SMALL}_driving_tinygrad.pkl", - expected_sha256=DEFAULT_SMALL_SHA256) - return path if path.stat().st_size == DEFAULT_SMALL_SIZE else None + row = json.loads(plan.default_json) if plan is not None else default_record("native02e") + path = materialize_file_chunked(Path(row["path"]), expected_sha256=row["artifact_sha256"]) + return path if path.stat().st_size == row["artifact_size"] else None except (OSError, ValueError, TypeError, KeyError): return None @@ -228,10 +316,13 @@ class RuntimeSelection: allow_big: bool = True small_sha256: str | None = None big_sha256: str | None = None + fallback_path: Path | None = None + fallback_version: str = "current" + fallback_sha256: str | None = None -def requested_runtime_id(chestnut_available: bool, *, root: Path = ROOT) -> str: - prefs = preferences(root) +def requested_runtime_id(chestnut_available: bool, *, root: Path = ROOT, plan: RuntimePlan | None = None) -> str: + prefs = json.loads(plan.preferences_json) if plan is not None else preferences(root) return prefs["big"] if chestnut_available and prefs["big"] else prefs["small"] @@ -253,26 +344,36 @@ def randomize_next_start(chestnut_available: bool, *, root: Path = ROOT, chooser return prefs -def resolve_runtime(chestnut_available: bool, *, root: Path = ROOT, randomize: bool = False) -> RuntimeSelection: - prefs = randomize_next_start(chestnut_available, root=root) if randomize else preferences(root) - entries = catalog(root) - small, big = prefs["small"], prefs["big"] - small_path = verified_artifact(small, entries, root) +def resolve_runtime(chestnut_available: bool, *, root: Path = ROOT, randomize: bool = False, + plan: RuntimePlan | None = None) -> RuntimeSelection: + if plan is None: + plan = freeze_runtime(root=root, chestnut_available=chestnut_available, randomize=randomize) + elif randomize: + raise ModelError("Randomize before freezing the model runtime") + entries = json.loads(plan.entries_json) + fallback = json.loads(plan.default_json) + small, big = plan.small_id, plan.big_id + if big and entries.get(big, {}).get("_runtime_family") != plan.family: + raise ModelError("Big artifact does not match the selected runtime") + if small != DEFAULT_SMALL and entries.get(small, {}).get("_runtime_family") != plan.family: + raise ModelError("Small artifact does not match the selected runtime") + small_path = verified_artifact(small, entries, root) if entries.get(small, {}).get("_runtime_family") == plan.family else None shipped = small == DEFAULT_SMALL and small_path is None if shipped: - small_path = shipped_default() + small_path = shipped_default(plan) if small_path is None: small = DEFAULT_SMALL shipped = True - small_path = shipped_default() + small_path = shipped_default(plan) if small_path is None: raise ModelError("Shipped RDFv4 is missing or corrupt; reinstall the validated model package") big_path = verified_artifact(big, entries, root) if big not in ("", BUNDLED_CURRENT) and chestnut_available else None allow_big = chestnut_available and big_path is not None - return RuntimeSelection(small, small_path, entries[small]["version"], big, big_path, + return RuntimeSelection(small, small_path, fallback["version"] if shipped else entries[small]["version"], big, big_path, entries[big]["version"] if big in entries else "current", allow_big, - (DEFAULT_SMALL_SHA256 if shipped else entries[small]["artifact_sha256"]) if small_path is not None else None, - entries[big]["artifact_sha256"] if big_path is not None else None) + (fallback["artifact_sha256"] if shipped else entries[small]["artifact_sha256"]) if small_path is not None else None, + entries[big]["artifact_sha256"] if big_path is not None else None, + shipped_default(plan), fallback["version"], fallback["artifact_sha256"]) class ModelManager: @@ -391,7 +492,7 @@ class ModelManager: parts.append(sidecar) identity = tuple((str(part), part.stat().st_ino, part.stat().st_size, part.stat().st_mtime_ns, part.stat().st_ctime_ns) for part in parts) - return (0, 0, DEFAULT_SMALL_SIZE, 0, 0, DEFAULT_SMALL_SHA256, DEFAULT_SMALL_SIZE, + return (0, 0, row["artifact_size"], 0, 0, row["artifact_sha256"], row["artifact_size"], any(part.is_symlink() for part in parts), identity) st = path.stat() return (st.st_dev, st.st_ino, st.st_size, st.st_mtime_ns, st.st_ctime_ns, @@ -417,7 +518,11 @@ class ModelManager: def _snapshot_installed(self, mid: str, row: dict, variant: str = "standard") -> tuple[bool, bool]: if mid == DEFAULT_SMALL and variant == "standard" and self._signature(mid, row, variant) is None: - row = {**row, "shipped": True, "artifact_sha256": DEFAULT_SMALL_SHA256, "artifact_size": DEFAULT_SMALL_SIZE} + try: + default = default_record("native02e", self.root) + except (OSError, ValueError, TypeError, KeyError): + return False, False + row = {**row, "shipped": True, "artifact_sha256": default["artifact_sha256"], "artifact_size": default["artifact_size"]} artifact = artifact_entry(mid, {mid: row}, variant) if "artifact_sha256" not in artifact: return False, False @@ -643,14 +748,17 @@ class ModelManager: raise ModelError("Unknown model action") def _refresh(self) -> None: - url = f"{RESOURCE_URL}/manifests/model_names_{GENERATION}.json" - with self.opener(url, timeout=30) as response: - raw = response.read(MAX_MANIFEST + 1) - if len(raw) > MAX_MANIFEST: - raise ModelError("Model catalog is too large") - data = json.loads(raw) - validate_manifest(data) - atomic_json(self.root / "catalog.json", data) + documents = [] + for generation, native in ((GENERATION, False), (NATIVE_GENERATION, True)): + with self.opener(f"{RESOURCE_URL}/manifests/model_names_{generation}.json", timeout=30) as response: + raw = response.read(MAX_MANIFEST + 1) + if len(raw) > MAX_MANIFEST: + raise ModelError("Model catalog is too large") + data = json.loads(raw) + validate_manifest(data, native=native) + documents.append((self.root / NATIVE_GENERATION / "catalog.json" if native else self.root / "catalog.json", data)) + for path, data in documents: + atomic_json(path, data) def _work(self, action: str, payload: dict, lock) -> None: failed = True @@ -693,7 +801,7 @@ class ModelManager: digest, received = hashlib.sha256(), 0 with os.fdopen(fd, "wb") as out: for piece in pieces: - with self.opener(f"{RESOURCE_URL}/models/{GENERATION}/{mid}/{piece}", timeout=30) as response: + with self.opener(f"{RESOURCE_URL}/models/{entry.get('_generation', GENERATION)}/{mid}/{piece}", timeout=30) as response: while data := response.read(1024 * 1024): self._check_cancelled() received += len(data) diff --git a/openpilot/starpilot/models/runner.py b/openpilot/starpilot/models/runner.py index 44f0300518..521db00b82 100644 --- a/openpilot/starpilot/models/runner.py +++ b/openpilot/starpilot/models/runner.py @@ -14,7 +14,8 @@ from openpilot.selfdrive.controls.lib.drive_helpers import MIN_SPEED, smooth_val from openpilot.selfdrive.modeld.constants import ModelConstants, Plan from openpilot.selfdrive.modeld.helpers import load_oob from openpilot.starpilot.models.parser import Parser -from openpilot.starpilot.models.catalog import ARTIFACT_ABI, COMPILER_REVISION +from openpilot.starpilot.models.runtime_bridge.runtime import selected_plan +from openpilot.starpilot.models.runtime_selection import require_artifact_contract from openpilot.starpilot.models.receipt import PreparedArtifact, artifact_identity, prepare_artifact from openpilot.system.camerad.cameras.nv12_info import get_nv12_info @@ -63,9 +64,7 @@ def load_verified_model(cam_w: int, cam_h: int, artifact_path: Path, behavior_ve def validate_artifact(artifact: dict, version: str, camera_size: tuple[int, int]) -> None: - if (not isinstance(artifact, dict) or artifact.get("artifact_abi") != ARTIFACT_ABI or - artifact.get("compiler_revision") != COMPILER_REVISION or artifact.get("format_version") != 1): - raise ValueError("catalog model compiler/ABI mismatch") + require_artifact_contract(artifact, selected_plan()) if version not in SUPPORTED_VERSIONS or artifact.get("behavior_version") != version: raise ValueError("catalog model behavior version mismatch") if artifact.get("model_type") not in ("supercombo", "vision_policy", "vision_multi_policy"): diff --git a/openpilot/starpilot/models/runtime_bridge/native-policy.json b/openpilot/starpilot/models/runtime_bridge/native-policy.json new file mode 100644 index 0000000000..9706e4da83 --- /dev/null +++ b/openpilot/starpilot/models/runtime_bridge/native-policy.json @@ -0,0 +1,1706 @@ +{ + "build_sources": { + "openpilot/common/transformations/camera.py": { + "bytes": 6209, + "sha256": "1de3f9e6147f28195c71673ae5c8ec38e65ede997ac98d2e1e3b114eda873ec4" + }, + "openpilot/common/transformations/model.py": { + "bytes": 2766, + "sha256": "c87aad27074362fe9fe361a71da92c1fc90daf63bcfd4d8c47d65d3a936ec15e" + }, + "openpilot/selfdrive/modeld/models/dmonitoring_model.onnx": { + "bytes": 7844499, + "sha256": "dee5a294e8afaacc9295ac5d100e00733ecac278e79264b96331e40a3ede1b04" + }, + "openpilot/starpilot/models/compile_native.py": { + "bytes": 32527, + "sha256": "74559f3f9c4f6164fabf8d719eb15fbbaa7484661fa680f58aeb2a41392e2c17" + }, + "openpilot/system/camerad/cameras/nv12_info.py": { + "bytes": 819, + "sha256": "b3f39bbfdd75c43d396b01f746d460068aa8e98862217d46bf3cd426cd034e1a" + } + }, + "catalog_sha256": "ec9dce0f3be784708ec261465f969dd80ac5fe801b0cd041ecb0584b8119a35a", + "compiler_revision": "02e698160eed1751738212144a7ea2cfb160b3f1", + "files": { + "bounded_wait.c": "a9e1a82e50ebefd983b3dbc6f784adc465cbd06848debed11dfff80cc8a832fe", + "libbounded_wait.so": "24ed559861c8636c1026cad9a244854bb2236b5ee8b91bf21c5efbf688fa4a69", + "libusb_guards.so": "66a3dfe48ac17899862ab80160cf6dac2c9b9707234527ba0d808f3b68404114", + "native_guards.py": "895349c6d5745eb1c3d4cd5bd8e767b200e0ca31ecb92a5287735dc28ab8a0d5", + "usb_guards.c": "8b3c207de74f92b74980da35428cff6f4a198ce97f9f8b6e64aded74e0110316" + }, + "host_runtime_dev": "CPU:CLANG", + "native_abi": "linux-aarch64-64bit", + "vendor_files": { + ".coveragerc": "94d165f3cb616e684b735b32954d7b0035877c6ba855917f6ad6167122136dbf", + ".github/actions/process-replay/action.yml": "34830890cbdc64b660fdf32bb6120d64a9276b48b7fe5af78256dd3f377743c1", + ".github/actions/setup-tinygrad/action.yml": "ff9602a8c8233423701d81216e7c0d29753bda65aab73a2e11ebcef555badf9c", + ".github/workflows/autogen.yml": "e95d672e485466741378d1914b5b7f32e6b5fd3279dfa97d3a878ac322354913", + ".github/workflows/benchmark.yml": "04886d98c48d722fb1fad580e3536fe1ba29a7f4c0fc46923d59738986b51a71", + ".github/workflows/benchmark_search.yml": "5c99a7431104d6ff5e17611aad31d200a38bfb6a8ea7e5484a155e458fa79be4", + ".github/workflows/docs.yml": "24e29f848fb8a3dfa00aa0078469c92f8bfc464724fc6c8d70a4699b0051c7d0", + ".github/workflows/mlperf.yml": "487d2ff2d21e3feee34f2805931d245ac5845114052437b0932ba3ddbe12d326", + ".github/workflows/platform.yml": "e4e20754fb0313e5d775cceef94052c95b1547dbbb3aa299678b18eb92bc42b1", + ".github/workflows/python-publish.yml": "f347be8b0be06e20f3d1ad3b3eb05f398fb26f73f3ef5e69ae0d438dacd9966f", + ".github/workflows/szdiff.yml": "b33b0ff18ca99148299ca2bed0bbd56c6d2d74a2fc9de4c17597bec19da8aece", + ".github/workflows/test.yml": "696f60317c1d6fb5e0c6b398dc749b9b165d088c4d4ed07108e1d4b32f5ca4aa", + ".gitignore": "9ba0fb528e7fe9eae4e7ae57b13966a9fba612d6ca5f77591e511b41ce29ff8b", + ".pre-commit-config.yaml": "bdd677cb236183302f8547e919942fc17f8eeefd459aeb9df721af7a64913b94", + ".pylintrc": "679133bc91bdb57c165676fffc059fc2bc0cf2bb5bfb96c028001e28ad7953d0", + "LICENSE": "00146150f1082f320d608ba481acc3fbfacf8a9914354c2c96b6f44719d5e977", + "LOCAL_PATCHES.md": "803ddb2ad49ccae0de8f78ad15cd235cd3d0147bf6e006637ec8b7fb29ead42d", + "README.md": "c20592a2417b38fd9aa521a0daf14a532bcdcadbcdad07f9a486ec3de315acc2", + "conftest.py": "fb06ede39759d0d3496ed8ee4e520ba9b1c986a8f355cd21b20bc0621b732bd1", + "docs/CNAME": "3846d058f953d7b26c5002c2c4ccbb9286551f24c274bbd894e396a5117361ac", + "docs/abstractions3.py": "bbd03302d65e8296199c420caa1cfa836458fe8660f1f92fad5c3805b70b9246", + "docs/abstractions4.py": "edc454b197d442e314357e6f49737550e5280f3e2db34525b33a60f85040cd33", + "docs/developer/am.md": "43983a8b05dacc1ae780a4d40d5044cd77ab744ab4a3eebc3af7b290bc894f87", + "docs/developer/developer.md": "cfa1353171a45383f5f527329dd591f9849207b58c86065a245aca5c011d0150", + "docs/developer/layout.md": "9a008945afc0be7e8a688eb5135ad5be4b71e2ea9e4ea1cf73994fb5460b1f78", + "docs/developer/runtime.md": "5109278763a2614ed1be5d3e1317cf2f0b2a63003bfe969ec4f127ee671d056f", + "docs/developer/speed.md": "25f0c398240ca399e6ad0479f2152412b87d9645afacd94768dabc890cacc72f", + "docs/developer/uop.md": "0e0bd9c5c3323018ac62ab14961d1294ef8e904add81ec1030e054c7d9c03a34", + "docs/dtypes.md": "9956fcba98d3d3e04d213ac352e530e66730b0eef65b80448ede3a091896a55f", + "docs/env_vars.md": "066cb11c7c6baa51375fe217ec9cbedd7239280ce158c34eafc6021f43c35be2", + "docs/favicon.svg": "2ca7e5cd1a4c5958b690174a365526bb03db7b98f605fe55ec30be1bdb10e0a9", + "docs/index.md": "732114266dc4e03987e7bf073d358fdd85e7c1f3eeed3abdb84a269b56913669", + "docs/logo_tiny_dark.svg": "74865d59c2e6d149eca7684805d383ce5fa8d2aeef453ef1fdf1f943c89318ea", + "docs/logo_tiny_light.svg": "f6c5b08fbb6be761b0c9e43ba7591abbfa963b050367aadda4115e8c72e5dc1a", + "docs/mnist.md": "62e0b733059613c9044664d5cdce25eb93ae99359c0aa899c3d6f1b6f4075a27", + "docs/nn.md": "3d49e98b3e670e4e27d71e27627883c8d914d625aea72c41d262643077bed642", + "docs/quickstart.md": "7fda3bc4419b6b3c0aa679f21c0438907803aac5df19d61c64dc0f33940a6a33", + "docs/runtime.md": "9200d331d4d2972a864f039751b8f60a64cb8920f8f13c2f096ab25a966c34e3", + "docs/showcase.md": "9764fd276c50ac3339f7ae0292336d9933e615c7ad86d95215f22dcf3faaca84", + "docs/showcase/mnist_by_tinygrad.jpg": "fd88476491e990cf41a156b1c4b513615a57ce538f773b140f0e63bd1c1faa70", + "docs/showcase/stable_diffusion_by_tinygrad.jpg": "4eb499665725fa07f9d01cdcb53ff572e527dd2819800ff378361b5a42b4413e", + "docs/showcase/yolo_by_tinygrad.jpg": "c8e6231fdb77ff81573edb0c9b148218935ebd9ef6aa3f79c1327b9d39509947", + "docs/showcase/yolov8_showcase_image.png": "95ac7af5213e6e78589569fc8f737a5dd8ff9ceaa2be6f291adc3a5f82a55473", + "docs/tensor/creation.md": "c542904f6aa0dcf634ffdc4ae9257873f28a2b44e8c99b5f922adc0edd1411f5", + "docs/tensor/elementwise.md": "34dfef42d4f17ff6fbce97fc35e50d24e5ccf6d8597f6e6d1ca594842132ca60", + "docs/tensor/index.md": "4dec2766c63974ac1c509cd2b776f96fc3b7034ce7815ceadc6405ce07719219", + "docs/tensor/movement.md": "00a8ec591e5b6765d09a43244780db12265a3bf11b0c76f8837e61c6a213dcbc", + "docs/tensor/ops.md": "b77558e91404d87518dcb0c5023d67878c192899070f3f9ae79917361f920e53", + "docs/tensor/properties.md": "c8227516d1fddca73b0b07b572b6c18e4b8ac839c908ca96cd06cf2ae62bc0e5", + "docs/tinybox.md": "7729bd4323c80ea418fb6a151401afcff38e2b3125841786b259b443a5ab8b6e", + "docs/tinygpu.md": "fd874e0634123d530d0e02ba63d7b2be05fd15ecafb28ac5369d59255e373ea7", + "docs/tinygrad_intro.pdf": "39cecb68dee2fa9c521a3ce6bb14a6d69d57d5047b1348bcb5065fb48bafa2ca", + "docs/tinygrad_vs_others.png": "6920c8407dd4cfd420a19d1b942fa54aa8c9bcaca7bc78b1891d374b2d0fde93", + "examples/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "examples/audio_helpers.py": "4f16c1ff9f7689cf79f123ebc0d30bc234f98b67d447801e3b9e490d2a07c89a", + "examples/beautiful_cartpole.py": "2a3183c22a4097a1f77990e80e61d39056e7ba5a3707a9667f1d8e63748f4c1f", + "examples/beautiful_cifar.py": "373ed632e079907be8c5c9f939c1ec97eb8d547b1146cb029c28c3d4ddb6061e", + "examples/beautiful_mnist.py": "14d8a2dd3cccf7fec205a5927a15ef08b51f69be3f7e325ba96aa05ebf9f033f", + "examples/beautiful_mnist_multigpu.py": "205ae8305e08a2b0b68e028555fca7b9e49b0352045d702764c3dc22605af3bd", + "examples/benchmark_onnx.py": "e8d0d8502b7a24f48cc120fa80492fa9088cb3a6e1d49bfb873f9401ed4bf549", + "examples/compile_efficientnet.py": "75b310cc665ad5ab02fa7fe98abb741b282d218b3922981df225075a7cc7a3f7", + "examples/compile_tensorflow.py": "672c8f6f380258dd487490dee3c1bcbd65ba92ed64d2595bd0c812a81d9039c9", + "examples/conversation_data/pre_prompt_gary.yaml": "473ac13fc13b6b30af93191317455b5b773a320453dce9d403714eafe3251a4b", + "examples/conversation_data/pre_prompt_george.yaml": "c4a5b76f52f5986cbf554593d94adb582560e091fcdf8fa400b9a6e7e43ab89f", + "examples/conversation_data/pre_prompt_lexie.yaml": "6fac8cf9d408693521f25c0c318589156c15d88e94021aa94a85c4ad733822eb", + "examples/conversation_data/pre_prompt_stacy.yaml": "2042ace0653841be447d6324e6d89ae4faed26ee4ca780a7d1ee8939a0b1d937", + "examples/gpt2.py": "1aacf58b436afb44e5c5a7ba3ebd1ab03926242570fb4a7cbbc8aca99a6de3a8", + "examples/gradaccum_mnist.py": "1697da7c0453c4e9870ab6353da1d3a476c9e01def32c51b228d9157ec5cc262", + "examples/hlb_cifar10.py": "9d692a09c52219f274c26199a6a1cb0143a1c004e019f5e563a06dd3480363ba", + "examples/llama.py": "a3eae2a12128d8109bd43107830ff7de6c72765558040a6d50b0f7b9adb9a77f", + "examples/llama3.py": "1d76292cf867dfa1cb199132aab9ce1c2523b13b78f610340b38eca92597617d", + "examples/llm.c/.gitignore": "ceef48fcfc240e9aaf81ec54662c23a6197ca14732687db1d6074317d65a3c88", + "examples/llm.c/export.py": "6a0a2792566f13ee3e443db74449a31e6222d6461fb06ee9c3b4f150da3fd2cc", + "examples/llm.c/train_gpt2.py": "5f642022d1a68ec7b0cdaf5234aa5fce2c87f08026f99abfa6d26c8d23163a49", + "examples/llm.c/ubench/matmul.c": "30e3bd058ae7205e46ac79219d9d0bfbdfac0bb51dc53adb25de011f2e5104e2", + "examples/mamba.py": "be4508e77e9d8ab19ecefdf91d3638386985fafae35b92db19cf9a95520c86eb", + "examples/minrf.py": "dadb3a778d26b059e5bad1b33a340eef0e69957bad90969e9222abb4b2ab0572", + "examples/mixtral.py": "9b485f7e7e0ccb6bfd36722014fc9b6c69f47d34f4ff9f0d8aac81e20a9e3aa0", + "examples/mlperf/README": "264156f88933346edc1afeb1e4ff65114347e65f652c20e57767c181213f2a01", + "examples/mlperf/dataloader.py": "fbdf5b0c7d5af807781eb3e055bca029a064ba94959c55da2270e53f7f775b03", + "examples/mlperf/helpers.py": "f2decbf74a81efe17dcf15b1ae12e0ec1d97e486ea95191f7ade1fe0651e2c56", + "examples/mlperf/initializers.py": "c6ada8b3b9a198fb82b7f035d088354085e6b3eb01bf1ec892b6bce71aeb9791", + "examples/mlperf/losses.py": "c6299b4d9d2f57abeceef10da976936f60dc923149c673e283550fed40ad2c95", + "examples/mlperf/lr_schedulers.py": "1c58ce533428f93376411ba87e02950e2a174d1e1acb6741bb147c2b5d9fe241", + "examples/mlperf/metrics.py": "2cf6cad436a2a86c598611f5b732fab3ecab7012f16fe7067156a499f82c7859", + "examples/mlperf/model_eval.py": "dabd6ac3de0e794ec3b79d49cdbf7258759cf52fa600e55f1b45317618d3926f", + "examples/mlperf/model_spec.py": "c4a87ee4d397df11b52338974871536dbe9c6782b4b1f36758dc56a0a3148e63", + "examples/mlperf/model_train.py": "1d6f690c0264e08a8ab029dca3f9c073e5abd33dfde312b2ed9c0fda2ad1a436", + "examples/mlperf/models/flat_llama.py": "afd5ee773701233ceb0d087a65602f6b914ab098786f4b5f5b6883df7260cdee", + "examples/mlperf/models/gpt_oss.py": "328844a8debae8995c5a370d5ba410ec2b5515352d3db5c73adf0ec6bee92b78", + "examples/mlperf/models/test_apply_grad.py": "28eb2b2010e8a24ef3a94e1261cea52104bcc9801a8eee39e9168b5c0d66b162", + "examples/mlperf/models/test_flat_llama.py": "46bf5304932388763ff001781982dd6bae326466e1f99485dfdb3a5be533c951", + "examples/mlperf/optim.py": "042a071818666a4ad3106a3c001b3e027d2c6a18ae542116a212c174229d4cd7", + "examples/mlperf/scripts/setup_kits19_dataset.sh": "f722a36a5c2c1471dd98a6f1dc6c61b596d3345b64dde8971faebef8471b9ec6", + "examples/mlperf/scripts/stable_diffusion_downloads.sh": "3dc23f31da95991af8568c0ce2c8eaa616215cf7d7e11ba8a833df6fcbf7b3e2", + "examples/mlperf/training_submission_v4.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v4.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_beam.sh": "eed866729ba583764b12673ee5eb519cf092935df0f718ebbfe75e594873c1c7", + "examples/mlperf/training_submission_v4.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_run.sh": "0cb0578032ec0ba7eb870a43e0e307fba608d22f18867c5ab40c8cbfecd4a411", + "examples/mlperf/training_submission_v4.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/run_and_time.sh": "42ed706ff7f576dad5a2bc57c4d1652502eff88a36a7db720f68da9b172fb7d7", + "examples/mlperf/training_submission_v4.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v4.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_beam.sh": "8a13bc7832a50110ad2d4f80c166b10c682f0799bf47e419bfb681f495e10cfc", + "examples/mlperf/training_submission_v4.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_run.sh": "b5808c6aa9d8f6edccd7fbadcd7d7e3b9d4aefaf53baf3f4a9c10f21b710aa42", + "examples/mlperf/training_submission_v4.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/run_and_time.sh": "4922292db5951d3d159b657481fb470b3462c15b109706f08dbd92d2351c09e0", + "examples/mlperf/training_submission_v4.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/setup.sh": "c35c04efe5da4df74d20f570878474dc923f7cc8f5e68130e66bbfba8b0f89de", + "examples/mlperf/training_submission_v4.0/tinycorp/systems/tinybox_green.json": "ad207c53d74a4edf6924bcc55ded50fe9f6a54f188fae761adc818519b871bd1", + "examples/mlperf/training_submission_v4.0/tinycorp/systems/tinybox_red.json": "1b1fd65df443336c8777c97a6f92d23fab573e113eba41d9785e76dd2d5b2b49", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/bert/implementations/tinybox_green/README.md": "61fa6669dd72c917146e59a99afa041fa9387e02a0635e22e3dc81bded997ea2", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/bert/implementations/tinybox_green/dev_beam.sh": "6e117ffea119feb5eee04ccfa42bd36eba22df7444590b06bedaf9e4826bbd48", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/bert/implementations/tinybox_green/dev_run.sh": "086803bd854a138bb90ce31ad1c355c38d6e0cc062f5f1733714643e60346aa0", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/bert/implementations/tinybox_green/run_and_time.sh": "f0d4b80122e8d4c91c57b2a60cbb7b4f9193148c9a8e1ee79e36c8cec45a658e", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/bert/implementations/tinybox_red/README.md": "61fa6669dd72c917146e59a99afa041fa9387e02a0635e22e3dc81bded997ea2", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/bert/implementations/tinybox_red/dev_beam.sh": "f026b12fbde5f3ab39654bdb30654d2879cb0ce0c94e3479e1bcab4c23e71db5", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/bert/implementations/tinybox_red/dev_run.sh": "a2800ac259d8b184e22597fb7875d72da59632c1def848ad0c255ddcc2ce0d9d", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/bert/implementations/tinybox_red/run_and_time.sh": "41670848f7f9fac7667718be6ddf22fe08165bbfbd6e49ff09ba1b154dcc8f6a", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/bert/implementations/tinybox_red/setup.sh": "f2a5ef8e8654b268270a90a301a617489b67291557077224163efd285c3856d3", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/resnet/implementations/tinybox_green/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_beam.sh": "eed866729ba583764b12673ee5eb519cf092935df0f718ebbfe75e594873c1c7", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_run.sh": "0cb0578032ec0ba7eb870a43e0e307fba608d22f18867c5ab40c8cbfecd4a411", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/resnet/implementations/tinybox_green/run_and_time.sh": "42ed706ff7f576dad5a2bc57c4d1652502eff88a36a7db720f68da9b172fb7d7", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_beam.sh": "8a13bc7832a50110ad2d4f80c166b10c682f0799bf47e419bfb681f495e10cfc", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_run.sh": "b5808c6aa9d8f6edccd7fbadcd7d7e3b9d4aefaf53baf3f4a9c10f21b710aa42", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/run_and_time.sh": "4922292db5951d3d159b657481fb470b3462c15b109706f08dbd92d2351c09e0", + "examples/mlperf/training_submission_v4.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/setup.sh": "c35c04efe5da4df74d20f570878474dc923f7cc8f5e68130e66bbfba8b0f89de", + "examples/mlperf/training_submission_v4.1/tinycorp/systems/tinybox_green.json": "2d652877f1bcd938ae1c0530fff3d7c8cc21a48618ed5450a9fb8b636a4f1b06", + "examples/mlperf/training_submission_v4.1/tinycorp/systems/tinybox_red.json": "e57795a5c90a95b453a517bd25e86857edde1c1e0c1fc39e79f388425c6be9f1", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_1xMI300X/dev_beam.sh": "fb76c62aeec4f6d3624ad8f187cc1baaf6aa0f40e1fa3ef77379d52eac678d8d", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/README.md": "e252dc4764afb0ec022f196c82ed47e9bae50d72e6380e50fd7834857aef2170", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/dev_beam.sh": "0e7b6147b005897dfbbe56dbf1727b4df7b6b804b0c2b61e6a1e2a82582834ec", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/dev_run.sh": "d4a62cf64e5d7c2f78d6e6463c52c3c2936cb7bf3914893f336e4f9a6d4a44e3", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/run_and_time.sh": "5274daff010bfee8d8db5e1ad18ae8aa048898f45291ad39d45deb0ee3816984", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_green/README.md": "e252dc4764afb0ec022f196c82ed47e9bae50d72e6380e50fd7834857aef2170", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_green/dev_beam.sh": "bed38719102f4b7e976157828e9f34174b5b612acccd2690204e109288a3eb91", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_green/dev_run.sh": "6bdd90ad63579088150fd7869b1fdca4b2fb73a889a7f4f7cb55fb9dd00c6c4d", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_green/run_and_time.sh": "073c6c33a5d4b99f6abf3060e672a262592267c8293053af35c3687591ad5b6b", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_red/README.md": "e252dc4764afb0ec022f196c82ed47e9bae50d72e6380e50fd7834857aef2170", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_red/dev_beam.sh": "934ba0086038f4d45e18584db3175335319d4c0db5dd194838db0936aec9768f", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_red/dev_run.sh": "bcc19fd884af62ee3abf5f5de0040c340806c284aa05730a76c0295c2686c3bf", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/bert/implementations/tinybox_red/run_and_time.sh": "9a95c9f04ad946bdd51268cb54e9e6f37cf5dc2f95faf69cb60348780e5d94ba", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_beam.sh": "0cacd33b960008231a1d7e391424d2fb23122955265725b36cb7c498001d49c0", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_run.sh": "66f6a8f652956c3167cdc2a7d710633e27cac1517c3cab7b5ffb675232200772", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/run_and_time.sh": "198095a50f2fd80aca8a9d3d16188cc6082277fbead9ada72579fdfbbe47ec6c", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_beam.sh": "5a9a17162066ba0e8b658cfa52bef1ed80b963e6efb83abc835a5e64f0cdaa86", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_run.sh": "73aa3ad7dd687dabb14c43fb1c54fc98c0232037fc9b3c5df04586258eb21810", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/run_and_time.sh": "e6d325efbb5869107daf9674e25234268713c089ec6edf3f3cbc7fb8e9780add", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/setup.sh": "c35c04efe5da4df74d20f570878474dc923f7cc8f5e68130e66bbfba8b0f89de", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/retinanet/implementations/tinybox_green/README.md": "b32a129f75179a7ef89c902e28b0fabcdc83e42c9f0c25a2c0e500a3c45256ee", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/retinanet/implementations/tinybox_green/dev_beam.sh": "354c1181083cb3f11e051a8fc79824e290642c9f15d548e664ad9308ee87e76b", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/retinanet/implementations/tinybox_green/dev_run.sh": "0a7172795bb089b45d4ebf1dda76f8b8852f18ad21c155450a43dd0473f6d778", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/retinanet/implementations/tinybox_green/run_and_time.sh": "995c303d14c9af440ba068fc9f2119eee7e5f4599943d95206f5d0cfcca040b0", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/retinanet/implementations/tinybox_red/dev_beam.sh": "695c7f319c853300acbb26ef5e0715344524a37458469c99e98c6df6ccaf8b4f", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/retinanet/implementations/tinybox_red/dev_run.sh": "a18a59d5105f11b307f2c87bc302f719244f3d37b474b813d6209a33162604ef", + "examples/mlperf/training_submission_v5.0/tinycorp/benchmarks/stable_diffusion/implementations/tinybox_8xMI300X/dev_run.sh": "513aa98ea5b9a083bc2713f929e0878d1d7b6b400a77d25768d5ed53a6b920f3", + "examples/mlperf/training_submission_v5.0/tinycorp/systems/tinybox_8xMI300X.json": "c102d14065547c84a4119318ec85646131ebb779ec425774f31527ac24aac580", + "examples/mlperf/training_submission_v5.0/tinycorp/systems/tinybox_green.json": "07a7688a82814bbf4f568e4b799793b4f8f02dd35d5845e8fa740ac5cea06043", + "examples/mlperf/training_submission_v5.0/tinycorp/systems/tinybox_red.json": "4ce4029bd016a57deda62697b21c3ffa9daedf0714f8de21701189363d534493", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_1xMI300X/dev_beam.sh": "d57fa9a41b464eacb9f4e4798793c9c467f6ff03bb09f298f379a52c247896e6", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/README.md": "e252dc4764afb0ec022f196c82ed47e9bae50d72e6380e50fd7834857aef2170", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/dev_beam.sh": "9120488654fb8d3dfa9638a20ad1ed8c4f7818bc63a8f3b6b3fe5d6216a43abb", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/dev_run.sh": "9ced4871977af11c1a7f0b9a821d41f70b2f0f0187524d47948108906a74fcc3", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/run_and_time.sh": "2af628f0033ceecfb1d9a569e3556ccdf9b3e63fa32e516dd64a47a9ad7dc276", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_green/README.md": "e252dc4764afb0ec022f196c82ed47e9bae50d72e6380e50fd7834857aef2170", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_green/dev_beam.sh": "e45a1ea7697d554e7490a5802fb67e65b197f8712c4cf32f59424001f5df253c", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_green/dev_run.sh": "5a3b9e368283ae0826d1abcbd14a9a2ef61e8070bd3b249960fd38c4cf289347", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_green/run_and_time.sh": "0c3b99cb189eebf77b67972d29d3f042be4412d98fa0cb9657bd89a740c611cb", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_red/README.md": "e252dc4764afb0ec022f196c82ed47e9bae50d72e6380e50fd7834857aef2170", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_red/dev_beam.sh": "13bb929b169191297dddb3c0fa46f9f993faf16a706d5edb04e95016ea04918b", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_red/dev_run.sh": "c24ec292d0e74630c1265a80b3c79066af71648fef1860446061b9fb1458f200", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/bert/implementations/tinybox_red/run_and_time.sh": "c022f3971ce0870333f58b4c72d27fb2281ca4a6f2bf5b97a9920c49ed9a785f", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/resnet/implementations/tinybox_green/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_beam.sh": "0cacd33b960008231a1d7e391424d2fb23122955265725b36cb7c498001d49c0", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_run.sh": "66f6a8f652956c3167cdc2a7d710633e27cac1517c3cab7b5ffb675232200772", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/resnet/implementations/tinybox_green/run_and_time.sh": "33f8861eb0807a428e6504224ee23ca065083e88fc9f4fd5817895c90fa2d7b0", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_beam.sh": "5a9a17162066ba0e8b658cfa52bef1ed80b963e6efb83abc835a5e64f0cdaa86", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_run.sh": "73aa3ad7dd687dabb14c43fb1c54fc98c0232037fc9b3c5df04586258eb21810", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/run_and_time.sh": "0e795a7487fd440c0405b9f24c6635dbd73e8b992cb602d6165076473eeb4e8f", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/resnet/implementations/tinybox_red/setup.sh": "c35c04efe5da4df74d20f570878474dc923f7cc8f5e68130e66bbfba8b0f89de", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/retinanet/implementations/tinybox_green/README.md": "b32a129f75179a7ef89c902e28b0fabcdc83e42c9f0c25a2c0e500a3c45256ee", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/retinanet/implementations/tinybox_green/dev_beam.sh": "354c1181083cb3f11e051a8fc79824e290642c9f15d548e664ad9308ee87e76b", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/retinanet/implementations/tinybox_green/dev_run.sh": "0a7172795bb089b45d4ebf1dda76f8b8852f18ad21c155450a43dd0473f6d778", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/retinanet/implementations/tinybox_green/run_and_time.sh": "f45b6907df735527adea553e28bc0ec57e227240357578fd21248d51981e5ee1", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/retinanet/implementations/tinybox_red/dev_beam.sh": "695c7f319c853300acbb26ef5e0715344524a37458469c99e98c6df6ccaf8b4f", + "examples/mlperf/training_submission_v5.1/tinycorp/benchmarks/retinanet/implementations/tinybox_red/dev_run.sh": "a18a59d5105f11b307f2c87bc302f719244f3d37b474b813d6209a33162604ef", + "examples/mlperf/training_submission_v5.1/tinycorp/systems/tinybox_8xMI300X.json": "c102d14065547c84a4119318ec85646131ebb779ec425774f31527ac24aac580", + "examples/mlperf/training_submission_v5.1/tinycorp/systems/tinybox_green.json": "07a7688a82814bbf4f568e4b799793b4f8f02dd35d5845e8fa740ac5cea06043", + "examples/mlperf/training_submission_v5.1/tinycorp/systems/tinybox_red.json": "4ce4029bd016a57deda62697b21c3ffa9daedf0714f8de21701189363d534493", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_1xMI300X/dev_beam.sh": "0ab48a69dbe41d9cc5575828b0fe5a289a79ce392a8de729c87abf0875755462", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/README.md": "e252dc4764afb0ec022f196c82ed47e9bae50d72e6380e50fd7834857aef2170", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/dev_beam.sh": "4d174db2239a5649e4c284c64a315d5dfa0f9b8dd08a6cb3e92cef82e71de093", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/dev_run.sh": "72056306c6c50fc4f68a597f1cd5c7c3deb5a5cf504067ed5fb0253b1e2bb796", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI300X/run_and_time.sh": "b682aab2e4889d05282986b2bbe23583218dc9358a57f10a8618b1c03f083d8a", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI350X/dev_run_fa.sh": "bfcaf722f4d550e31ba016553fdc49a97000a87b71e8f1aa90497eb929bc7a0a", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI350X/dev_run_fp8.sh": "8e154134ce125bba9d409917d802126d9371b45d4234acc1048bb7431fb779fc", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_8xMI350X/run_and_time.sh": "b1a2319094ae7ea0884492b82f0aaed5d9f31aaea31ac59610c79f9758a8b312", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_green/README.md": "e252dc4764afb0ec022f196c82ed47e9bae50d72e6380e50fd7834857aef2170", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_green/dev_beam.sh": "125581d7739998e7683b78c06e4a0de1c881ed789fb93e6d0222d97d8460fa11", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_green/dev_run.sh": "a85f4b46ac0d390f62922a152fa6415e8829b312d55a84b6326a61a3fa95eb22", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_green/run_and_time.sh": "2a5404c7c85f2bcb25f9368743254f2904071f302c38456fda0598efde3557d2", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_red/README.md": "e252dc4764afb0ec022f196c82ed47e9bae50d72e6380e50fd7834857aef2170", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_red/dev_beam.sh": "cf55b42baad8b9ccffa8182d5bff95a0307db0490104901f132a1fc425a7c4d2", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_red/dev_run.sh": "2ae79b116af6f382aeabddd9e92edfff347fc81b0e8fbbfc0a0682db4c32bc63", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/bert/implementations/tinybox_red/run_and_time.sh": "93b79ee4844e9f638fcfd098c42df7104c722deb1ba39ae6ba3c32d562ca6f6a", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/gpt_oss/implementations/tinybox_8xMI350X/dev_beam.sh": "f747d5ba46774cdf5020a000c1837eb04dbfeaf76cdf4f76ac75d65ba501760f", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/gpt_oss/implementations/tinybox_8xMI350X/dev_run.sh": "7f44113258c601113c66027455be23ec23cf0cb4ced27d3689a0d812803e3e75", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_405b/implementations/tinybox_8xMI350X/dev_beam.sh": "49f83d6a86a787edfbe4c5311e47c7a797a81c166643ed7d85a9a7836f195086", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_405b/implementations/tinybox_8xMI350X/dev_run.sh": "1bc726288aa08bce5debbe8d0daeb9aea2433ada881536ca800c02d4fa50cf98", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/buid_dataset_cache.py": "e0a7a8ab1a1d1648dc241e20e7a5db42c51a680625bfcef1bf52068091d48e77", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/dev_beam.sh": "92c99dd15e0c720b39ed2f2d1ee6d66a705ec79a5e37b9cce61c4b4be3a16312", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/dev_beam_mp.sh": "db92c636f636e4ef4252afc6f462f59d80989128f130b2bcb1fbadec0fdf3733", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/dev_run.sh": "5bbe45c31686df6bb1aca1ba475087c8c2f60abf8753653ee73cfd0329fbe898", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/dev_run_mp.sh": "62014eb841464ea83c6ee6a314a5d20fe84c2045e1d9b53edfb53fde47f668de", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/profile.sh": "f42f19b52a045840c50cfd2203b3b90a18db41a8e05e25218adaa3e676e11ec7", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/run_and_time.sh": "25a209774875453995d443bc02ad421d7cb150f27f49bdf52cae6ce6b71bf19c", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/startup_walltime.sh": "7d7000c704f11fbc3574f35b290700e0d775ee67a5be5243bfdf4f6c4edd200b", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_beam.sh": "0cacd33b960008231a1d7e391424d2fb23122955265725b36cb7c498001d49c0", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/dev_run.sh": "66f6a8f652956c3167cdc2a7d710633e27cac1517c3cab7b5ffb675232200772", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/resnet/implementations/tinybox_green/run_and_time.sh": "33f8861eb0807a428e6504224ee23ca065083e88fc9f4fd5817895c90fa2d7b0", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/README.md": "29040051d002baaa751401ba8d8f358bc5258810a92e4aa8d1b2559411b85843", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_beam.sh": "5a9a17162066ba0e8b658cfa52bef1ed80b963e6efb83abc835a5e64f0cdaa86", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/dev_run.sh": "73aa3ad7dd687dabb14c43fb1c54fc98c0232037fc9b3c5df04586258eb21810", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/run_and_time.sh": "0e795a7487fd440c0405b9f24c6635dbd73e8b992cb602d6165076473eeb4e8f", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/resnet/implementations/tinybox_red/setup.sh": "c35c04efe5da4df74d20f570878474dc923f7cc8f5e68130e66bbfba8b0f89de", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/retinanet/implementations/tinybox_green/README.md": "b32a129f75179a7ef89c902e28b0fabcdc83e42c9f0c25a2c0e500a3c45256ee", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/retinanet/implementations/tinybox_green/dev_beam.sh": "354c1181083cb3f11e051a8fc79824e290642c9f15d548e664ad9308ee87e76b", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/retinanet/implementations/tinybox_green/dev_run.sh": "0a7172795bb089b45d4ebf1dda76f8b8852f18ad21c155450a43dd0473f6d778", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/retinanet/implementations/tinybox_green/run_and_time.sh": "f45b6907df735527adea553e28bc0ec57e227240357578fd21248d51981e5ee1", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/retinanet/implementations/tinybox_red/dev_beam.sh": "695c7f319c853300acbb26ef5e0715344524a37458469c99e98c6df6ccaf8b4f", + "examples/mlperf/training_submission_v6.0/tinycorp/benchmarks/retinanet/implementations/tinybox_red/dev_run.sh": "a18a59d5105f11b307f2c87bc302f719244f3d37b474b813d6209a33162604ef", + "examples/mlperf/training_submission_v6.0/tinycorp/systems/tinybox_8xMI300X.json": "c102d14065547c84a4119318ec85646131ebb779ec425774f31527ac24aac580", + "examples/mlperf/training_submission_v6.0/tinycorp/systems/tinybox_8xMI350X.json": "55cc6e6727786368bfc3c7eb33e1e39bb390925ea064c910f4b33d173b785eb0", + "examples/mlperf/training_submission_v6.0/tinycorp/systems/tinybox_green.json": "07a7688a82814bbf4f568e4b799793b4f8f02dd35d5845e8fa740ac5cea06043", + "examples/mlperf/training_submission_v6.0/tinycorp/systems/tinybox_red.json": "4ce4029bd016a57deda62697b21c3ffa9daedf0714f8de21701189363d534493", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/gpt_oss/implementations/tinybox_8xMI350X/dev_beam.sh": "24f6db58f83c0ba148315c51912f37f95618fa6f8df9a69b6f373bf4fe625b87", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/gpt_oss/implementations/tinybox_8xMI350X/dev_run.sh": "91e5afb1be65b76c3b1899b34781fb5db8c387b6e100bf6e92d845471d42f409", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_2x8xMI350X/dev_beam.sh": "da80dc7206c869f05430f5577ab3bfd0739feacca329731b8f91efd7fa5f2bbb", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_2x8xMI350X/dev_run.sh": "0ffe1ef72f0ed18065b0a4980e62ef995a97e348f6b3a0cf4964b9c3a49490d3", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_2x8xMI350X/setup.sh": "a83a87fd73d601c27b9cd15d8ce99a40288fd4b5dd52f396157f24b236ad3fd4", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/dev_beam.sh": "6682a74193edbbdcf093fb6de759659c3eff6cdcbd5b8409ddcbb516ba66bce0", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/dev_beam_mp.sh": "db92c636f636e4ef4252afc6f462f59d80989128f130b2bcb1fbadec0fdf3733", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/dev_run.sh": "9b9a87e32776d43fbf5d1729e1b43ec275641c9d518ca495e56d232a493f58ef", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/dev_run_mp.sh": "62014eb841464ea83c6ee6a314a5d20fe84c2045e1d9b53edfb53fde47f668de", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/profile.sh": "360ecc495cfc74961046b9081c89e630d6b24364ce14f0ec14b197961a7a3bba", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/run_and_time.sh": "379a442426ccd46aa7bf9e9df1b2e9653ada76f5a9c0307bed9c546787960021", + "examples/mlperf/training_submission_v6.1/tinycorp/benchmarks/llama31_8b/implementations/tinybox_8xMI350X/startup_walltime.sh": "7d7000c704f11fbc3574f35b290700e0d775ee67a5be5243bfdf4f6c4edd200b", + "examples/mlperf/training_submission_v6.1/tinycorp/systems/tinybox_8xMI300X.json": "c102d14065547c84a4119318ec85646131ebb779ec425774f31527ac24aac580", + "examples/mlperf/training_submission_v6.1/tinycorp/systems/tinybox_8xMI350X.json": "55cc6e6727786368bfc3c7eb33e1e39bb390925ea064c910f4b33d173b785eb0", + "examples/mlperf/training_submission_v6.1/tinycorp/systems/tinybox_green.json": "07a7688a82814bbf4f568e4b799793b4f8f02dd35d5845e8fa740ac5cea06043", + "examples/mlperf/training_submission_v6.1/tinycorp/systems/tinybox_red.json": "4ce4029bd016a57deda62697b21c3ffa9daedf0714f8de21701189363d534493", + "examples/mnist_gan.py": "fe70d4a66a4615acdabf3877240494840632d851895323eee9c4c1da81c29192", + "examples/olmoe.py": "745e69653184ef229254aad4fb1f008af08d89e275f6d65ccda0121468eb4458", + "examples/openpilot/check_image_reads.py": "3d6c02151070b3be0c6f97f48fcc6696db2dc9085de90477bc301e2d77ddf656", + "examples/openpilot/compile_onnx.py": "512571a84dc7931a07713a81b342e5087c41b173edea2d9a3b209fb83c5ab340", + "examples/openpilot/compile_warp.py": "97a6814fde7f16e1ce265c6b6388cd5799c8e2f8969ac78cfc4fd5a929b1921d", + "examples/openpilot/helpers.py": "277dadab6ff477a27c7b51302f91dac2920598b34710e9ce39675a10ab4c69d4", + "examples/openpilot/load_pickle.py": "5076c9cebe08711c028b2e9e11f6399ef7fba830834d9e350ccefb4f0ed2cb6f", + "examples/other_mnist/beautiful_mnist_torch.py": "b26c04e648ce3dc63505fc71222e9630f8983c105a76b0b8741b01f9cad68682", + "examples/qwq.py": "574715ffa8bf7c1273093a378c91a7dbba8621a4d3bbd0251a4d00dc545f4221", + "examples/sdv2.py": "6464a1610f3f1a2dad4f4238b6f9db03a0ba428c8d0c1abf458d56d396c89530", + "examples/sdxl.py": "744c8e0fd7417f0380f36320cdff7a3180d34e2680c96c4897014f9a17e6ab39", + "examples/sdxl_seed0.png": "60cee4eea0c5852a732d518ef960b3c0496e4152d5ee483ef1b8324742f4b11a", + "examples/stable_diffusion.py": "c14ece8ee41f0fc83b383f947889b09b14843d22d25bcf57b890f23ad3957431", + "examples/stable_diffusion_seed0.png": "990b78eff8e437f3c077af43825b605a7224fdbad9d8e3ae4c4a0125439363f6", + "examples/stunning_mnist.py": "64e92b799ad43d476831cdeae3b84187dc81d06399fb7f65f29b7505681e2f41", + "examples/test_onnx_imagenet.py": "83af1ba0dcce3e96418003d2a7ff2657eeb68891e569145155e3fd5c12d225ec", + "examples/test_pkl_imagenet.py": "9dc05049bc52fa23caeea8c7958244917235744da7201b4b3d4b6ff49d324be2", + "examples/tinychat/assets/cdn.jsdelivr.net/npm/@alpine-collective/toolkit@1.0.2/dist/cdn.min.js": "34a23d525a68149fe4cc6a18a3fecd0ec849fa9dc59d90a067d891f1e4941dad", + "examples/tinychat/assets/cdn.jsdelivr.net/npm/@alpinejs/focus@3.x.x/dist/cdn.min.js": "0326aee04b8abdaed23caba37025291a5b81a812daf938128bfe1e44845573ef", + "examples/tinychat/assets/cdn.jsdelivr.net/npm/@alpinejs/intersect@3.x.x/dist/cdn.min.js": "b1abfbdea4404f7101de26ef6e2e65f4efae73be7b3302141eecf27def68560e", + "examples/tinychat/assets/cdn.jsdelivr.net/npm/purecss@3.0.0/build/base-min.css": "ffb9da134ed8f6846627d2504cfee31504f3c3ef91100a4bc7c03c6a982dd96c", + "examples/tinychat/assets/cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/css/all.min.css": "5ceaaba22d75b58e04150311f596306562a3e595e27ed4b1dfa451b82dda9e50", + "examples/tinychat/assets/cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/webfonts/fa-solid-900.ttf": "b4990d0d0c5f5d38d62e936eea120674e584c7eea8dcee38a975c0cf9a37539b", + "examples/tinychat/assets/cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/webfonts/fa-solid-900.woff2": "ae17c16afbea216707b2203ea1cf9bdb45b9bfe47d0f4ae3258ddbc6294dd02f", + "examples/tinychat/assets/unpkg.com/@highlightjs/cdn-assets@11.9.0/highlight.min.js": "837a6fa5b0c736b52bbde2b2b6190f305da3fc9ed41681db5321507057b5c846", + "examples/tinychat/assets/unpkg.com/@highlightjs/cdn-assets@11.9.0/styles/vs2015.min.css": "3e2efbd7efa306bc2078755818e6b5b2337c89d5e5aeb612290548efe240e789", + "examples/tinychat/assets/unpkg.com/@marcreichel/alpine-autosize@1.3.x/dist/alpine-autosize.min.js": "34d3d3b16cd33c31c87352e1fa71a1d5ab0df4bb0f0033c10ad5c8e3a42248b5", + "examples/tinychat/assets/unpkg.com/@marcreichel/alpine-autosize@1.3.x/dist/alpine-autosize.min.js.map": "a42f272ba9b78a45add8b5b146bf77f82d11af9ef7ea52ae9209ec698f695c56", + "examples/tinychat/assets/unpkg.com/alpinejs@3.x.x/dist/cdn.min.js": "b600e363d99d95444db54acbfb2deffec9ae792aa99a09229bcda078e5b55643", + "examples/tinychat/assets/unpkg.com/dompurify@3.1.5/dist/purify.min.js": "20b0b3840a73da51d3a66c51f073e3ed6da1042b3741c5861c1b7a36693dc928", + "examples/tinychat/assets/unpkg.com/dompurify@3.1.5/dist/purify.min.js.map": "f0bfc01c16eba3d6d9235aac5193925810d24908c30b018844bd3b409ab81c8d", + "examples/tinychat/assets/unpkg.com/marked-highlight@2.1.2/lib/index.umd.js": "fc36b48b66e6b0d15cb6adecc72d3cbf935b379a6e3069f63cc8d85d73991d6a", + "examples/tinychat/assets/unpkg.com/marked@13.0.0/marked.min.js": "95674eef99e625a35507b91ae746e82ce59a2ffcc6d83f69c6c4e62e79d21835", + "examples/tinychat/common.css": "a9cbc5104376fa9804adb9944f775512ee2b9ff471c67ff41fd56223b32c16ca", + "examples/tinychat/favicon.svg": "2ca7e5cd1a4c5958b690174a365526bb03db7b98f605fe55ec30be1bdb10e0a9", + "examples/tinychat/fetch_assets.sh": "b1aa9c7d152570722ccdb6ab313eb78b372c9ae4af47802e8642a8c885c4f322", + "examples/tinychat/index.css": "0d77d7a88d26d868d57d33f6fba907e19197df21757a8cbf5e9bc6f5ae784163", + "examples/tinychat/index.html": "b24a00cd30c93ad63efd2851434d7b6beacfd902493c80a9545da1379e7a468f", + "examples/tinychat/index.js": "f58b412ca4f6f0a49fd112556621d0ab75a3ff64e4f9984423e4a7728a0bb991", + "examples/tinychat/tinychat-browser/.gitignore": "e5ba6268ac76baad71e0320e0e9820f26cf145122284b4eee8bccd1396f5bc8d", + "examples/tinychat/tinychat-browser/README.md": "85cfc8ed419749f3ca233f8efa440572ea3691a0c33fe56d08b320f67b31b528", + "examples/tinychat/tinychat-browser/compile.py": "aa9dfedb22614bf5f45b917f3e19def1349208144b21e31b8bb17be3dfbc430f", + "examples/tinychat/tinychat-browser/compile_wasm.sh": "ebaa1f2e45b8ad2fe1f3246abf81f9d632453fa28876ea3d29c33ca313027538", + "examples/tinychat/tinychat-browser/index.css": "581190942da5cf5184a024a9e5cd1fecdf45b231b5c9e68ce2f38c8425670112", + "examples/tinychat/tinychat-browser/index.html": "1e965e504b3a1ed4ccff04b99146078ca162af7b820434af5f45766c3d36f373", + "examples/tinychat/tinychat-browser/index.js": "c7f8c90338a7c7bb270f4f7f0bcab88dc050c003613d767890a0a858f39760e4", + "examples/tinychat/tinychat-browser/make_tiktoken_js.sh": "e3aee73f4473873879aacfe6b736bfb479ce52c07e997cfb115aaf9308314870", + "examples/tinychat/tinychat-browser/tiktoken-export.js": "07bdd636416228f4999f8629e1d3d3b3ce3172a1453a523f01eb6440030ff9f5", + "examples/tinychat/tinychat-browser/webpack.config.js": "2d0f0ab5ada1e565cfd284d8f975c3ff79de455ccbadacd9afd7006a70907276", + "examples/tinychat/tinychat-browser/worker.js": "bd6b2c00beac8be2f1db6142da5e8a4eed33a1b98fb7fcfca1002bfe674e3b26", + "examples/tools/bandwidth_test.py": "5a25330d274d0b30439d81b6b557a53e6184124553218f01696ee5e7a327e268", + "examples/tools/gpuburn.py": "1053e43fdf38b36b0a2e06eeb5340f389035b868113e2bf64a0220a8bd2dcf7c", + "examples/torch_cuda_kernel.py": "05ee9877d22d2f35db0a08d4a0991c8ac09661713bfb5c164ee49d40ca40a60f", + "examples/train_resnet.py": "f607280a4065f0d3868e047d048d1da32a726e37c7c02367293860c966c8d8c0", + "examples/transformer.py": "76f9772b20f4f029919071c10a6f0983dead50f2a297d204a981933cee688655", + "examples/vgg7.py": "0cc1183765cdab8f459b7c6c1327f1b33c5c6a050354341e093f69249a0d3563", + "examples/vgg7_helpers/waifu2x.py": "b5a833021995032ca0872a763db13ea3530d0d050ef5be18200feef99e0ae013", + "examples/webgpu/efficientnet/index.html": "7f1f8046e081256ee234cda2161b5e581ad705dc96182f5b41a8b98e6f51bfe3", + "examples/webgpu/stable_diffusion/compile.py": "8be79cad14cf8d95ac3b2c6d3954e41727e88b7e8adbc02a73b5c69c4da7a23f", + "examples/webgpu/stable_diffusion/index.html": "6ceb57f12134bfc710d244d50f3be52cc1ad660bd4598b6ecd93cc13f487bd2e", + "examples/webgpu/yolov8/compile.py": "a9ff00e24f1a76a9713eaa0450c7a6930c1e42aa81ec20e39d043c0df4e2f783", + "examples/webgpu/yolov8/index.html": "e9f25dbd19fb5f0a291483f796df2d78ab21bf62c28ca1be24bffe1129282cf5", + "examples/whisper.py": "e853d31e70cb538f8d2b2aa084b54b25d60c52791f4e5b2311a314a2ff1681e7", + "examples/yolov3.py": "37dfaf48a4df50829af675b407e1c3d1b94ae2bef83ebe756d761e093259d287", + "examples/yolov8-onnx.py": "80a2064055280c105a70c592bd0aabd957f67398307d379cd322bc54dd0f1d4f", + "examples/yolov8.py": "c8996963689e1ddd1bc6a92c17dc43756abaacba8e964d6e44cfdecf4ea92640", + "extra/amdflash/README.md": "bd751a9e9651b3d42a7b03674cbff2def1442e1686208ee1bc4a12010b01124a", + "extra/amdflash/common.py": "7e1820aac5d9e9e80f9b4630d32798b167cde2cbd1a1983f52686aab61e50b57", + "extra/amdflash/fw_live.py": "086d47a675e51d4e0e77390bd1a35e016bc9b324cce3716887d98fce8eede380", + "extra/amdflash/romless.py": "8cb354b6ede7f3beec6a263b876e050297e2e198d840e9579641f8124a36670c", + "extra/amdpci/am_smi.py": "9e7bd356f5c1331710420a351b23e678c679fd9f2519dceb510f184e66cd29ce", + "extra/amdpci/headers/amdgpu_doorbell.h": "dffd9c89f6a7c95ec497cd31d0e6a3db751712fff6c531fe1cab22816c21e949", + "extra/amdpci/headers/amdgpu_irq.h": "32f44f92e4d563ae8a662334a1d96dbe48f9e0b373700f8475280266bfcad6bd", + "extra/amdpci/headers/amdgpu_psp.h": "f5367439b078a8e46a104fa11b469350d5108ca3bd5c295a132bdaf070e433fd", + "extra/amdpci/headers/amdgpu_smu.h": "4573855bc5511243fae0b96b362f34b46babb45bd5423553c91f79d94fcb1243", + "extra/amdpci/headers/amdgpu_ucode.h": "741b622250c954c1c59b6c19ab638dca4236650796b21882581c31d7a9010967", + "extra/amdpci/headers/amdgpu_vm.h": "8f1547acb5b7a9f7f20b1e2b03dd68479beb60aa7f2926e287c13fd541c12290", + "extra/amdpci/headers/discovery.h": "53dcd9c316b1d1d98ff57cf1b2889a4cbb804c92621d1174d759d8c7cb8efaa4", + "extra/amdpci/headers/psp_gfx_if.h": "71e86fbc2057cf0d9a704dd3ad5aadb1661f1a96df48fd033aa6b09c1bd5ae15", + "extra/amdpci/headers/v11_structs.h": "d54ab6ea03fc382659e09bf3c357f988d0efb404b5d860844c2c88dfa42a6730", + "extra/amdpci/headers/v12_structs.h": "e3c687d7c727cb488996e04540b038eb62bdb89948dfd05509d85dcac0a78c7d", + "extra/amdpci/hive_reset.py": "73c5c56705e5cf4a7b68d4c7335a89a46f9e3e754780d64798363b9ce24c45c1", + "extra/amdpci/overlay/gc_9_4_3.h": "eadc9f85c598f2c34221f8fa8f81818b577fae579688b7eb3062aea96d3ac749", + "extra/amdpci/proclogs.py": "afc7a92c6310516448ab957af6653c2a30f85b31d2229efd4ee78d94efe43096", + "extra/amdpci/setup_python_cap.sh": "79b2645f4e12db637510b65d01cd5e5aef7a34223bb74d3c1cfa08249328558c", + "extra/amdpci/setup_vfio.sh": "9943993dd466f4f86bc6d37c6e0e71639588a33d2ca97c64afbbdbb56545997f", + "extra/archprobe.py": "11836faad29b9644eee7ffdfa85508316fe7095865b1f0e7bd13c6e0e8c91398", + "extra/bench_log.py": "5105d9db57e609ba00f8518e754bbf6c95f2d02221a150f2b78ca409dd47cb98", + "extra/benchmark_llm.py": "301564880681ca5fabef7832d95bb114c165453f9b171994de150e1783382dae", + "extra/bnxt_driver/connect.py": "c69b7d064eca5564c948443a2ef3969e9ef8e920213d15e4440c7d9adc67778f", + "extra/bnxt_driver/loopback.py": "5c2329eebb9f1d06089dbe449d8e50c923812d8396626e1cfba195398c1121a6", + "extra/bnxt_driver/test_bnxt.py": "fe7986f1efa39964fe8f1e9f85d850bbfd59d2ef4f207b5c103ad44e4c9332f8", + "extra/bnxt_driver/test_bnxt_transport.py": "506afc68e0e32604d4fe883e546325a6399c58b47647ff9570e024f6c92cf2dd", + "extra/cl_android.sh": "ac96d0ad559cdb918f7f8d9e7a10d435eee6a1a15ac0c42bd79dfcbd2aa3eda6", + "extra/datasets/.gitignore": "f298011860bcc43989448cc9b2d2ddde688b221812a752972b7848af98530ce9", + "extra/datasets/__init__.py": "5acd2561467e61e0a4fba8638726d6ba6d431c63c6e8fa42929230d31f725964", + "extra/datasets/fake_imagenet_from_mnist.py": "7bfc98b9efb2439685890448f9b164dfa673d0f1c5a3be00c4c30a9de0287d43", + "extra/datasets/imagenet.py": "26fa5df7d61cca59fffbdfc0f2bec3876747d5b4f4507379ab0c9fc8dc61ad00", + "extra/datasets/imagenet_download.py": "e0365cd545fa26636b24204a127e7e5cfc7bd9e338453f455269c7c853a36754", + "extra/datasets/kits19.py": "8261b361b75f98527fa18ec947cd6980f859ec395b92df857eedccb75b17c4a8", + "extra/datasets/librispeech.py": "8a4aac8e6242e6aba8abe6791be7a55773cbf0c60c55a21adb54840278576d0d", + "extra/datasets/openimages.py": "ea1586f8e15ef8290096297143d41fec2745884fde6ebbdc68b851b672cc082e", + "extra/datasets/preprocess_imagenet.py": "fdbc2bbd459bcd09520576d23e1fb0c87a454a875c59b93953680c4becef227c", + "extra/datasets/sops.gz": "4eefbf445bfb1f1484530d3dc1098ffd750ddf1f34c66680f53a4b70090423f2", + "extra/datasets/squad.py": "2dbe18b006bb35cbee115458a72315fade6c1b0205248578ed433d4fb3e54ffd", + "extra/datasets/wikipedia.py": "45529868f279b91aabd6169f9ab14379bda57d2e42f838933ec6f0812ed35a45", + "extra/datasets/wikipedia_download.py": "763269e6f1fb60aad5b0e9db8b0d9f39151f9314439806bb514e316f4ff9ef80", + "extra/dsp/Dockerfile": "33ae9a588b1ff0f873d6d5007c561f14a6aeff6d99997ba7a38274c411fd8f93", + "extra/dsp/compile.py": "a89cee701b5a31b5430fd94ffd0b83a6bf1ec38fbeb889a26f223d68261cde01", + "extra/dsp/gen.sh": "98ac10fe105454fefd471526acb79a1075f919994cfdd5c7c887d63617278aad", + "extra/dsp/hook.py": "edd96c53b908cc8213ab46e71d22d1b422b329c5aaf93918358911643f167f86", + "extra/dsp/include/AEEStdDef.h": "85dbeac5cce17d078b1f399fad1813fe4b8ac25c637b3a745ff14dda1cbc7544", + "extra/dsp/include/AEEStdErr.h": "6ad70b62297d2bc0997f341e32062c702379242b5b13046643300cce1d76345d", + "extra/dsp/include/HAP_power.h": "d4487380b4536185ef85885725087389260e6b4bc309d64d39d93363debbaff0", + "extra/dsp/include/adsprpc_shared.h": "67f0911bc94faa9b1167b2471e9c2ab5e50ebe34c0a669ff33126c21669e1f9d", + "extra/dsp/include/apps_std.h": "7647308c4fa4bf4fa69135b1c62baac085bc9dbb969861cc219eac1dc907763e", + "extra/dsp/include/ion.h": "7a315bcb99076e2173de591abaa57b4cbf0d540ae76de3f5209885a8c5b6c7d7", + "extra/dsp/include/msm_ion.h": "4b92f2ace584474866fd88892ea62850900e4785b604e5e642bf98d1d743c1de", + "extra/dsp/include/remote_default.h": "542b0ac4130659378aa6ea9c162e8db63f4310999cc1b37940f4338c43ee7601", + "extra/dsp/invoke_bug.py": "48064708c6cb0795cae19ed6980d0989c3476e60f9c55e01b26cb1d760738cd9", + "extra/dsp/invoke_bug_2.py": "fd0f46b1a6e11bc76c1dec92037b16aba23a168a795b2f8d849ff3f32b9eb58b", + "extra/dsp/opt.py": "37556749d29448856a46beec6ca1f9af6dd6de0846e8505642c4e872c15dccfa", + "extra/dsp/preload.c": "e0dd4470ade662d39bf18f3f4d531b32963f2b4348ba5371da5ec8d97f2f54c8", + "extra/dsp/run.py": "e3969b412661635536d5b09132176ccff933f221b024e4fb29bdfe7bf968c96e", + "extra/dsp/run_3.py": "b0223cf171e0c959e6bd971f047ef3202814e706f14bf3211a407bfef8246265", + "extra/dsp/snpe.sh": "9afe86a76f94e89f892a3868f812dcbc4100816dff447f64fe8fb74eea35b917", + "extra/dsp/snpe_logs/dlc_info_2": "b15bf12bbe8a49b7422429cbbe5b1b9e78b97a0b67c7d233f4cc468e87384b8a", + "extra/dsp/snpe_logs/high_perf_2": "1857dd9348254091626a36bbb38c990e83c59e595f1b88dbd077a69cc2486769", + "extra/dsp/snpe_logs/parse.py": "f90c432a7169177103364975982db8cb54e9f0ba53ac3fc25eeec122225cde55", + "extra/export_model.py": "69bde000efa68528cbac4993bbe3f1b0ae87634c688a6a8d631610730c8f7816", + "extra/f16_decompress.py": "6600120df854f2e8f0dac0208a2f10dce485d00c9d63f361c29d16d828012fdd", + "extra/fp8/fp8_linear.py": "577423193acff7f3454a7e4b6be2bec5d0b35db45164320a55a985f890656d33", + "extra/gemm/.gitignore": "a4e8eb08cb66bf404e40a51da6201fe3668a623ea29f890a8f42bf406ac4df14", + "extra/gemm/amd_asm_matmul.py": "0a7f74482b3ce21fd6706c98b08d154f429f55271adcae1d6aae5d8c6bf2c0c1", + "extra/gemm/amd_call_matmul.py": "b161ee1ffb0be4320c8dce11a67047e2c0d247db73dbcbade94b8f21015c547d", + "extra/gemm/amd_copy_matmul.py": "3c5a585896bcae7c2edf66c064076a881ce9da84f8877b40ed5a0430d652e4c2", + "extra/gemm/amd_matmul.py": "bf0f4898928643859c4e255e41878248704c104c6c524363a1b9a42ed3121b16", + "extra/gemm/amd_seb/kernel3_registers.cpp": "e03b17e22e26f59f1484e3f42534f4c52d86147461b1e62f4850abfedb107e8c", + "extra/gemm/amd_seb/kernel4_gmem_df.cpp": "76538860ab82f03a240b187a9e9cddccd7ac390718e127f59484e5d9d12ab215", + "extra/gemm/amd_seb/kernel5_lds_optim.cpp": "45e1ac4f1a2026ad559e41748d0bb68244da7b4ecbcf42bb44a7e420a4969882", + "extra/gemm/amd_seb/kernel8_batched_gmem.s": "07ca97914f3cb0c79b1b4c6c60843b05fd6a6a8254acd486f618a8095146f603", + "extra/gemm/amd_uop_matmul.py": "1f3d161d1dedc94f42e670d1eade065a16bbabcf7a35f42634203908a62a9d51", + "extra/gemm/cdna_asm_gemm.py": "4fe778801f67e90efd7439f4741da966205b958bfa0716a6bf4e3abfff23d262", + "extra/gemm/cuda_matmul.py": "214611c15f192d909a7ec13ef4645be88af9e19a08aec9ae9d383a2e349638e4", + "extra/gemm/fuzz_matmul.py": "11bd4bb449c7add65ff29417782a0a5ca75e87a9c53fdd83eb42bd73810c0679", + "extra/gemm/gemm.c": "ffe65086670eeeeecc612e2edf1acae6eba7ef96719f224d69f10284a70a5dac", + "extra/gemm/gemm.py": "1578be8d2c6b082733651109e1d965f71331ae97d6cc75e76d5c7a6c03834f1b", + "extra/gemm/gemm_mxfp4.py": "3df9ef28a30c3a385fc7e2eb81742528a9bcbc188af4bbee6fd00c8e335e2200", + "extra/gemm/halide_gemm.py": "b5d9d626abc603a79a5330540db62a20f5e1de8a763407130fb59fc849d36697", + "extra/gemm/hip_matmul.py": "57a083baf5eda83b4c11c060ca1074b0d41f58b23f6366d9032270682e52cbc8", + "extra/gemm/max_kernels/nv.fp16_fp16_fp16.2_stage.cu": "09ea69c3f810da24daeb26d375454658595bc98703370b53c3bcc700f4cd7ee9", + "extra/gemm/max_kernels/nv.fp16_fp16_fp16.3_stage.cu": "56d320493be4e221f3a84033f41464444b324f4b213a3c29f2f95658b36443c5", + "extra/gemm/max_kernels/nv.fp16_fp16_fp16.3_stage_swizzled.cu": "723281b15f931f0941c3da7955d19d33d98319c94c00266138b8c5cb649d9c54", + "extra/gemm/max_kernels/nv.fp16_fp16_fp16.max.cu": "b62cc430231820d5ce81a45556f7b48afa6e389a192281c09184b985b3ae2049", + "extra/gemm/max_kernels/nv.fp16_fp16_fp16.no_xor.cu": "b917c540071ef9239fd47f8564b5d3067d6c32cda430468ea8d7b1fcf7f7b4b9", + "extra/gemm/max_kernels/nv.fp16_fp32_fp16.hcopt.cu": "4e87ebee78902f625119d342dcdf0d91d4e708829b602b9331ee417398db0743", + "extra/gemm/max_kernels/nv.fp16_fp32_fp32.2_stage_swizzled_smem_input.cu": "c4131f8094997965c92584b77f29536082f16dfde469889e2ff3e0e894a6ec38", + "extra/gemm/max_kernels/nv.fp16_fp32_fp32.flat_smem_input.cu": "72d0b4b1d6dec2b0827b1c73ddf678ad6564ad48a0f27ecdbf88a13e1696dc01", + "extra/gemm/max_kernels/nv.fp16_fp32_fp32.max.cu": "ea7a48a0bc6451641049ad585ecc59e1baf39d19a23d22e6a6df6e93c8debfb3", + "extra/gemm/max_kernels/nv.fp16_fp32_fp32.swizzled_smem_input.cu": "42246d345b4a8fdde93eb6080eed6744c1ec0ece266452654ec5c2d079506c8e", + "extra/gemm/max_matmul.py": "17c29004a1c705d23b95127c1c2d82afa2c973010057d815f7486e0f80b1b7b1", + "extra/gemm/metal_conv.py": "5bd9951a9b9b61a389a3903ceb0d5c03ac13794bdf91c61bbfd7eeb80bbb865f", + "extra/gemm/metal_matmul.py": "dc4f998c9abd3ec7bf0c9767330a7b313c607fa33749e4da239f9d35ef77931e", + "extra/gemm/metal_matvec.py": "58e03895eebbc82712114f106c469698006b2cfbf8d131f671e147386c8af959", + "extra/gemm/metal_uop_matmul.py": "76004ffc5c55321971deef0efac1aa19de44dda7e9673cc538f40f25d0429277", + "extra/gemm/mi350x_uop_matmul.py": "812524be0a044b181a9c92e0cfd757f52034819f6f5a46b88efab9676326ac09", + "extra/gemm/mi350x_uop_matmul_2.py": "557efc83c533ae736045f5bce436bf195e8f30600a90072574a242d183e70576", + "extra/gemm/moe_gemm.py": "25c3c5d37330eded12a5db98c3f41c081d058cafadf24f1e5ef3478900d1f477", + "extra/gemm/moe_routing.py": "6687a638cc174df026081fb5babdca5d069a5188f2b559a784682fca371a2aef", + "extra/gemm/rdna4_asm_matmul.py": "9ed2524692f7b5fe98734028c30119dbcab6a8310bedab2c12a9b4344f904d21", + "extra/gemm/real_pmatmul.py": "6df4507f5a87a0b68d5f59d80200f8a4e42a6c34932f55077af133ace6f5e691", + "extra/gemm/simple_conv.py": "109ec46fe219490c16f611911c48e4dd9ed38fa0277619ba79523bf661264fb5", + "extra/gemm/simple_matmul.py": "b2718439b46a8e532d3a95a70e826cbe6383e9575f0bd0f1cb89c682d19b966d", + "extra/gemm/simple_matvec.py": "35755643b5d49ac92994b3585a80708de4b3f74a74227462d22eb3c8ce061d6a", + "extra/gemm/tinygrad_nv_matmul.py": "9171ce0c565f39de1cc496aa6481205b18a91a8ecea73b5aa509f64ad58ee0ea", + "extra/gemm/torch_gemm.py": "82f91245f500681da869e48db6baca38c7d16499d88211ab84c863b5af8ecb01", + "extra/gemm/triton_nv_matmul.py": "5f4795788a709371cbebf2e95614ef51e824423b56a228aaff1dfa8d9a971ede", + "extra/gemm/tvm_gemm.py": "e714146bfbb8e81d216d56a7231a2d62e238a37fc5a216dfbe16c7e6e7fd65ca", + "extra/gemm_fragment.py": "4cb4ea48079989e267ed7189f589d7b3cc28e0445bd3f8031daece2e472114ad", + "extra/gptoss_kernels/combine/__init__.py": "f99a223d6894579520bf29232286f9a7b03e4c61df05b7468a2712c5c542711b", + "extra/gptoss_kernels/combine/forward.cpp": "a35de1232ce92b6e856da7afb6f72081554681122559a0f606910bc0569a9c7b", + "extra/gptoss_kernels/combine/input_backward.cpp": "e15dc4ceccf7660627ec33f8a6944179baa477ec613ed31e38f3bb7438dd57ee", + "extra/gptoss_kernels/combine/input_quantize_backward.cpp": "9b47a97da1f6c4d30dcc3a129bf50a53ebea1793dfbc1b5d98a5c8ca4a8dca03", + "extra/gptoss_kernels/combine/weights_backward.cpp": "5545b6c32d261193f7ea10f63a51b7e515af938bd3fa1c26e79c86dbc147b8d7", + "extra/gptoss_kernels/dispatch/__init__.py": "ef6775adf051a9aa38b508f4c145001db76b434642b121cda315ab1568b973c5", + "extra/gptoss_kernels/dispatch/gather.cpp": "21307de676147c634e24c6cb89ed63cb63cb44f87aed0fc065fb2efb4e0a6d4a", + "extra/gptoss_kernels/dispatch/inverse.cpp": "570d72bd4965408c1fb1602aa03ab2c7f7f2de5a631a68bd68e79b568883d00e", + "extra/gptoss_kernels/embedding/__init__.py": "11bdb33f5ddaadaacd1ccb832592ec49383665726ff3022cafe2323b59d06936", + "extra/gptoss_kernels/embedding/embedding_bwd.cpp": "132cca6390cf4dcc5ebf8b94ec4c44254ef82d5c08100fd5c464579e7f2e013d", + "extra/gptoss_kernels/embedding/embedding_fwd.cpp": "e2ca63b1c08ee6a93167e2b58b74472d2074bd20c4266183834ab1477622a29f", + "extra/gptoss_kernels/gather_sum/__init__.py": "95c7d21303e938cb00804b5acab2feed53c03ba3c3397adf612ded48fd5f7434", + "extra/gptoss_kernels/gather_sum/gather_sum.cpp": "c7cd6e467bb63f909d38ea09694a8a14e3e1c7fe5de820d0317cc31394304366", + "extra/gptoss_kernels/grad_norm/__init__.py": "dcdd5687a83e17128f60e08c71b0d637fbe4b8f1399d33396d4183868dad8156", + "extra/gptoss_kernels/grad_norm/sum_squares.cpp": "a7232bb88a8da1c27cae5b3857847c1e236a1902174f0368633cc04d7cd00bf7", + "extra/gptoss_kernels/qkv_rope/__init__.py": "99f2820cf213b7d7ff91f8e4e931eee0d92f4295dd125e894fae3d8a8b70bef2", + "extra/gptoss_kernels/qkv_rope/backward.cpp": "a75efa646888b343b18cf6149c4f3f46a57993987064f743926f2065a07c118d", + "extra/gptoss_kernels/qkv_rope/forward.cpp": "f411d4ec382c52200c1422ee1ea147cd09271900c54e018912f3ce3553567221", + "extra/gptoss_kernels/quantize_mxfp8/__init__.py": "db7bbcf0aba4c03345b9614d5efe360cbcfc4a5fcb37a136f18f0f1d592280f5", + "extra/gptoss_kernels/residual/__init__.py": "a9187f514d015216bcad3236975ce4b4f68802ad9c07ab2ba4e430ba1a837119", + "extra/gptoss_kernels/residual/residual.cpp": "47fd933a4a5d86dfdc93f40dacf3f0a85ff8fe4b0b3d28de4216bcedcf9f8873", + "extra/gptoss_kernels/residual/wo_bias_final.cpp": "ade9a267efa3c82d7956f279a39f6a3c54ce7abd930c8cbfbfdce44fa2862bfd", + "extra/gptoss_kernels/residual/wo_bias_partial.cpp": "bef76320eaeb41455569181518906deb9b094d9946df592707454c41765134d6", + "extra/gptoss_kernels/rmsnorm/__init__.py": "6b20e7c6314e8fcc0a504abf9ba9afe6aaf891ca7fb9a70474b5a6e4bde78840", + "extra/gptoss_kernels/rmsnorm/fast_final_denom.cpp": "0be56833a91d6f73832509c93456219d87c4d6712061c4abf8fccd9c2ec56c20", + "extra/gptoss_kernels/rmsnorm/rmsnorm_mul_bwd.cpp": "33bb336ff5743bf77ebb054758b06fcc2243e06ec1a7a76216754753421923b9", + "extra/gptoss_kernels/rmsnorm/rmsnorm_mul_quantize_mxfp8.cpp": "28c378dc2ada69c20d4b0686f2738ab8d32b1f0f6db7b1497e10aee6bc2d681f", + "extra/gptoss_kernels/rmsnorm/rmsnorm_mul_quantize_mxfp8_bwd.cpp": "8d182d19ae6cc36093f0382b1d4899348019d506fa919b6906fa1317a3411f19", + "extra/gptoss_kernels/router_topk/__init__.py": "fd9d0992ec059d48e24f696cbc334b8feed1ee443202126505d660844df0bcba", + "extra/gptoss_kernels/router_topk/backward.cpp": "ca1f4089c8636fa307fb927837232d317077a9e2d11b940faa52cc425e65b049", + "extra/gptoss_kernels/router_topk/forward.cpp": "11c063e3c6f185a3c05bdb90670122f0e5dfbc4663a28bbcc81715008d353f68", + "extra/gptoss_kernels/router_topk/input_backward.cpp": "d590f751660bfe3aba1a58e7aecd37790a8ca1dceccb15a3246df9b0f8c91a9f", + "extra/gptoss_kernels/router_topk/weight_backward.cpp": "3ee6dced4330a03dccbcb71171a08141791afe9a85b3040ddbd1952cdffe0b38", + "extra/gptoss_kernels/swiglu/__init__.py": "effe11552190e96559115c5671c45c340fa2871a3ff43c9a4daae84fb96aa030", + "extra/gradcheck.py": "72401f9a0b660d041c39fffaad6a296455ade6069d30b5e97a772fefde6e0364", + "extra/hcq/hcq_smi.py": "2542ee145f703268f2331fcac44a79c5479bdf48081fdb1bc52dde712e241f3f", + "extra/hcq1/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "extra/hcq1/graph.py": "9a6ea7de210395b95800b2afa336835711102124390532f0762f2e1d123e1f86", + "extra/hcq1/hcq.py": "fc3f18a10add12cbea0e9b34ee11aaba7b76ae0e71c70ee15b25d05c7c53b546", + "extra/hcq1/ops_amd_old.py": "188762121f46459834bb6ec43c9cd596e835ab014a32b8083569c680b2397fda", + "extra/hcq1/ops_rdma.py": "738070f0dc13345edf852bd58dcac46dcc7ee1530cc1ed8c073ec503616e72c4", + "extra/hcq1/remote.py": "bbfbc4a52ec142ee810353fa6fb3c4af9ce21b337a98af993012d9c2bddc8182", + "extra/hcq1/test_hcq.py": "36d7082ed95c1e0f2111190a9cb048a4ff427498e15eb9c887f713caf4d27d2b", + "extra/hcq1/test_hcq_graph.py": "10c08c8f203a6ab67dd0d3981cdaee14d3362c5d9b256927d7a2ac45814a46b1", + "extra/hcqfuzz/.gitignore": "7f26104f77a7ce477546cd1ea99b6c99b5eb079e3ec9238583314eccea00440a", + "extra/hcqfuzz/fuzzer.py": "81196a071a64e2f1f669286e07dc4a99b2e14eb644d07f034e82259740b25951", + "extra/hcqfuzz/readme": "864d139a9a38083f5995f373bd0eec813f9ba4b55a26a507d4de8a7dbc1d4f87", + "extra/hcqfuzz/spec.py": "3d3d6d9bb81198c0f64d0c48a20a566a0d02f80fcd1798053dfa0e9c56ac61d9", + "extra/hcqfuzz/tests/allocator.py": "57a1608371a6d3793d5f466d2f40304e09fc71a637df42688ac87d37b5e64432", + "extra/hcqfuzz/tests/allreduce.py": "48b1e5e06a91a5f89cf0ed496e16b7c2438fcbc346b7aea530e3c83e82bd5cf5", + "extra/hcqfuzz/tests/bert.py": "4def1e7c22545bfb316dd3da5711de792c0e6a8b79db7efc9729ef5145162fa1", + "extra/hcqfuzz/tests/hcq.py": "a5f1937347bf4e125a1427917e7d1e9a6ba94b85292a893395aedd5c208eab98", + "extra/hcqfuzz/tests/resnet.py": "f46042a8913b37d4d7f103a865fcf24c8c1a7fe1e6851970bb4ed613943be6e3", + "extra/hcqfuzz/tools.py": "f22b2d2e6f924cd1bd377a783e0f2e049a3e5dc62a299bbfd59a0daee28e645f", + "extra/hevc/.gitignore": "a888b9df89402a815bdb15d30c5280b090be11655ab4cc2299ce748d44cd6ed4", + "extra/hevc/decode.py": "5225419b4d6eff10b341ca6909fe38e1d7d016386772f60208d51489167cd982", + "extra/hevc/hevc.py": "a3b6c98a933db1b5c36937923ce121570a6133d44644ebb76fd97eb40e104431", + "extra/hip_gpu_driver/amdgpu_drm.h": "3efa26de285a7ad2155fcbfda1862570d5cc70383624f4529b333d66735f92af", + "extra/hip_gpu_driver/gc_10_3_0_offset.h": "a2753522ec060283230c6c8ab8737ca331a147f8cd96a317f4b48eb8dcb6e533", + "extra/hip_gpu_driver/gc_11_0_0_offset.h": "a2394677509a3415a9e6307d876cae9cd654a99275ab40b3027d983da26801f2", + "extra/hip_gpu_driver/hip_ioctl.py": "4e2e92236c3310f934473266616f4ee695358bfe86c2890100e9f785a765653d", + "extra/hip_gpu_driver/kfd_ioctl.h": "d927d7f5fd24023ac4bae8e2a6bc82ea0158ada76d768ce1484e904ad0190d61", + "extra/hip_gpu_driver/kfd_pm4_headers_ai.h": "78ccf018aadf80d833ba5e2ebfa670a96d25bb42dbfd670289cdfdf93ab55914", + "extra/hip_gpu_driver/navi10_sdma_pkt_open.h": "ff093a7c887625f20b21c2e64ee1f464d942c6da36e145cf69e1e9f530d3e01d", + "extra/hip_gpu_driver/nvd.h": "f65a105dfceff3bc03b3e02ac52ed18586586a5866135170a3239ec77fbe29c8", + "extra/hip_gpu_driver/sdma_registers.h": "de3d8f00a9cf766542bc18de63d4b45cbeaafe9b5d63fcc53b53746e1af99216", + "extra/hip_gpu_driver/sdma_v6_0_0_pkt_open.h": "0de8b070de8c27f12dc0ceb5089ee7a2aff7e183e896e684684f4b744b1ff4ac", + "extra/hip_gpu_driver/sienna_cichlid_ip_offset.h": "27ce382f43a5df3fffdfb5abdaafc85dc8beb940f68e6b10f52f5731068f3bbd", + "extra/hip_gpu_driver/soc15d.h": "45426641c204f06f54951174ac02a58c9bd49f7b0a7c822eaf984668ba3b8457", + "extra/hip_gpu_driver/soc21_enum.h": "38180a3a0b49d4cb1f3ced4df45e0d2fb1963fb928d8ec6ed5eb4ed9c9c42099", + "extra/hip_gpu_driver/test_kfd_2.py": "270a50f1bc9b2880cba7a971ac39b6b173b175ae28af58dabd08691dae5f2d41", + "extra/hip_gpu_driver/test_pm4.py": "573dfdefb02b9425ec4a944152b5e3af557767eed5b4a6bfcd0e86ae5588c824", + "extra/hip_gpu_driver/test_sdma_fun.py": "0c7980ff40905280b1ee592e091f03d20028acac18b1557febbf582ee4576c62", + "extra/hip_gpu_driver/vega10_sdma_pkt_open.h": "67b76881b8dac15c02e073f6a9a7d8970ce9a5a03c52949d46198dbb06a24168", + "extra/hip_large_kernel.py": "5bcd9174c912396a17d216996e4ebd61405bb525406c57b0d60e91f33f4655be", + "extra/hiprtc/hiprtc_runtime.h": "165775b49c30f0b247633bb3dcdb473b0879e644b1298abefcbda24bb2221e85", + "extra/hook_cuda.py": "5cb40e692c87d7700555362c5882e9c3eb313b4b73ac1f168c46b9991c1e8ba9", + "extra/huggingface_onnx/README.md": "ba83d2f09a7d19cc975202c7b62145c27cb17a700f2d70a6fb78c048ae33a678", + "extra/huggingface_onnx/huggingface_manager.py": "d1a88f53bd39c88a604245649d368651abe847659f7ed32cf5a597e991d65c1a", + "extra/huggingface_onnx/run_models.py": "02e65c0376ed165a6573aa8387bad8cf7088a80c5a711e834d9268e3ae8e0e70", + "extra/introspection.py": "42ff8f0554938b447f0ab368ecbd7d301cf2f587dc14007be863de62c1c78b16", + "extra/llama_kernels/__init__.py": "42168a8d0510f878a1eb7e8b06e781d43e23544d487cd5a4d4bd8911286121e7", + "extra/llama_kernels/fused_ce/__init__.py": "b8b0d2a7d5d7ba79dd0e20d1d3e9c9ff9a4ea9de21543f92215f90bc5d0849ca", + "extra/llama_kernels/quantize_mxfp4/__init__.py": "f8d70f120adc624d82c6f1d26bfcdc85f54ea961d161c2cfc137442a19adb8a8", + "extra/llama_kernels/quantize_mxfp4/quantize_mxfp4.cpp": "9850d5d9be81a9445350b3b48466724f016a34e12c520ae787279cf38020d8a9", + "extra/llama_kernels/quantize_mxfp4/quantize_mxfp4_device.h": "02310c44fd674c285947dff8d43d78c637eabde7db7106b3780883d991bf7a44", + "extra/llama_kernels/rmsnorm/__init__.py": "e8d54e527fc6ffb6ddeea33c3fcf8a4cac7235180762b74bd5ec41b66753104b", + "extra/llama_kernels/swiglu/__init__.py": "cac7f20d522a9c3f93575e9ac2e16837bcc48444181080797eb29a7aad9c92c9", + "extra/llama_kernels/swiglu/swiglu_bwd_mxfp4.cpp": "5acaa601ae756db6a6149e72559e4d9abac3d47cd9aa02c7534d29e24aebd0f4", + "extra/llama_kernels/swiglu/swiglu_fwd_mxfp4.cpp": "e8f597123d8349314dff7766d826a5fc7abdeab557c34c8bed490197ec276075", + "extra/llama_kernels/transpose_quantize_mxfp8/__init__.py": "aecd1868a3ed264be14b53ab1cc84c773d0d9ae921704da44fdc19dc66a5384e", + "extra/llama_kernels/transpose_quantize_mxfp8/transpose_quantize_mxfp8.cpp": "9e4925c665ee2764182737d7129f9cfea6036149ae2db3da168540c9fc98f0d5", + "extra/lr_scheduler.py": "e0f024b96dbd1f224a733f17b1124ef35958d8d396430f5866eb5e54ab5abcbd", + "extra/mesa/lvp_nir_options.sh": "74ff414d6b64a61c3c605b84a708a6dad048def155f6437b667e91a6de345a57", + "extra/mlx_driver/connect.py": "3ca8c1523da94bc2c6189bc355b6d7a7de49e4eee91f2cc9eede96b1c62ea926", + "extra/mlx_driver/loopback.py": "313548f476ea1cd643e6543f9a0093391b02f505144bab9a41865794cfae0375", + "extra/mlx_driver/mlx5.h": "e63c83ccb0fe2c7b2ff2b04282352dc78a2de10d6f4f751c8accc4c9bbd69e9b", + "extra/mlx_driver/mlxdev.py": "cc2e3394af041669a8bfa5c5c69c390762bcf4590f5bf348efdc027b07803fca", + "extra/mmapeak/mmapeak.py": "5df76d58e220337fe2a992ed64028f862ccb81792be7d4f3ab82ff7f8f804a09", + "extra/models/bert.py": "06853f0d76450f5cbe1b4c72b5f9597cc9e567785d409c8c3999e776cbaa2668", + "extra/models/clip.py": "50478184a36af03d53d0146ea10bbf62a9a9068ea55742f34fabc055ab52b132", + "extra/models/convnext.py": "3618219b76322552b382be44d57e290d2725bb6e9d79ca0771be8efda3a894b4", + "extra/models/efficientnet.py": "4d468e263b34a0bf142d70c41ad2a863991f57ca543b2e245d4bebf3cd9377ec", + "extra/models/inception.py": "c5ef8597da691d89def41024f4e624e44d55a890c144776f034fe881eb205327", + "extra/models/llama.py": "880eb66101cc39d360e989b4b24ed98e2e1d7025eaa8ea05ca89e3da4852c9cd", + "extra/models/mask_rcnn.py": "b47c6bb8deb73377abaf0c698409b9f629e12c262632a7cd27b5584d0172b652", + "extra/models/resnet.py": "4beed43567255f991fc92f516fa240c935f90d96717d255bed4d8a386a4ce9dd", + "extra/models/retinanet.py": "637c0acf5f4285caa46b53182e7ab9d3163893738c9b0c5e6ade448bd0c2ddbb", + "extra/models/rnnt.py": "bcbe0d9bc55e9ee51e08a280399640f3f0dad703cf755931c8fa06503a9c994e", + "extra/models/t5.py": "2309e2256bbf4c6b5a9cf4f6f0d343efbafd1eea308952f34814950f19fb6e70", + "extra/models/transformer.py": "b39659a62189fb47e82bdf82450d435321e21811a0b37af47ea48712a80f5d08", + "extra/models/unet.py": "0d1a8e2c1e15561a382fd83271ab4c79c413250a608044d0655d022c9c211e92", + "extra/models/unet3d.py": "16b6ed473cafb6cc8a9a4514abc106d298c33c982e0e3aae28db0c1784ca7810", + "extra/models/vit.py": "285b357c17e254dbbef289238c6387f2588a559dbafceb246b812b7e45642a5c", + "extra/multitensor.py": "b82945a389474ab462ae1e1faf1743ce102319f7fbd685cb5193e7634a7d07c7", + "extra/nvJitLink.h": "0bc9080c146d5a747d140a6fe6821047e71edd5d8fd6e766d22c73636c158931", + "extra/nv_gpu_driver/clc6c0qmd.h": "9427646887d0620e5dbf0957b04d979413319c7dc37839267c05d7c6408cb004", + "extra/nv_gpu_driver/clc9b0.h": "3749d0c4e393a063ee49387d6b8fe951ef1c4847106c0016aecc4036a52c349d", + "extra/nv_gpu_driver/clcec0qmd.h": "5d248e0ba4c6e0b789076db73f82b067059eece539b237fee70c7388f677de74", + "extra/nv_gpu_driver/fw.h": "bc3375b4ecbdf4acd76af1991cc86da4f59c7d2cf4c79c6fdecab3208dbd647a", + "extra/nv_gpu_driver/g_rpc-message-header.h": "53be2bbc116adbe636cdaf688417fc38e95197b61978a88358460381bda8b783", + "extra/nv_gpu_driver/gsp_static_config.h": "a0231886ce5fc85dab8920ccc7e48370b8390486a9560a0da14ce379e142ca74", + "extra/nv_gpu_driver/hs.h": "be03924ba31b6735ea6ce00c87aad4390a62ecd8ddea96e8b3e27e621a413f75", + "extra/nv_gpu_driver/nv_ioctl.py": "2b94db270aa26a45850097ca2bb944f36e814d9e7a0542a411fae5966877913f", + "extra/nv_gpu_driver/nvdec_drv.h": "e50fc0d970d675d59b8d1ef52788510c0325fb68173e7c056f39aeedbb80a512", + "extra/nv_gpu_driver/pci_exp_table.h": "f6542dd11c70a1ea0f8d02ab19fd30297c76af276f532078f1211fd9b09b4d88", + "extra/nv_gpu_driver/vbios.h": "391cc66ab6509bd8bc2dabc501a23d5224932c1279e521c92ab9e7baa7fb939e", + "extra/nv_pma/.gitignore": "a91ec2486e71eed71c078cc8004a7e1a693248f350ba67f59edc93ae01c5047a", + "extra/nv_pma/collect.py": "dcff46bbf4334e4e7089ce629dfc4d680f45234ca1fa05d2849ebe614574f296", + "extra/nv_pma/cupti/__init__.py": "f06f49e149c93879404cdde5f45ef75160e99f4488288043e1dc8ea5120c7d3e", + "extra/nv_pma/cupti/cu_prof_ext.py": "60eb59a253dde54049800c672d40fa115dcde726e173e84a88cf48002c700eb1", + "extra/nv_pma/cupti/cupti.py": "fee2cfe4130c2aa2befbc397abd7df5a8058bc99cf648f5484f0689dc38b3a80", + "extra/nv_pma/decode.py": "6bfbfd7500f5c3f1e6a41884008737d7021fb6accb245b52e081cab330d2f173", + "extra/nv_pma/test/test_nvprof.py": "62b6bade86370e9c7552afb55a6817296471d3c2dcb11ed8e30d67a00eff9df4", + "extra/onnx_helpers.py": "548aadbd1d654753c0e6c04b102be7684860578dc065f08e7710ffb6b4e9de96", + "extra/optimization/extract_dataset.py": "679cdfccb520c5dbbd72dd9d2f25eee7bf00930796023729aff7d900215b180a", + "extra/optimization/generate_dataset.sh": "ca2cde831ac8032c8aff6e5fb2b1513a285ab34ddecaf802aa86055e26157234", + "extra/optimization/test_beam_search.py": "b747e1a8a45e77071e09e67d30e16b6b638c81450dfa88102e4d2b12ebe990fd", + "extra/perfetto/perfetto.html": "5f9a2ecdfc36d306c375608cede1328020e134f17b80a311c8d33b9324637080", + "extra/perfetto/to_perfetto.py": "9c8789b84a833ce3a01086187c82e454bdbf6c7a11e795999d113798f43f8d17", + "extra/qcom_gpu_driver/a6xx.xml.h": "25d15ed9bf646eacc0579fb74ee2d9cdf8952190cc2681623cda7521d1f9ba42", + "extra/qcom_gpu_driver/adreno_pm4.xml": "668e68a155eb85f5d0c8e4d115e424538f50b7e92e9d90aa076a314592b50bf7", + "extra/qcom_gpu_driver/gen.sh": "6f42c3dac27f35ec1302f6aaaf4a8c3dc504652618aeefbb5555ebcae5d86f8e", + "extra/qcom_gpu_driver/msm_kgsl.h": "76c86db97c2a8d9275ce7ff98ae8f19e610892cd34d1163d1de6d3b5a3a1815b", + "extra/qcom_gpu_driver/msm_kgsl.py": "573a61357b0e965509d9b1ede14370843c1f3ecdeeff0cf7fa6ddadfd207bda7", + "extra/qcom_gpu_driver/opencl_ioctl.py": "564697220f93cfa7233ae1ca4476be9cf7b940dc8ca74abb904e937fd4a5bde4", + "extra/qcom_gpu_driver/qcom_opencl_interop.py": "5610b4e772d2a79ee7b990e05b9d881040f88344db0c7e40379778da5f2efc22", + "extra/remote/bench.py": "4c35230a5e060491668bef057229efe6f0bfd69fec22a99736864b81cd1a4ae7", + "extra/remote/serve.py": "460dfd07c29205cfb346c4c850d37a2f1b3c6dcc15cf4db7ceb79646e7237143", + "extra/runbook_digitalocean_mi350x.md": "1f64e8813bdc56e72352737fccc7ab2f85dc1bf5be12386a092727c56eb1a7f1", + "extra/setup_hipcc_osx.sh": "6bb81bcb4ce178971f824c962d410063cf3c95e54e2fcf43ba2f2f3207de72ea", + "extra/setup_hipcomgr_osx.sh": "e17db9f32e943f4f7909183c3c50d33e07459b980ab0be17575bd2a8c1c14364", + "extra/setup_mock_amd_osx.sh": "18c1347f9a63f82de2e259a09f2291d47b20ad82b62ee8441e5f0dd44af31ed7", + "extra/setup_mock_dsp_osx.sh": "b62fc79e67183f3e2c771a907aaecc283c5a5bf1095e6be9f8096ea4c24ac2fe", + "extra/setup_mock_nv_osx.sh": "806c03bebccb566984fc51e2fbc2338159873cf36b767bb36178290bfeee690a", + "extra/setup_nvcc_osx.sh": "bc7979eb685a86053679b31dd4c3a099d21a0d19099ec4bcce6f02b46351147a", + "extra/setup_tinygpu_osx.sh": "5e797e662b14f2fac6f12903f6f79821ed5f8b4a155d5d7c89413fbd0ca2162c", + "extra/sqtt/README.md": "ff1f9c2f3d7bb39315f40b15fe52d97ef8282046c111c61a9d5f51fa49620d3f", + "extra/sqtt/examples/generate_examples.py": "9049bf2fb51140265f776c01ea75da431c7e3eed2c5ac0550cdf2711075610ed", + "extra/sqtt/examples/gfx1100/profile_empty_run_0.pkl": "0f09796e2caf78f99f2032b8f7e697c2f180ce933cbcba94bb5f7a7b5a9f4615", + "extra/sqtt/examples/gfx1100/profile_empty_run_1.pkl": "065a9f6124f0a6bd24d21f92665400698e33b6f2c393ef7602405e55b324baf8", + "extra/sqtt/examples/gfx1100/profile_gemm_run_0.pkl": "840861dee95eb11a9ddf861c64f7e680b9f25b15ec0f8699c65e69a8766398f6", + "extra/sqtt/examples/gfx1100/profile_gemm_run_1.pkl": "0bd393b671c36465b600b771e788e038e75d0e5a050db6f1ef6331eeb072c5ea", + "extra/sqtt/examples/gfx1100/profile_plus_run_0.pkl": "93858101d8fc1c261d02180822d14045c84e564de9eb2b7a81a11b1198f42ae9", + "extra/sqtt/examples/gfx1100/profile_plus_run_1.pkl": "5dacf92065dcb6f257c65acccf16c85351edbbbf0e761aceeb5eb816d62a29c4", + "extra/sqtt/examples/gfx1100/profile_sync_run_0.pkl": "b92504c6129be26fa6d3f997b8a574df23ba7eb5f12014028b81be93bc21d746", + "extra/sqtt/examples/gfx1100/profile_sync_run_1.pkl": "329afab0893503b9a0efde36dc894c8bd0ebc1b0e3b8624430fe6e20a1549939", + "extra/sqtt/examples/gfx1200/profile_empty_run_0.pkl": "d175a783336d6e3d322b6430bb8573ba1612e34789770ff954624ee35c5be7e6", + "extra/sqtt/examples/gfx1200/profile_empty_run_1.pkl": "07c1bba8a8efe900737b72b9f30f17c7522f96be1c75a1d0ec4948eb2aa73182", + "extra/sqtt/examples/gfx1200/profile_gemm_run_0.pkl": "5d415b256e4bc944a8380505ef3d92c3c0e989f1b2812c792f194a6741c3e776", + "extra/sqtt/examples/gfx1200/profile_gemm_run_1.pkl": "e6b123e1f204f633baf454da82928f391f82b82b89dd683a9a65b3691b1ad2a3", + "extra/sqtt/examples/gfx1200/profile_handwritten_run_0.pkl": "b749bc5c54a8d7b94d5ad771573ff5fc71f3eafa5bcc4b4f38c7d38218a1ff30", + "extra/sqtt/examples/gfx1200/profile_handwritten_run_1.pkl": "b0f82ed9cb2107e81077422210636919b413b076a804477689e8fecfc85ac0c6", + "extra/sqtt/examples/gfx1200/profile_plus_run_0.pkl": "3e192e74669c0f0eb62f558b41869bb06954aef408800677a192acf21f6c01c6", + "extra/sqtt/examples/gfx1200/profile_plus_run_1.pkl": "17494ce1d7a6e9579bbd79e344f1d83c9bac3d1d9dadc13aed4a923b9ab8b28a", + "extra/sqtt/examples/gfx1200/profile_sync_run_0.pkl": "977e7caa435ed12e8a51f2ef54b13fe2ecb30516bb38d823f5716478a0e0d059", + "extra/sqtt/examples/gfx1200/profile_sync_run_1.pkl": "6f63594c0241ad9b2b679fd93b475b2c11faf53c013f1b26d2dec5293e46d2ed", + "extra/sqtt/examples/gfx950/profile_empty_run_0.pkl": "f97263d02937d60ec513cbb7fb3dd95caed426c73cc30a5c6a03618982c708f2", + "extra/sqtt/examples/gfx950/profile_empty_run_1.pkl": "a022d96519d849b37101724cea33c955ccf3020f19cd465ce2f20ee4693c9ce6", + "extra/sqtt/examples/gfx950/profile_gemm_run_0.pkl": "f73580344a18658c9b4c56ef44e5feace0cb9495fd3f12310e2ab0fca62af5fc", + "extra/sqtt/examples/gfx950/profile_gemm_run_1.pkl": "243f959d0b22dcb28c35c66d2bd1ff9dc309e73791fc89cb371f47592c81d06a", + "extra/sqtt/examples/gfx950/profile_plus_run_0.pkl": "a3907cf1f0049a88d6164718dd27d19ed6d3cd0814bbae5e207d3a03808b44ab", + "extra/sqtt/examples/gfx950/profile_plus_run_1.pkl": "9079181b40034f8339ae4fc33f8f8b21bce7cf5045cadb19ac118dcaea63540b", + "extra/sqtt/install_rocprof_decoder.py": "3712ec2bec85314d2535598c120dfdf6aa2ff3414348f85efdf9714f277d2f07", + "extra/sqtt/rgptool.py": "a299991fc975165eaf600b0a52453f8a200ce71daf826f7029c1ccdda586f72f", + "extra/sqtt/roc.py": "ff19d07020f18d802b1f8ae2c8c089e0c327680ec7ff0c1742cd42c3d935dbbf", + "extra/sqtt/sqtt.h": "4dd0cda9ac05096391640bad94760427268e7d9a927213cb9b6017f488dc0cb4", + "extra/test_mi350.sh": "f1be1a6f4d3bc84af96e0dc96312de1cc320058e68673d8fb8509cdfb9004537", + "extra/testsig/generate_testsig.py": "15eea80a8b31ecfb0c83551cf3d5ba90f5451340c40ad4b628d62bfa8a35e9e8", + "extra/thneed.py": "a1bd0ba2435815973795178283de1f7790e0dbc2f31b6b8e9b1a313f7abca23a", + "extra/thunder/amd/fa.py": "e024edd9e9135364d0b5a26bf8ef6730ea607a27a1490065e910089593abb85c", + "extra/thunder/amd/fa_bwd_causal.cpp": "c14b8ca22b1863e88f2a2e0ee415cd9eac3e9743381686f4b7da5ec6121c6bcc", + "extra/thunder/amd/fa_bwd_post.cpp": "a78e1830f756d32e96c3e99e72852a6f1069ec9309a3f6969c1f0575729d6a71", + "extra/thunder/amd/fa_bwd_pre.cpp": "d9428f41d791f7aee9ab3efdb4a7226f760f99794275e3e8e11c9b1c5e3f7e42", + "extra/thunder/amd/fa_fwd_causal.cpp": "888321ac7ca5fb470781743dc222d6dee27c677a25112dab2302f0e88f79e3e5", + "extra/thunder/amd/fa_fwd_causal_d64.cpp": "5640c041b640e025c8935df0aaef16129e7c59f758f189f25f474ba0bdfae8fc", + "extra/thunder/amd/fa_fwd_causal_d64_window.cpp": "e52d45f8ffcb524be0d09001bf0815cf6e2b85e7653f5b7231e8ed157e61e1c8", + "extra/thunder/amd/fused_qkv_rope_bwd.cpp": "4dffe7e45049fb3a0ee3d96c001c3e0d7d19aa13e19b73a860f1c936a818478f", + "extra/thunder/amd/gemm_bf16.cpp": "3bbaf368c46884545fd7e19053b41d505732ad4276589f2e891749e988e8d1c9", + "extra/thunder/amd/gemm_bf16_atb.cpp": "07fa907319cfcef21f476c854ef45b553675f769fa91ae5fe5057d3ba3411c06", + "extra/thunder/amd/gemm_mxfp8.cpp": "46dce83a96de2956df5f5b7516c06efe89dddb03b847ec5b24262f1c114f0c8d", + "extra/thunder/amd/grouped_mxfp8_gemm.cpp": "dfefdeb835a778980e95829e3fbf57243605c0925c46c52130fd5b54eb13382f", + "extra/thunder/amd/grouped_mxfp8_wgrad.cpp": "631bce6bed3729b21e03b50ef5d676880c9b281c930b9b44e20d7042bbb72535", + "extra/thunder/amd/include/cdna4/common/base_ops.cuh": "94e433fbb0cf8058ac5859c7a2cc2813a6badc635a70ec190aaa6fbe1a5985a6", + "extra/thunder/amd/include/cdna4/common/base_types.cuh": "fefcf9ba4ab2f2eeae6b349195315a0fa5da8de1f72ac6bf312b1df6067ab01b", + "extra/thunder/amd/include/cdna4/common/common.cuh": "27ae292df2e109b1eee529db90d6e287c0f67a75fcc23ce09ca646c3f214b7a4", + "extra/thunder/amd/include/cdna4/common/debug.cuh": "0924809d50559ecedbff73ce6c8643034644258b55610123905074cc073bac0c", + "extra/thunder/amd/include/cdna4/common/macros.cuh": "36035e189e0cdd643eac61deef3186f2b2e7d59bca303f356e1cf17c161a1336", + "extra/thunder/amd/include/cdna4/common/util.cuh": "c11f7787e33d5f5fc2b1781550e9b30b3f0423c3447b54610804767e4ce0b1b9", + "extra/thunder/amd/include/cdna4/includes.cuh": "88ea4e8eebc8c1a4cb01ca51ceae4a71e1cc30e1b9ed8b67b1d09b964839a2ae", + "extra/thunder/amd/include/cdna4/ops/group/group.cuh": "6a44f8e8a01e75e973b69ec36b8b97cdfb2c8bccc642c450e02c5c8706262266", + "extra/thunder/amd/include/cdna4/ops/group/memory/memory.cuh": "a04c12fdbdccbb674e2a9f5fd3f0767fa694b2379f3c576241e13172478829bc", + "extra/thunder/amd/include/cdna4/ops/group/memory/tile/global_to_shared.cuh": "e317cb74726b54858ade0c30b14e59b05202ce0d28fb6f344d3b21be1a0e2e2f", + "extra/thunder/amd/include/cdna4/ops/group/memory/tile/tile.cuh": "64896f28ec6023f84ad2502e5708c9276422a1232614d9ec1e97e406cdea562f", + "extra/thunder/amd/include/cdna4/ops/group/memory/vec/global_to_shared.cuh": "11c0ade8d5fa923e0db3adb5a0fa5f27d3878fa0eba028ba6f5fb59cc67187ee", + "extra/thunder/amd/include/cdna4/ops/group/memory/vec/vec.cuh": "99ba19596452777490ecf6d433c0309ce86494238f3998402ca5345ea6c18142", + "extra/thunder/amd/include/cdna4/ops/ops.cuh": "3d5a0e17905b30b52dd5c377919b252f128573efc9a01e6c08ee179460955f02", + "extra/thunder/amd/include/cdna4/ops/warp/memory/memory.cuh": "1532071f09f9c8d7c3ff92faad08246f5626f91e324a55b972b28b6c6fe5bc59", + "extra/thunder/amd/include/cdna4/ops/warp/memory/tile/assembly/global_to_register.cuh": "407389f16b79af1308fa9622cc5985f89b0f2dee0b3ae9ccb2eef52f1f0840a5", + "extra/thunder/amd/include/cdna4/ops/warp/memory/tile/assembly/shared_to_register.cuh": "d5b12a08f3cad7a75a82ef3589ec4b923b99a6de16684e4b333845118be9c848", + "extra/thunder/amd/include/cdna4/ops/warp/memory/tile/assembly/tile.cuh": "cc2b2768431e6cad4848a83543477309ac4cd8d93abcb751500dbf88f94f866e", + "extra/thunder/amd/include/cdna4/ops/warp/memory/tile/global_to_register.cuh": "3f8e4ed1251d17fbfa5b2b1f7a89dc67fc29629a08dbb80f8762a501bc7ce3cd", + "extra/thunder/amd/include/cdna4/ops/warp/memory/tile/global_to_shared.cuh": "eac667d05201e2cfd6a4b6e6d09cb2f57a71bfe96b860d3be16b4fec286b60be", + "extra/thunder/amd/include/cdna4/ops/warp/memory/tile/shared_to_register.cuh": "6754bc39c7f23302e94325dd62ef98f0822cf58da3ddca494b2cfd0affc479f9", + "extra/thunder/amd/include/cdna4/ops/warp/memory/tile/tile.cuh": "276b339920ce7a8bd9bc5cf90879a2bc1dff9d5faab233761f47a9fbe33dbd93", + "extra/thunder/amd/include/cdna4/ops/warp/memory/util/util.cuh": "a8c97773d9532d448d89bbca9bc73d3c635ac1fab97fe8438ea8f2170dfb643d", + "extra/thunder/amd/include/cdna4/ops/warp/memory/vec/assembly/shared_to_register.cuh": "aa840c2cb71759afa7c173c892895afe82290328e19936f6e68e86ac8dc66089", + "extra/thunder/amd/include/cdna4/ops/warp/memory/vec/assembly/vec.cuh": "3621339508229b1e3371abedb29c63375b80eb63d8747a2c295500d4d306d30a", + "extra/thunder/amd/include/cdna4/ops/warp/memory/vec/global_to_register.cuh": "cf54597f3fd2c88d0efa5160290ca783c3f7276f097f0d3a2fbf430bb1a01fc2", + "extra/thunder/amd/include/cdna4/ops/warp/memory/vec/global_to_shared.cuh": "4f274aa32b3692f2dc80d67dcb4eb95e0230b3faabb937fb84c2c19b518f502b", + "extra/thunder/amd/include/cdna4/ops/warp/memory/vec/shared_to_register.cuh": "1a0e7dab037a724e5902544dfd590a00f6146a23ca26c453e51a01177b6297f7", + "extra/thunder/amd/include/cdna4/ops/warp/memory/vec/vec.cuh": "9753fc02a5b8c925b63d3526fcf5dab32adc3b3cb2ebeebab0db7b321819c643", + "extra/thunder/amd/include/cdna4/ops/warp/register/register.cuh": "2f2b310b2760c25d255a9298db0e32da07f99cb7a3361934ecfa4e652189b79e", + "extra/thunder/amd/include/cdna4/ops/warp/register/tile/assembly/conversions.cuh": "eadb03095cfdcaae16b8279aa10a8adc6ef4dfdff6d3ab4d013ebc0024692de6", + "extra/thunder/amd/include/cdna4/ops/warp/register/tile/assembly/maps.cuh": "c3c17bd0ee7a6ef20c99bf91287483cf0bbe91f31aa40abcfe237c8fa1f7c37d", + "extra/thunder/amd/include/cdna4/ops/warp/register/tile/assembly/mma.cuh": "e58046aa5c3a19652ced6db5a6c364ec5d8d3debed7dc3ac414d70c0b8fd5a07", + "extra/thunder/amd/include/cdna4/ops/warp/register/tile/assembly/tile.cuh": "da9709ed2eae6720c7a75d241d067a73edba110267a1caa0fa28bf189362229e", + "extra/thunder/amd/include/cdna4/ops/warp/register/tile/conversions.cuh": "d709d046490043c1f38327b290db3958ef720895bb2b227f04e796ca67dab26f", + "extra/thunder/amd/include/cdna4/ops/warp/register/tile/maps.cuh": "c5a25a7fb1866fd6a4edcc4438a2b53ff7f315f5ff4ff2af76e54cd2d449bb21", + "extra/thunder/amd/include/cdna4/ops/warp/register/tile/mma.cuh": "b0075188df956a53fac4a66ae96423433bc98e7f45157697756e50baf52b5fdf", + "extra/thunder/amd/include/cdna4/ops/warp/register/tile/reductions.cuh": "d909c2559a662603d9b313afc3e94c99a33c98446fdaf42f3ba057bbc5abd598", + "extra/thunder/amd/include/cdna4/ops/warp/register/tile/tile.cuh": "b3319c89fd9ad867cd0afda7b08397cdc7446cd98d055536a3e88581a5c91fc2", + "extra/thunder/amd/include/cdna4/ops/warp/register/vec/assembly/maps.cuh": "9ce494a0ac38f67f5bf610f6e41054b638661eb4123032bd0ce1e138a3b0c167", + "extra/thunder/amd/include/cdna4/ops/warp/register/vec/assembly/vec.cuh": "ceb15653e2cb9903041e816340fc8d9457851d3411b8b59946835b2deec5492f", + "extra/thunder/amd/include/cdna4/ops/warp/register/vec/conversions.cuh": "c1dd77de33219d664fdb668d5c128d77ab1087b23cf0c80a8009f0c3ee04bcbc", + "extra/thunder/amd/include/cdna4/ops/warp/register/vec/maps.cuh": "71e384bf400d1f52b7e0eed340663a385de205678d857466fd4c641689232517", + "extra/thunder/amd/include/cdna4/ops/warp/register/vec/reductions.cuh": "f245d6cf8a09c1323364a117ffa7605f3fd3f25be8980e63eecddf72236de523", + "extra/thunder/amd/include/cdna4/ops/warp/register/vec/vec.cuh": "502fe6d9d293313231c1ded411e989bda151d6bd13afb396713840102bebb0af", + "extra/thunder/amd/include/cdna4/ops/warp/shared/shared.cuh": "a94dd2790c82513de5f89195d0210ad4b81bdd9a3e03817bd32c5af6c62f6009", + "extra/thunder/amd/include/cdna4/ops/warp/shared/tile/conversions.cuh": "1ce3670a2469c633f90eccb8aa555180ee0cd8a15c0f97c5c6ce8eaa63e02c1c", + "extra/thunder/amd/include/cdna4/ops/warp/shared/tile/tile.cuh": "715fb8ccfae22dadd2f53bbfcbee3d91e269091688eed4fb9b514c56a8c358eb", + "extra/thunder/amd/include/cdna4/ops/warp/shared/vec/conversions.cuh": "3f7c724bf94cc824f30b57c1f15135040ca37348f1f483d7c655781350709586", + "extra/thunder/amd/include/cdna4/ops/warp/shared/vec/vec.cuh": "3358c33602f6a608ae003f2b16fb9d4802dabd04a65b20cd278dd628480dc67c", + "extra/thunder/amd/include/cdna4/ops/warp/warp.cuh": "e38ac9e3c45279363c6db861cf9a786d9df1be635e1786d3c1bb204401c206a5", + "extra/thunder/amd/include/cdna4/types/global/gl.cuh": "6276ea27c2a9a6a0b393884020039aefa1d4ca9ff1c025852cf3b0b1b592dbc5", + "extra/thunder/amd/include/cdna4/types/global/global.cuh": "865c555adc68adaba49594a96d547e76ea3da6f7331cc4e6ddff769c23e94e38", + "extra/thunder/amd/include/cdna4/types/global/util.cuh": "735cda03066360ce5e827940ae01f60e427e65f9570cc82a11f1f850eddf3b33", + "extra/thunder/amd/include/cdna4/types/register/art.cuh": "4fcd1111cc3a6154388cfdcfc6639312bfd09808d9abd3a32cb36a5e2eed8be0", + "extra/thunder/amd/include/cdna4/types/register/art_base.cuh": "57e5dd9c0634228bcf6c58e4c0468acc4206a425e6bf494ddb93cc09700651c6", + "extra/thunder/amd/include/cdna4/types/register/register.cuh": "e90b389cde5b848ace67067574ba31ac17ed516b768385dd78d90b760319747c", + "extra/thunder/amd/include/cdna4/types/register/rt.cuh": "6d6968171903ebf0b55e3cbd321b9adbfb0508cc09491ec0798e3367bfdfbbf8", + "extra/thunder/amd/include/cdna4/types/register/rt_base.cuh": "011d999f5dcd746ad05bba8d3e251d15f74c21dd543bf26853e2bd7da6b38fb7", + "extra/thunder/amd/include/cdna4/types/register/rt_layout.cuh": "cb7a02768fb14eea91b404288ebf8d7636b9c1a1be44e7c4a06d4aee80a9fb46", + "extra/thunder/amd/include/cdna4/types/register/rt_shape.cuh": "748da90c04389b36d296066df88de4c954bce0048d49fd60a9172e240e1ec0e1", + "extra/thunder/amd/include/cdna4/types/register/rv.cuh": "d2eb5570c33bcd914a4f5cc70198b55049393a59ba36ec1651e9bbcb32535e48", + "extra/thunder/amd/include/cdna4/types/register/rv_layout.cuh": "d6c55e785ed7c72f09678375d74b0f5f4d3c4156922e2fd6ce8d12fc3042af58", + "extra/thunder/amd/include/cdna4/types/shared/shared.cuh": "f38cc1d019cbc1df779057f8972800648f618c75455cb45a7a0c5fb3762e22b9", + "extra/thunder/amd/include/cdna4/types/shared/st.cuh": "6c8432453133faae2cf29890d1f01037dd5a1e1e3cd5fb4d3461fe9b7af454b1", + "extra/thunder/amd/include/cdna4/types/shared/st_shape.cuh": "61b68bcff6d7765e8e1b67c748ea4709e0d8266d516e8f6888723311c4369976", + "extra/thunder/amd/include/cdna4/types/shared/sv.cuh": "6911833f24791c4f86dee35d675162576f9e3aa4b83722bf09ff5ff061dab219", + "extra/thunder/amd/include/cdna4/types/types.cuh": "05df14b25f4944bc4c0a63422e110d7d5bb06a3ed455dba3e3e53314079f6290", + "extra/thunder/amd/include/kittens.cuh": "2e6ee6e536668aacbcf98f636c06df4cf4ef414973ee0898dd6ff51b93b70c33", + "extra/thunder/amd/include/pyutils/pyutils.cuh": "1d2283584772cdc3087a97d4a2220e31a1c596e0f7e4ecbb119ba95fc726ec7e", + "extra/thunder/amd/include/pyutils/torch_helpers.cuh": "d8aea826ac33d0e1c0e057d3f5585f0d5b9bd51b6e0fac18b68ecbdaca68afc7", + "extra/thunder/amd/include/pyutils/util.cuh": "5462375e85a44b05d05b22f08e365370368de607129ca6b1de26b390b08e5a87", + "extra/thunder/amd/include/udna1/common/base_ops.cuh": "94e433fbb0cf8058ac5859c7a2cc2813a6badc635a70ec190aaa6fbe1a5985a6", + "extra/thunder/amd/include/udna1/common/base_types.cuh": "fefcf9ba4ab2f2eeae6b349195315a0fa5da8de1f72ac6bf312b1df6067ab01b", + "extra/thunder/amd/include/udna1/common/common.cuh": "27ae292df2e109b1eee529db90d6e287c0f67a75fcc23ce09ca646c3f214b7a4", + "extra/thunder/amd/include/udna1/common/debug.cuh": "0924809d50559ecedbff73ce6c8643034644258b55610123905074cc073bac0c", + "extra/thunder/amd/include/udna1/common/macros.cuh": "36035e189e0cdd643eac61deef3186f2b2e7d59bca303f356e1cf17c161a1336", + "extra/thunder/amd/include/udna1/common/util.cuh": "c4bc7966e9f4ae63602cbcdaafbd99e97c90980f352250ebbb8cc5d03f805b8f", + "extra/thunder/amd/include/udna1/includes.cuh": "cd47cef4fdc8946e1839bfe96b240b9fef24f9c13caf40657e46b3aabc74af38", + "extra/thunder/amd/include/udna1/ops/group/group.cuh": "6a44f8e8a01e75e973b69ec36b8b97cdfb2c8bccc642c450e02c5c8706262266", + "extra/thunder/amd/include/udna1/ops/group/memory/memory.cuh": "a04c12fdbdccbb674e2a9f5fd3f0767fa694b2379f3c576241e13172478829bc", + "extra/thunder/amd/include/udna1/ops/group/memory/tile/global_to_shared.cuh": "02a5e49f285555930a930ac8f3df9eab0bd4e0d6ff0316b2c31b391d6b5e2b21", + "extra/thunder/amd/include/udna1/ops/group/memory/tile/tile.cuh": "64896f28ec6023f84ad2502e5708c9276422a1232614d9ec1e97e406cdea562f", + "extra/thunder/amd/include/udna1/ops/group/memory/vec/global_to_shared.cuh": "f3267e030d35415a68e949914783937c7c1fdbb6d1a936d4aae793e024fbc40f", + "extra/thunder/amd/include/udna1/ops/group/memory/vec/vec.cuh": "99ba19596452777490ecf6d433c0309ce86494238f3998402ca5345ea6c18142", + "extra/thunder/amd/include/udna1/ops/ops.cuh": "3d5a0e17905b30b52dd5c377919b252f128573efc9a01e6c08ee179460955f02", + "extra/thunder/amd/include/udna1/ops/warp/cluster/cluster.cuh": "43319df36a6b111e6544ff7dd2a58777d76f21611e229c8979ce214d9f98b266", + "extra/thunder/amd/include/udna1/ops/warp/memory/memory.cuh": "1532071f09f9c8d7c3ff92faad08246f5626f91e324a55b972b28b6c6fe5bc59", + "extra/thunder/amd/include/udna1/ops/warp/memory/tile/assembly/global_to_register.cuh": "407389f16b79af1308fa9622cc5985f89b0f2dee0b3ae9ccb2eef52f1f0840a5", + "extra/thunder/amd/include/udna1/ops/warp/memory/tile/assembly/shared_to_register.cuh": "d5b12a08f3cad7a75a82ef3589ec4b923b99a6de16684e4b333845118be9c848", + "extra/thunder/amd/include/udna1/ops/warp/memory/tile/assembly/tile.cuh": "cc2b2768431e6cad4848a83543477309ac4cd8d93abcb751500dbf88f94f866e", + "extra/thunder/amd/include/udna1/ops/warp/memory/tile/global_to_register.cuh": "3f8e4ed1251d17fbfa5b2b1f7a89dc67fc29629a08dbb80f8762a501bc7ce3cd", + "extra/thunder/amd/include/udna1/ops/warp/memory/tile/global_to_shared.cuh": "67a6a12fde4abab6c46b9c16162debe2d6172da870f51452344c17a9c4c2ede5", + "extra/thunder/amd/include/udna1/ops/warp/memory/tile/shared_to_register.cuh": "37ac10b08645094a2abff3e0dd0ec7099ab688b9f2dc4fcaab6cc11c901f9293", + "extra/thunder/amd/include/udna1/ops/warp/memory/tile/tile.cuh": "276b339920ce7a8bd9bc5cf90879a2bc1dff9d5faab233761f47a9fbe33dbd93", + "extra/thunder/amd/include/udna1/ops/warp/memory/util/util.cuh": "69d52c87b43b186b063024726425ddc876d5b13dbe1deae4d54e0b969ffc850d", + "extra/thunder/amd/include/udna1/ops/warp/memory/vec/assembly/shared_to_register.cuh": "aa840c2cb71759afa7c173c892895afe82290328e19936f6e68e86ac8dc66089", + "extra/thunder/amd/include/udna1/ops/warp/memory/vec/assembly/vec.cuh": "3621339508229b1e3371abedb29c63375b80eb63d8747a2c295500d4d306d30a", + "extra/thunder/amd/include/udna1/ops/warp/memory/vec/global_to_register.cuh": "cf54597f3fd2c88d0efa5160290ca783c3f7276f097f0d3a2fbf430bb1a01fc2", + "extra/thunder/amd/include/udna1/ops/warp/memory/vec/global_to_shared.cuh": "62d6b62a3a161849630d882bd4f104083b493e484d1f9a54199c58cbc00c906c", + "extra/thunder/amd/include/udna1/ops/warp/memory/vec/shared_to_register.cuh": "1a0e7dab037a724e5902544dfd590a00f6146a23ca26c453e51a01177b6297f7", + "extra/thunder/amd/include/udna1/ops/warp/memory/vec/vec.cuh": "9753fc02a5b8c925b63d3526fcf5dab32adc3b3cb2ebeebab0db7b321819c643", + "extra/thunder/amd/include/udna1/ops/warp/register/register.cuh": "2f2b310b2760c25d255a9298db0e32da07f99cb7a3361934ecfa4e652189b79e", + "extra/thunder/amd/include/udna1/ops/warp/register/tile/assembly/conversions.cuh": "eadb03095cfdcaae16b8279aa10a8adc6ef4dfdff6d3ab4d013ebc0024692de6", + "extra/thunder/amd/include/udna1/ops/warp/register/tile/assembly/maps.cuh": "c3c17bd0ee7a6ef20c99bf91287483cf0bbe91f31aa40abcfe237c8fa1f7c37d", + "extra/thunder/amd/include/udna1/ops/warp/register/tile/assembly/mma.cuh": "e58046aa5c3a19652ced6db5a6c364ec5d8d3debed7dc3ac414d70c0b8fd5a07", + "extra/thunder/amd/include/udna1/ops/warp/register/tile/assembly/tile.cuh": "da9709ed2eae6720c7a75d241d067a73edba110267a1caa0fa28bf189362229e", + "extra/thunder/amd/include/udna1/ops/warp/register/tile/conversions.cuh": "d709d046490043c1f38327b290db3958ef720895bb2b227f04e796ca67dab26f", + "extra/thunder/amd/include/udna1/ops/warp/register/tile/maps.cuh": "c5a25a7fb1866fd6a4edcc4438a2b53ff7f315f5ff4ff2af76e54cd2d449bb21", + "extra/thunder/amd/include/udna1/ops/warp/register/tile/mma.cuh": "e06c3f33b10ca55db7c525f453bfa692905bb6f760a42812e0ac2d92a6eab82e", + "extra/thunder/amd/include/udna1/ops/warp/register/tile/reductions.cuh": "d909c2559a662603d9b313afc3e94c99a33c98446fdaf42f3ba057bbc5abd598", + "extra/thunder/amd/include/udna1/ops/warp/register/tile/tile.cuh": "b3319c89fd9ad867cd0afda7b08397cdc7446cd98d055536a3e88581a5c91fc2", + "extra/thunder/amd/include/udna1/ops/warp/register/vec/assembly/maps.cuh": "9ce494a0ac38f67f5bf610f6e41054b638661eb4123032bd0ce1e138a3b0c167", + "extra/thunder/amd/include/udna1/ops/warp/register/vec/assembly/vec.cuh": "ceb15653e2cb9903041e816340fc8d9457851d3411b8b59946835b2deec5492f", + "extra/thunder/amd/include/udna1/ops/warp/register/vec/conversions.cuh": "c1dd77de33219d664fdb668d5c128d77ab1087b23cf0c80a8009f0c3ee04bcbc", + "extra/thunder/amd/include/udna1/ops/warp/register/vec/maps.cuh": "71e384bf400d1f52b7e0eed340663a385de205678d857466fd4c641689232517", + "extra/thunder/amd/include/udna1/ops/warp/register/vec/reductions.cuh": "f245d6cf8a09c1323364a117ffa7605f3fd3f25be8980e63eecddf72236de523", + "extra/thunder/amd/include/udna1/ops/warp/register/vec/vec.cuh": "502fe6d9d293313231c1ded411e989bda151d6bd13afb396713840102bebb0af", + "extra/thunder/amd/include/udna1/ops/warp/sched/sched.cuh": "6431f495022293a4edb88b89b24116d6557a6b6a1b000601616125e61abed6a1", + "extra/thunder/amd/include/udna1/ops/warp/shared/shared.cuh": "a94dd2790c82513de5f89195d0210ad4b81bdd9a3e03817bd32c5af6c62f6009", + "extra/thunder/amd/include/udna1/ops/warp/shared/tile/conversions.cuh": "1ce3670a2469c633f90eccb8aa555180ee0cd8a15c0f97c5c6ce8eaa63e02c1c", + "extra/thunder/amd/include/udna1/ops/warp/shared/tile/tile.cuh": "715fb8ccfae22dadd2f53bbfcbee3d91e269091688eed4fb9b514c56a8c358eb", + "extra/thunder/amd/include/udna1/ops/warp/shared/vec/conversions.cuh": "3f7c724bf94cc824f30b57c1f15135040ca37348f1f483d7c655781350709586", + "extra/thunder/amd/include/udna1/ops/warp/shared/vec/vec.cuh": "3358c33602f6a608ae003f2b16fb9d4802dabd04a65b20cd278dd628480dc67c", + "extra/thunder/amd/include/udna1/ops/warp/sync/barrier.cuh": "78f540c48d3eee6548cb012e20aa025ebc9e941c497e9c22500a507cf3d5c54a", + "extra/thunder/amd/include/udna1/ops/warp/sync/sync.cuh": "e7f5679b4247e03744abb9149d4a3ee3eee413dd52120170ebe0ba9f09ae4795", + "extra/thunder/amd/include/udna1/ops/warp/warp.cuh": "fdf5af2f5f3f197f3d782db874c2740c605f6b36208fdb100f3f106abc7d600c", + "extra/thunder/amd/include/udna1/types/global/gl.cuh": "e1e8484f5bc444c2c4f3254f5d76a89f32fae6e8fb0364572d70dbe87bd6940d", + "extra/thunder/amd/include/udna1/types/global/global.cuh": "865c555adc68adaba49594a96d547e76ea3da6f7331cc4e6ddff769c23e94e38", + "extra/thunder/amd/include/udna1/types/global/util.cuh": "735cda03066360ce5e827940ae01f60e427e65f9570cc82a11f1f850eddf3b33", + "extra/thunder/amd/include/udna1/types/register/art.cuh": "4fcd1111cc3a6154388cfdcfc6639312bfd09808d9abd3a32cb36a5e2eed8be0", + "extra/thunder/amd/include/udna1/types/register/art_base.cuh": "57e5dd9c0634228bcf6c58e4c0468acc4206a425e6bf494ddb93cc09700651c6", + "extra/thunder/amd/include/udna1/types/register/register.cuh": "e90b389cde5b848ace67067574ba31ac17ed516b768385dd78d90b760319747c", + "extra/thunder/amd/include/udna1/types/register/rt.cuh": "6d6968171903ebf0b55e3cbd321b9adbfb0508cc09491ec0798e3367bfdfbbf8", + "extra/thunder/amd/include/udna1/types/register/rt_base.cuh": "011d999f5dcd746ad05bba8d3e251d15f74c21dd543bf26853e2bd7da6b38fb7", + "extra/thunder/amd/include/udna1/types/register/rt_layout.cuh": "cb7a02768fb14eea91b404288ebf8d7636b9c1a1be44e7c4a06d4aee80a9fb46", + "extra/thunder/amd/include/udna1/types/register/rt_shape.cuh": "748da90c04389b36d296066df88de4c954bce0048d49fd60a9172e240e1ec0e1", + "extra/thunder/amd/include/udna1/types/register/rv.cuh": "d2eb5570c33bcd914a4f5cc70198b55049393a59ba36ec1651e9bbcb32535e48", + "extra/thunder/amd/include/udna1/types/register/rv_layout.cuh": "d6c55e785ed7c72f09678375d74b0f5f4d3c4156922e2fd6ce8d12fc3042af58", + "extra/thunder/amd/include/udna1/types/shared/shared.cuh": "f38cc1d019cbc1df779057f8972800648f618c75455cb45a7a0c5fb3762e22b9", + "extra/thunder/amd/include/udna1/types/shared/st.cuh": "cbb26681e4faab6c7d191476a312d3263a1258e6f0805218ee697b40329ac49f", + "extra/thunder/amd/include/udna1/types/shared/st_shape.cuh": "2447e5fb611827c7a0d051e88f646ef3d1f8c599853fdb234fa55f68c2b8c09a", + "extra/thunder/amd/include/udna1/types/shared/sv.cuh": "6911833f24791c4f86dee35d675162576f9e3aa4b83722bf09ff5ff061dab219", + "extra/thunder/amd/include/udna1/types/types.cuh": "05df14b25f4944bc4c0a63422e110d7d5bb06a3ed455dba3e3e53314079f6290", + "extra/thunder/amd/include/utils.cpp": "b483adb097e06e3effc5432a847a464728244d1c0b56e05836abe045b120a62a", + "extra/thunder/amd/moe_router_mfma.cpp": "3e1d7eec71fd962695ed4900d7ac9e97963545a7086b632de999f10b427d0326", + "extra/thunder/cuda/fa.cu": "9f2a69d4078496a1f94b0d0082e8982a9380b39f3baa24fa80a9bedb92ccc321", + "extra/thunder/cuda/fa.py": "c111c064109508b387f2d65f412b1fc7eb759ae94780be0c87713f6bc6457fc1", + "extra/thunder/cuda/include/common/base_ops.cuh": "d5a47481b47f0c469a7f69c993e3df1bb5bbe1e92655452784059cd25b58f6ee", + "extra/thunder/cuda/include/common/base_types.cuh": "6224be784e89d1503c980f2653a4df9e5fdb586f1c3aa946b0a41e5c792e7b56", + "extra/thunder/cuda/include/common/common.cuh": "ee66f4c51eb00d4739bf5490120f99faba6e8345f41187ec2c6bbe084e5b72b0", + "extra/thunder/cuda/include/common/debug.cuh": "0924809d50559ecedbff73ce6c8643034644258b55610123905074cc073bac0c", + "extra/thunder/cuda/include/common/util.cuh": "d7f5a03fc472f50fbbcc90f466493226ab47c072361fa1cf1872d87d57a7fe4d", + "extra/thunder/cuda/include/kittens.cuh": "d7a9e0a36e23834509ac63337ab161f2a4c5356723bef71784d48b00faf13677", + "extra/thunder/cuda/include/ops/device/device.cuh": "6fdd7c434f0f7bd5a510893e962905b50108103f756bb86a61bb258e24ca6480", + "extra/thunder/cuda/include/ops/group/group.cuh": "b90118befb36f1e7b4f70d657af0fb864ac4519444f3fe4c0973067520e1ee3b", + "extra/thunder/cuda/include/ops/group/memory/memory.cuh": "05c960ad9fd5a0d77405f2f41b5c0648317ba053dbde2d8740ce018c0ced406e", + "extra/thunder/cuda/include/ops/group/memory/tile/complex/complex_global_to_register.cuh": "22bba11c9854f6ff4f43d9c5a522f34e64adbda4de0623268680c2a7cbc7e7c1", + "extra/thunder/cuda/include/ops/group/memory/tile/complex/complex_global_to_shared.cuh": "2f7fb802ef46cb9362e35d402b4f3711a5f435e4738d703ea06fe6fdf23a5dfe", + "extra/thunder/cuda/include/ops/group/memory/tile/complex/complex_shared_to_register.cuh": "62d4db32b771f9d560f17534c66d8831f673baf08ae4d085a53d5ce9fa11768c", + "extra/thunder/cuda/include/ops/group/memory/tile/global_to_register.cuh": "fbfa890eb9af11d794ddefce26be32d36c8faf2244d6f776d29205dba3ed18ab", + "extra/thunder/cuda/include/ops/group/memory/tile/global_to_shared.cuh": "9566df54d55e08b6e639b35d2759ca4d2c42b5347585b970a55f6aeea3d55d56", + "extra/thunder/cuda/include/ops/group/memory/tile/shared_to_register.cuh": "3a6aee2811ad29cebc45d41819073cb7481676b6b9fbafa43a10b301cb1ad3a5", + "extra/thunder/cuda/include/ops/group/memory/tile/tensor_to_register.cuh": "d9c91ce5bd8b391aa4bfe7b7660296b290f61b82b750bf0f0652c27d38131f3b", + "extra/thunder/cuda/include/ops/group/memory/tile/tile.cuh": "01e3b4232d338d30120088ca3859d4bf5384b7dd605e1d37a988fc33f747daec", + "extra/thunder/cuda/include/ops/group/memory/tile/tma.cuh": "7392025aae035fe208d75226f95cf71486ee5202b4d9961a6dbaf111900a1e6f", + "extra/thunder/cuda/include/ops/group/memory/tile/tma_cluster.cuh": "e1fe443ea282d3758b341db6125ea434c5addf091646b9d21639b0378c2ff89e", + "extra/thunder/cuda/include/ops/group/memory/util/tma.cuh": "a2eb8f0ccce2b4f84b7964353b597758b3d0a6d645bb1abfe92543da496b6cf3", + "extra/thunder/cuda/include/ops/group/memory/util/tma_cluster.cuh": "ad17e823071f219e18f7e592c7301706db1e912eab03225f46fd4a31040f1fe3", + "extra/thunder/cuda/include/ops/group/memory/util/util.cuh": "5df40e6573ade5ee1de7e6852b85e0d7f9dcc2b0cf403085fe670a8282e545ce", + "extra/thunder/cuda/include/ops/group/memory/vec/global_to_register.cuh": "d8930187c05617a6febd0da7e89dfc1021fe0cd993cd4dfa6637b54e619ba1e8", + "extra/thunder/cuda/include/ops/group/memory/vec/global_to_shared.cuh": "232f93bc854b815648d1ec3f704473d0821fb28d58adc70c2b642581e7821aba", + "extra/thunder/cuda/include/ops/group/memory/vec/shared_to_register.cuh": "0b8c72edaf78d22b9bda42a4062581b4e76dd5d35d9607da8cd6b0b0b405571a", + "extra/thunder/cuda/include/ops/group/memory/vec/tma.cuh": "f2ede73a618e6fc8c11036eed748c5fd15c61bd024060a5881cfcdbed0c5e349", + "extra/thunder/cuda/include/ops/group/memory/vec/tma_cluster.cuh": "dbb43ae38ff4340648fc534e1fb7286066b345b45b4af4669756dd80de02e69d", + "extra/thunder/cuda/include/ops/group/memory/vec/vec.cuh": "505c25952df720e912f4240e9835fd0516578a5546be042508ee581144fe5bcc", + "extra/thunder/cuda/include/ops/group/mma/mma.cuh": "9d440c05cc81db995b800bfad395bd4562e4db966e4214fd5053ff47c86007ef", + "extra/thunder/cuda/include/ops/group/mma/tensor/tensor.cuh": "fcf0a209d33cba2dedd99b5deb544a78a4cec1d8fbc06fb7b3c1b190414ec05e", + "extra/thunder/cuda/include/ops/group/mma/warp/warp.cuh": "c3cb1b373ff405d136eddc478d67e0ce7fb59c8b2234073f86c6912decaf052f", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x112.impl": "a9aaff495dc01203d7703e90bc935fcdb1c5df389444c436c4c9b96280af6a01", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x128.impl": "3e4289b5b804df791e834694d3d80f8169f5d8d11398ac9403e9143f6688e7d7", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x144.impl": "32caa22b864a25809b5010847a1a3e6473e4029324f8a44854c3503820b6f61d", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x16.impl": "026bcbd592559a85166a761c023837bb29b798fe10f106444309931fbbd27fa2", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x160.impl": "1b5632e554e18b8d75006cd4e3767dc236621beebd336c4373479071cbe69078", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x176.impl": "13db564d000d2b9105cd83c5a82bece3d401cf442d5d3f3105cbf966209034d6", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x192.impl": "f5e01a7042dd1c8c1b0e754882177c4433d6398eacad564269bfbda13d3bd61f", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x208.impl": "18285f84e7978678a1dc26d4c71ef7b6ef0fb6c3cade0e62db4a945c5f9169c8", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x224.impl": "f0c77bf1acc790b4ef740cc85c07762aecef9c6f29b0ef31cb2d7752727cd9bb", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x240.impl": "0210555fa309989ef50854476ec1d84edbd4d837ca5b2e8a809d4b67eb797d67", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x256.impl": "7a9d28d9962b91e71aebcd05723104f4ff4217e3c4728a4512eac5fb55cfc498", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x32.impl": "40b7ce914e7f54abf7bcda7834bf388722c72aca4362b5d41af29b40bd36a2d4", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x48.impl": "0dfca5903898b10ee55c262cb71ab5df9a931b0e95c641bb49696c6388569c33", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x64.impl": "2446cb3c4c468322d84a3282d3c8b4d6f80f3b41de5b95791692b8602031de31", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x80.impl": "bd752a13579a9f3c88d390770777de99820998f80df12e1ca6c9ae08354507b1", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/64x96.impl": "0f120f41b9cdd474a5149f60457e78b3b5b5f0361cd0546c5dcc88e45f986a4f", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/base/base.cuh": "ea11771706c1997570857481d02b329a6ba26389c9686e7a0bbad3ecb7f35811", + "extra/thunder/cuda/include/ops/group/mma/warpgroup/warpgroup.cuh": "8f90207cfbda0f5000f5d4c2d7e7d6d0fb18dcdc2aaaf07340a0cc0d52f634e0", + "extra/thunder/cuda/include/ops/group/register/register.cuh": "446a67af95bd0899496c0a166c00312f50a6c55b1950f7b74429ebfc963d02b9", + "extra/thunder/cuda/include/ops/group/register/tile/complex/complex_conversions.cuh": "73964b4cf32a0fea01cf528e75c6ef43d82af9b7a0002c17a789ac6e8c476718", + "extra/thunder/cuda/include/ops/group/register/tile/complex/complex_maps.cuh": "930479bf9df2553f1865c9020786a6ecc99bdbc7cc71d668e4e35fd191938c25", + "extra/thunder/cuda/include/ops/group/register/tile/conversions.cuh": "f5a82f5d727c750b28355979aa38e1123f44785a920b6d9cf9e53385a7a20c98", + "extra/thunder/cuda/include/ops/group/register/tile/maps.cuh": "8dd3584e5cae686e127b5da798ed315e1e3eda90456a82108635c7bc063dcd80", + "extra/thunder/cuda/include/ops/group/register/tile/reductions.cuh": "98ee2dc662a6d9da44ac9d0c9e7d9e2244958d1632c4b024f91d5efe393d859c", + "extra/thunder/cuda/include/ops/group/register/tile/tile.cuh": "7d347f65ca8db79a0983de1649e0b85fdd75773eca628cbe645bdee1c1761c6f", + "extra/thunder/cuda/include/ops/group/register/vec/conversions.cuh": "53ecf1e64caf52adb1e1eb38ea0ace34bbc41c46d70a73eb7765b0a361782a62", + "extra/thunder/cuda/include/ops/group/register/vec/maps.cuh": "a11cff1affe66dc7ef05910e819660f42c7807957be4a9f02f184e254b6f42b4", + "extra/thunder/cuda/include/ops/group/register/vec/reductions.cuh": "620c52f0c831d7ddc67a217258561dfea4a7c7c869f40e72feb5307aede868b5", + "extra/thunder/cuda/include/ops/group/register/vec/vec.cuh": "c59b5ac1179673c5e7fb7a0cc2e9f4206852c073065af03ee9b66f723abf8843", + "extra/thunder/cuda/include/ops/group/shared/shared.cuh": "30f76466d094e2de794b9fbd6a9030259d65bc0219a75b0a095ab6cd799da47f", + "extra/thunder/cuda/include/ops/group/shared/tile/conversions.cuh": "d3f1232e9015d7a7d2f1a31e67ede3770b93369054630a04a340a2988330c8c1", + "extra/thunder/cuda/include/ops/group/shared/tile/maps.cuh": "a02947fef24091cbe70bb5380906f74b47dc674f1e0badcba0edd5ed33ef02d5", + "extra/thunder/cuda/include/ops/group/shared/tile/reductions.cuh": "f2810c1bc9904a300a45dca491c2b99d2cc53fac094afe2c99a28cb0aa1c9407", + "extra/thunder/cuda/include/ops/group/shared/tile/tile.cuh": "0435b67ce56148654518aa6039263e8e799c9b896c58b02b97992601a21a4db7", + "extra/thunder/cuda/include/ops/group/shared/vec/conversions.cuh": "831e0d42c50079d4a7b9f2efa1cc1d85a95e50f8a2ce1de059ed5cc08752e4c0", + "extra/thunder/cuda/include/ops/group/shared/vec/maps.cuh": "794075651fd562709e24481061aba13b6c682dd38f386282149a5582943f02c0", + "extra/thunder/cuda/include/ops/group/shared/vec/reductions.cuh": "e5132a0d810900b993ffb890ed71368c860914dde0d62b98691c2f47fc895364", + "extra/thunder/cuda/include/ops/group/shared/vec/vec.cuh": "27062e07ac2a3279028d08fe5e7eed099a4ca4b540f6be241785475e71b153c4", + "extra/thunder/cuda/include/ops/ops.cuh": "f16b8dbfe7c76b7e9eba529f2fee4c5cb85c282d5978d4ce03a078d834a73430", + "extra/thunder/cuda/include/ops/thread/memory/memory.cuh": "1532071f09f9c8d7c3ff92faad08246f5626f91e324a55b972b28b6c6fe5bc59", + "extra/thunder/cuda/include/ops/thread/memory/tile/tile.cuh": "93e6aece9cb43cfb6da81b5e757ab5fffe31cb92038e072677ae12df4f97b5e0", + "extra/thunder/cuda/include/ops/thread/memory/tile/tma.cuh": "20b982bda45ec1522c88256a12f01c281d23bc00d199ff476a6face28f160e05", + "extra/thunder/cuda/include/ops/thread/memory/util/multimem.cuh": "638e3dddbadb575ad7e013126a098df45356cbcc2aa17a14ce73f72809067054", + "extra/thunder/cuda/include/ops/thread/memory/util/tensor.cuh": "8ba4754119edb272f635a6c4853ce78808d1166e3b715db6644746fb1c96c1c5", + "extra/thunder/cuda/include/ops/thread/memory/util/tma.cuh": "79c5ad62c90f4669f90d8f4101fe8025d4e4b13a6938092fa183681a41ea4601", + "extra/thunder/cuda/include/ops/thread/memory/util/util.cuh": "40766c6401ed74060b6d9515c1e5d2f01f7a9ebe7a7d03cc5c2d36dd2376609b", + "extra/thunder/cuda/include/ops/thread/memory/vec/tma.cuh": "1fcec21e719e760e84fe80a9e360af793cdac590fee2db934816c6206f2d266e", + "extra/thunder/cuda/include/ops/thread/memory/vec/vec.cuh": "72107cef3810bc810daa0b8c85c4b6b2ae8fd2e1a01775b2f760094e0f403d88", + "extra/thunder/cuda/include/ops/thread/mma/mma.cuh": "79c0518c21683b486957f999151f44abced39fa99ef9896e8338dfbc5bfef0bd", + "extra/thunder/cuda/include/ops/thread/mma/tensor/tensor.cuh": "47d6e5b152c4afa1bf237f2ca7eed97c9090d8611399402b97ece42a5dd9d388", + "extra/thunder/cuda/include/ops/thread/thread.cuh": "b01ec7fffda2e2c08a4214276034b6b90cdf4d148272cb8d15902ebab4fc0973", + "extra/thunder/cuda/include/pyutils/broker.cuh": "017c7c91a1ab8082045f7464b1fb21fb539333d0ecbae41ae50e665a4045f51e", + "extra/thunder/cuda/include/pyutils/club.cuh": "eda94d5c2262f9924f93e84ad561b23f58173929aed4718acdf865b0bbebfd6b", + "extra/thunder/cuda/include/pyutils/parallel_tensor.cuh": "68e412c022cd565873441d863866697b7416b7b1bfa8d18bba4b38be6c49ac2e", + "extra/thunder/cuda/include/pyutils/pyutils.cuh": "2aa935990aafe2b3c35680cd301df44738ed377f6eecc12035b63d1330a3debf", + "extra/thunder/cuda/include/pyutils/torch_helpers.cuh": "d8aea826ac33d0e1c0e057d3f5585f0d5b9bd51b6e0fac18b68ecbdaca68afc7", + "extra/thunder/cuda/include/pyutils/torchutils.cuh": "dec5ef73bcbe74dfdd0ff17cdc7295159fe517f783314e25bd1b2d5580a3caa2", + "extra/thunder/cuda/include/pyutils/util.cuh": "4c2834600e4f0e727af3599132dd1a4ff940088517bf7eb665eaac409385439a", + "extra/thunder/cuda/include/types/device/device.cuh": "4c5deea370d0cb3090b87725b1f494c0b2cb5fafee0f7736d16e1d7e691d1006", + "extra/thunder/cuda/include/types/device/ipc.cuh": "bd65a24a65bc62b7d6acc4af44e3367bd1202bcfe210ae4c8892b8d1f9c2fcff", + "extra/thunder/cuda/include/types/device/pgl.cuh": "2af231e83e16b9111da4ab61a9da6af0bc38a3341d0f480b8825faab2ca061a0", + "extra/thunder/cuda/include/types/device/vmm.cuh": "5536f323c62e44c996a31beda536a5eb4ad6f449fb51ac2bce1bc43fc989b854", + "extra/thunder/cuda/include/types/global/cgl.cuh": "05eca00a40f2504ad886c2002f1c465bf6a9fdb0395b7e05058dc7b29c49cfe2", + "extra/thunder/cuda/include/types/global/gl.cuh": "8bf647d9f3c6a6d7a0c84bb3b4f81562b0b084e6e1e87bd8ad30c04733d97c26", + "extra/thunder/cuda/include/types/global/global.cuh": "3d1a8bedc83149a336ef70fae6ca411074885952d3bd8365c220f32f72de5616", + "extra/thunder/cuda/include/types/global/tma.cuh": "3336d1766dd327314f944ea045a81ffd920340494662ddba55044fd10423ad6d", + "extra/thunder/cuda/include/types/global/util.cuh": "e6393e7b4f3c41781e8b052d6396704b3c007258890222c6d3ef791b8d549b61", + "extra/thunder/cuda/include/types/register/crt.cuh": "f710701182ae8904d917c043545c83b66074e90452e3cfb7826d37d04090684d", + "extra/thunder/cuda/include/types/register/crv.cuh": "62b9a97c57d5e92c09b26090a0bb7e3d77cad683070423856b0985e9988e1660", + "extra/thunder/cuda/include/types/register/register.cuh": "5102ec7e7aa6b66312297c24f7df9b27395e9122fe549fc024b0bf8d17b8d666", + "extra/thunder/cuda/include/types/register/rt.cuh": "d041874009fc31cb668eb47ccc87cae5e8f29afd8ce854168cb69943ca7859c4", + "extra/thunder/cuda/include/types/register/rt_base.cuh": "2cb273415d24145e51996b0f4d86df75daf5225a1d920160e29917b6f0488ee3", + "extra/thunder/cuda/include/types/register/rt_layout.cuh": "8f27d8b9f3516269b09b24195eb2fb382fd63daf770534b6285696c925d649b6", + "extra/thunder/cuda/include/types/register/rv.cuh": "e932d1f2d49dce659e83066c340f47af3376a04e15164219e4d831558c762e1e", + "extra/thunder/cuda/include/types/register/rv_layout.cuh": "8205aa7b6941852c093e32a113be35390fd292a440b69c6be357fd7cb3003d30", + "extra/thunder/cuda/include/types/shared/cst.cuh": "b07d82506f6fae3a5ce00cf9c63338ea40ae6d2de498e52b6d5e3f1ea0e3f4a4", + "extra/thunder/cuda/include/types/shared/csv.cuh": "5dec6ef6a3ea9dcc6e771a09cf112824dfb960e477e0267a440c8719b36b11d2", + "extra/thunder/cuda/include/types/shared/shared.cuh": "fa882939ee51f9343402bd223eed2e9b36d20f3a2942762626f59758c64f55df", + "extra/thunder/cuda/include/types/shared/st.cuh": "ce9d08cfe1bdbbbd10499bd3a2b3ed80ef2639e2ed601367761232c02f53b55e", + "extra/thunder/cuda/include/types/shared/st_descriptor.cuh": "178a2bf1a2aa5a1db283b38b4c0447bf5c0a01393164abf3d604a1c3f66cadb1", + "extra/thunder/cuda/include/types/shared/sv.cuh": "12505ce24877d1313a28768abf8817c2d66b8841f3aceb9d0516a5c9241700bd", + "extra/thunder/cuda/include/types/tensor/tensor.cuh": "d0c9e4f5565410ddd2c4df2da59a5b055d5a65099dbf00920026aa29ebdd4596", + "extra/thunder/cuda/include/types/tensor/tt.cuh": "9ed2edb5b903a67b7508763902cd5dd9408cabed1a87395c608258d728c10b51", + "extra/thunder/cuda/include/types/types.cuh": "247f208aec81d0b2c0db0a2e4186600b0c74bea582ac5425b3c606c4c411a70a", + "extra/thunder/cuda/matmul.cu": "215a6c6c52dd14bc3fe1a7256cae4d47c91827cd127f431e3b873bcd93487d81", + "extra/thunder/cuda/matmul.py": "6f0f7fbf78f1f346845dfaf9aa3068b0ef4bde47a381fc3ad03ede81e42a9958", + "extra/thunder/cuda/matmul2.cu": "d8e6cd7339af59ebdb672062f6cd73191419712419533659443e147e89e4ca86", + "extra/thunder/metal/gemm.py": "c9d98de6c29ef6c52cfd9142dfbfac3de236a869f0d23f08ebbbb02616c02bc4", + "extra/thunder/metal/include/common/base_ops.metal": "4b15d1d4df56c65719bbc881c5d3edf154ce471ec49e4b3f0362a260e7ceedd7", + "extra/thunder/metal/include/common/base_types.metal": "fb7a87129ecdacd8d190192b8ff71f23e5e5a4f96ee06b5d0aa61fa1f5e469d5", + "extra/thunder/metal/include/common/common.metal": "286b45f9fd6b79e5ba3c11bd950052e6218184acbeea228602454bf959b140dd", + "extra/thunder/metal/include/common/utils.metal": "491a69c649e6f44ea8f874ab1d86b0a5c8e2e1685234f8817b5b038429ec6004", + "extra/thunder/metal/include/ops/group/group.metal": "213e676091bcf63686fdfeefa25115c670ec027305ed2e5a438f710650161836", + "extra/thunder/metal/include/ops/group/memory/memory.metal": "fa31ec425a142ad41442f7dc4ae0361b5a4d681f14c7e241f912bbe6206a7519", + "extra/thunder/metal/include/ops/group/memory/tile/global_to_register.metal": "75f26873d302271722b5abeeb72323a1c8efbc7423983621aba8a3d987707964", + "extra/thunder/metal/include/ops/group/memory/tile/global_to_shared.metal": "f191ef58f7af598edb592cc7586123782fd4a72e9d2b4a60403fabeb5a8d9c7e", + "extra/thunder/metal/include/ops/group/memory/tile/shared_to_register.metal": "d536d802e6035cd757f8eed44b0b29ea35d2ced406b2e2fcb77fe00ef64c4835", + "extra/thunder/metal/include/ops/group/memory/tile/tile.metal": "3b43161ed50bd503369d4e2f06b241c1221af6bde95425a2936669669c56870c", + "extra/thunder/metal/include/ops/group/memory/vec/global_to_register.metal": "f00150a04c3632cc4349bb63ca552690fc34440711f20494ad546aed13437f6f", + "extra/thunder/metal/include/ops/group/memory/vec/global_to_shared.metal": "589631f85ca6de10930876bf4712f2a5e44acb4167bbddce23dc524a2f1526b0", + "extra/thunder/metal/include/ops/group/memory/vec/shared_to_register.metal": "b45d7da44b793ffab05320c769082c23c629a9397af457ffee16753d43e01bda", + "extra/thunder/metal/include/ops/group/memory/vec/vec.metal": "92710b44ef698ee8b3e51d916dfe1cc2a8de9ff7d4493a6288bb3bd742350077", + "extra/thunder/metal/include/ops/group/shared/shared.metal": "0deeb1e6f3682a7e18b11b43b97630d0c1e781213708359eece9dc368a6f21a6", + "extra/thunder/metal/include/ops/group/shared/tile/conversions.metal": "4ad9e627dad171603127d7ea6dfef58a151f6e739be413fd3184237139f35031", + "extra/thunder/metal/include/ops/group/shared/tile/maps.metal": "b05fd9bb4e5778834c432dcc12dadde2c84c477c94af5a5fc39b6fa0ae4ce195", + "extra/thunder/metal/include/ops/group/shared/tile/reductions.metal": "66e7658d800ae193d0b5c03ed0260a131b1b4e1c344ad7b23fc97dce60c260ad", + "extra/thunder/metal/include/ops/group/shared/tile/tile.metal": "23b0c079d373e4bc4ea1395dfc638ea3e27506fc39e5ff4c0f1ed894e55d925f", + "extra/thunder/metal/include/ops/group/shared/vec/conversions.metal": "c30a6ac2a587d28df9e96e17320d8cc9eeb95ec238e8206b3e11370d56c9bf38", + "extra/thunder/metal/include/ops/group/shared/vec/maps.metal": "9809f437d26ff79a71b058946c28f7e6cb43feec6a29cc391801491082f18cf0", + "extra/thunder/metal/include/ops/group/shared/vec/vec.metal": "0cf24b26553b3f70a5897674c31472141915959e4d73103d20d41ecfb7e439d1", + "extra/thunder/metal/include/ops/ops.metal": "2a643c8fc067686b338ecb39bbfcd7b67a1a070be3d12c1ef0e5f23c1417deff", + "extra/thunder/metal/include/ops/warp/memory/memory.metal": "e3fbbe17ae1aac1bc872a3bcbed753f42559f54cd64d74be4e3821c82ef4560b", + "extra/thunder/metal/include/ops/warp/memory/tile/complex/complex_global_to_register.metal": "7ff1292248a5b728f2c39bbed32916f9d6e64dcc4c1b98097a049e4c15cf1d08", + "extra/thunder/metal/include/ops/warp/memory/tile/complex/complex_global_to_shared.metal": "4e8aa0b432e45b1c13855e36446faff28e8afbf8654d42aa69bce17605376488", + "extra/thunder/metal/include/ops/warp/memory/tile/complex/complex_shared_to_register.metal": "6345fdae84c996b917ec3cf65de01bfc84fee1198826b7b352f2f8507fc4a204", + "extra/thunder/metal/include/ops/warp/memory/tile/global_to_register.metal": "e731186df4ba38790d456079ffd91c45cb0be262cae08c5604b23d7fdb7baa2e", + "extra/thunder/metal/include/ops/warp/memory/tile/global_to_shared.metal": "62577f1f11da83e2a52bd1442884585bc74bde436410b68d1387401c95d72aa1", + "extra/thunder/metal/include/ops/warp/memory/tile/shared_to_register.metal": "a6a967cba6e7cc8ca5ef4d7b959fe06bd23d06ba8286d61759f30a43a03f51ef", + "extra/thunder/metal/include/ops/warp/memory/tile/tile.metal": "a6ce7c55ebe9dafec9459283145aa10e5aa40efb084d4ca1152b1ed80a38f01c", + "extra/thunder/metal/include/ops/warp/memory/util/util.metal": "83a6618253735688ec5f58d7a8ab1c716b5cfd7b998fc152f245ac912255e4dd", + "extra/thunder/metal/include/ops/warp/memory/vec/global_to_register.metal": "d4b56b51a88ffa4ed40d834497c326ef34e6a32aff7eb6185c6b1183b7743a07", + "extra/thunder/metal/include/ops/warp/memory/vec/global_to_shared.metal": "b30789f4d4260b869dedab082793e21c020df8c420a4c0e129f8ff9bea07197d", + "extra/thunder/metal/include/ops/warp/memory/vec/shared_to_register.metal": "37f307d45e4a2f0b1490ad4293821efa3c7a50095ae73869fee4fcecd59cd479", + "extra/thunder/metal/include/ops/warp/memory/vec/vec.metal": "dc339c2e1678b074b03598070ba8ef10d2a81979e3e4a043e004ff466aa50aa1", + "extra/thunder/metal/include/ops/warp/register/register.metal": "2820bcfd2b7c3c493ce74585a7c661f4a2484d68562a5c4274ce4687dc2a7374", + "extra/thunder/metal/include/ops/warp/register/tile/conversions.metal": "a5bc579787af3f1e3a5427bdb221750a003785d902c5b2e28a4e00c6adfbfa88", + "extra/thunder/metal/include/ops/warp/register/tile/maps.metal": "ca9614eacfcad1d6d014f44709cdd7967482e1afc6faac0aec32e075607a1dc3", + "extra/thunder/metal/include/ops/warp/register/tile/mma.metal": "438858accb4bed7ed844e8307c76e57121d55b5a749f68070dcd09fae47064dd", + "extra/thunder/metal/include/ops/warp/register/tile/reductions.metal": "a5d544fe04b2336d4a32bada83233aceecbe36217e378208ea86d936f949e15c", + "extra/thunder/metal/include/ops/warp/register/tile/tile.metal": "8df03031a47bf68425de3e813e84c0556a686b048e70debd689489dacf912e08", + "extra/thunder/metal/include/ops/warp/register/vec/conversions.metal": "7312275a4fde8a21fa2de70bb63da2f2ef7dd37d725326cdeefb9166f2ebf734", + "extra/thunder/metal/include/ops/warp/register/vec/maps.metal": "07088712eef16da3454e613cdf00bfa6df2468315cd720e04f283cee0bf27dac", + "extra/thunder/metal/include/ops/warp/register/vec/reductions.metal": "e52ef2f85e53a56f5a6ef4a6715196a8e7b65c5ab464702c670ee79adf7027d2", + "extra/thunder/metal/include/ops/warp/register/vec/vec.metal": "c92efc2ae8d626ed0df0fd82af7a5cdeafc7489982d1d9d0f76b794df0390f7e", + "extra/thunder/metal/include/ops/warp/shared/shared.metal": "2820bcfd2b7c3c493ce74585a7c661f4a2484d68562a5c4274ce4687dc2a7374", + "extra/thunder/metal/include/ops/warp/shared/tile/conversions.metal": "43c425da64dc94267ac439bd1388c1fc32c19f54230ca8800140c2a0dbe171e4", + "extra/thunder/metal/include/ops/warp/shared/tile/maps.metal": "a7561d88b49c1298cdd0a5238b5cb104129b94dfefbaffc4c7ad05955dc09ad1", + "extra/thunder/metal/include/ops/warp/shared/tile/reductions.metal": "4702bb525654387efd1a71fb2478bd4b61e2a2f30d851757b47d670b1833987a", + "extra/thunder/metal/include/ops/warp/shared/tile/tile.metal": "c92efc2ae8d626ed0df0fd82af7a5cdeafc7489982d1d9d0f76b794df0390f7e", + "extra/thunder/metal/include/ops/warp/shared/vec/conversions.metal": "02004f248cbcbde9653b80b80add1a1623936c3bdb2fed1748c7a85246846f0b", + "extra/thunder/metal/include/ops/warp/shared/vec/maps.metal": "0722c647a80e51eabe7455f19afa6ea224758166086e32d2f8d88df6e85e15f3", + "extra/thunder/metal/include/ops/warp/shared/vec/reductions.metal": "c7ad84bebb1bacb468a438db93e1832d1b440cb1bdfd0c90f0f67f3e9f01a653", + "extra/thunder/metal/include/ops/warp/shared/vec/vec.metal": "c92efc2ae8d626ed0df0fd82af7a5cdeafc7489982d1d9d0f76b794df0390f7e", + "extra/thunder/metal/include/ops/warp/warp.metal": "23d416e60b2bcb1fb7cd9c2fc2ac2ab23f337e5c2e5a1c185c338103bf9951c7", + "extra/thunder/metal/include/tk.metal": "d1fe51ba401fed06b2d5d028b3d0ee8da8668c6d4578a00da51e9a03b47ec7c7", + "extra/thunder/metal/include/types/global/cgl.metal": "fc567a53d3c10acc2cdccef0260dcf2bd49713aceedce5c173ae996e53d31247", + "extra/thunder/metal/include/types/global/gl.metal": "46e5d81a4517bb96ebdf8c3ee754ef0633e2fea502c646f9807b328502362af3", + "extra/thunder/metal/include/types/global/global.metal": "7c89f5e1c93a4e52216ab7dc7ebc99862f31b7e461bfac25c3c28a255853653c", + "extra/thunder/metal/include/types/global/util.metal": "672e0c3d198278caec8cc13ad763c69fcca8664ec627e4d45af160fe963c7f35", + "extra/thunder/metal/include/types/register/crt.metal": "c11aa22129a357650edb2dbb8f89f480dbe020b01b6a2810513e4ea29a0c26fa", + "extra/thunder/metal/include/types/register/crv.metal": "d8902385df4cbfac0c47f86eab19e92aa1ee64ceb80b4c54d937ad29164970af", + "extra/thunder/metal/include/types/register/register.metal": "85f4be53415a9dcb293fe9e945bcf9dddf1f8b8d75a876f619dd286bcf5d59fd", + "extra/thunder/metal/include/types/register/rt.metal": "b0bc09061ff501067b28488a64286b7453fc58bc009d66b507f55d28443bdfb6", + "extra/thunder/metal/include/types/register/rt_base.metal": "500671889671714eb01c93b342c2e57da9e05eccf5e4393c664d558f2e6b2fdb", + "extra/thunder/metal/include/types/register/rt_layout.metal": "00a93b9cb389a42d1795b2716f887180f31e92821806bf3b7db8d0a33b3c2b08", + "extra/thunder/metal/include/types/register/rv.metal": "2a1deb3ffea0a81b272488762c67a3c85a58031140c89f59b3bb0c7ab17c06c8", + "extra/thunder/metal/include/types/register/rv_layout.metal": "df18a63c5e9102d442302876aaad451e1d5adc6c1f9cf648cc7d49ddef9a7459", + "extra/thunder/metal/include/types/shared/cst.metal": "b2c97ce74a22ed4282cce141fd334e6c8e6cc8530235c05392aac7fe2caaeaac", + "extra/thunder/metal/include/types/shared/csv.metal": "221b943dd59823d618fad71a066ff7f7f4e265fc49a4641c7b28f0f762ba7f89", + "extra/thunder/metal/include/types/shared/shared.metal": "b020290f58a02adc8c385dca1ba171b74549c93bd7dad0eb572dd749c3397591", + "extra/thunder/metal/include/types/shared/st.metal": "1e8eb5b3c765ca8c50a65f919e819d9b0a29c60cb982b26d5df67925889ac4a9", + "extra/thunder/metal/include/types/shared/sv.metal": "bae7efb1b96b8afc4ae1f948c760d511db21e8a88e8ee7e1b86e64cfa54febdb", + "extra/thunder/metal/include/types/types.metal": "83ff59e3bafa3728797fa511dc392389aee0524615ea2fdf9431a369b2d55245", + "extra/thunder/tiny/fa.py": "17ed30fe20d8043c5d770213e9e5f26fa15ce9e360d8f7f3609313a942d4bf23", + "extra/thunder/tiny/tk/__init__.py": "55893adac83a3cca934ad944c7bedcd5c628e827c107067dd361b9018b2f391c", + "extra/thunder/tiny/tk/group.py": "5390d744eb4efd0805c0db05abf9fc0e7cb2eba26ef3b217fb18449faac706a9", + "extra/thunder/tiny/tk/kernel.py": "ba67daab40bca942ef44aa7fd37d8eb57408503fe897a2f804079804abf414d9", + "extra/thunder/tiny/tk/tiles.py": "ea76497627f5c907020731e3e83f6a546ff5d56628ac5b5698df6be0c8c15262", + "extra/thunder/tiny/visualize_tile.py": "4ace0c4e482654479fc783c69ff9a78192539762a97a20a061a43d20de5953f2", + "extra/tinydreno.h": "966039aa6b18e5395578d52f0103fb185b85ae5ed481e36bd8d9002fd7357024", + "extra/torch_backend/.gitignore": "6667b2d1aab6a00caa5aee5af8ad9f1465e567abf1c209d15727d57b3e8f6e5f", + "extra/torch_backend/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "extra/torch_backend/backend.py": "6e6c308c97687ff65c3864812e0e88ab948f46139e7797afd7194c67371d074e", + "extra/torch_backend/backend2.py": "6c7134abcf194def49c6bf0be040067060dab6ac42494f7ebba0495b8730965d", + "extra/torch_backend/example.py": "5ffd92837234d6500d7e5e87fbab4dbbc4cd02f385c1680b35259a9ed4f911b9", + "extra/torch_backend/test.py": "dece17270963b0d76a78e1c710849c68e1085d06f6857b7a1936be74614a97c0", + "extra/torch_backend/test_compile.py": "cc90f5a1941dca91672680ca32d2d58e40c468a93eded747d37b59a3a3a7c7a7", + "extra/torch_backend/test_inplace.py": "650746357ece34844c9f222c84581ab28c40c3a06038029e06160039f4dc051b", + "extra/torch_backend/test_kernel_fusion.py": "fb476a398aa85a72c46d1406b3c651def1577bc18b5db4a808e2379e7aa9c266", + "extra/torch_backend/test_multigpu.py": "872408727adc094056444b403daecb467a5fc9180821cb83fa7749f4c4100cc4", + "extra/torch_backend/torch_tests.py": "0c519dfd9cad67b91d0b670cc97a79536ad0ec07e4bd312810668022986ce02f", + "extra/torch_backend/wrapped_tensor.cpp": "00865845bb37fded9944be760d71c3a76bb157913d59ced21988adb5b1e2d5cb", + "extra/torch_hook/hook_cuda.py": "91bf8eb9f9b8df7c5fa036f2346045dc5fe9c57f81967478436409cdec23e7ad", + "extra/torch_hook/hook_torch.py": "88bc6400d407658d0d8b669c7c30d8b2051cbbb0b31bce1409ce2ec014a993ae", + "extra/training.py": "95ef86027c934aa970af5532c1cc9a681bb559ad5fe92684be16cb0ee589582d", + "extra/usbgpu/.gitignore": "bf9525b73f91f2d53703ded7159979592bb3511e1fcebaa4bbc1a5cea33b6ff8", + "extra/usbgpu/debug.py": "f459aece569c39d4196b30102560f151c17ad77b29eb08c55c2d9968765b1c7f", + "extra/usbgpu/legacy/nvme_speed.py": "1a0d793bb8d5f3c2fb17b87d74e7d20c0df159bd12220a3ed1fab34f4f3660b1", + "extra/usbgpu/legacy/patch_exp.py": "35151c562b39ec1e78dbbba107925b15d793a23f07b2f0ffabb1479016f48f5f", + "extra/usbgpu/legacy/wr_speed.py": "1454bc4de77782550b84e91b99703c22a3f8b353c07cfcaf5042eeedf771f862", + "extra/usbgpu/patch.py": "785c7a04328ae68eceda73eee2be1c63180e5b0b0e72dc36416e5bfa03172fbf", + "extra/usbgpu/scan_pci.py": "022f4e20a69ad7eab80d5ea0c84dd43c43e671d346df440a5d6a0ef7a8ff9e52", + "extra/usbgpu/tbgpu/install_tinygpu.sh": "74cbf5a01899a1d3d3f3756cc53cd164c5406a7587406048a1178b766cfaab00", + "extra/usbgpu/tbgpu/installer/.gitignore": "ebd141efe01b18efa8d1374baa783da3974c7e6b1f0e22c40c1a77fe7d657f18", + "extra/usbgpu/tbgpu/installer/Shared/Assets.xcassets/AccentColor.colorset/Contents.json": "9af65086fa30b49252fae1a1225731691de794f7775af74d71befeb507d12b7c", + "extra/usbgpu/tbgpu/installer/Shared/Assets.xcassets/AppIcon.appiconset/Contents.json": "8f9579c1eab4166096391be9b543d31d163cb949712426c61cdde32f976c4c78", + "extra/usbgpu/tbgpu/installer/Shared/Assets.xcassets/Contents.json": "0fd49ba3c3585c709678e0046a821c3c60685ec7063720d30d3a3448be3a208b", + "extra/usbgpu/tbgpu/installer/Shared/TinyGPU-Bridging-Header.h": "42215a1b832a546daa36a21346295d4916e6e533fa52c1ac9ced74efe32bad7f", + "extra/usbgpu/tbgpu/installer/Shared/TinyGPUApp.swift": "ea176f417f0e1bf68e4d7f3b3a122710bea7058eb4b554d9e86711be0e1b67aa", + "extra/usbgpu/tbgpu/installer/Shared/TinyGPUCLIRunner.swift": "22b1a2709b7a48379376df7a92eeaae975c8dec4c32fd5ac4ad1188ab0e38899", + "extra/usbgpu/tbgpu/installer/Shared/server.c": "8f8ede8f9ae758ddb48526ccecbaa8dd3c42957b439922e9f763aa9fb3fb7e34", + "extra/usbgpu/tbgpu/installer/Shared/tiny_icon.icon/Assets/tiny.svg": "aaac2c09714eeada976f689ac7c3a07d56c60c5efe90e191c3705dc475009be7", + "extra/usbgpu/tbgpu/installer/Shared/tiny_icon.icon/icon.json": "9abb8964f41833eb8f465066df9c559c9e24cde4d94046ab1c66ba7d980b2570", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension.xcodeproj/project.pbxproj": "ee794e583c15e954528784628df27d5c1df27fb2f40347969464ad5d116bd34f", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings": "f2a6f2cb2cd412710cfe871fc27ede66e54198c19cc22b6d6797264528635ff0", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension/Info.plist": "35bd835528f1cbb4f39112251e6bb10d2d69a42a84c34fd9e89cda5fe9109807", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension/TinyGPUDriver.NV.Release.entitlements": "cc9cd66567f980317e6e7f6409ba2007c15e0070fa624a2a0729373414cb3472", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension/TinyGPUDriver.NoSIP.entitlements": "59c1f9709d995e18e7626188c12847c4be99d11898aaa84fa5f0591c50413660", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension/TinyGPUDriver.Release.entitlements": "6362009318e6fbeb8dab0a561bcfe907c9a04479322338b9ad80b3dd09119e5b", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension/TinyGPUDriver.cpp": "b7c076392d5d3672cff9a812a3b3e6d6758121e8faebca88f3f0735c3d7df53b", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension/TinyGPUDriver.entitlements": "0fe10748de8781d6be7a93fca08a1d567ce8e7c2aae7173bd7ba435a4b1046f9", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension/TinyGPUDriver.iig": "d40281e7939808023f6ba697b5f5dd26ecc109e3c4bb3548bbae3dd0ee3131bc", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension/TinyGPUDriverUserClient.cpp": "84b87acfed8466b3f6b9d1b082a817517b4797d3f4886b827be07fb87f9609c2", + "extra/usbgpu/tbgpu/installer/TinyGPUDriverExtension/TinyGPUDriverUserClient.iig": "be37dc44a92c4703398dfb50ef86c515d17782263ad0d4b1ac6a8b848faa2185", + "extra/usbgpu/tbgpu/installer/build_and_sign.sh": "b7bbf95a80aca63f660b3b5f97b11a5ec6e18133ccfe423e48117dc3d59cd717", + "extra/usbgpu/tbgpu/installer/build_and_sign_nv.sh": "7d51d71601e467569e0aa8fac1c9441fa98ae2eba61a97a02b9852c689837c60", + "extra/usbgpu/tbgpu/installer/install_nosip.sh": "942ab786cfabbc0da269ac9ecd207c159160b1b257b712a1de38843d19e8284d", + "extra/usbgpu/tbgpu/installer/macOS/macOS.entitlements": "1e6fc3c126686fc30c3fcb30bd5a72c72abaacb3ffa7c0de1d9887808ccee5fe", + "extra/usbgpu/tbgpu/installer/notary_tool.sh": "20401056724b8c18bf2acddd818877ec87a178050e43c46b60dcb2fb4f4b613d", + "extra/usbgpu/tbgpu/kill_tinygpu.sh": "3b852be83effed6c2c1499dc19a7d3fcd76031a0180c1961f43d835d1aa24a24", + "extra/webgpu/webgpu.h": "0bc1a8fdb2afcd81ba511131e60b09deb2f83389654c9d94ce2cbefcf6319d7e", + "extra/weekly_commits_table.py": "7153fc84c0b48a8801067033f56214bdd2a0ce4cd6c5d5464a0464b5171b8057", + "mkdocs.yml": "29d18c81299df3b765b49cfbaff0e570bae854100b7975d9291bacbd04639df4", + "opencode.json": "52c46faa4eae4980f628d2b879eacf62a62d0096b96e5c827701929bb1ef5ede", + "pyproject.toml": "ab7b9c8fd6dfa2dfad0fe1ead8ced3713bbb75ece54a4fbcc028e1cc305a9c3f", + "serve_docs.sh": "722d0136fd98b5211f0fb36307ef91e2e42d93f111651aa36516a168f0cbc5ca", + "spec/README.md": "7451ce91e4bda441c8ab3138634368b66d79d29b7a2558d3db340a6492dcbf5a", + "spec/render.sh": "521fc1a10fc444f3780b1e802a486dde06f207d04b2ddffe3baca88392625705", + "spec/tinyspec.pdf": "b70c2c8749f70d0235e85f764dfb8b191f23d8ea9736452a859f3c948ddbdedf", + "spec/tinyspec.tex": "8b15a15bad30e20f1c4959e73d7170d69a7c5fac11073b99c89589ddc2129b75", + "sz.py": "c1d3c0f1067056f9f80ce025bde302250df3fc2930914feb373f6e27e9aef8eb", + "test/README": "33c77cb265f73e916d34b6a68e6694e3c84ade0ca197abb1b13751b9d1a3b08b", + "test/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/amd/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/amd/disasm.py": "76f2e9148e0a6166aeb3ceec5c0488d001ef10280c8f565c3b202f7e258f6541", + "test/amd/helpers.py": "5bafa54d63d7d18606d53a0e1799477665ea0717d667314c06b5091e574ad7b4", + "test/amd/hw/__init__.py": "e761c9e5d6b026c1542672240ec917488cd54497a75cede9bfafa66d3297a68c", + "test/amd/hw/helpers.py": "9cc3c724f95af92f272f6d2e5c037609c857bd3d6bc442bd4be7389904094646", + "test/amd/hw/test_cdna_sdwa.py": "480463bfed2093d348ca2a271ae69a026e8ae7973a805eac2e3c045161955943", + "test/amd/hw/test_cdna_vop3.py": "793faf53fe23493862f44a87a56d6f33efd3f70903f56f57f91497f6df6c95cf", + "test/amd/hw/test_dpp.py": "105101e8543b7c1165cb667ae3978f80bcec33d1ed2f86f33a28d94153ab4d7d", + "test/amd/hw/test_ds.py": "96d55b95c58640b875fb316cab7507ba7a865ca6886ead8f7d321caf43df891f", + "test/amd/hw/test_flat.py": "174bb0ba2fcd0b0e4cf44ea3ae461a8703d407e657319dd81b75965cbfc78779", + "test/amd/hw/test_global.py": "138d8e16356a013101e9d8f9595346ed35ed188768b81dce6abe0b3c04d54acc", + "test/amd/hw/test_rdna4_fp8.py": "10f3811ac91f2ed703af68e9e04c7905f2afc78e878bc060ff7e2ff161ac2d4a", + "test/amd/hw/test_rdna4_permlane_var.py": "277ea1459833ece64ce4558b542fe0b49d36a93f5b3e2524c40bbb310f02fe38", + "test/amd/hw/test_scratch.py": "f14039f63e506092bc9c16a94f0541d1da95b1a0ba52ca231ca77b5839acf1c7", + "test/amd/hw/test_smem.py": "56fa96a2de1064cd42d5aa8e77dfa2c5dddd7aba00eef1fdb304104cd971f290", + "test/amd/hw/test_sop.py": "b3393dd126ca5b1b1a07b239abb3fb9e6e6fc74115aefe0a0f874a6e652f3622", + "test/amd/hw/test_vinterp.py": "bf6937ade43cace80c4cc2458b7c213788c22023e148c8cf21c9d12cb482ab2c", + "test/amd/hw/test_vop1.py": "cdc06090cbf98ae65257ae15d849ed131f4f2174afe5d350072fb0cb5b1c5a7b", + "test/amd/hw/test_vop2.py": "8b475eed2dffe498c1b1d2c2d06917140972a5463a0d20ee5ac76e81a5d140ca", + "test/amd/hw/test_vop3.py": "e319072db4f976dd6a1cc77023b752f5c3e163f6da3955209b2205b204876606", + "test/amd/hw/test_vop3p.py": "63c4eac79e1966d87be7ece5f9821add9e9da63f56a3135193e7443bb487d050", + "test/amd/hw/test_vopc.py": "06b79bda734bcb0e1611a2600420f27c712202bd2ca39c88bcb3b5697a0abfa9", + "test/amd/hw/test_vopd.py": "69e081e38855b14030e10178b689e28c8219ab75b6273eab78ab504344ffda35", + "test/amd/test_asm_kernel.py": "9345f227074709ade365e6932fae70293c273eaec03e3f79a85bdd71e5f32888", + "test/amd/test_dsl2.py": "4d64263ec53a2bfe07bda5d9e0a7a7c37768d07de7c02b73dcf7ef517779e2af", + "test/amd/test_emu2_pcode.py": "cf75e6dd7f17669faa306754b3bf6dca922a314fbb04c85fd6e33bfb287e0d1f", + "test/amd/test_emu_memory.py": "36e810e30d7b4da8858b41d200d9b23929c76c5a4db4a2c97d98e7929fe175ab", + "test/amd/test_formats.py": "d50428f711aba1a5afdd44e041d69dd7c27a49fc8cdc906de8ce696376b50445", + "test/amd/test_handwritten.py": "3193fd918bfd741a67d9cb7b552befa4a98e69fc8c9ddda18e828eee6fcf9390", + "test/amd/test_integration.py": "4fb9ac996fe61a5d006028aa435f911bf69e0210353cbaaafa512d7488d4f26b", + "test/amd/test_llvm.py": "fc18f15cd175764e11bfe1a5f36642ef54f9560657241bd88a8614d5e48f4ad1", + "test/amd/test_mockgpu_invalid.py": "e95b8f61b673e628aacff67cd66d07763deeb05fb33c390a1c6d965591338b6e", + "test/amd/test_pdf.py": "69148bc43e7f8353c507123c00f88b99822bf4769b01b425ab145354376962b9", + "test/amd/test_rdna3_asm.py": "371bfa6330f59915c758d469e2a2af148487d846fa1a680a049bba0fbbdef15a", + "test/amd/test_roundtrip.py": "a82c12563537381f14a851004e13a6251e941d2b427029406c8cf685f357dbb7", + "test/amd/test_sqtt_encoder.py": "e736730812cdf300cbda05a74c9cb8f988f37c8aa6c443e5a273cd450a5a5fc6", + "test/amd/test_sqtt_examples.py": "ca4dd9f9a7783c1877fb790b0057afd973fa89b33b5ca3a3a293da46f9397d2d", + "test/amd/test_sqtt_profiler.py": "54086e81351aa80d91f91da1000a71872e675ca952b6faf9a36bca166b4e7a96", + "test/amd/test_sqttmap.py": "e85f804021d6e4a074687bf8685c38cfd9b0e04249f7c097e0e475f01d5a98e2", + "test/device/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/amd/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/amd/test_arange.py": "ae31e5cac128c702106a7fc3e20ebbb5ed1dfe097980789d900e6edad8f52aba", + "test/device/amd/test_asm_gemm.py": "27589c100827f03a61fac60fc694714023445b7238fff8ceb7c21a8be7d4c83d", + "test/device/amd/test_attention.py": "7672539c9e85b0770382c9b244ea8b32022717ac5e13adcf0ebc6d0ca6cc9bf3", + "test/device/amd/test_llama_kernels.py": "d90b0c15bf2449957f30b5cef9532fbde04e72705539b02c750254105e2d348b", + "test/device/amd/test_llm.py": "bc03bf2e86987c2bc3c5a85266945c54494aa2d8aa2bb4426dfa766bdbae3258", + "test/device/amd/test_llvm.py": "42c97a85d4ad481047facd77bab6445aaddd3c667838e7a1aa3c500c8d2e40f4", + "test/device/cl/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/cl/test_ocl.py": "b095b4b22c1f857663fecb28f9381d2c3170c98e4ca1de4e16db2c1390f2d46b", + "test/device/cpu/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/cpu/test_call.py": "e3c268e3b5a4c4f11cfaabfd6949d150832cb04d06d33ba552e2bbdf482d702a", + "test/device/cpu/test_cpu.py": "bf8a62b30018749b7bbfb207304f187a9f51608986514c08a9e246fa4439268e", + "test/device/cpu/test_custom_kernel.py": "f5e85ab090e77a827f15696d7b4fe9548558140a50827bd14d735227ca2106cc", + "test/device/cpu/test_ops.py": "2ebd3b1d34ca27a6749d47938ccf0965f06991928c63293b1c9a37d37f3a7714", + "test/device/cpu/test_quantize_onnx.py": "f47928a945b428a83715a51710b48e10fe98ff699a548914a1f4f1f53d9bb72f", + "test/device/dsp/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/dsp/test_quantize_onnx.py": "d29108597228d7ea3bbddb1fe23b105dea0d59a49cb2859bc20ae6cee506ef49", + "test/device/metal/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/metal/test_metal.py": "b02f0beb1bb4e3bdfe41e278cb8e70dd4b3d514c7a0f1c04f2ee4ba4201b52a9", + "test/device/metal/test_softmax_fusion.py": "1854c7adc280d40c6430ab6949d02fad755b74f539b29dc9fe2d9e64e8cdc876", + "test/device/nv/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/nv/test_renderer_failures.py": "6b3bb349db2e5ee85b7071cdad28de1b5c803c727ea278a21a6b3ea85be1aa4f", + "test/device/python/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/python/test_uops.py": "04c602da68aa3824ec76a563ad7df29e3d8a11494475ae8d10a828fc4a3518a4", + "test/device/qcom/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/qcom/test_qcom.py": "8d6546e6c82294c3c8438d9055f014f222ddbb46dbc67f5af4124b2f93657427", + "test/device/webgpu/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/device/webgpu/test_renderer_failures.py": "47d34217fccb31ea67f1c921539b835159fbcfb6bb846fac338640d850904103", + "test/device/webgpu/test_uops.py": "766ee1520644e1475584aca7de7283a83558d550d4c317b01a1a6b21c450de86", + "test/external/external_benchmark_all2all.py": "c7889050fa4a57943c648453e4415625a5ae8ca1054c8cb3e6abc5e077c1c9a0", + "test/external/external_benchmark_am.py": "4fad8bac9c255b05a297c8ef90a8c8e89842d53ded0961c45a1ff781398b3095", + "test/external/external_benchmark_bert_matmuls.py": "dc3e5a15c0e4d86c59e416e7c24f24d2c78da9f6e26412b5cdd784b02d46c47c", + "test/external/external_benchmark_bert_softmax.py": "fedb26887719fa645ba896ad8330cb2831e1f1e1545af7e874484fd8c4b8a0ad", + "test/external/external_benchmark_disk_raw.py": "b696ee71352adbaaef6ce3282e4f17e98d79552ec2155ccac1e236ae9fba894b", + "test/external/external_benchmark_hip_compile.py": "896f0c44cb436c368542efbbaca33022ecc2bccf76f7197a1061940d5d4f2f32", + "test/external/external_benchmark_keccak.py": "78df26ac9957f1a8697aa9b425efca3fd6a63bad3500c606419c84efa2dd7ba7", + "test/external/external_benchmark_kernel_launch.py": "320e71b1918fc6c071321f30c6ee909f9c332724ac16e119b903e915325aacee", + "test/external/external_benchmark_llama_offload.py": "49e6f1f2723eb1cf6020480b92ce5af5ac3a9b2bcbbb87fab968a8c27b63c456", + "test/external/external_benchmark_llama_schedule.py": "27f4e2b4795cbee4be256bac88f6d9bd8429f39ff4957695ad934b3827f56d5e", + "test/external/external_benchmark_multitensor_allreduce.py": "fbd21d717a27af9c5b528f5c8f17af18cc3405c530feee5e5cc9689603f67905", + "test/external/external_benchmark_op_conv.py": "a2cb26a85c4c11a923b966f07f6cffe7c5b76436b592930095b68659bc8c2c85", + "test/external/external_benchmark_resnet.py": "997f162296f0e2c9ba770a521713b88d393c3e60c323ee290dbb88bde51f49f5", + "test/external/external_benchmark_schedule.py": "a29c242b04b9ddd768a853ecc040529c042829ede32e105244a2f14b01345cc3", + "test/external/external_cl_half_max.py": "886e3068979bfb3d51a2b88cfe9a26375055b447bc4b2f3286f219d7087fa975", + "test/external/external_fuzz_ampt.py": "1f62808d240fe5d1e5494cfe33089f04ef812cc1c7b64447eb3c7b36e0302387", + "test/external/external_fuzz_beam_timeout_recovery.py": "4e4b73c087ed9f3c0003d05daca9c6ce6d1b47ea155268c15afb4fef1c69d396", + "test/external/external_fuzz_hcq_mp.py": "953625042b0940887d9d69372eae0b04152c10376b051dcb213ed0386d96e64e", + "test/external/external_fuzz_hcq_signals.py": "d75b19499f3a656d0e67d49a04bb6bfbf226171ba354f19ae577dd7983d09188", + "test/external/external_fuzz_qcom_cpu_cache.py": "96b88f5b8f1358d355f2d5fdea2da89b3bd909776823e71f2c96a578277dea3b", + "test/external/external_fuzz_sdma_warm_start.py": "8197d7a11fe950fb71d01f4eefbe691117246d4315c798af0411d4bffbe3d92e", + "test/external/external_fuzz_tlsf.py": "1d0367075e5118c605bad3c9f76855df1f8d09d5b24aa10ae07176a6da99640a", + "test/external/external_gpu_fail_osx.py": "99dc8f8f3a7214d63bd62ced84cd0210b87fe49fa4843db60f82c2255b7eb7de", + "test/external/external_jit_failure.py": "d236162d0ed5e07481d9c78a55377514c65422e7afef5f589b1d85b6c33f60cb", + "test/external/external_llm_eval.py": "720727a7f46568ef728df1a3896411046ec9a0ddd4483b3a70c0ae92d48396a4", + "test/external/external_metal_compile_fail.py": "b8a141127f5fb7ce1aab9bc25479a7a77b9e9560fda54dab3ed6909ed4792583", + "test/external/external_model_benchmark.py": "35a350d9dd448fcb68470cd012a9347138183dd0f5be56449683511cf55172b7", + "test/external/external_multi_gpu.py": "45f3eb11c750e211e99133db89a9960d120f1418eaa3074c3c3c0a095e65e75a", + "test/external/external_nhwc_conv.py": "20433ffd612cb8c11e1b434f091b63c9fe1de44db78cd2996ee20cdcd275d19c", + "test/external/external_openpilot_image_warp.py": "0676e9c69d63f291ed7f43b8de7a1f7df95ed5bfedd755d089d25bfe0bf505ae", + "test/external/external_osx_profiling.py": "643d0a314b43ebd98e9c971b0fb14a7e11e49a44a4a4ed1188d38a28e102c2b2", + "test/external/external_test_am.py": "cc9cde8c530b0f73a37b206a2eb83b214d48b8491bca170170029bd0d924728d", + "test/external/external_test_am_fault_recovery.py": "4c2f062ea7a2aba72d36a35f4930868af03f1027f2f2ce25cefd6431079884a3", + "test/external/external_test_amd.py": "5059733a151b2b1c5449414f537838cfe5b80d64b3291709c849fdb05db6f172", + "test/external/external_test_compile.py": "e83497108dc3043a0ba925a1c62caef36c4ed3163ef76d9919422c9c6bd7b51e", + "test/external/external_test_datasets.py": "0728e65b85a02930cbbbcc707379d1aba4c868075900137cdf434b6cb98e6b58", + "test/external/external_test_dev_var.py": "d9a2655749c479fb98692949a2d200a303a7f45ee1ffa9aaa604c44de9d19c11", + "test/external/external_test_example.py": "076c7b95175a70caa39a01fd27796e6d831c9ae1b9ccd940490f2cb7a8b6236a", + "test/external/external_test_gpu_crash.py": "3b70f2e148f3319d4e95a87b5e1b1cc7785c49a132c683cbf54727e410ff78e6", + "test/external/external_test_hcq.py": "b59f3b9f78bfb3f699bc17e3a323814f608a2c189f16738b24ad733d84de7731", + "test/external/external_test_hcq_open.py": "157f42289203f89d9808ccb9964f3cf6066e8de0572edd9dd65c0fc65cd8496f", + "test/external/external_test_hip_compile.py": "8cc72b3990a694d12492a824e254c382869866c43d8cee1078ed1308e76ea365", + "test/external/external_test_hive_reset.py": "15f37695baf8bf9e190fd46e3115b34bf78b752d9cb97c6fc5acfaa6bb1094cd", + "test/external/external_test_image.py": "f11ca5a7390419dc2088ae34464de3bb2e8276ae05d8561a9b642951b7ddccef", + "test/external/external_test_jit_on_models.py": "826a051078bc833c900a88acb70ae5480724a3b6cbaf6dfacdacac1c76a14b8c", + "test/external/external_test_keccak.py": "25e5a867a20dddf2ea62698d8949696a1777ef3835089137a735bb8382040e4c", + "test/external/external_test_llama3_ff.py": "525d2f959a39e357260714518ecfec36b642c896d8495671e85e6e52518e2f9f", + "test/external/external_test_llama3_layer.py": "55b85b886125903e521f10f171a0aaceabe3b727b9bd7b3e7f787470e2bda6df", + "test/external/external_test_lm_head.py": "0e28361b11d198d93ad2752c8d6302e362d38e4b11ed9335683777e81a47d1f4", + "test/external/external_test_losses.py": "364add215facd42f778f1439619d20626d5a5db03e39622ad24557d6a956001b", + "test/external/external_test_lr_schedule.py": "605cddb663d0960a076102752dbdeffe8668ef4a4c2f2153484ef832c2406a4f", + "test/external/external_test_mamba.py": "6cc87bd9ab5a961bf47e4b27e7439f19b5977f29db3b8f6e97d7bbd0d57a998d", + "test/external/external_test_metrics.py": "bf177d7056d145061fe316ec006fbe9786082f11e3607fe84bbe1dcbb2b9e46a", + "test/external/external_test_mnist_data_select.py": "37bfd08ddcf994895fc068fb99ec0f6fb7c425a297d87e01dcd75b514a3b0e75", + "test/external/external_test_onnx_backend.py": "e6910bce97aeab48f8cf15272c50bac9e19656883b3222cffb0d48244ddf5900", + "test/external/external_test_onnx_ops.py": "527798db875e431edbc14edc8b837299792de5c3e469f9b5fb272e68e7f3ab63", + "test/external/external_test_onnx_runner.py": "b885c786a9ba2382224b8e9a70344003415cedccdd28a74d7167fb060ba23dc9", + "test/external/external_test_opt.py": "b9f99bee4f51502e2d354d6c27aab19adb5f39139d48e6aeac778d5476c25995", + "test/external/external_test_optim.py": "dc10556260125e55eaab8269a526d2445e375afefb0c11e5a46668ab3870e03a", + "test/external/external_test_process_count.py": "36754814edfad80a89c6b09d64678b5d16a8a58a3edf59f01f38cb8af2b73c25", + "test/external/external_test_schedule_scaling.py": "9756c816563d4b4427e87a369333a1db888888e73bc7c191d2218d33d1beffde", + "test/external/external_test_simple_tokenizer.py": "97b93c2fb75b5041744d6fa16f3c479ec8060bb3a42ca4925fda2913c57373ad", + "test/external/external_test_speed_llama.py": "c2a41acb627b64176200ceaeace85c23a53912769ac61e39877c30dafacdad7e", + "test/external/external_test_speed_theoretical.py": "ee0f0f5c17f4c5c82ee3a57380cd86bade69936c0bf1a08820e7ef5207bd34ea", + "test/external/external_test_tlsf.py": "f11ba006346c149b233a88b40c5f4d17c8f9e4b1f2516e0bf0e65e5e46171403", + "test/external/external_test_usb_asm24.py": "52ca8f995180ca1797babf06d7f13a8a5571b03ca4459a7d2ffde6166f5ff308", + "test/external/external_test_whisper_librispeech.py": "e9eef6bea766c0a40f13e2a146bbcf564cf758889aa38b006fc0d934be11009e", + "test/external/external_test_yolov8.py": "992ac6c2ebc65297e6f98ff2dad97f4dae028457d25f11fb5e3b32f5f44c9af1", + "test/external/external_uop_gc.py": "6554054234b3e16e331215d2b6193a9b684227c80378bcaf17609d7de505672d", + "test/external/fuzz_fast_idiv.py": "0e434b47bde060d5be05caa5e85a6cb4f38420e1bd4d44f95d6c747120187e28", + "test/external/fuzz_graph.py": "cb49b8cdfa6fcacd88083c8b3356f56cfc1a901562f7171746c5fcd9a16b6633", + "test/external/fuzz_kfd.py": "c10f009b0e23721fb01f0f129d14853a75949c5b91b9def4e3073279a9fc0163", + "test/external/fuzz_shape_ops.py": "03c614bd3c23a5db1c0a795b9306a1df8432487024c2a447301a07ff5f805b0a", + "test/external/fuzz_symbolic.py": "3fcf3cdbe4a7574b8a677ff8edd36c2f8fd8de6164a636a187dd409665deb762", + "test/external/fuzz_symbolic_div.py": "f995575fd16d07ebe5308971090068b6849b0cdf848a7a1a38f8fd1294c5f1b7", + "test/external/mlperf_bert/external_benchmark_bert.py": "2793283ca10843ea3755f08c11c74d2b07a63f2336b9cbea091fdef9670692d3", + "test/external/mlperf_bert/external_test_checkpoint_loading.py": "7f4020fab9da6d068920ea05739f93d2e5c3edde46f61a53b2ce4ee116779c9b", + "test/external/mlperf_bert/preprocessing/create_pretraining_data.py": "b92fe72e7272c83a977d4c4adb09a898a9b1c452a58aee3334d01b1b1225b964", + "test/external/mlperf_bert/preprocessing/external_test_preprocessing_part.py": "30837b3145519b0a1ae59f9ffe3b1e80c6e8edbebf7c2901c525e51e59487983", + "test/external/mlperf_bert/preprocessing/pick_eval_samples.py": "19a203ca028fb13afe86dccf611f2a4e48d2740d2e02210fe2c80fc16b1bfd16", + "test/external/mlperf_bert/preprocessing/tokenization.py": "06f36900e24094d52a20bb6c9c31a8e5ac41dd22f53b9605e1c833bb27ddd692", + "test/external/mlperf_resnet/lars_optimizer.py": "4e372648776055497f9822a5c4aba2a769b5cd5cbc4a394bc37212030b6403fb", + "test/external/mlperf_resnet/lars_util.py": "3b439a94b4072d0ba6559320900d7ede595d1620be815ae4444f2c5d8184524d", + "test/external/mlperf_retinanet/coco_utils.py": "794a4bbc9b3a71039d5c67375cdd4d8a2e777382c76892d15dbb228472e61586", + "test/external/mlperf_retinanet/focal_loss.py": "f58ec4a1bdc7aff2f00d8f5cddfd732edea9319690a0e3b7b092dba81dfa57f3", + "test/external/mlperf_retinanet/model/boxes.py": "371ac10cf6135f32d4535c88b7c1ae83007f9cb008cebbd063f1851bfad07c22", + "test/external/mlperf_retinanet/model/image_list.py": "742efaa05629179c9f8aa11b2f2324bd9ba6d7979cae480a0f29373af13ab16e", + "test/external/mlperf_retinanet/model/transform.py": "0487d64cc8851c34bd5bba7164f067a3888b5f6023694824d237b40736788f04", + "test/external/mlperf_retinanet/model/utils.py": "a9936f289b6d50bb8eb1f8fee30a4fdfe3d53d2f2e5ca49eb437b2a674830ca3", + "test/external/mlperf_retinanet/openimages.py": "50c7a0901e41234dde605566e850cfca209b076e93450c14e0e0712af239b38a", + "test/external/mlperf_retinanet/presets.py": "66827ea7eb3b7b848e5a9f45f5937a8949dc7f95d84714f5429daadfb2284ace", + "test/external/mlperf_retinanet/transforms.py": "f6ab3edc908f91525d34c92db1b2de0ad70770ece6cefa889c1bad631771f5c0", + "test/external/mlperf_stable_diffusion/external_test_eval.py": "3403bd5881f3581950fd9cc845f266f973995122d36260f1d51fd18d87942ed2", + "test/external/mlperf_stable_diffusion/external_test_models.py": "da6ca0a6abbd08df0d6987e6028bca14b67f78a62eefa7ab7f660418e12b4620", + "test/external/mlperf_stable_diffusion/external_test_train.py": "b70af3e43a98cdadfb80f543299bf8f52e3bb4f5fb8d19a9fe992b3e574ccc0a", + "test/external/mlperf_unet3d/dice.py": "f63ee660756307c0682c6e6c15d2ea7a966b03bfd684985bfbb7d48402bb4e60", + "test/external/mlperf_unet3d/kits19.py": "7efb6f0acf342ccf2ea30b81cd0e29d8b93ca6b0aa8bc2feafaf11be2a38ac9d", + "test/external/openpilot/b1ab7897cbfa35981e1636fe551e4ce5.npy": "1e71bcca5801d98628412086a718e1744adee3867f8f091ed3ce9f46bdc59fdd", + "test/external/process_replay/README.md": "1fcd551416cc1907f4870dda762bb7524b0ca57ecebe52cc3ce7c3328943064f", + "test/external/process_replay/local.sh": "447660a1ebb884fe28c92007a5601bbf2767f7b34c1d2d7d59df6302fdfac22a", + "test/external/process_replay/process_replay.py": "8c26d6ee052907bd12f9324f189cbd924ac318bb708c82e8951b3389f54fa147", + "test/external/process_replay/reset.py": "eaae13951c1a0d58ada8e2219f51af56c6e7e32f29e45a03b3500ee0f69398a2", + "test/external/sglang_llama/external_llama_eval.py": "19a353dad247af20a2c11af846e377ee2a97f3db9d1427dbdf2742b2c944ab92", + "test/external/sglang_llama/mgsm.yaml": "c4727b504d53e91f0cb30e71b2a1e42c243e58631b7d032b5ccae3f70813fce5", + "test/external/speed_v_theoretical.py": "2e6650ee4d70b34cfed593ac89100e1da90b1db7c69aff615f07097b9af079a0", + "test/helpers.py": "41d7fa2e22cade0621db194fbd705325ca6ed12858f12a11fea4cf55d993c8ce", + "test/mockgpu/am/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/mockgpu/am/amdriver.py": "2b4c4562128766fa0e2a8514f7afdb2d5ceebfe96eae036b6899bbbb09598c25", + "test/mockgpu/am/amgpu.py": "0ea482021524296bc8dd8e4f887e46e4dc2fea880050b3bb4f8e32df26b185fa", + "test/mockgpu/amd/README": "e7c5281137bc766ab90b948f9bfaf7d2ddd92b8af4f32d985778a56886acd7ec", + "test/mockgpu/amd/amddriver.py": "2ddbd3b6c16f768c5f9fb5ca2269e92b91e477d7fbde39a0c7bf14e442c8c628", + "test/mockgpu/amd/amdgpu.py": "bafa63afe15a1ec4e1d9355e46d995b24dc8a73d60ccb05cd903c4329e1e4645", + "test/mockgpu/amd/call.py": "5b776afb164916ead85486920cd1da90f53fc2a02a240fddfaf3f408be51722f", + "test/mockgpu/amd/emu.py": "19a08c035cf21c2c2a4691991aa724e279e5137f8409b6091d427a930fc04068", + "test/mockgpu/amd/pcode.py": "5748cee319556dcc6eb32cc6db1a2e9d62c1e808123c486797b27da6c07e0954", + "test/mockgpu/amd/sqtt_enc.py": "29bc6d0fc3fe009646514f040d7a1b89b400969352722a2fdfab90cfcccd0531", + "test/mockgpu/cuda/cuda.py": "bd5959a5ed1c80b86d9d4461c41f61173c0228dc534422235f2a0d0dff9cb58e", + "test/mockgpu/driver.py": "82a6040b1f761f2f1ed44e97b649bdf77ad094ea54b5ab72ff2f137e3b880c1a", + "test/mockgpu/gpu.py": "4feba536bb62f3875da31b89d3b115ad26dd6b6f9734bc1c4803e04c7e16b90e", + "test/mockgpu/helpers.py": "bffc87b597015579432e02ba90e40f792d503c005af0a18c102d34ae98bbf4ea", + "test/mockgpu/mockgpu.py": "050a455b3a4d76d318eb810ef75136d96d0d381eddf79d52dacab675ed371d31", + "test/mockgpu/nv/nvdriver.py": "f04f3425fcb7342154962cc93ff71ffc20240a7b4f0aea9cc28b8e03b81ad041", + "test/mockgpu/nv/nvgpu.py": "85a1f7ce946e32c53657db67e6c769e2c8dc03744e076a74731c1501f9692674", + "test/mockgpu/usb.py": "ac09bcb1a928a956bb8a59d78a82db189f8612848fe814fad35f05cff84ca775", + "test/models/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/models/efficientnet/Chicken.jpg": "f70792a4bcdecdef65e3166b2be89a6ab5c1515ff822decac03d279168b1400a", + "test/models/efficientnet/car.jpg": "d550f2ce0458ff9f0553ca7ebd86aa3d45d752c80a5eee7e2f8f60ce792e7aba", + "test/models/efficientnet/imagenet1000_clsidx_to_labels.txt": "e6ac1e05778e809de37a089105170398e5d0b5f7e337165c94aeaacb80fbba14", + "test/models/test_bert.py": "1f347d246f7a20cae8b6b82801d3b3fcd61b8dc6fef4a5a33dd9e3c93e950731", + "test/models/test_efficientnet.py": "b7dc8f7311c8071b8b73a8b6276b37977ddff89a588a19d2ad955fe5078b95fd", + "test/models/test_end2end.py": "a8dae98afe28f60f0f74f85ffcbe1a2628731000b428f21a9ca497fc4f9a2892", + "test/models/test_mnist.py": "7a3c0a1f05ba7fead9ab04127086d1d6fa8e6d7927157af2925dab7f01c91438", + "test/models/test_onnx.py": "d6bcc44981d55b6928264f07fa6669645276b515149ba82985f3ece385aac8f7", + "test/models/test_rnnt.py": "6ae73ef6d9c5689fc4b3c717f44dda8fdfee108ccef65a3599a4435efec40e9c", + "test/models/test_train.py": "b8505ee5ae6f450880bb07c3f3897e31f28e20f2361d35d14db4827b7b33dfb2", + "test/models/test_waifu2x.py": "8fbf01505c177bfe9bd44d00e08c28c38051f021da5877ea909cc8c1f09c7dc0", + "test/models/test_whisper.py": "2ac2bc61ea2d194f9b0d56cf6c61d01aac75fa8bb283a79e9c46e42e3cd45fae", + "test/models/waifu2x/input.png": "f796040252d3042f64e3a88d8f7a8d36f79c53751433061da7b03408446347d7", + "test/models/waifu2x/output.png": "05c87abda07868f2b765cad384b3cf515b8ba73e9d162b38d7e83dbe5db5586a", + "test/models/whisper/test.wav": "245ee3ab9e6d3920dbfa2a2c473d033adf9b7a6d71173ec5cfcea109a5c82ef0", + "test/models/whisper/test2.wav": "5802edc5713f248857f439004c2ead02559bf9610a8fde7d1143c13ac047a334", + "test/null/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/null/test_allreduce.py": "e068e2c5f2997749e80ea3765c9d085e2cfcef39c5b834182d794c930f8c50a5", + "test/null/test_arange.py": "b1b31b98be8e8252528ec94484f57181893ca8d30f609b08559c7dce8234dbd2", + "test/null/test_assign.py": "f5e338bd58ff29198e54073c8be11af99eba8a690c131cbd694ccadbe348750a", + "test/null/test_attention.py": "5b50f907fe722e43704b8aa40effb65d0acdc7ea1906aaa97dc30e8842489c8f", + "test/null/test_autogen.py": "23f7f708e0c20ed57f07112c1a6efeef60d2a7c45c3f06fa7f4a8619251d103e", + "test/null/test_call.py": "397242c5c14194d288520d07bb1d383fa6a62b87db741bcfd20d2d8c4bddec91", + "test/null/test_compile_failures.py": "7f545f32d4e9fccb370a9e767c7a991d4044ea90bc57b6d3bae765f3a48e66f9", + "test/null/test_const_folding.py": "fc45d4c2069a570b6e89d5c18d00254f7ad18601ed4d816846981f7f2ee61def", + "test/null/test_custom_kernel.py": "fa648d0ff31fbbe75b28a1247124dd455849db22b7ecd91d1f5f123c7fb4e85a", + "test/null/test_device.py": "2bd0ebbc31887e3827b6e05f71cd330ad62ce2127c18595d0b8872b31f3945cf", + "test/null/test_disk_cache.py": "45f0feed65377556b5bcf39d27b2bdf4295095b0382ba96875b4ab4d7c4255fd", + "test/null/test_dtype.py": "9bf8449a5019c906bb9a14a217e5e9318c370bc2c3f8de259496fa853ca064d9", + "test/null/test_dtype_spec.py": "7e6131b4ed1bd349dcf17edda156d3047232179b5f0f0300b390d1917ebd1b55", + "test/null/test_dtype_weak.py": "c2499ac5f9e96be5739fdd80ca4694178be5b02f93167d740a9cca6ab117c7b9", + "test/null/test_edgecases.py": "78dc6f3338424325a59fb6ab06dcd479c91380d176e3154ebec8a096154e4088", + "test/null/test_elf.py": "86f8c0d493211594a4ed3668c4e446fa23a25fa94b3c7f2b8888c426e26966ee", + "test/null/test_encodings.py": "843a44b9d177baf44bc66c9c874749176c78a7344ef40c67cb45e37fc4921191", + "test/null/test_firmware_fetch.py": "6032fc25493beffef1550e1caddf2168d36c348e3fb31c12087b333f9e603f7c", + "test/null/test_function.py": "214c69ee9c94a668a8cdf9a2acd39dbc64634344a8f7486827f7ff0ea6887934", + "test/null/test_gc.py": "cd150690d6a56d52e1415f1f7fa053b7390baefa79f10e4ef99396ebeaa2b28b", + "test/null/test_gen_float4.py": "4ca6af5dfdadffab717973658d676eea3d36911de2045589cde02d4b659ddd2a", + "test/null/test_gguf.py": "df246724da7af2bff58854d922786791e035801cb6f5955c6713be4141cd7944", + "test/null/test_gpudims.py": "094fcb7f9c7879473fd33ae58cc1e0290e24d39c0f75cc022ad55eeab861b39b", + "test/null/test_gradient.py": "5710fff4d7fa3e9a5fd529926973a442210ddde394f680c54e7936b8da8d0bdf", + "test/null/test_graph_rewrite.py": "9543029c43d8400e714a4f003ff81bcc6a3588c47253206f894e428607e4a952", + "test/null/test_hashing.py": "5a0bb03b2a1d5f8bf6534804f2d21bd21c1fd181f5f30f4d342d98fc954c49b7", + "test/null/test_hcq2.py": "246372e34ff8ec6d11e0ad7dd4aa7d47b2d621b35a4b1afdfc9aefe8523289fd", + "test/null/test_hcq_iface.py": "2dea17ef2cfc4445f1ba14c8db6c92669d28a12518be99d3cb9ea09b39511750", + "test/null/test_helpers.py": "3f1389a280df053d07d6d145f3e19d8a30e3bb1e202967782f4515d9c1dffe48", + "test/null/test_indexing.py": "ca9d62d8c47652c1a0e6aaf0d345a704cbf56a5cb562f8ea57a9af3655b00061", + "test/null/test_invalid_tensor.py": "a6ad9ee195b0f95053a5616b8f31528d7ea991e2f844c4a496647751f4e2246e", + "test/null/test_isel.py": "27b05146437a8cf866754b7ef7af6ac76b2cb706cfce06a638950ebbe8e3829d", + "test/null/test_linearizer.py": "0f76171656bf6b70f3a9ce90b7d1abb42123e2ec195c88a473b9c4f32c450d60", + "test/null/test_linearizer_failures.py": "3c0829a5ed576253d5104a2235565d8ef7aac95e813450493bb0c9895a537a86", + "test/null/test_linearizer_rewrite.py": "5564d9b458f6d632bde6761ea1258e8e6d16a96f6e8decee4c945749afce8743", + "test/null/test_llm_mla.py": "d6ea54c049dd3d9b9b6b3f1cdf4be2d8f44e41bd2ebbab064160d53c51c34661", + "test/null/test_llm_server.py": "676dc20595345ceaf0dcd1e5fedd130b3c3a977952b4ece4b677e3cd20edc8c8", + "test/null/test_llm_tokenizer.py": "7c546b767c12a5df9ffe5d8b808ceb18af7b3a8c19f50d0cff498ecde96e290c", + "test/null/test_memory_planner.py": "053b3b97add99b4059c0c2c033f6254b994d338a93b2832a8982fd2a1cd54bde", + "test/null/test_method_cache.py": "a9124650e53e66644ffcabe21abb46d0cf8beaf0a381aa670c0f3a9a53911096", + "test/null/test_microbenchmarks.py": "8d004922cf8f35b8e60bf9bedcd587199554386f512677f34811f0ac1e8aec0c", + "test/null/test_mnist_dataset.py": "24c83633009e3bd635e232a0e1f00a2fd6a1de91b78a11605b6c8054e44fcc20", + "test/null/test_multitensor.py": "b261940a10d8d84fdac64113f6fc70a1695d7722f6ed52500acef0c4f06f860d", + "test/null/test_nn.py": "e7ed913293269757cce67c6a04e83b56e0c7a629900b83b897e189a44dab596d", + "test/null/test_objc.py": "2a6d4b65d6439349b9f9f019ef24002e75cf29836e7baa7c8245586867693f24", + "test/null/test_ops.py": "53f95bb35f98ab7ad8a03e6ef3fd381435fdf77d5f199fe329f8ede83261cf66", + "test/null/test_pattern_matcher.py": "77ec4a5be2f093481e133b819135025d9223e0fab18028289faeabe7c10fe7a8", + "test/null/test_pickle.py": "4baf0e3c868e9cca945a711c3ce03d6019aa374b4aac2f60318d8aed437a2c00", + "test/null/test_postrange.py": "d15e476241c95c7e6b633758f3868ff14d5cb61af846a4790213cf473f3eea3c", + "test/null/test_process_replay.py": "02c856a40a96b424339b51ff86bbc967b91bd386bfdd3eae513b87690b33b9f1", + "test/null/test_randomness.py": "d3af7d3c03f32275f3a8162cf57aa97bfbddd8f766f0785e32c4e5ea729c7bfe", + "test/null/test_real_world.py": "c3ea385655550caed484df3272bc9a43df5bfb5b1a5a1810639e01209e0400a9", + "test/null/test_rearrange_einops.py": "3faf2feec4b50b83441947952e34c520100d0ca9876a41793f19196010c9398c", + "test/null/test_renderer_failures.py": "16bf245145965e7cd756e852d75ff1d4d3a3f21c7fcb2eb05dffce498712663b", + "test/null/test_resnet.py": "dd0c9012e1515db216bf9578ccc71df744dd1f11c17594822b6159894063d9df", + "test/null/test_rewrite_bottom_up_gate.py": "7e7dfdf3c12e4d738fe71fd468f5d6cdffc2de79ba58f585fd3d84e42a5adda1", + "test/null/test_schedule.py": "15a4e2bf8dd951f71f42c254162749f380e7c87083408501a3cf5c5000529bda", + "test/null/test_schedule_cache.py": "e73e98b20762818f7a13e694e5016374690e8b61b9fb5565f6b4d781efe8fc02", + "test/null/test_setitem.py": "9654963c93e3794d5f7aef3df15cd8853a6505e0a9d31458db765f8fa70744b5", + "test/null/test_setitem_schedule.py": "ff9e7495f822833aafc9b9da7e4360154be033e75276f53541110091e0058cdd", + "test/null/test_simplify_valid_idx.py": "7f5fc3e2c745f7b19e9f29a46163b96f944dae0851978b4193a7bd36ec0b7c3d", + "test/null/test_symbolic_failures.py": "8ee90f5df82e0fd2aabca612458f967afedd52af748214cdf267d24b644ca83f", + "test/null/test_symbolic_ops.py": "ecbbf525aebfff15a97e9dff79f15e3370ec45c10012f95652f6db2bafd5915f", + "test/null/test_symbolic_tensor.py": "5c46949bbd8cf8675715f95c051ea08d0a599ca6b96640a23d57591ce8d0459d", + "test/null/test_system_pci_scan_bus.py": "9521b479005df4520e68831b8aad592c354bfb0d1a0443543af4fe4bf07bec01", + "test/null/test_tensor.py": "f4c5f1647bed344e20072a6b5d91a34747c4c19bb498c60cf09aa5ae51b03fc0", + "test/null/test_tensor_io.py": "6878994400b6844a06b4f53d10bc4bc2eb7f0c013ab2f03e36c0a815baa1a53c", + "test/null/test_tensor_metadata.py": "b070ee0dcbaed85b264afe8d287c9830f4e9d6f8483da7952fb01baf47e7afa8", + "test/null/test_tensor_uop_mixin.py": "1cd9a02078c8d70d0bf182ecaa2150bfed28ff3401fe9c992e22e20cbb0d89ca", + "test/null/test_tensor_uop_representation.py": "ca2325ae7d2e64c846f01b8b25c3821f92cb8ddf34e85ae94adc6ef50886a297", + "test/null/test_tensor_variable.py": "10ade39debb6df9613cb0063c20bb11c75e8a96ef56c24a16b88134901119d06", + "test/null/test_tqdm.py": "1bce3ccd7668cb928c2176a548bcbbe0cb1161e15faaa79f165caff64ad2a9ed", + "test/null/test_transcendental.py": "5d09e8fd506e8715edb913f91bfc172bf525e1fe6bd5de43b445052b1611faa3", + "test/null/test_transcendental_helpers.py": "fb39ae805179efb52e9100467dff3e191acfbfb98d8c0dedb6ee25b49bd6c49e", + "test/null/test_uir_render.py": "98ebeb3eb65cd9ef741b3297b68321b46fd7074fc662347816965e33d94b2609", + "test/null/test_uop_graph.py": "161490b94b85540a01e0eefb09b7feef98602f54698dcf88513a876182736f99", + "test/null/test_uop_repr.py": "b18108b1f62375c4ddb65b84aa28fb3e4b6a2241a967781ff6355004084fa90b", + "test/null/test_uop_resolve.py": "548e85598e8d7a008da38ea4efde96a940fd84c56e4c68da756e37c2cea54744", + "test/null/test_uop_symbolic.py": "e043eea8b6add4131210f58790368717a776a2eaacb90f869a460880ac09b315", + "test/null/test_uop_vmin_vmax.py": "b7221870e7c3fe4fdeea336a2cc590f4288caf8a6a890f3fba3fc167c8b4487f", + "test/null/test_uops.py": "b9d9f8f87a63f3083daf951c038659eee93023db141b595c5fd207d1e25c57ff", + "test/null/test_uops_stats.py": "f454d4dda3d4891a06952fad579fa6cc87af09c7a6838e6837a35857ef67bfdf", + "test/null/test_upat_compile.py": "00dce566e701c6db4881baa89df7d3caebc1354670e78ab002ebdbcb5d8db435", + "test/null/test_validate_oob.py": "4a0f0347f3e550fba93645e5b158973e9e74eddc632dfe10318ae6d7bf1eb72b", + "test/null/test_viz.py": "49a8b74f0ee4c697a930cd400632df9ac573fafff2578982c1d471176049fa1a", + "test/null/test_winograd.py": "36616c26b4b89dada856e54774a48dcb93350bdd18efa7b9e0fcf277b60fc12e", + "test/runtime/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/runtime/test_after.py": "99cbe8a28f4eb577d90ba1a00e7d1d18ec123dad3762e506d91b5517e48075b9", + "test/runtime/test_allreduce.py": "464c82d889a973dcb1601f148147c16fb340fda08aeafe070334fbfe83a19edd", + "test/runtime/test_arange.py": "14736801e7b0c2ddef13b7c13fe21960633287ad4cfbe8e3da12eed9d7eb5c2b", + "test/runtime/test_asm_gemm.py": "259e811de1c70da50e31637d5600d6f0843c167ee5030bc05466c5891675e945", + "test/runtime/test_assign.py": "e05a0572c90ca49209540953c24c2c75193d25a9ffe6c922ef2dc68a3b36db10", + "test/runtime/test_attention.py": "9610c719a6c17a9e73b36cb8551aca73c89f96e454dc35941963395ddc49c177", + "test/runtime/test_buffer.py": "d5a02aebc7a48df11d9f1eacfd2b37c0679a9a34f1b8a976b60175426b5550a2", + "test/runtime/test_call.py": "6f3eb103f67167947b69582485575b82f9c435f9c69c6cabbd4ffe73be4b9cce", + "test/runtime/test_const_folding.py": "7de08efd81399251307ee0a581755f55d0787775eb8c7bdbaeb54d7498edede1", + "test/runtime/test_conv.py": "7c34d61ff500d957d3228565b7c0870c9f4e54333412633a4c65aee36a1a240c", + "test/runtime/test_custom_kernel.py": "1653b8d6a09fb00384c842d8d9cb9dd75ef20ac0c4d4704516074bf4ee741e71", + "test/runtime/test_disk_tensor.py": "8c9e42ebf0581efc6885af2ec3cc9c99f02649819625b0eef05b535dd62c9605", + "test/runtime/test_dtype.py": "2fc716d065737e246e46eef31ee5a83766d312a5d2c9e64d422301ea214e052f", + "test/runtime/test_dtype_alu.py": "085214cb67df041ecfe3325d6f5c26078f8157fc3bab26f99855c6b9d2aaced9", + "test/runtime/test_dtype_spec.py": "8ed73de0300cb0886687b4a693445cafe02805e3d4bc06092eb3b6b305e98188", + "test/runtime/test_dtype_weak.py": "48d06083f32870a2db7e3800eeac1f933b1da455ac3026aec2fe95d969ad8e21", + "test/runtime/test_edgecases.py": "eec85249cd7e9f6c85905677a4766cb057fc960db2caadf0131081d92eca73f5", + "test/runtime/test_flip.py": "c12982273483b8422ef2084c07ce73724bbaa9879b581ccfdee0ffb5750dcfc6", + "test/runtime/test_function.py": "ed4ddd0324b850433d730343b82436f63b1abce870984a5bd11c0a9c21dd273c", + "test/runtime/test_getitem_ops.py": "1a68c907e1405979c2bfd3ff64b65b53eba16bcc8e066b9bd5a8facf0eaa30ca", + "test/runtime/test_gguf.py": "5c42d6440b683aa913a6c3d320bd1202f52bb3c494de60f65711c17137408b32", + "test/runtime/test_gradient.py": "5c71d17c4c50d2d30788f6fd7a212874663a23dd5006605e1fd376725df6e8bd", + "test/runtime/test_hashing.py": "4b48864dff004344343539d96f54ad45b5afe93dd1f9bd538cd22a4f2323644b", + "test/runtime/test_hcq2.py": "8f418622ca8355dc113c5ce2f066951ef2b6bcae97d68b321b61d822e2dc9024", + "test/runtime/test_helpers.py": "cefd40f4a66d20ebdb35dbd8832ff4066525a37e73324c6c7527b2379df31cc1", + "test/runtime/test_indexing.py": "1b6d89d681c43ac5900ecb0e8a9d62c1c28efc240f90491f5ef23c71c52caac6", + "test/runtime/test_interop.py": "b839dc458b167c6d6c2ae99c602dcddba61543f59024f07d90f61beb2cdff27d", + "test/runtime/test_invalid_tensor.py": "09963c09363133d5ee0a939589a29eaeaa6d133b729c1b13b0557c01483e351d", + "test/runtime/test_jit.py": "b19e4e69f8a6ebb613afba7520cd79f79524d91059a519e6f0bd30bdfd8d57c4", + "test/runtime/test_jit_cases.py": "eae73dc94f293f240fc6210738c95a3f092205dbebeafc2034f0d7e1438f7a7e", + "test/runtime/test_jit_footguns.py": "3ea266631478d2a1d58765c72ef0402d842de7cb943ede17af78fdf50b5841b2", + "test/runtime/test_kernel_opts.py": "355a46b04a1176393decdeede927d3507d3a5a219659d2f30dbd5438e41e934c", + "test/runtime/test_linalg.py": "7a1c9e0885f27d204d7dc7cb263a16be0e9d7c5f00c7dec8a569ca8e79dd1b9d", + "test/runtime/test_linearizer.py": "1fa19b511b3dafdb4781862ba0c4bfcd585501748c0bb87317e9fe9b8f85e239", + "test/runtime/test_linearizer_dumb.py": "5aa85c0d7db11450c4600880913962afe19e889d626b8d09fae6148ef9b269e0", + "test/runtime/test_llama_kernels.py": "89fc03a39058c929303b12c9545e7b6ca09dfd7e05b23380e0e1da9bc1107b02", + "test/runtime/test_llm_mla.py": "b49e71ca446cf4d54ddc0538ede9ebe4512ff2edb71cdb04312f3a0ee3b8c535", + "test/runtime/test_llm_moe.py": "7a1e7f25b8fbaf98c36e871d2cacaaf2e51cfb6d4546ee8ab9dd287d3e80cb0d", + "test/runtime/test_llm_quantized.py": "c9604828b63320d28b1898ed754048d674998ffe2eb35d6435f2c64b1f580d9b", + "test/runtime/test_llm_server.py": "de8c10086c4db2bf39ba74d4ed799c053bff84885fe118b7925e7713e7e075f7", + "test/runtime/test_llm_tp.py": "65b66cdb66d12e1dedff22b866b3a7db9f2e55368e59dfbb98fac04f2adab36a", + "test/runtime/test_masked_tensor.py": "e1cb90fdc322cdddecd19efcbe58932086667d26e1f9be795457a4d4a9aee585", + "test/runtime/test_multitensor.py": "bdf3a7847e6ffcf7dae02fd533854f15804f94204bd97dbf01278a6793418038", + "test/runtime/test_nn.py": "2d69c3da12dfc9413365c9407c845a2eaf2ae88c72338944e67e52a13cd710f6", + "test/runtime/test_ops.py": "361d04881a0bd9b8fe83e7b602bacee597aab18cc7f8f1c84a8badd2281a3247", + "test/runtime/test_opt_gemm.py": "b78dbfe82fcf9846ed5c9612b10130f54cd52b4fb67ec5feec94d4b01990889c", + "test/runtime/test_optim.py": "1b6a8537c1c826ee5500cca1134a6a4a61dc302b2a3440393d64fc163370faa6", + "test/runtime/test_pickle.py": "748003af81a447d61e585acba88c5f9705ce85a786f5cddc9cb967f18b9ed83e", + "test/runtime/test_profiler.py": "7f432807298a592905dbd85b49ca5e86bc4774c913b3ca491501d02ec40fd923", + "test/runtime/test_randomness.py": "350f01ea7f7322ad69f2b2bed7bd84304114bde1cf6d09b6e3214861adf89a72", + "test/runtime/test_rangeify.py": "b109a697c22b416587dd9eced748d9decd85c8610308009fca9392da2d299590", + "test/runtime/test_realize_is_realize.py": "9ada9141538d1afa912636c2db9ea741caac6bb196323480a0edb96f40c19b2f", + "test/runtime/test_rearrange_einops.py": "ede6e91cd70ae5dc60abeb437bb3ddbcb12fde9b5ff3da94ba48d9d9bca5cf02", + "test/runtime/test_renderer_failures.py": "867fb548102344d54fef53e7a2210466e7f27e77bb63b9939d7a02a3ffcd6776", + "test/runtime/test_schedule.py": "2c4349f52b28c15ca049dbef07da19c2f1a3abf59fed49cb731dadeea48669fa", + "test/runtime/test_schedule_cache.py": "58143570918db396120ef0a4516f9355cc868b99b2631a75815bd8c950745c2f", + "test/runtime/test_search.py": "a744b20037ad4dae5902690e88e22cde846b73df9ee79bcf4e4cb7e5f9077cdc", + "test/runtime/test_setitem.py": "773a84ef84215217a4961dcd4f9b2e9ba5af50ba1ddd44bee4f75efeae9a8735", + "test/runtime/test_setitem_schedule.py": "f6ec21ec5a740818351c5c928e47492ad2ccb1c4b1c1c7d0e6048f9e8545df06", + "test/runtime/test_shm_tensor.py": "e6fbe1db8f9043ffbddcea47c3121e7ac6d70e1d618f4e1f7cd79ae75d1d1c71", + "test/runtime/test_softmax_fusion.py": "63f29b35bc87c92b201a579269c1febd05edf8b441d519c2808610e7f2cbd8ac", + "test/runtime/test_stunning.py": "28e25e3f0b9877ec08340e3f14886dfe7f544d013741bebb334c05b986307250", + "test/runtime/test_subbuffer.py": "559a843cac9fdb331fb02c5d978942b5707a2fee39a6c8aeb91cdae2597bd5e2", + "test/runtime/test_symbolic_jit.py": "1b9dcc03084624ca514dbc2ac55836601b1d08b01cba9f876d83c3495a165b2a", + "test/runtime/test_symbolic_ops.py": "b75c30b8f12fbc35582fd050f89fc3384c20c3bad92442dfdbade5d00c101d91", + "test/runtime/test_symbolic_tensor.py": "01aff857a74959ca2236bdd5a86f7ceb9a63156c5071a0efd116351bbf1f8774", + "test/runtime/test_tar.py": "c1a0737e087f4ef42f52ce09f2a1ac338ecc4bfe39a7756584ee3ad11b28a275", + "test/runtime/test_tensor.py": "c4a57c6fcc3ced3ef291a19d4cc7771026cd6140aa1fd975a3cd1ecaafbe0175", + "test/runtime/test_tensor_cores.py": "22513b59836f302d88b3ec51eb08c00c00eeb31117277501c19da25a85ee613b", + "test/runtime/test_tensor_data.py": "14ceda9958f7662794e9e3af98c05a85e97d64e704322054591e63a5cdc314b7", + "test/runtime/test_tensor_io.py": "a7a6a58d0d81148823ababcfafbbbebf948aa0194d0637fa14558d3590b4fc27", + "test/runtime/test_tensor_variable.py": "a147aeb964573674f8af37c668f888c7f2fa0fb9f7ebcb1ba8f877c96003ed77", + "test/runtime/test_to_numpy.py": "4ecb4a92c73841e39d729fe8330499d6e74fa08e383c6c5813a1f2e80635a407", + "test/runtime/test_transcendental.py": "5f56407c2519a3cc7ea6c58a48495444498929bf31e5eeb6031c78a8535298cf", + "test/runtime/test_uops.py": "1fca3bcb515dd70984180da6ba81e1917e6014cb722671458a619ee0699cd1b2", + "test/runtime/test_validate_with_cpu.py": "14045b851a28bfb205e40a2e8eedc2a3656e61b88919806d67607d98beaefdc6", + "test/runtime/test_wait_loop.py": "1c89c80f8815eceace27cc965462c71b5a731b4d002dda4855ec6a1e481b70a2", + "test/runtime/test_winograd.py": "19fc1286d502d23c06bd469410a4993bdb80bbd56de063719720a024af5a7f7a", + "test/runtime/test_zero_copy.py": "131ad34091238872c495c72a03f392985b32ded830405a824d1199cdb389b488", + "test/speed/external_test_copy_speed.py": "f91d0dca25ac0ea39ddc3266302649ce52a839a9d61bc78bb431a7933c59f250", + "test/speed/external_test_device_speed.py": "39aaf2165c6eb07597beac80dc2cc8352596d510dd3b750a2842981bf606f3a7", + "test/speed/external_test_specific_conv.py": "bfe82e5703b1bd61b7b8ccc5b00dbefadbeffa0382459bdb22995c76dde9c2c9", + "test/speed/external_test_speed_v_torch.py": "94ae9a19adc23e53af959c7b01db698e105b57483bb065446e42a06f5053ea95", + "test/test_tiny.py": "c16067ed13ef7f4cbc1540f28b958e9542160b8b858151a87176b9c7b052e65d", + "test/testextra/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "test/testextra/test_bench_log.py": "0509b37f24c981dc772676176df5bd8a5c30361c80e83f0d18522e19fd25f245", + "test/testextra/test_export_model.py": "e6a3188c30775345f48f40877a61e49a6e476de07dc08323dfc09d5f0f55313b", + "test/testextra/test_f16_decompress.py": "694df4d0aef28d3736ca3d6bc68f2cd293dad9f7bd903047b723fa14bdd317a2", + "test/testextra/test_fp8_linear.py": "22c4612c9b9c4bdf5af8c348c85f129999eba785105f4bf3a36b6941af16e702", + "test/testextra/test_hevc.py": "1f43058d81e754cbdfe316af07ebfac2130ac1de722fddc126918cf294c10a14", + "test/testextra/test_hk_fa.py": "315337f3224eb211fa30d96e94f12330648581933c70d4000fe948922806d207", + "test/testextra/test_lr_scheduler.py": "936624ac1c8dc6fb046d4c20a38b09f579fb8db11fd1c75eb44e4ef6fe4e5b3e", + "test/testextra/test_mockgpu.py": "e51efb581ba14368f79126d7f4da785e8125e82c33403913ad238ca6d829c8f5", + "test/testextra/test_tk.py": "c170f357ab1b37e89057dabd2bb080e40235bb6aa8f8f8431d801290f83cd312", + "test/web/test_webgpu.js": "c54b8e22a6c5e13dd573c21627f01e7093ace813c4e4769bc67ee9aa93108afa", + "tinygrad/__init__.py": "fc24d5d0df1b1a14bbee0bd2641a61ca5f34ec7d83f1b0b755adf6eb83d5c0be", + "tinygrad/codegen/__init__.py": "1e833687cc6373f8de7fcebbfbf53db052161aad7a0b918d63da51ea2a8eedcf", + "tinygrad/codegen/decomp/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/codegen/decomp/dtype.py": "11f48505babdb86bea309278927886ff08e6eddf9bf948d7d2197cdab8efbdfa", + "tinygrad/codegen/decomp/op.py": "2d5ff52711a92c45f8814056d799da3c0aade9498822cc5cdee2a83dc3276ae1", + "tinygrad/codegen/decomp/transcendental.py": "1d737c265c9f96b8f09d82b85eb660dbb91b558a5af88512075c5a20540d00c5", + "tinygrad/codegen/gpudims.py": "15d368b1a45c237c8d3ea0b28af5f3b80fa49dbe73694bd8b315d835c4335ae5", + "tinygrad/codegen/late/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/codegen/late/coalesce.py": "36d59f15f202ae20444cd76795e0068b79f4158833e691da3c0ac72848e0d475", + "tinygrad/codegen/late/gater.py": "c194d9ffe8d022e62894367d4c0ce0fdf57ff02f34f128efcdac3072334275b9", + "tinygrad/codegen/late/linearizer.py": "9c1d7ae56a0381bdb4fd1340fe32eee77ad66617b06a215b8c4c46bf3f97fbe8", + "tinygrad/codegen/late/regalloc.py": "e120e26baee8021becfd716e39cb85dc0f5c5992bd30d5a50e48e7a0f528c9e5", + "tinygrad/codegen/opt/__init__.py": "6bddcc6a2052b1a39e9a421731275524fa6f0f861abfdefeafae5403747f8778", + "tinygrad/codegen/opt/heuristic.py": "029537ca82fadbbc34c9780fee3853466eb5a157a51b7c43dd45a94b3cde2a89", + "tinygrad/codegen/opt/postrange.py": "0bc039e6ad1016841e9fc5e9b1e5594b9a91f094d16097b79cbde517131fc9b7", + "tinygrad/codegen/opt/search.py": "670111d23c6360c6bd57f473a0e8877fe9b6615455aa27473f52c6bb99ef81b7", + "tinygrad/codegen/simplify.py": "a05ecef8e0f13d104516be51e4289653b00ca3104893000ed09a3b9b639a629f", + "tinygrad/device.py": "cc4bba6d295117780532708c4dfae0356c28e1e72adcf8bfaf92e2e9ee966b09", + "tinygrad/dtype.py": "7800592dcccbdd5a5beaee889342b5f62790d37445938fe601416c8b76057926", + "tinygrad/engine/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/engine/jit.py": "021d324e8672cdcd73f3186e4a5e66680dab5877220f223aad97323655b2efe7", + "tinygrad/engine/realize.py": "c71a72c19b99cc45a8cc6356f691fd1f33af82c3878f09879a8edc1a74fdcb34", + "tinygrad/engine/worker.py": "b9d47164d0b2fa09f4f396efcfd856b8ebe93a4e446ff683692ea9d605bb017d", + "tinygrad/function.py": "0749f1a4a71c5abfd193f44c6defa36afd8bdb1163befeaca201d845fa19cc27", + "tinygrad/helpers.py": "7d1e21f3a210aa15fb16977bf1933ae8dc89cd656fc3a09463312257a0cde51e", + "tinygrad/llm/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/llm/__main__.py": "2b2aeb15c8e098d5268709723bf52e22845634a68075e5904a474ec01f4165f0", + "tinygrad/llm/chat.html": "be5098c66dedd9fe3e225fa78e75e757120b09b225313c104f3ff935e03dae13", + "tinygrad/llm/cli.py": "7d899c487ba7d07eff0c0589339acb6519ce6a90798c1d4af51d5ab19f6b6f87", + "tinygrad/llm/gguf.py": "6a5dbd089e0e71e3949b83eacefa2aefcefd15146123ab4e9779ba8104077fa2", + "tinygrad/llm/kernels/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/llm/kernels/amd.py": "05a05aa63391251eea4b8c2dfcc1c56718bdecb712ad9041e56ab84a31edd92c", + "tinygrad/llm/model.py": "78f235aff13d3bdd7b2db47416abb7f0600f5ccaa234a74c8ce9ed2fb2680e90", + "tinygrad/llm/serve.py": "4750c7971d126c91c776886b03f2dbf47815317907d7c05d418388f371e16c00", + "tinygrad/mixin/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/mixin/creation.py": "4099d41e065e5638f8bb17f6c016ec6b286bac52e5ca6c9a86b89d73cbebbebb", + "tinygrad/mixin/dtype.py": "99027a5281c17bfbd572f12a090bf0d31db36bd239202606c1d3d6237486ec64", + "tinygrad/mixin/elementwise.py": "951d9d8a83e5cd3ae5a26571d685f2cef44fa8b41b1e4c3e028f1bf4d31076de", + "tinygrad/mixin/gradient.py": "c88b1b5557ab5edb450ed0f7e10bd2adebfcfb572f9977446fa04c2f39cc58d6", + "tinygrad/mixin/movement.py": "e6412a4f11b8dadb72cab73b260405c0b39389979e4786f0d981be321f121a50", + "tinygrad/mixin/op.py": "c09ecfca6522014dbd7b5ac1faae8c85fdc936484cd95084ac41a3ef135e82c7", + "tinygrad/mixin/rand.py": "19623f666365a318b6730123dd0fad27469ced754740415b86563ce0857c0363", + "tinygrad/mixin/reduce.py": "6981c71968b41ee79e8e97dfdc89db4b62216fd508707b57dfa0cd42b414e79e", + "tinygrad/nn/__init__.py": "992c14aec20683a93469d289d5817d1a023f0e3f39ddd5b93181dc8ef5b0691e", + "tinygrad/nn/datasets.py": "bc5ff2d74e07452c4f82afc5d6f7e2656978e189cb64689a1e8a1670825dff67", + "tinygrad/nn/onnx.py": "035ed57be17c2f72529b23e8b062dd23239cca7cc21a9482bafe06ba129cefdf", + "tinygrad/nn/optim.py": "981bdfa9de9baf3b82f7e80f5c32bab954c56d4f8ef902bf9940770e783dee4b", + "tinygrad/nn/state.py": "8b709853bca9edf31b99eb7e76c756968cb9bf521747f7dc50a86110ff974e6b", + "tinygrad/nn/torch.py": "377d20ff02d4c70e112830be326c8ad9a188cb490c9d15ca7d4bcffc0820d4ca", + "tinygrad/py.typed": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/renderer/__init__.py": "07ef1364283731710fb0e521e022bcc836c2fdae499bcbf51710b19bbfa8bb11", + "tinygrad/renderer/amd/__init__.py": "daa2583cf98a69bf59aa3f842bacb704598445fb23b9166bebc3adb9a9b7112f", + "tinygrad/renderer/amd/dsl.py": "dd45cbdf0d63570742eb54a21ef09266eaed95b8f3708de5363ef1c64d86606f", + "tinygrad/renderer/amd/elf.py": "faa631ce5f4d71fae646fa4e44b7ef6012f08b9738ba45691b9d901dcfbe77fc", + "tinygrad/renderer/amd/generate.py": "2bbf3599176b8dc500b253a97714977e443b7397063e38a775bcc9bd1c709824", + "tinygrad/renderer/amd/sqtt.py": "1bb1807a141e2bf5446af8b092e65520ddb775ff08af272271fb22b02362e49b", + "tinygrad/renderer/cstyle.py": "2037f03ff227eb56c3a2a0f2dd6406d1c765b01c2eaa30ddc0bf948806eb8a5d", + "tinygrad/renderer/isa/__init__.py": "585b453de58ad3a9a9f6a3ac24512f5d2bf7f62a7bdf00c704236ccf01ac79dd", + "tinygrad/renderer/isa/x86.py": "5c284adc391d71f1da888848c49504a2053a78c3d6bf0384d6412debe0c8dbeb", + "tinygrad/renderer/llvmir.py": "c04479a4ef47a3afa3ca1ad70fb5989e40f94b3dc8b35d4fd77941bbbc635828", + "tinygrad/renderer/nir.py": "a3d8186dcb5b6df0ef3c8aaaee3361b6d9433fe35a6b46d4a4aa0dc1193f05a7", + "tinygrad/renderer/ptx.py": "906bd04176ef07274e0fc9d9bf99bc86bb8d8bc9674a3099aee2eceff3d3d3e0", + "tinygrad/renderer/tc.py": "f8836d7fa6dee7f0f84f6adf29c192a29ffae62ca40e0372f74b128cde4e6654", + "tinygrad/renderer/wgsl.py": "8a5f1823834fef671a28822e21775912393f8b718b0b8e3ff7e319d9a926ef8d", + "tinygrad/runtime/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/runtime/autogen/__init__.py": "1817c514419ba743e54eaf29cf4c2ff1677c90fcc0c0a23789064aa66444d961", + "tinygrad/runtime/autogen/am/__init__.py": "fb2a32843680df3df2ebef7692b0ce5aa4f8ce5da778c6abe456160c0112de74", + "tinygrad/runtime/autogen/am/am.py": "075d9d29b885c546897143ade1b18f36d4a4450d1fb1d899d2df8f08aa5853e1", + "tinygrad/runtime/autogen/am/fw.py": "c60f58eb1ee6d61cee3817c5af23ef1fdb8c9ac9d4353d07972114cef09c7c02", + "tinygrad/runtime/autogen/am/navi_offsets.py": "9080f1a21706918dc9392709804115aa60201c8865ac86ef2b49252a2441c7cf", + "tinygrad/runtime/autogen/am/pm4_nv.py": "9bb32046114fd7ddbb976cc25bd5300bad08298b87682539a1a3e860954aad16", + "tinygrad/runtime/autogen/am/pm4_soc15.py": "f1ace5672c822d7a728f72b376a4ee5842aa4805944ea5f24dc8289dd341fac8", + "tinygrad/runtime/autogen/am/pmc.py": "b65aa28d165f88fd1f17c965e48e5fcbeb7f33bb3da4cba498b819f648ea8b3e", + "tinygrad/runtime/autogen/am/regs.py": "81d38816611a1e086e21feca4c2e021174decab385650405e520457aacbfd10f", + "tinygrad/runtime/autogen/am/sdma_4_0_0.py": "e2538620e5e73b0a745ce2ba0284c709f158e2893dd478f98bbd86c04c50292b", + "tinygrad/runtime/autogen/am/sdma_5_0_0.py": "33e42eb0e8c9be08f698ce8dded66446ad600cf03f64179696556a69617ee5bd", + "tinygrad/runtime/autogen/am/sdma_6_0_0.py": "523636d23466359b244b9e5454a8d0a80a5bf8e67882a9238e571ee90d580e88", + "tinygrad/runtime/autogen/am/smu_13_0_0.py": "5a2254c980525c8d5c8acc15f56f2ae72520d510aa1c2499b4c2b3586570c125", + "tinygrad/runtime/autogen/am/smu_13_0_12.py": "0e558c4f37ef3608d5c0498c96b123bb3362ed0a093ce50acd7a0f2102342919", + "tinygrad/runtime/autogen/am/smu_13_0_6.py": "acd6efb5ad0b972a5553c53db400d1f806c1d37d97ee0a583d8e45947060183d", + "tinygrad/runtime/autogen/am/smu_14_0_2.py": "f1b5e7d9d10f0a4cfb28dad0b8afe42cd5a276206959bd525bb8e871888991d4", + "tinygrad/runtime/autogen/am/soc_11.py": "da4af42a9f6bd4e980cd7a8a2ae3fc34ada4995bb693506f65148ddd7f45ef6c", + "tinygrad/runtime/autogen/am/soc_12.py": "8e81635ccab1b30c312778ccd8804e6b5d4df81c0b391a1e9c7f1bb3375e7933", + "tinygrad/runtime/autogen/am/soc_9.py": "b5386d6f41ce2ec65e1f9de20bb4439eceedcccfebf0dbd269891367c7cd8d2d", + "tinygrad/runtime/autogen/am/vega_offsets.py": "aeedb84cc5ee439c578ab015f0a2c424d95faf3304965041fcb7b116cce2a1eb", + "tinygrad/runtime/autogen/amd/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/runtime/autogen/amd/cdna/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/runtime/autogen/amd/cdna/enum.py": "6273f0c16e079332c354b849f38268527f7bc99bf943a9e5e2831ec3f705eb4a", + "tinygrad/runtime/autogen/amd/cdna/ins.py": "d98fad08ef7bd7af6e1ce6459d6bc5f1f7e0f81c6be93561857049675255a3dd", + "tinygrad/runtime/autogen/amd/cdna/operands.py": "ae871116dbad3aa9644975ed0f1b6042c9d53d64078f01f6688c7d73ae01f381", + "tinygrad/runtime/autogen/amd/cdna/str_pcode.py": "e67649d19bb728278d97065a843518535a87126358710aa85f5a5cd61760fb1a", + "tinygrad/runtime/autogen/amd/common.py": "c05fa9bd4e9efb05483d29ddeefb5994ac21560e0d13b4cb18548a57177c7d44", + "tinygrad/runtime/autogen/amd/rdna3/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/runtime/autogen/amd/rdna3/enum.py": "4c495befe2c1f11f3b2f2820fbd0d3d9b3faf4d4969312ad757c6fa7569cc9dc", + "tinygrad/runtime/autogen/amd/rdna3/ins.py": "652a5df671664024650c5f5b6c2eddf7af0354a556e84473a3eb207bacfc4746", + "tinygrad/runtime/autogen/amd/rdna3/operands.py": "96fd869a40884dec0247633c49af6e80dffc375afdbf222eb70f6b7d04bcf806", + "tinygrad/runtime/autogen/amd/rdna3/str_pcode.py": "b7705c1430b06c5ce1a90ac625a515708ebe11c184068bf89746f3fd5466ae39", + "tinygrad/runtime/autogen/amd/rdna4/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/runtime/autogen/amd/rdna4/enum.py": "e7f785ef907c6ae1109baf9188a4b63b964e3137bf2f1328196b081396a71388", + "tinygrad/runtime/autogen/amd/rdna4/ins.py": "927770e3b602975581ca933998b8e8cd87e8fc9bb2213133835e0059a77c0a0b", + "tinygrad/runtime/autogen/amd/rdna4/operands.py": "5cca92ffc1d5f92ab3c31fbf73a8ba47d5d49dc3bdb52f257556b6ce6638d6a8", + "tinygrad/runtime/autogen/amd/rdna4/str_pcode.py": "b8a9001477cc9b6cfdf0b5dd8aec0bc2a49b073a6bcec0d0a811cc6fa67d3490", + "tinygrad/runtime/autogen/amd_gpu.py": "478e889f08e47ebf4410ea089602dd1cfe62718b92a5fe085d56ef11633ad8b6", + "tinygrad/runtime/autogen/amdgpu_drm.py": "c9e226465de3421c70f8986814244ce832b78b3b7643047823053e901f4a68ff", + "tinygrad/runtime/autogen/amdgpu_kd.py": "bbb71ab4ab4a69a8acf468222b8562ed6466c72eb3abb6df5186a78f320bd68a", + "tinygrad/runtime/autogen/avcodec.py": "b5dd616799a3ed4e69bf0a35b5d05c2c80759a24e6573ad68c849c0dfcc6af05", + "tinygrad/runtime/autogen/bnxt.py": "a2c0a2f1b9d85b04701fe1b6279ac3b50064ba5d712c1519443eb27cfe083a8c", + "tinygrad/runtime/autogen/comgr.py": "ed3f777f3841706da31d6b186f09e719bdc429d85d08b2c79b5db37e59f257ed", + "tinygrad/runtime/autogen/comgr_3.py": "8afed852b5fa28ec802a2de73bcc455ea966973058c63f41371bda444db9a62d", + "tinygrad/runtime/autogen/corefoundation.py": "56795809f590e21234877a256681371ee32d8cf5a597417e784988e31622087f", + "tinygrad/runtime/autogen/cuda.py": "fd9f44aa833d13fd9f163fbb74ff6eae4aceefaafece467ba57ce2220d043c73", + "tinygrad/runtime/autogen/ggml_common.py": "7edaed6afd77bd84459ebaab381c6998bb2e2788eb620a0f4c07b26242a8b891", + "tinygrad/runtime/autogen/hip.py": "d69dcb6f55bd4dcac2178065ebe462ad55fbed8acf17a8c3561e918fdf59aa77", + "tinygrad/runtime/autogen/hsa.py": "b8457e9fd6ce160d072af0e4ba1e1c34e443dd71cabd767c6511457a72f3d901", + "tinygrad/runtime/autogen/io_uring.py": "d8b1658c94ab9727973700f14fe40661eb87272bb9e40a02904563f304ca05ef", + "tinygrad/runtime/autogen/iokit.py": "d0033fb9bd4ecf4a796ac01e280d6fb3289614c8008d6e62b312d09894189162", + "tinygrad/runtime/autogen/kfd.py": "248a7e74aa98b54f5e9cac56bf7a2495e8f6994386705a3c6c19ab0c7c053197", + "tinygrad/runtime/autogen/kgsl.py": "9f050c287acacb79a4e6d15cd32eb12a137c556de9c18d77baaea80b2e8b070d", + "tinygrad/runtime/autogen/libc.py": "edc96d14bdacf6992407318faabdf20690ceedbb915084626e59d1514b26f04e", + "tinygrad/runtime/autogen/libclang.py": "01a44cb7778733772636a74c4b05f3b8122868b1d5c6d537524c2c99d8d464d8", + "tinygrad/runtime/autogen/libusb.py": "f234ee7c90cc4ac1c7d97724db665f2dba466580bc1205deab1a58de99992a6e", + "tinygrad/runtime/autogen/llvm.py": "4be40c8a580350bdbd3e7f4386d96c939eca4c5b8e4f1f89601e8a60ae5009a1", + "tinygrad/runtime/autogen/llvm_qcom.py": "a0032f4677216211f658b92e11fc7a1060d556133d8b5e9482c7554698f08ea6", + "tinygrad/runtime/autogen/mesa.py": "355cc3facb9c31ce6c808a850fa9e3962e9690cf759d776cb05c1da354b61df7", + "tinygrad/runtime/autogen/metal.py": "842e5f17ad86aef820af1c14409660cad373c0b7d2559d81dbe978cd028fdb99", + "tinygrad/runtime/autogen/mlx5.py": "7b1782a5ec4aed44cf849b3e574d15b85924390b24f9368cc17014ac4ffc1e99", + "tinygrad/runtime/autogen/nv.py": "261256ac4322e046ff2db28235ae2ca8f68df081af1ce1509b407e814194aed6", + "tinygrad/runtime/autogen/nv_570.py": "411e74f3a283d3f4bed0294fb6a54a34ddf6fe624a3db8ec58df97ab66909abf", + "tinygrad/runtime/autogen/nv_580.py": "57157c789576e3107e187bc26242bbaf34b4cfc1a8f67245a8e587e984cd692c", + "tinygrad/runtime/autogen/nv_610.py": "9615048a5619c64fbb95ce61b1bea809ca42f1d301366f77a55a813d1047b41c", + "tinygrad/runtime/autogen/nv_regs/__init__.py": "cc89dd8a3df44879f7013b61d9d741df9bd77d50a292c6ef81ab5130c66cc8a3", + "tinygrad/runtime/autogen/nv_regs/dev_bus.py": "7ba8a3407e27a809be0504d285991c7a1aef1826d9e689b3aa59bb80aae65e6e", + "tinygrad/runtime/autogen/nv_regs/dev_falcon_second_pri.py": "391295f032d2c0fbe905d236e52a6e018f9438d2bdd76282d57f0eca5d2bfc0d", + "tinygrad/runtime/autogen/nv_regs/dev_falcon_v4.py": "6b3c9aedf59a7a37ba67d9b5b77f77cd5cadaac1b82040b0926e9acf1dedcee9", + "tinygrad/runtime/autogen/nv_regs/dev_fb.py": "6cbeb46bc9577e576926fcc982fcc0b8fa31e10206d1615311075eb28b48fe41", + "tinygrad/runtime/autogen/nv_regs/dev_fbif_v4.py": "8d2c87027939226d3a910157d41e660427774c3b11a17bd25c0ed1b2a9651c23", + "tinygrad/runtime/autogen/nv_regs/dev_fsp_pri.py": "f461181260b8e072b8df132322b03960058ce435d6da71c169153ace417edd1a", + "tinygrad/runtime/autogen/nv_regs/dev_gc6_island.py": "16329261e64d0f54104b062155166378319885968a7ff9ae9c2b47979b15f14f", + "tinygrad/runtime/autogen/nv_regs/dev_gsp.py": "8425f6b358af1acdf4dbb5549429feb05f95f649d451bccd6dc44eadd4674bc8", + "tinygrad/runtime/autogen/nv_regs/dev_mmu.py": "d36ae887aa8026067486e2f3fea295ca1f17c9e7867f2842d4cedea1bbf46355", + "tinygrad/runtime/autogen/nv_regs/dev_riscv_pri.py": "bb48da8a9f2f5b92a2aede932076709a4f2ae7266f895c77386b8aa373ab9207", + "tinygrad/runtime/autogen/nv_regs/dev_sec_pri.py": "ad4e6690236365ab4edad12c15d49a8a55f787a9ceecdd96d47794e25979808c", + "tinygrad/runtime/autogen/nv_regs/dev_therm.py": "af124c35f2ede3c96477d405b588dff2689bbd15fb5e7f1fdb40c7d2e8bdb10a", + "tinygrad/runtime/autogen/nv_regs/dev_vm.py": "724a62f3a9b748c63fbe5d04f3ed19cc9ffc2f3e29a8f9f4a9dca37e61887a7b", + "tinygrad/runtime/autogen/nv_regs/nv_ref.py": "7486129fa0586428ed6570add35d49db5f9edc4cda83457a5094b58066ba55ef", + "tinygrad/runtime/autogen/nvjitlink.py": "272066e86e6d51d0a064e711f22c5baa6fd065a09b640da789d60a3cac2f56d7", + "tinygrad/runtime/autogen/nvrtc.py": "26c305997b4f63950e8b0712d9f3cd513dc92b1753595e63235e035b7597592b", + "tinygrad/runtime/autogen/opencl.py": "e0da74f9804788dbb88724d5ce1e0f26c027ea4125039d62c08ad98c1f074c9a", + "tinygrad/runtime/autogen/pci.py": "baceb6b8c4e45429c8dc3b7eff17259aaed30d30d6ea50935ce28d69534d8bac", + "tinygrad/runtime/autogen/qcom_dsp.py": "4838000bcc679270d8beee74bb06d6dcd7d1a52faea0dd3d8c84f7acc160a87f", + "tinygrad/runtime/autogen/rocprof.py": "b7561632d83083620e34fc14472f5c4f1e30878eb8c856df1bf74a764a317c73", + "tinygrad/runtime/autogen/sqtt.py": "9f47e053dacbfe732d653db926a3957dd65c33b879b02d809b38baa8eaad98c3", + "tinygrad/runtime/autogen/vfio.py": "c501177743326af85725911c225ebe7dbc50f56e8882913ae22ad2d50fa33c27", + "tinygrad/runtime/autogen/webgpu.py": "b72c937e90c5ec53aae47d50e233f37ca97e7805507da0306d86abd39c643548", + "tinygrad/runtime/ops_amd.py": "2fec2d6f0bc1bd47bc00c7ff91f393c5248ddffb1e3b056ac727df035f284409", + "tinygrad/runtime/ops_cl.py": "6ed7a8a1fc57b3b355282b7bc7e54df67330f45454381d0fa1b8b68ab4ad6753", + "tinygrad/runtime/ops_cpu.py": "e202c0eb1e7d950f647e67229b3ff2555cd8898ac09227c6c5b8b7b2391db455", + "tinygrad/runtime/ops_cuda.py": "3ca26e0faa894a58003fcc8748d59adc3951686ad9c47ebfd45614f91a33dce1", + "tinygrad/runtime/ops_disk.py": "ea17f7ade702d5d62ec0c2c824e2f5af9fb7d86a3fc69d5557b72cb2c538432f", + "tinygrad/runtime/ops_dsp.py": "d64db81f554dfb76dfa87c41833e0508540b766d4695f40a6602c234f771cd18", + "tinygrad/runtime/ops_hip.py": "ccb3740fd789621a5e597941e466cdf1897bd1f1bbd6ca98adaab403a3ac4fb4", + "tinygrad/runtime/ops_metal.py": "dd2c82707daf16625713243b57b7f64e0354cc246f6802374ee78614e3836389", + "tinygrad/runtime/ops_npy.py": "53de851f9d707e6fceb871914b812c138cd5b1ebb669be02b55115c68266710c", + "tinygrad/runtime/ops_null.py": "47effc03074e3e2c36792686bfcb2ac2f534da4685889fa11eb379b9904f1190", + "tinygrad/runtime/ops_nv.py": "a4312fbc98fd5150d5363f5899642863cb67736b77e63b60b107f362e97262c2", + "tinygrad/runtime/ops_python.py": "0bd27a8ad0c3679313b1ed421d715622fc5a3075be53a72d2a7ae282fdf97f01", + "tinygrad/runtime/ops_qcom.py": "750b7befc18a482c769768faadf1e66bbea181b2c21f4072e2445ea3f5de05e3", + "tinygrad/runtime/ops_rdma.py": "0574fe3282b5faf1594b6ce4a0e547e03d818a8e66cd8b438fe629d9d8c90454", + "tinygrad/runtime/ops_webgpu.py": "94217f2e61e4fe9ac8452680907d91b0f0b3351173581aa9681cbb103a86b61a", + "tinygrad/runtime/support/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/runtime/support/am/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/runtime/support/am/amdev.py": "4b2dc513868aa7aaed32a3ee5d8aa13209e930acdf809ccb64134eea7050d4bb", + "tinygrad/runtime/support/am/ip.py": "1c68ec77b6d3e40feeb699a9f5929e7a470d4b7d0f736d45d94b53bc66f2d38f", + "tinygrad/runtime/support/am/startup_trace.py": "93eb3813e692f9ca84e7ef51eed7dedc95a7beafe746dbff73e2acb7600f9a42", + "tinygrad/runtime/support/amd.py": "3c888308b57f5f9b4922ffb008829610f6333a547c9fd9168f9f770fc6315c10", + "tinygrad/runtime/support/autogen.py": "3571a0c1e955e2c7173e3066a79040efb0f333e3302013f28e6d478ccdaf763c", + "tinygrad/runtime/support/c.py": "adc7d321647ed9e4a6d8eefa0cd1310b33c758b7b010be4e11d350a7d435adb6", + "tinygrad/runtime/support/compiler_amd.py": "230b53fbae926583d6a4a1fa4ea085773924e042496ed786aa8fbc2f8aa6ebec", + "tinygrad/runtime/support/compiler_cpu.py": "7980be156006d76fbc0e893154e7fb2900597d0c4d5171b4497a44d888d4fe48", + "tinygrad/runtime/support/compiler_cuda.py": "44e2eb882f867db26cb0a0c27716cc5c1000e4a7ea2401d3346d226573078bda", + "tinygrad/runtime/support/compiler_llvm.py": "4f4128c0cf88860e5445345139e81d360c7c4189912a67159d6822d2649735e5", + "tinygrad/runtime/support/compiler_mesa.py": "2301ed834ceea0798128e765fceff5231ec88851ca73b10a34e423952ae7eee0", + "tinygrad/runtime/support/compiler_qcom.py": "9c99f6e4c9e594e44c46846558e66f85d8ca700b73d371e0da54a997f72cfe34", + "tinygrad/runtime/support/compileserver.py": "f977fbab9038e6b895174f07c540fb26247137c63c989e373745433cd52157ec", + "tinygrad/runtime/support/elf.py": "155aaeb2cfdd748814150feafcb10c1ef34eb01cbd702bdbe5e0c9b03be3f388", + "tinygrad/runtime/support/hcq2.py": "dc392e0d9a38facc3002a73b8e9e942b403efb19cfa563dbc7d654bb439c00f3", + "tinygrad/runtime/support/memory.py": "5cd20a3b98a69caa855a7e660a0a53a64bd969fee282b853a5f68097977a5bcb", + "tinygrad/runtime/support/nv/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/runtime/support/nv/ip.py": "5ad88909badc5d30ab2527569d791b58ac28d56a8d9019f1e7c43eb764b4fe8a", + "tinygrad/runtime/support/nv/nvdev.py": "5329dffaa57b690eb516f0d33a219c552d92dcad3f2af8a5563bc8df2b51073b", + "tinygrad/runtime/support/objc.py": "c00586d4e58f14adeb899275ab215dbcb75b9c7a3e8d6210c001fd2941f4628b", + "tinygrad/runtime/support/rdma/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/runtime/support/rdma/bnxtdev.py": "c682c931db0c51c861ce7016a00d7aad5dc0e88bc8bef930bade4117910660f3", + "tinygrad/runtime/support/system.py": "ff90a058ac33ed2241aef2aafa6c24db2391eb5853dcd71d3f7a9316fe42ee2c", + "tinygrad/runtime/support/usb.py": "c235a5786e833a53ba4c5d5012a912e2ad83347b94372048da3829c22cd28965", + "tinygrad/schedule/__init__.py": "69bed42c074fa61ad864c69cdf569f723d80430541ac213eb395305128549f0a", + "tinygrad/schedule/allreduce.py": "d736bb1070049ad4c14e9354a66be534bb6ebdc53e75f80328f2ad4f846a8ea1", + "tinygrad/schedule/indexing.py": "1f416839ec6f8d296f3a0f8598da33f678f0b84560dacea4f8baa75a15e00a1c", + "tinygrad/schedule/memory.py": "24122dbab59fe1856939520e74fdb3828040ed7652fe897a3fac2d14f45785c6", + "tinygrad/schedule/multi.py": "5c88ce3832852af4a583d35bcb5ad6834eaf3d0366bf61e6b242ed6818cb72d0", + "tinygrad/schedule/prepare.py": "beaf12aacca39e39c9584c69b31c16f506946dca96406b0d5e0962e755225130", + "tinygrad/schedule/rangeify.py": "3bc1d12f7b377a8eb2dc60e741379e553991a049104d6948a91995415799102c", + "tinygrad/tensor.py": "0921dd1c06679046095a98a619089b3ea4c6ca2dd8a834ddb4af359214997f5e", + "tinygrad/uop/__init__.py": "22495f25f31b744f0362575fe42f2608a349d4642cba4a2d0a71150f234c7db3", + "tinygrad/uop/divandmod.py": "40c04f04dc9057eb17c9680304fb797ce78add201e394736f6558d4e145f075c", + "tinygrad/uop/movement.py": "7508947bf142145b2e2ec2234d21ac424cd801ef0acb18bd79a2292c886f7a09", + "tinygrad/uop/ops.py": "d22513c93f235d63f40c0e7d6af168d6e798828dbe64228d1ec130b9eadcd9ce", + "tinygrad/uop/render.py": "88d3a93436a1e82113217d1760cd2d1a69165c7cc671daf79215a06613ad9c62", + "tinygrad/uop/spec.py": "13a8e64ad12f24a4c3806b1bce8e3d04be4478e37d84d82b45ae860e776fd4c6", + "tinygrad/uop/symbolic.py": "779e39218360b51120dd0a52ca72e7466cc394370cf8a2c5d052cabb0920c0c2", + "tinygrad/uop/upat.py": "f89095353c93afb851b080aff975f861c070f87cc82aab90df481eade4e8c6bd", + "tinygrad/uop/validate.py": "9f0f248f17fb9d31e19e6537cc593d5e3e6a4ee41efc657338efc32dac7eef43", + "tinygrad/uop/weak.py": "856defae2c4afe2425cf5c58e2c3b2ef17ee63831c878dcdc298816721a3c97d", + "tinygrad/viz/README.md": "e500534e3884f1eb5a394673aeb10c188dd86877f35c1ffa553c943853018d2b", + "tinygrad/viz/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "tinygrad/viz/assets/cdn.jsdelivr.net/npm/markdown-it@15.0.1/dist/browser/markdown-it.umd.min.js": "f9f377ca892291fbe32904e77a00c6e27e8f95c14f435a54c8cb6859b3d97692", + "tinygrad/viz/assets/cdnjs.cloudflare.com/ajax/libs/highlight.js/11.10.0/highlight.min.js": "471ef9ae90c407af440fcdc48edfeeb562106b3267bd12d99071c162fb52ed32", + "tinygrad/viz/assets/cdnjs.cloudflare.com/ajax/libs/highlight.js/11.10.0/languages/cpp.min.js": "fcf9e657a60e1f6803a69470651646bf36f2b8b3aa7c85cf29c38eec3ff57573", + "tinygrad/viz/assets/cdnjs.cloudflare.com/ajax/libs/highlight.js/11.10.0/languages/python.min.js": "2c3dcc1fd2d8688bf399c4fee8c220fe9a09b4abd439d89f6d2cb2c767731a55", + "tinygrad/viz/assets/cdnjs.cloudflare.com/ajax/libs/highlight.js/11.10.0/languages/x86asm.min.js": "4ee03ea6c4f6e83b1dede7a9f6e7e89f84b2d2d8f434529bf9b6c088f31d934c", + "tinygrad/viz/assets/cdnjs.cloudflare.com/ajax/libs/highlight.js/11.10.0/styles/default.min.css": "fbde0ac0921d86c356c41532e7319c887a23bd1b8ff00060cab447249f03c7cf", + "tinygrad/viz/assets/d3js.org/d3.v7.min.js": "f2094bbf6141b359722c4fe454eb6c4b0f0e42cc10cc7af921fc158fceb86539", + "tinygrad/viz/assets/dagrejs.github.io/project/dagre/latest/dagre.min.js": "7c0a6aea0e7befb5e0c6ba1f0393faa4d6d708f9d765f0ec90af92463b691413", + "tinygrad/viz/assets/unpkg.com/@highlightjs/cdn-assets@11.10.0/styles/tokyo-night-dark.min.css": "3c24d046d2e1e02b9e8beb641f9dc639c76ff44ad89f0fbac9eab9062d55f51b", + "tinygrad/viz/cli.py": "997ee8b2c57f6f17a3773937432f7931591bdd081c98abfb29174ff5d0c91db9", + "tinygrad/viz/fetch_assets.sh": "c56f7d260c1096d1bfb9dd642ed5c6f949828f887a963aae837f9927e1e1231c", + "tinygrad/viz/index.html": "1bff678e3031001b529365f55f0eb0d4a727389a54fc19066679efbad8275e78", + "tinygrad/viz/js/index.js": "00f022e5f8a8f40c48ae8477abe7406da1043e99f1cdd9827a88a339e901033e", + "tinygrad/viz/js/worker.js": "9706fe6ff8119c7072f54824439c25e9d5ee3fcd4fc2a4b1f3136c01dd32e7ad", + "tinygrad/viz/serve.py": "b13395a4dc071c65a34f0f7a7932fd5e0a6eca6d4dc2d91b0fbd61db51b0f7e7" + } +} diff --git a/openpilot/starpilot/models/runtime_bridge/native.py b/openpilot/starpilot/models/runtime_bridge/native.py new file mode 100644 index 0000000000..91396eb831 --- /dev/null +++ b/openpilot/starpilot/models/runtime_bridge/native.py @@ -0,0 +1,281 @@ +"""Integrity gate and native02e loader; no tinygrad imports before prepare.""" +from contextlib import contextmanager +import atexit +import hashlib +import importlib +import json +import os +from pathlib import Path, PurePosixPath +import stat +import sys +import tempfile +from collections.abc import Callable +from typing import TYPE_CHECKING, Protocol, cast + +from openpilot.starpilot.models.runtime_selection import NATIVE_REVISION +from openpilot.starpilot.models.runtime_bridge.bootstrap import ( + IMPORT_FAMILIES, _check_source_package, _namespace, _private_cache, +) + +if TYPE_CHECKING: + from tinygrad.device import Buffer + + +class PersistentLoad(Protocol): + persistent_load: Callable[[tuple[int, int]], "Buffer"] + +# Deliberately unpublishable until native source/guard and model evidence is sealed. +POLICY_SHA256 = '6608a8280152a1b37c39370942a910c8f34180f4c0626f7ee73340b32a6b6c7e' +ROOT = Path(__file__).resolve().parents[4] +BRIDGE = Path(__file__).parent +_LIBRARIES = { + 'libbounded_wait.so': '24ed559861c8636c1026cad9a244854bb2236b5ee8b91bf21c5efbf688fa4a69', + 'libusb_guards.so': '66a3dfe48ac17899862ab80160cf6dac2c9b9707234527ba0d808f3b68404114', +} +_role = None +_allowed = {} +_protection = None + + +def _plain_file(path): + for parent in (*reversed(path.parents), path): + mode = parent.lstat().st_mode + if stat.S_ISLNK(mode): + raise ValueError('Symlink in native runtime input') + if not path.is_file(): + raise ValueError('Missing native runtime input') + + +def _digest(path): + _plain_file(path) + with path.open('rb') as stream: + return hashlib.file_digest(stream, 'sha256').hexdigest() + + +def _verify_policy(): + path = BRIDGE / 'native-policy.json' + _plain_file(path) + raw = path.read_bytes() + if hashlib.sha256(raw).hexdigest() != POLICY_SHA256: + raise RuntimeError('Native runtime policy is not qualified') + policy = json.loads(raw) + required = {'native_guards.py', 'bounded_wait.c', 'usb_guards.c', *_LIBRARIES} + if (policy.get('compiler_revision') != NATIVE_REVISION or policy.get('native_abi') != 'linux-aarch64-64bit' or + policy.get('host_runtime_dev') not in ('CPU:LLVM', 'CPU:CLANG') or + not isinstance(policy.get('files'), dict) or set(policy['files']) != required or + not isinstance(policy.get('vendor_files'), dict) or not policy['vendor_files']): + raise ValueError('Native runtime identity mismatch') + for name, expected in policy['files'].items(): + if _digest(BRIDGE / name) != expected or name in _LIBRARIES and expected != _LIBRARIES[name]: + raise ValueError('Native guard source/artifact changed') + if _digest(BRIDGE.parent / 'catalog-native02e.json') != policy.get('catalog_sha256'): + raise ValueError('Native stock release metadata changed') + vendor = ROOT / 'tinygrad_repo' + expected_files = policy['vendor_files'] + actual = set() + for directory, dirs, files in os.walk(vendor, followlinks=False): + dirs[:] = [name for name in dirs if name not in ('__pycache__', '.git')] + for name in dirs: + if (Path(directory) / name).is_symlink(): + raise ValueError('Symlink in native runtime source') + for name in files: + if name.endswith(('.pyc', '.pyo')): + raise ValueError('Standalone native vendor bytecode is not source-pinned') + if name == 'AGENTS.md': + continue + actual.add((Path(directory) / name).relative_to(vendor).as_posix()) + if actual != set(expected_files): + raise ValueError('Native vendor inventory changed') + for name, expected in expected_files.items(): + relative = PurePosixPath(name) + if relative.is_absolute() or '..' in relative.parts or '\\' in name or str(relative) != name: + raise ValueError('Invalid native vendor path') + if _digest(vendor / name) != expected: + raise ValueError('Native vendor source changed') + return policy + + +def _remove_empty_prefix(path): + try: + os.rmdir(path) + except OSError: + pass + + +def prepare(role, plan): + """Run before any tinygrad import; root seals policy after actual qualification.""" + global _role, _allowed + if role not in ('driving', 'monitoring') or role == 'driving' and (plan is None or plan.family != 'native02e'): + raise ValueError('Invalid native runtime role/plan') + if _role is not None: + raise RuntimeError('Native runtime was already selected') + if any(name == family or name.startswith(family + '.') for name in sys.modules for family in IMPORT_FAMILIES): + raise RuntimeError('Select native runtime before importing tinygrad') + policy = _verify_policy() + from openpilot.starpilot.models.manager import SHIPPED_MODELS, native_stock + stock = native_stock() + if role == 'monitoring': + allowed = {str(SHIPPED_MODELS / name): row for name, row in stock.items()} + else: + default = json.loads(plan.default_json) + entries = json.loads(plan.entries_json) + allowed = {default['path']: default} + small = entries.get(plan.small_id) + if small is not None and small.get('_runtime_family') == 'native02e': + allowed[small['_artifact_path']] = small + if plan.big_id: + row = entries[plan.big_id] + allowed[row['_artifact_path']] = row + cache = Path('/data/starpilot-model-runtime') / NATIVE_REVISION / role / POLICY_SHA256 + _private_cache(cache) + _private_cache(cache / 'xdg') + bytecode_prefix = Path(tempfile.mkdtemp(prefix='python-', dir=cache)) + _private_cache(bytecode_prefix) + if any(bytecode_prefix.iterdir()): + raise RuntimeError('Native bytecode prefix is not empty') + atexit.register(_remove_empty_prefix, bytecode_prefix) + tg_root = ROOT / 'tinygrad_repo' + sys.path[:0] = [str(ROOT), str(tg_root)] + sys.dont_write_bytecode = True + # A fresh private prefix isolates READS too; dont_write_bytecode alone does not. + sys.pycache_prefix = str(bytecode_prefix) + os.environ.pop('PYTHONPYCACHEPREFIX', None) + os.environ['HCQ_RUNTIME_DEV'] = policy['host_runtime_dev'] + os.environ.update(CACHEDB=str(cache / 'tinygrad.db'), XDG_CACHE_HOME=str(cache / 'xdg'), PYTHONDONTWRITEBYTECODE='1') + sys.modules['tinygrad_repo'] = _namespace('tinygrad_repo', tg_root) + sys.modules['extra'] = _namespace('extra', tg_root / 'extra') + importlib.invalidate_caches() + _check_source_package('tinygrad', tg_root / 'tinygrad/__init__.py') + _check_source_package('examples', tg_root / 'examples/__init__.py') + _role, _allowed = role, allowed + return {'role': role, 'family': 'native02e', 'compiler_revision': NATIVE_REVISION, + 'manifest_sha256': POLICY_SHA256, 'runtime_files': len(policy['vendor_files']), + 'tinygrad_origin': str(tg_root / 'tinygrad/__init__.py'), 'cache': str(cache)} + + +def _guard(): + global _protection + if _role is None: + raise RuntimeError('Native runtime is not prepared') + if _protection is None: + _verify_policy() + from openpilot.starpilot.models.runtime_bridge import native_guards + _protection = native_guards.install(_role, BRIDGE / 'libbounded_wait.so', BRIDGE / 'libusb_guards.so') + return _protection + + +@contextmanager +def _verified(path): + path = Path(path) + record = _allowed.get(str(path).removesuffix('.unchunked')) + if record is None: + raise ValueError('Artifact is outside the frozen native selection') + fd = os.open(path, os.O_RDONLY | os.O_NONBLOCK | os.O_NOFOLLOW | os.O_CLOEXEC) + with os.fdopen(fd, 'rb') as stream: + before = os.fstat(stream.fileno()) + def identity(value): + return value.st_dev, value.st_ino, value.st_size, value.st_mtime_ns, value.st_ctime_ns + if (not stat.S_ISREG(before.st_mode) or before.st_size != record['artifact_size'] or + hashlib.file_digest(stream, 'sha256').hexdigest() != record['artifact_sha256']): + raise ValueError('Native artifact identity mismatch') + stream.seek(0) + def unchanged(): + named = path.lstat() + if (not stat.S_ISREG(named.st_mode) or identity(before) != identity(os.fstat(stream.fileno())) or + identity(before) != identity(named)): + raise ValueError('Native artifact changed while loading') + unchanged() + yield stream, unchanged + unchanged() + + +def _load_driving(stream, unchanged): + import io + import mmap + import pickle + import struct + from tinygrad import Device + from tinygrad.device import Buffer, HCQ_RUNTIME_DEV + length_raw = stream.read(8) + if len(length_raw) != 8: + raise ValueError('Missing native OOB envelope') + length = struct.unpack('= 0), default=argument_count) + if not 0 <= slot <= argument_count or any(u.addrspace is not AddrSpace.ALU and u.arg.slot >= slot for u in params): + raise ValueError("Native host pointer/scalar parameter order changed") + return slot + + +def _shift_native_params(sink, first_slot, argument_count): + original = tuple(u for u in _nodes(sink) if u.op is Ops.PARAM) + moving = tuple(u for u in original if u.arg.slot >= first_slot) + if not moving: + return sink + # substitute recursively rewrites replacements. Disjoint temporary slots + # make both phases simultaneous; no original or final slot is a temp key. + temporary_start = max(argument_count, *(u.arg.slot for u in original)) + 2 + temporary = {u: u.replace(arg=replace(u.arg, slot=temporary_start + i)) for i, u in enumerate(moving)} + final = {temporary[u]: u.replace(arg=replace(u.arg, slot=u.arg.slot + 1)) for u in moving} + shifted = sink.substitute(temporary, enter_calls=True).substitute(final, enter_calls=True) + expected = {u.replace(arg=replace(u.arg, slot=u.arg.slot + 1)) if u in temporary else u for u in original} + actual = {u for u in _nodes(shifted) if u.op is Ops.PARAM} + if actual != expected or len(actual) != len(original): + raise ValueError("Native host parameter renaming lost an original binding") + return shifted + + +def _verify_cpu_parameter_abi(program): + # Clang emits PARAM declarations in the compiled LINEAR's order. CPUProgram + # invokes every globals pointer first, then every ProgramInfo.vars scalar. + linear = program.src[1] + if linear.op is not Ops.LINEAR: + raise ValueError("Native host has no compiled parameter declaration order") + params = tuple(u for u in linear.src if u.op is Ops.PARAM) + expected = (*program.arg.globals, *(u.arg.slot for u in program.arg.vars)) + if tuple(u.arg.slot for u in params) != expected: + raise ValueError("Native CPU parameter ABI is misordered") + boundary = len(program.arg.globals) + if (any(u.addrspace is AddrSpace.ALU for u in params[:boundary]) or + any(u.addrspace is not AddrSpace.ALU for u in params[boundary:])): + raise ValueError("Native CPU parameter ABI mixes pointers and scalars") + + +def _fresh_host(call): + if call.op is not Ops.CALL or not isinstance(call.arg.aux, hcq2.HCQInfo): + raise ValueError('Expected fresh actual 02e HCQ call') + if call.arg.aux.device not in (('QCOM',), ('AMD',)) or call.body.op is not Ops.SINK: + raise ValueError('Native guards must precede CPU compilation/outlining') + if call.body.arg is None or call.body.arg.name != 'hcq_submit': + raise ValueError('Unknown fresh CPU host source') + return call.body + + +class Protection: + def __init__(self, role, fence_library, usb_library): + if role not in ("driving", "monitoring"): + raise ValueError("Unknown native model role") + if HCQ_RUNTIME_DEV.device.split(":")[0] != "CPU": + raise ValueError("Native guard requires actual CPU helper target") + renderer = Device[HCQ_RUNTIME_DEV.device]._select_renderer(HCQ_RUNTIME_DEV) + if not isinstance(renderer, ClangRenderer): + raise ValueError("Native guard requires its qualified Clang host renderer") + self.role, self.renderer, self.records = role, renderer, [] + self.fence_library = _load_library(fence_library, FENCE_SHA256, "starpilot_native02e_fence", + ("starpilot_bounded_wait",)) + self.usb_library = None + self.ffi_buffer = None + self.ffi = None + if role == "driving": + self.usb_library = _load_library(usb_library, USB_SHA256, "starpilot_native02e_usb", + (*WRAPPERS.values(), "sp_loop_touch", "sp_loop_check")) + fields = {name: (typ, offset) for name, typ, offset, *_ in libusb.struct_libusb_transfer._real_fields_} + if any(fields[name][1] != offset or ctypes.sizeof(fields[name][0]) != 4 + for name, offset in (("status", 16), ("length", 20), ("actual_length", 24))): + raise ValueError("Unqualified native libusb transfer layout") + if ctypes.sizeof(ctypes.c_void_p) != 8 or ctypes.sizeof(ctypes.c_ulong) != 8: + raise ValueError("Unqualified native host ABI") + addresses = [ctypes.cast(getattr(libusb.dll, name), ctypes.c_void_p).value for name in FFI_NAMES] + if not all(addresses): + raise ValueError("Missing native libusb functions") + self.ffi_buffer = Buffer(HCQ_RUNTIME_DEV.device, len(addresses) * 8, + initial_value=b"".join(address.to_bytes(8, "little") for address in addresses)) + self.ffi = UOp.alloc((len(addresses),), dtypes.uint64, 0, device=HCQ_RUNTIME_DEV.device).rtag(FFI_TAG) + previous = Compiled.pm_bufferize + Compiled.pm_bufferize = previous + PatternMatcher([(UPat(Ops.ALLOC, tag=FFI_TAG, name="b"), _resolve_native_ffi)]) + self.identity = { + "format": FORMAT, "compiler_revision": REVISION, + "implementation_sha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + "fence_sha256": FENCE_SHA256, "usb_sha256": USB_SHA256, + "host_target": str(self.renderer.target), + } + + @staticmethod + def _native(name, args, dtype): + return UOp.custom_function(name, dtype=dtype).call(*args) + + def _compile(self, original, rewritten, args): + before = _payloads(_fresh_host(original)) + if _payloads(rewritten) != before: + raise ValueError("Opaque GPU payload changed before CPU compilation") + updated = original.replace(src=(rewritten, *args)) + if updated.device != HCQ_RUNTIME_DEV.device: + raise ValueError("Guard rewrite attempted non-CPU compilation") + compiled = realize.lower_and_compile(UOp(Ops.LINEAR, src=(updated,))).src[0] + program, sink = _host(compiled) + if program.arg.target != self.renderer.target or _payloads(sink) != before: + raise ValueError("CPU target or opaque GPU payload changed") + _verify_cpu_parameter_abi(program) + self._verify_call(compiled) + self.records.append(_proof(compiled)) + return compiled + + def _qcom(self, call, sink): + loops, replacements = _weak(sink), {} + if len(loops) != 1: + raise ValueError("Expected exactly one native QCOM fence") + loop = loops[0] + ends = [u for u in _nodes(sink) if u.op is Ops.BACKEDGE and u.src[1] is loop] + if len(ends) != 1: + raise ValueError("Unknown native QCOM loop boundary") + done, _, condition = ends[0].src + if done.op is not Ops.LOAD or done.dtype is not dtypes.uint64: + raise ValueError("Unknown native QCOM timeline load") + comparisons = [u for u in _nodes(condition) if u.op is Ops.CMPLT and u.src[0] is done] + timers = [u for u in _nodes(condition) if u.op is Ops.CMPLT and _constant(u.src[1], 30000)] + if len(comparisons) != 1 or len(timers) != 1: + raise ValueError("Unknown native QCOM deadline condition") + target = comparisons[0].src[1] + if target.dtype is not dtypes.uint64 or loop in target.ranges: + raise ValueError("Unknown native QCOM fence target") + index = done.src[0] + if index.op is not Ops.INDEX or len(index.src) != 2 or not _constant(index.src[1], 0): + raise ValueError("Unknown native QCOM signal address") + signal = index.src[0].without_after + arguments = realize.get_call_arg_uops(call) + if signal.op is not Ops.PARAM or not 0 <= signal.arg.slot < len(arguments): + raise ValueError("Native QCOM timeline is not an outer parameter") + outer = arguments[signal.arg.slot].without_after + if outer.op is not Ops.ALLOC or outer.tag != "timeline" or outer.device != "QCOM": + raise ValueError("Timeline is not the native QCOM allocation") + pointer = index.substitute({loop: UOp(Ops.NOOP)}, enter_calls=True) + replacements[ends[0]] = self._native("starpilot_bounded_wait", (pointer, target), dtypes.uint64) + rewritten = sink.substitute(replacements, enter_calls=True) + if _weak(rewritten): + raise ValueError("An unguarded QCOM polling range remains") + return self._compile(call, rewritten, call.src[1:]) + + def _usb(self, call, sink): + if self.role != "driving" or self.ffi is None or not Device["AMD"].is_usb: + raise ValueError("Expected the actual native USB AMD device") + return self._usb_rewrite(call, sink) + + def _usb_rewrite(self, call, sink): + args = list(call.src[1:]) + argument_count = len(realize.get_call_arg_uops(call)) + if any(not a.is_bound_var for a in args[argument_count:]) or any(a.is_bound_var for a in args[:argument_count]): + raise ValueError("Native bound-variable argument order changed") + ffi_slot = _native_ffi_slot(sink, argument_count) + sink = _shift_native_params(sink, ffi_slot, argument_count) + pointer = UOp.param(ffi_slot, dtypes.uint64, (len(FFI_NAMES),), HCQ_RUNTIME_DEV.device, name="native_usb_functions") + loops = _weak(sink) + if not 1 <= len(loops) < 256 or len({r.arg for r in loops}) != len(loops): + raise ValueError("Unknown native USB polling structure") + specifications, ends = {}, {} + for slot, loop in enumerate(loops): + boundaries = [u for u in _nodes(sink) if u.op is Ops.BACKEDGE and u.src[1] is loop] + if len(boundaries) != 1: + raise ValueError("Unknown native USB loop boundary") + end = boundaries[0] + condition, timeout = _polling_condition(end.src[2]) + specifications[loop] = (slot, timeout) + ends[end] = condition + calls = _calls(sink) + if any(_name(u) not in {*FFI_NAMES, "memcpy", "clock_gettime"} for u in calls): + raise ValueError("Unqualified native USB callback") + def scalar64(u): + return UOp(Ops.CUSTOMI, src=(u,), arg=("((unsigned long)({0}))", dtypes.uint64)) + substitutions, touched = {}, set() + for callback in calls: + name = _name(callback) + if name not in WRAPPERS: + continue + touches = [] + for loop, (slot, timeout) in specifications.items(): + token = next((a for a in callback.src[1:] if loop in a.ranges), None) + if token is not None: + touches.append(self._native("sp_loop_touch", ( + UOp.const(slot, dtypes.uint64), UOp.const(timeout, dtypes.uint64), scalar64(token)), dtypes.uint64)) + touched.add(loop) + marker = sum(touches[1:], touches[0]) if touches else UOp.const(0, dtypes.uint64) + function = pointer.index(FFI_NAMES.index(name)).load() + substitutions[callback] = self._native(WRAPPERS[name], ( + function, *(scalar64(a) for a in callback.src[1:]), marker), dtypes.int32) + if touched != set(specifications) or not substitutions: + raise ValueError("A native USB polling loop has no entry guard") + sink = sink.substitute(substitutions, enter_calls=True) + # Substitution can rebuild range identities; immutable unique range args + # are the previously checked stable lookup keys. + by_arg = {loop.arg: (slot, timeout) for loop, (slot, timeout) in specifications.items()} + expected_conditions = {end.src[1].arg: condition for end, condition in ends.items()} + replacements = {} + for end in _nodes(sink): + if end.op is Ops.BACKEDGE and end.src[1].arg in by_arg: + slot, _ = by_arg[end.src[1].arg] + condition = expected_conditions[end.src[1].arg].substitute(substitutions, enter_calls=True) + check = self._native("sp_loop_check", (condition.cast(dtypes.uint64), UOp.const(slot, dtypes.uint64)), dtypes.uint64) + replacements[end] = end.replace(src=(end.src[0], end.src[1], check.cast(dtypes.bool))) + if len(replacements) != len(loops): + raise ValueError("Native USB loop protection is incomplete") + rewritten = sink.substitute(replacements, enter_calls=True) + args.insert(ffi_slot, self.ffi) + if len(args) != len(call.src) or any(args[i + (i >= ffi_slot)] is not original for i, original in enumerate(call.src[1:])): + raise ValueError("Native host call argument insertion lost an original binding") + return self._compile(call, rewritten, args) + + def protect_call(self, call): + original = _fresh_host(call) + sink = inline_host_sink(original) + if _payloads(sink) != _payloads(original): + raise ValueError("Host scope binding changed opaque payloads") + if any(_name(u) in GUARD_NAMES for u in _calls(sink)): + raise ValueError("Refusing partial or repeated native protection") + return self._qcom(call, sink) if call.arg.aux.device == ("QCOM",) else self._usb(call, sink) + + def _verify_call(self, call): + program, sink = _host(call) + if program.arg.target != self.renderer.target: + raise ValueError("Native CPU target changed") + _verify_cpu_parameter_abi(program) + calls = _calls(sink) + if call.arg.aux.device == ("QCOM",): + if _weak(sink) or sum(_name(u) == "starpilot_bounded_wait" for u in calls) != 1: + raise ValueError("QCOM native guard proof missing") + else: + if self.role != "driving" or not Device["AMD"].is_usb: + raise ValueError("Native Chestnut identity missing") + if any(_name(u) in FFI_NAMES for u in calls): + raise ValueError("An unchecked native USB function remains") + weak = _weak(sink) + boundaries = [u for u in _nodes(sink) if u.op is Ops.BACKEDGE and u.src[1] in weak] + if not weak or len(boundaries) != len(weak): + raise ValueError("Native USB polling proof missing") + for end in boundaries: + cond = end.src[2] + if not _checked_poll_exit(cond): + raise ValueError("An unchecked native polling exit remains") + if not any(_name(u) == "sp_loop_touch" for u in calls): + raise ValueError("Native polling entry proof missing") + markers = [u for u in _nodes(UOp.sink(*call.src[1:])) if u.op is Ops.ALLOC and u.tag == FFI_TAG] + if len(markers) != 1 or markers[0].dtype is not dtypes.uint64 or markers[0].shape != (len(FFI_NAMES),): + raise ValueError("Fresh native function table marker missing") + return _proof(call) + + def _prepare(self, jit): + # The only preparation path is fresh HCQ re-encoding from authenticated + # pre-HCQ input. Stored outlined PROGRAMs are never reverse-inlined. + self._verify(jit) + return jit + + def _verify(self, jit): + cap = getattr(jit, "captured", None) + if cap is None or "linear" in cap.__dict__: + raise ValueError("Native guard verification must precede captured execution/linking") + for entry in cap._linear.src: + call = entry.without_after + if call.op is not Ops.CALL or not (call.body.op is Ops.STORE or isinstance(call.arg.aux, hcq2.HCQInfo)): + raise ValueError("Unknown native captured schedule entry") + calls = [u for u in _nodes(cap._linear) if u.op is Ops.CALL and isinstance(u.arg.aux, hcq2.HCQInfo)] + if not calls: + raise ValueError("Missing native guarded submission") + return [self._verify_call(call) for call in calls] + + @staticmethod + def _capture_items(artifact): + return [(key, value) for key, value in artifact.items() if getattr(value, "captured", None) is not None] + + def prepare_artifact(self, artifact, chestnut=False): + items = self._capture_items(artifact) + expected = 3 if self.role == "driving" else 1 + if len(items) != expected or "_starpilot_native_guard" in artifact: + raise ValueError("Unknown native artifact capture count or repeated preparation") + if self.role == "driving" and (artifact.get("execution_device") != ("AMD" if chestnut else "QCOM") or + artifact.get("warp_device") != "QCOM"): + raise ValueError("Native driving backend contract changed") + for _, jit in items: + self._prepare(jit) + artifact["_starpilot_native_guard"] = { + "identity": self.identity, + "captures": {repr(key): self._verify(jit) for key, jit in items}, + } + return artifact + + def artifact(self, artifact, chestnut=False): + items = self._capture_items(artifact) + expected = 3 if self.role == "driving" else 1 + if len(items) != expected: + raise ValueError("Unknown native artifact capture count") + proof = artifact.get("_starpilot_native_guard") + if not isinstance(proof, dict) or proof.get("identity") != self.identity: + raise ValueError("Native artifact guard identity changed or missing") + actual = {repr(key): self._verify(jit) for key, jit in items} + if actual != proof.get("captures"): + raise ValueError("Native compiled host proof changed") + if self.role == "driving" and (artifact.get("execution_device") != ("AMD" if chestnut else "QCOM") or + artifact.get("warp_device") != "QCOM"): + raise ValueError("Native driving backend contract changed") + return artifact + + def prepare_warp(self, jit): + return self._prepare(jit) + + def warp(self, jit): + # The loader must authenticate the complete known stock warp file first. + self._verify(jit) + return jit + + def install_fresh_guard(self): + original = hcq2.lower_and_compile + if original is not realize.lower_and_compile: + raise ValueError("Native host compiler was already replaced") + def guarded(linear, *args, **kwargs): + replacements = {} + for call in _nodes(linear): + if call.op is not Ops.CALL or not isinstance(call.arg.aux, hcq2.HCQInfo): + continue + if call.body.op is Ops.SINK: + replacements[call] = self.protect_call(call) + elif call.body.op is Ops.PROGRAM: + self._verify_call(call) + else: + raise ValueError("Unknown fresh native host body") + prepared = linear.substitute(replacements, enter_calls=True) + for call in _nodes(prepared): + if call.op is Ops.CALL and realize._get_call_to_compile(call) is not None: + raise ValueError("Residual unqualified compilation after native guards") + # Every compiled host is guarded before returning to HCQ. This does not + # execute the intermediate graph or ask a GPU compiler to rebuild kernels. + return original(prepared, *args, **kwargs) + + hcq2.lower_and_compile = guarded + + +def install(role, fence_library, usb_library): + global _INSTALLATION + if _INSTALLATION is not None: + if _INSTALLATION.role != role: + raise ValueError("Native guard role cannot change") + return _INSTALLATION + candidate = Protection(role, fence_library, usb_library) + candidate.install_fresh_guard() + _INSTALLATION = candidate + return candidate diff --git a/openpilot/starpilot/models/runtime_bridge/runtime.py b/openpilot/starpilot/models/runtime_bridge/runtime.py index d7d6f02a86..a1bf2f5db6 100644 --- a/openpilot/starpilot/models/runtime_bridge/runtime.py +++ b/openpilot/starpilot/models/runtime_bridge/runtime.py @@ -18,10 +18,11 @@ _GUARD_HASHES = { _POLICY_SHA256 = 'c7eae9e0fab99e8c5fa56854b5a1e1ca8c36c81ef73668dd18ede27de61e3f4b' _selection = None _protection = None +_plan = None def prepare(role): - global _selection + global _selection, _plan if _selection is not None and _selection.get('purpose') == 'compiler': raise RuntimeError('A model compiler cannot become an inference child') from openpilot.common.hardware import AGNOS @@ -31,9 +32,20 @@ def prepare(role): if _selection['role'] != role: raise RuntimeError('A model child cannot change its execution role') return _selection - _verify_policy() - cache = Path('/data/starpilot-model-runtime') - _selection = activate(BUNDLE, MANIFEST_SHA256, LEGACY_REVISION, role, cache) + if role not in ('driving', 'monitoring'): + raise ValueError('Unknown model runtime role') + if role == 'driving': + import os + from openpilot.starpilot.models.manager import freeze_runtime + _plan = freeze_runtime(recovery_small_only=os.getenv('STARPILOT_MODELD_RECOVERY_SMALL_ONLY') == '1') + if role == 'monitoring' or _plan.family == 'native02e': + from openpilot.starpilot.models.runtime_bridge import native + _selection = native.prepare(role, _plan) + else: + _verify_policy() + cache = Path('/data/starpilot-model-runtime') + _selection = activate(BUNDLE, MANIFEST_SHA256, LEGACY_REVISION, role, cache) + _selection['family'] = 'legacy9d' return _selection @@ -46,6 +58,7 @@ def prepare_compiler(): selection = activate(BUNDLE, MANIFEST_SHA256, LEGACY_REVISION, 'driving', Path(tempfile.gettempdir()).resolve() / 'starpilot-model-compiler') selection['purpose'] = 'compiler' + selection['family'] = 'legacy9d' _selection = selection return _selection @@ -84,7 +97,15 @@ def _library(name): def selected_legacy(): - return _selection is not None + return _selection is not None and _selection.get('family') == 'legacy9d' + + +def prepared(): + return _selection is not None and _selection.get('purpose') != 'compiler' + + +def selected_plan(): + return _plan def _guard(chestnut): @@ -197,6 +218,9 @@ def _load_chestnut(path): def load_oob(path, chestnut=False): + if _selection is not None and _selection.get('family') == 'native02e': + from openpilot.starpilot.models.runtime_bridge import native + return native.load_oob(path, chestnut) if _selection is None: raise RuntimeError('A device model loader requires the selected runtime') if _selection.get('purpose') == 'compiler': @@ -232,6 +256,9 @@ def load_oob(path, chestnut=False): def load_warp(path): + if _selection is not None and _selection.get('family') == 'native02e': + from openpilot.starpilot.models.runtime_bridge import native + return native.load_warp(path) import pickle if _selection is None or _selection['role'] != 'monitoring': raise RuntimeError('A monitoring warp loader requires the selected runtime') diff --git a/openpilot/starpilot/models/runtime_selection.py b/openpilot/starpilot/models/runtime_selection.py new file mode 100644 index 0000000000..1124de757d --- /dev/null +++ b/openpilot/starpilot/models/runtime_selection.py @@ -0,0 +1,54 @@ +"""Freeze one driving runtime before importing either tinygrad family.""" +from dataclasses import dataclass +import hashlib +import json + +NATIVE_REVISION = "02e698160eed1751738212144a7ea2cfb160b3f1" +LEGACY_REVISION = "9d0446a4ba8a532c8b674fb6ad795af015cd9dcf" +NATIVE_ABI = "tinygrad_single_v2_arena" +LEGACY_ABI = "tinygrad_single_v1_arena" +NATIVE_GENERATION = "native02e-v1" + + +@dataclass(frozen=True) +class RuntimePlan: + family: str + compiler_revision: str + artifact_abi: str + small_id: str + big_id: str + preferences_json: str + entries_json: str + default_json: str + snapshot_sha256: str + + +def selection_family(preferences: dict, entries: dict, *, recovery_small_only: bool = False) -> str: + # Entries come from validated catalogs: native rows include qualification identity. + if recovery_small_only: + return "native02e" + small, big = preferences["small"], preferences["big"] + if big and big != "bundled-current": + return "native02e" if entries.get(big, {}).get("_runtime_family") == "native02e" else "legacy9d" + return "native02e" if small == "rdf43" or small not in entries else "legacy9d" + + +def freeze_plan(preferences: dict, entries: dict, default: dict, *, recovery_small_only: bool = False) -> RuntimePlan: + # Keep unconverted BIG and its fallback on legacy9d in the SAME process. + small, big = preferences["small"], preferences["big"] + family = selection_family(preferences, entries, recovery_small_only=recovery_small_only) + native = family == "native02e" + if default["runtime_family"] != family: + raise ValueError("wrong runtime fallback for frozen selection") + selected_big = big if not recovery_small_only and entries.get(big, {}).get("_runtime_family") == family else "" + parts = [json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) for value in (preferences, entries, default)] + return RuntimePlan(family, NATIVE_REVISION if native else LEGACY_REVISION, NATIVE_ABI if native else LEGACY_ABI, + "rdf43" if native else small, selected_big, *parts, + hashlib.sha256("\n".join(parts).encode()).hexdigest()) + + +def require_artifact_contract(artifact: dict, plan: RuntimePlan | None) -> None: + revision, abi = (plan.compiler_revision, plan.artifact_abi) if plan is not None else (LEGACY_REVISION, LEGACY_ABI) + if (not isinstance(artifact, dict) or artifact.get("compiler_revision") != revision or + artifact.get("artifact_abi") != abi or artifact.get("format_version") != 1): + raise ValueError("catalog model compiler/ABI mismatch") diff --git a/openpilot/starpilot/models/tests/native_fixture.py b/openpilot/starpilot/models/tests/native_fixture.py new file mode 100644 index 0000000000..86581926d2 --- /dev/null +++ b/openpilot/starpilot/models/tests/native_fixture.py @@ -0,0 +1,36 @@ +"""Release-shaped metadata fixtures; never qualify or execute fixture model bytes.""" +from contextlib import contextmanager, ExitStack +import hashlib +import json +from pathlib import Path +from unittest.mock import patch + +from openpilot.common.file_chunker import package_file +from openpilot.starpilot.models import manager +from openpilot.starpilot.models import catalog as catalog_module +from openpilot.starpilot.models.runtime_selection import NATIVE_ABI, NATIVE_GENERATION, NATIVE_REVISION + + +@contextmanager +def native_fixture(root: Path, data: bytes): + shipped = root / 'shipped' + source = root / 'native-fixture-source.pkl' + source.write_bytes(data) + for relative in ('rdf43_driving_tinygrad.pkl', 'compat9d/rdf43_driving_tinygrad.pkl'): + destination = shipped / relative + if not Path(f'{destination}.chunkmanifest').exists(): + package_file(source, destination) + source.unlink() + identity = {'artifact_sha256': hashlib.sha256(data).hexdigest(), 'artifact_size': len(data), + 'qualification_sha256': hashlib.sha256(b'metadata fixture, no runtime qualification').hexdigest()} + doc = {'generation': NATIVE_GENERATION, 'compiler_revision': NATIVE_REVISION, 'artifact_abi': NATIVE_ABI, + 'models': [{'id': 'rdf43', 'name': 'RDF metadata fixture', 'version': 'v15', 'uses_external_gpu': False, + 'artifact_format': NATIVE_ABI, 'artifact_chunk_count': 1, **identity}], + 'stock': {name: dict(identity) for name in ('dmonitoring_model_tinygrad.pkl', + 'dm_warp_1928x1208_tinygrad.pkl', 'dm_warp_1344x760_tinygrad.pkl')}} + path = root / 'native-fixture-catalog.json' + path.write_text(json.dumps(doc)) + with ExitStack() as stack: + for module in (manager, catalog_module): + stack.enter_context(patch.object(module, 'NATIVE_CATALOG_PATH', path)) + yield doc diff --git a/openpilot/starpilot/models/tests/test_catalog_status.py b/openpilot/starpilot/models/tests/test_catalog_status.py index 7266955f8d..61a237a471 100644 --- a/openpilot/starpilot/models/tests/test_catalog_status.py +++ b/openpilot/starpilot/models/tests/test_catalog_status.py @@ -2,13 +2,33 @@ import hashlib import json from pathlib import Path import unittest +import tempfile +from unittest.mock import patch +from openpilot.starpilot.models import manager +from openpilot.starpilot.models.runtime_selection import NATIVE_ABI +from openpilot.starpilot.models.tests.native_fixture import native_fixture from openpilot.starpilot.models.catalog import BUNDLED_CURRENT, CATALOG, CATALOG_PATH, DEFAULT_SMALL, resolve_selection from openpilot.starpilot.models.status import (ModelHealth, ModelLoad, ModelOutput, ModelProcess, ModelVariant, project_status) class TestModelCatalogStatus(unittest.TestCase): + def setUp(self): + temporary = self.enterContext(tempfile.TemporaryDirectory()) + self.root = Path(temporary) + self.enterContext(patch.object(manager, "SHIPPED_MODELS", self.root / "shipped")) + document = self.enterContext(native_fixture(self.root, b"catalog source identity fixture")) + # Status requests need a qualified published BIG identity, not a pending + # historical catalog row. No artifact is executed or marked installed. + historical = json.loads(CATALOG_PATH.read_text())["models"] + big = next(row for row in historical if row["id"] == "cinquev3") + document["models"].append({"id": big["id"], "name": big["name"], "version": big["version"], + "uses_external_gpu": True, "artifact_sha256": "b" * 64, + "artifact_size": 123, "artifact_chunk_count": 1, + "artifact_format": NATIVE_ABI, "qualification_sha256": "c" * 64}) + manager.NATIVE_CATALOG_PATH.write_text(json.dumps(document)) + def test_catalog_pins_current_source_and_lists_model_metadata(self): manifest_ids = [row['id'] for row in json.loads(CATALOG_PATH.read_text())['models']] self.assertEqual(len(manifest_ids), len(set(manifest_ids))) @@ -17,7 +37,7 @@ class TestModelCatalogStatus(unittest.TestCase): self.assertCountEqual(catalog_ids, [BUNDLED_CURRENT, *manifest_ids]) entry = resolve_selection(None) self.assertEqual(entry.model_id, DEFAULT_SMALL) - source = Path(__file__).resolve().parents[4] / entry.source_path + source = manager.SHIPPED_MODELS / Path(entry.source_path).name from openpilot.common.file_chunker import get_existing_chunks digest = hashlib.sha256() for part in get_existing_chunks(source)[1:]: diff --git a/openpilot/starpilot/models/tests/test_manager.py b/openpilot/starpilot/models/tests/test_manager.py index 90c0f75a40..ed774450aa 100644 --- a/openpilot/starpilot/models/tests/test_manager.py +++ b/openpilot/starpilot/models/tests/test_manager.py @@ -10,6 +10,7 @@ from types import SimpleNamespace import unittest from unittest.mock import patch +from openpilot.starpilot.models.tests.native_fixture import native_fixture from openpilot.starpilot.models.catalog import ARTIFACT_ABI, BUNDLED_CURRENT, CATALOG_PATH, DEFAULT_SMALL from openpilot.starpilot.models.manager import ( ModelError, ModelManager, atomic_json, catalog, preferences, randomize_next_start, resolve_runtime, validate_manifest, @@ -17,28 +18,30 @@ from openpilot.starpilot.models.manager import ( def run_download_owner(root, manifest, data, entered, release, result): - class BlockedPart(io.BytesIO): - def read(self, size=-1): - entered.set() - if not release.wait(5): - raise OSError('fixture stalled') - return super().read(size) + with native_fixture(Path(root), data) as native_document: + class BlockedPart(io.BytesIO): + def read(self, size=-1): + entered.set() + if not release.wait(5): + raise OSError('fixture stalled') + return super().read(size) - def opener(url, timeout): - if '/manifests/' in url: - return io.BytesIO(json.dumps(manifest).encode()) - if url.endswith('chunk01of02'): - return io.BytesIO(data[:10]) - return BlockedPart(data[10:]) + def opener(url, timeout): + if '/manifests/' in url: + document = native_document if 'native02e-v1' in url else manifest + return io.BytesIO(json.dumps(document).encode()) + if url.endswith('chunk01of02'): + return io.BytesIO(data[:10]) + return BlockedPart(data[10:]) - manager = ModelManager(root=Path(root), parked=lambda: True, gpu_present=lambda: False, opener=opener) - with patch('openpilot.starpilot.models.manager.shutil.disk_usage', return_value=SimpleNamespace(free=1024**3)): - try: - manager.action('download', {'model': 'gwm8223'}) - manager.worker.join(6) - result.put(manager.snapshot()) - finally: - manager.close() + manager = ModelManager(root=Path(root), parked=lambda: True, gpu_present=lambda: False, opener=opener) + with patch('openpilot.starpilot.models.manager.shutil.disk_usage', return_value=SimpleNamespace(free=1024**3)): + try: + manager.action('download', {'model': 'gwm8223'}) + manager.worker.join(6) + result.put(manager.snapshot()) + finally: + manager.close() class ModelManagerTest(unittest.TestCase): @@ -63,6 +66,7 @@ class ModelManagerTest(unittest.TestCase): identity = patch('openpilot.starpilot.models.manager.' + attribute, value) identity.start() self.addCleanup(identity.stop) + self.native_manifest = self.enterContext(native_fixture(self.root, self.data)) self.manifest = json.loads(CATALOG_PATH.read_text()) self.row = next(x for x in self.manifest['models'] if x['id'] == 'gwm8223') self.row.update(artifact_format=ARTIFACT_ABI, artifact_sha256=hashlib.sha256(self.data).hexdigest(), @@ -74,7 +78,8 @@ class ModelManagerTest(unittest.TestCase): self.assertTrue(url.startswith('https://huggingface.co/buckets/StarPilot-Driving/StarPilot-Resources/resolve/')) self.urls.append(url) if '/manifests/' in url: - return io.BytesIO(json.dumps(self.manifest).encode()) + document = self.native_manifest if 'native02e-v1' in url else self.manifest + return io.BytesIO(json.dumps(document).encode()) if url.endswith('chunk01of02'): return io.BytesIO(self.data[:10]) if url.endswith('chunk02of02'): @@ -136,6 +141,42 @@ class ModelManagerTest(unittest.TestCase): assert self.manager.selected_gpu_status() == (False, False) assert not (self.root / '.download-job.json').exists() + def test_downloaded_native_rdf_respects_frozen_big_runtime_family(self): + from openpilot.starpilot.models.runtime_selection import NATIVE_ABI, NATIVE_GENERATION + + # Metadata fixture bytes are never unpickled or submitted to a device. + native_rdf = self.root / NATIVE_GENERATION / 'rdf43/rdf43_driving_tinygrad.pkl' + native_rdf.parent.mkdir(parents=True) + native_rdf.write_bytes(self.data) + legacy_big = next(row for row in self.manifest['models'] if row['id'] == 'cinquev3') + legacy_big.update(artifact_format=ARTIFACT_ABI, artifact_sha256=hashlib.sha256(self.data).hexdigest(), + artifact_size=len(self.data), artifact_chunk_count=0) + atomic_json(self.root / 'catalog.json', self.manifest) + for native in (False, True): + with self.subTest(native_big=native): + document = json.loads(json.dumps(self.native_manifest)) + if native: + document['models'].append({**legacy_big, 'artifact_format': NATIVE_ABI, + 'qualification_sha256': document['models'][0]['qualification_sha256']}) + atomic_json(self.root / 'native-fixture-catalog.json', document) + big_path = self.root / NATIVE_GENERATION / 'cinquev3/cinquev3_driving_tinygrad.pkl' if native else ( + self.root / 'cinquev3/cinquev3_driving_tinygrad.pkl') + big_path.parent.mkdir(parents=True, exist_ok=True) + big_path.write_bytes(self.data) + atomic_json(self.root / 'preferences.json', {'small': 'rdf43', 'big': 'cinquev3'}) + selection = resolve_runtime(True, root=self.root) + self.assertTrue(selection.allow_big) + self.assertEqual(selection.big_path, big_path) + if native: + self.assertEqual(selection.small_path, native_rdf) + self.assertNotIn('compat9d', selection.fallback_path.parts) + else: + self.assertEqual(selection.small_path, selection.fallback_path) + self.assertIn('compat9d', selection.small_path.parts) + self.assertNotEqual(selection.small_path, native_rdf) + self.assertEqual(selection.small_path.read_bytes(), self.data) + self.assertEqual(preferences(self.root)['big'], 'cinquev3') + def test_chunk_download_verifies_and_selects_next_start(self): self.download() self.assertEqual(self.manager.progress, 'Downloaded!') @@ -144,7 +185,8 @@ class ModelManagerTest(unittest.TestCase): selected = resolve_runtime(True, root=self.root) self.assertEqual(selected.small_id, 'gwm8223') self.assertEqual(selected.small_path.read_bytes(), self.data) - self.assertTrue(all('/v26/' in u or 'model_names_v26.json' in u for u in self.urls)) + self.assertTrue(all('/v26/' in u or u.endswith(('/manifests/model_names_v26.json', + '/manifests/model_names_native02e-v1.json')) for u in self.urls)) def test_corruption_never_publishes_or_selects(self): self.bad = True @@ -654,7 +696,7 @@ class ModelManagerTest(unittest.TestCase): validate_manifest({**good, "models": [known]}) def test_remote_metadata_cache_refresh_and_root_isolation(self): - from openpilot.starpilot.models.catalog import BY_ID, model_entries + from openpilot.starpilot.models.catalog import model_entries row = dict(self.row, id="remote_cache", name="First name", version="v16") atomic_json(self.root / "catalog.json", {**self.manifest, "models": [row]}) self.assertEqual(model_entries(self.root)[row["id"]].name, "First name") @@ -664,7 +706,7 @@ class ModelManagerTest(unittest.TestCase): self.assertEqual(model_entries(self.root)[row["id"]].name, "Second name") with tempfile.TemporaryDirectory() as empty: self.assertNotIn(row["id"], model_entries(Path(empty))) - self.assertEqual(model_entries(self.root)[DEFAULT_SMALL].source_sha256, BY_ID[DEFAULT_SMALL].source_sha256) + self.assertEqual(model_entries(self.root)[DEFAULT_SMALL].source_sha256, self.native_manifest["models"][0]["artifact_sha256"]) def test_catalog_page_refresh_is_async_bounded_and_parked_only(self): entered, release = threading.Event(), threading.Event() diff --git a/openpilot/starpilot/models/tests/test_modeld_startup_fallback.py b/openpilot/starpilot/models/tests/test_modeld_startup_fallback.py index 833a53e5c6..b1dcdf3bf4 100644 --- a/openpilot/starpilot/models/tests/test_modeld_startup_fallback.py +++ b/openpilot/starpilot/models/tests/test_modeld_startup_fallback.py @@ -115,6 +115,7 @@ def test_remote_inference_failure_does_not_change_chestnut_status(): def execute(statements, env): env.setdefault("os", SimpleNamespace(getenv=lambda key: None)) env.setdefault("recovery_small_only", False) + env.setdefault("MODEL_RUNTIME_PLAN", object()) from openpilot.starpilot.models.recovery import STARTUP_FALLBACK_EXIT env.setdefault("STARTUP_FALLBACK_EXIT", STARTUP_FALLBACK_EXIT) exec(compile(ast.fix_missing_locations(ast.Module(body=statements, type_ignores=[])), str(MODEL_SOURCE), "exec"), env) @@ -136,13 +137,16 @@ def test_observed_availability_and_big_eligibility(monkeypatch, present, cable, import sys manager = ModuleType("openpilot.starpilot.models.manager") - manager.resolve_runtime = Mock(side_effect=lambda chestnut_available, randomize: + manager.resolve_runtime = Mock(side_effect=lambda chestnut_available, plan: SimpleNamespace(allow_big=allow_big and chestnut_available, big_path=big_path)) manager.requested_runtime_id = Mock(return_value="selected") amd = ModuleType("tinygrad.runtime.ops_amd") amd.AMDDevice = type("FakeAMDDevice", (), {"wait_timeout_ms": 123}) monkeypatch.setitem(sys.modules, manager.__name__, manager) monkeypatch.setitem(sys.modules, amd.__name__, amd) + am = ModuleType("tinygrad.runtime.support.am") + am.startup_trace = SimpleNamespace(ENABLED=False, REPORT=None) + monkeypatch.setitem(sys.modules, am.__name__, am) body = main_body() start = next(i for i, node in enumerate(body) if isinstance(node, ast.ImportFrom) and node.module == manager.__name__) end = next(i for i, node in enumerate(body) if ast.unparse(node) == "gc.disable()") @@ -152,8 +156,8 @@ def test_observed_availability_and_big_eligibility(monkeypatch, present, cable, "jetlink_adapter": SimpleNamespace(link_on=lambda: link)} execute(body[start:end], env) available = present or (cable and not link) - manager.resolve_runtime.assert_called_once_with(chestnut_available=available, randomize=True) - manager.requested_runtime_id.assert_called_once_with(available) + manager.resolve_runtime.assert_called_once_with(chestnut_available=available, plan=env["MODEL_RUNTIME_PLAN"]) + manager.requested_runtime_id.assert_called_once_with(available, plan=env["MODEL_RUNTIME_PLAN"]) env["chestnut_present"].assert_called_once_with() assert env["cable_connected"].call_count == (0 if present else 1) assert env["CHESTNUT"] is expected @@ -209,6 +213,9 @@ def test_big_worker_waits_before_load_and_failure_requests_fresh_small_process(c small_version=1, small_id="small", small_sha256="small-hash", big_version=1, big_id="big", big_sha256="hash") from openpilot.starpilot.models.catalog import BY_ID, DEFAULT_SMALL, DEFAULT_SMALL_SHA256 + selection.fallback_path = "bundled-small" + selection.fallback_version = BY_ID[DEFAULT_SMALL].version + selection.fallback_sha256 = DEFAULT_SMALL_SHA256 env: dict = {"BY_ID": BY_ID, "DEFAULT_SMALL": DEFAULT_SMALL, "DEFAULT_SMALL_SHA256": DEFAULT_SMALL_SHA256, "time": SimpleNamespace(monotonic=lambda: 0), "cloudlog": Mock(), "selection": selection, "CHESTNUT": True, "vipc_client_main": SimpleNamespace(width=1928, height=1208), "wait_for_chestnut": wait, @@ -332,8 +339,8 @@ def test_recovery_child_resolves_small_without_randomizer_or_amd(monkeypatch): "chestnut_compiled": Mock(side_effect=AssertionError("Big compiled probe forbidden")), "Params": lambda: params, "os": SimpleNamespace(getenv=lambda key: "1")} execute(body[start:end], env) - manager.resolve_runtime.assert_called_once_with(chestnut_available=False, randomize=False) - manager.requested_runtime_id.assert_called_once_with(True) + manager.resolve_runtime.assert_called_once_with(chestnut_available=False, plan=env["MODEL_RUNTIME_PLAN"]) + manager.requested_runtime_id.assert_called_once_with(True, plan=env["MODEL_RUNTIME_PLAN"]) assert env["CHESTNUT"] is False assert "AMDDevice" not in env assert params.put_bool.call_args_list == [(("ChestnutLoading", False),)] @@ -362,7 +369,9 @@ def test_failed_selected_small_uses_only_verified_rdf_or_refuses_startup(monkeyp monkeypatch.setattr(manager, 'shipped_default', lambda: None if fallback_failure == 'missing' else shipped) loader = Mock(side_effect=[RuntimeError('selected failed'), RuntimeError('RDF failed') if fallback_failure == 'load' else (rdf, 'rdf-prepared')]) stock = Mock(side_effect=AssertionError('stock model must not load')) - env: dict = {'selection': SimpleNamespace(small_path=Path('custom.pkl'), small_version='v15', small_id='gwm8223', small_sha256='custom'), + env: dict = {'selection': SimpleNamespace(small_path=Path('custom.pkl'), small_version='v15', small_id='gwm8223', small_sha256='custom', + fallback_path=None if fallback_failure == 'missing' else shipped, + fallback_version='v15', fallback_sha256=DEFAULT_SMALL_SHA256), 'vipc_client_main': SimpleNamespace(width=1928, height=1208), 'load_verified_model': loader, 'ModelState': stock, 'modeld_pkl_path': stock, 'cloudlog': Mock(), 'BY_ID': BY_ID, 'DEFAULT_SMALL': DEFAULT_SMALL, 'DEFAULT_SMALL_SHA256': DEFAULT_SMALL_SHA256} diff --git a/openpilot/starpilot/models/tests/test_partial_native_selection.py b/openpilot/starpilot/models/tests/test_partial_native_selection.py new file mode 100644 index 0000000000..234f44046c --- /dev/null +++ b/openpilot/starpilot/models/tests/test_partial_native_selection.py @@ -0,0 +1,297 @@ +"""Metadata-only tests of actual selection functions; no runtime admission proof.""" +import ast +from dataclasses import dataclass, FrozenInstanceError, replace +import hashlib +import json +import os +from pathlib import Path +import re +import types +import unittest +from unittest.mock import Mock, patch + +SOURCE = Path(os.environ.get("STARPILOT_PARTIAL_NATIVE_SOURCE_ROOT", Path(__file__).resolve().parents[4])) +MODELS = SOURCE / "openpilot/starpilot/models" + + +def extract(path, names, namespace): + tree = ast.parse(path.read_text(), filename=str(path)) + selected = [node for node in tree.body if isinstance(node, (ast.FunctionDef, ast.ClassDef)) and node.name in names] + if {node.name for node in selected} != set(names): + raise AssertionError("Missing actual source definitions") + # Compile the original nodes unchanged, including decorators and annotations. + exec(compile(ast.Module(body=selected, type_ignores=[]), str(path), "exec"), namespace) + + +def subjects(): + ns = {"__name__": __name__, "dataclass": dataclass, "hashlib": hashlib, "json": json, "Path": Path, "re": re} + # This entire module has only standard-library imports; no production imports. + exec(compile((MODELS / "runtime_selection.py").read_text(), str(MODELS / "runtime_selection.py"), "exec"), ns) + ns.update(ROOT=Path("/metadata-fixture"), DEFAULT_SMALL="rdf43", BUNDLED_CURRENT="bundled-current", + GENERATION="v26", COMPILER_REVISION=ns["LEGACY_REVISION"], ARTIFACT_ABI=ns["LEGACY_ABI"], + MODEL_ID=re.compile(r"[a-z0-9][a-z0-9_-]{0,63}\Z"), SHA=re.compile(r"[0-9a-f]{64}\Z"), + SUPPORTED_VERSIONS={f"v{i}" for i in range(8, 17)}, MAX_ARTIFACT=2 * 1024**3, + MODEL_RUNNER_REVISION=2, BY_ID={}, + RUNTIME_ARTIFACT_KEYS={"min_runner_revision", "artifact_format", "artifact_sha256", "artifact_size", + "artifact_chunk_count", "conversion_provenance", "validation"}, + CATALOG_PATH=Path("/metadata-fixture/legacy.json"), NATIVE_CATALOG_PATH=Path("/metadata-fixture/native.json")) + extract(MODELS / "manager.py", ["ModelError", "validate_manifest", "native_stock", "catalog", "RuntimeSelection", + "requested_runtime_id", "resolve_runtime"], ns) + ns["ModelEntry"] = types.SimpleNamespace + extract(MODELS / "catalog.py", ["resolve_selection"], ns) + return ns + + +class TestPartialNativeSelection(unittest.TestCase): + def setUp(self): + self.n = subjects() + self.prefs = {"small": "optional-small", "big": "traintrack", "userFavorites": ["optional-small"], + "blacklistedModels": ["another-small"], "randomizer": False, "sortMode": "favorites"} + self.entries = { + "optional-small": {"id": "optional-small", "version": "v15", "_runtime_family": "legacy9d", "artifact_sha256": "a" * 64}, + "traintrack": {"id": "traintrack", "version": "v16", "_runtime_family": "native02e", "artifact_sha256": "b" * 64}, + } + self.default = {"runtime_family": "native02e", "version": "v15", "artifact_sha256": "c" * 64} + + def plan(self, **kw): + return self.n["freeze_plan"](self.prefs, self.entries, self.default, **kw) + + def resolve(self, plan, available=True, installed=True, fallback=True): + self.n["verified_artifact"] = Mock(side_effect=lambda mid, *_: Path("/verified") / mid if installed else None) + self.n["shipped_default"] = Mock(return_value=Path("/verified/rdf43") if fallback else None) + return self.n["resolve_runtime"](available, plan=plan) + + def document(self, native=True): + return {"generation": self.n["NATIVE_GENERATION"] if native else "v26", + "compiler_revision": self.n["NATIVE_REVISION"] if native else self.n["LEGACY_REVISION"], + "artifact_abi": self.n["NATIVE_ABI"] if native else self.n["LEGACY_ABI"], + "models": [{"id": "traintrack", "name": "TrainTrack", "version": "v16", "uses_external_gpu": True, + "artifact_sha256": "b" * 64, "artifact_size": 123, "artifact_chunk_count": 0, + "artifact_format": self.n["NATIVE_ABI"] if native else self.n["LEGACY_ABI"], + "qualification_sha256": "d" * 64}]} + + def test_native_big_uses_native_rdf_without_rewriting_saved_small(self): + before = json.dumps(self.prefs, sort_keys=True) + plan = self.plan() + self.assertEqual((plan.family, plan.small_id, plan.big_id), ("native02e", "rdf43", "traintrack")) + selected = self.resolve(plan) + self.assertTrue(selected.allow_big) + self.assertEqual((selected.small_path, selected.big_path, selected.fallback_path), + (Path("/verified/rdf43"), Path("/verified/traintrack"), Path("/verified/rdf43"))) + self.assertEqual(json.dumps(self.prefs, sort_keys=True), before) + self.assertEqual(json.loads(plan.preferences_json), self.prefs) + + def test_default_rdf_selects_native_without_a_big_request(self): + self.prefs.update(small="rdf43", big="") + plan = self.plan() + self.assertEqual((plan.family, plan.small_id, plan.big_id), ("native02e", "rdf43", "")) + selected = self.resolve(plan) + self.assertEqual(selected.small_sha256, "c" * 64) + self.assertFalse(selected.allow_big) + + def test_unconverted_big_keeps_legacy_payload_custom_small_and_saved_request(self): + self.entries["traintrack"]["_runtime_family"] = "legacy9d" + self.default["runtime_family"] = "legacy9d" + plan = self.plan() + self.assertEqual((plan.family, plan.small_id, plan.big_id), ("legacy9d", "optional-small", "traintrack")) + selected = self.resolve(plan) + self.assertTrue(selected.allow_big) + self.assertEqual((selected.small_id, selected.big_id), ("optional-small", "traintrack")) + self.assertEqual(self.n["requested_runtime_id"](True, plan=plan), "traintrack") + self.assertEqual(self.prefs["big"], "traintrack") + + def test_optional_small_only_uses_legacy_and_legacy_fallback(self): + self.prefs["big"] = "" + self.default["runtime_family"] = "legacy9d" + plan = self.plan() + selected = self.resolve(plan) + self.assertEqual((plan.family, plan.compiler_revision, plan.artifact_abi), + ("legacy9d", self.n["LEGACY_REVISION"], self.n["LEGACY_ABI"])) + self.assertEqual(selected.small_id, "optional-small") + self.assertEqual(selected.small_sha256, "a" * 64) + self.assertFalse(selected.allow_big) + missing = self.resolve(plan, installed=False) + self.assertEqual((missing.small_id, missing.small_path), ("rdf43", Path("/verified/rdf43"))) + + def test_absent_chestnut_or_artifact_retains_big_request_but_disables_execution(self): + for available, installed in ((False, True), (True, False)): + with self.subTest(available=available, installed=installed): + selected = self.resolve(self.plan(), available, installed) + self.assertEqual(selected.big_id, "traintrack") + self.assertIsNone(selected.big_path) + self.assertFalse(selected.allow_big) + self.assertEqual(selected.small_id, "rdf43") + + def test_recovery_forces_native_rdf_and_preserves_preferences(self): + before = json.dumps(self.prefs, sort_keys=True) + plan = self.plan(recovery_small_only=True) + self.assertEqual((plan.family, plan.small_id, plan.big_id), ("native02e", "rdf43", "")) + self.assertFalse(self.resolve(plan).allow_big) + self.assertEqual(json.dumps(self.prefs, sort_keys=True), before) + + def test_frozen_benchmark_snapshot_is_detached_and_does_not_write_preferences(self): + before = json.dumps((self.prefs, self.entries, self.default), sort_keys=True) + first = self.plan() + self.assertEqual(first, self.plan()) + self.assertEqual(json.dumps((self.prefs, self.entries, self.default), sort_keys=True), before) + self.assertEqual(first.snapshot_sha256, hashlib.sha256("\n".join( + (first.preferences_json, first.entries_json, first.default_json)).encode()).hexdigest()) + self.prefs["small"] = "later-choice" + self.entries["traintrack"]["version"] = "v15" + self.assertEqual(self.n["requested_runtime_id"](True, plan=first), "traintrack") + self.assertEqual(json.loads(first.entries_json)["traintrack"]["version"], "v16") + self.assertNotEqual(first.snapshot_sha256, self.plan().snapshot_sha256) + with self.assertRaises(FrozenInstanceError): + first.small_id = "mutated" + + def test_wrong_fallback_and_missing_verified_default_fail_closed(self): + self.default["runtime_family"] = "legacy9d" + with self.assertRaisesRegex(ValueError, "wrong runtime fallback"): + self.plan() + self.default["runtime_family"] = "native02e" + with self.assertRaisesRegex(self.n["ModelError"], "missing or corrupt"): + self.resolve(self.plan(), fallback=False) + + def test_unknown_or_pending_selector_is_rejected_without_silent_default(self): + rdf = types.SimpleNamespace(selectable=True) + self.n["model_entries"] = lambda _: {"rdf43": rdf, "pending-big": types.SimpleNamespace(selectable=False)} + for requested in ("unknown", "pending-big", 7): + with self.subTest(requested=requested), self.assertRaisesRegex(ValueError, "unqualified"): + self.n["resolve_selection"](requested) + self.assertIs(self.n["resolve_selection"](None), rdf) + self.assertIs(self.n["resolve_selection"]("bundled-current"), rdf) + + def test_artifact_revision_abi_and_format_are_exact(self): + for plan in (self.plan(), None): + artifact = {"compiler_revision": plan.compiler_revision if plan else self.n["LEGACY_REVISION"], + "artifact_abi": plan.artifact_abi if plan else self.n["LEGACY_ABI"], "format_version": 1} + self.n["require_artifact_contract"](artifact, plan) + for key, bad in (("compiler_revision", "0" * 40), ("compiler_revision", "corrupt"), + ("artifact_abi", "unknown"), ("format_version", 2)): + with self.subTest(key=key, bad=bad), self.assertRaisesRegex(ValueError, "compiler/ABI mismatch"): + self.n["require_artifact_contract"]({**artifact, key: bad}, plan) + + def test_native_manifest_requires_exact_revision_abi_and_qualification(self): + good = self.document() + row = self.n["validate_manifest"](good, native=True)["traintrack"] + self.assertEqual((row["_runtime_family"], row["compiler_revision"]), ("native02e", self.n["NATIVE_REVISION"])) + for key, bad in (("compiler_revision", self.n["LEGACY_REVISION"]), ("compiler_revision", "corrupt"), + ("artifact_abi", self.n["LEGACY_ABI"]), ("generation", "unknown")): + with self.subTest(key=key), self.assertRaises(self.n["ModelError"]): + self.n["validate_manifest"]({**good, key: bad}, native=True) + for key, bad in (("qualification_sha256", "bad"), ("uses_external_gpu", False), ("artifact_format", "unknown")): + doc = self.document() + doc["models"][0][key] = bad + with self.subTest(key=key), self.assertRaises(self.n["ModelError"]): + self.n["validate_manifest"](doc, native=True) + + def test_catalog_preserves_unconverted_legacy_big_payload(self): + doc = self.document(native=False) + small = {**doc["models"][0], "id": "optional-small", "uses_external_gpu": False} + doc["models"].append(small) + self.n["read_json"] = Mock(side_effect=[doc, FileNotFoundError()]) + self.n["native_catalog"] = Mock(return_value={}) + rows = self.n["catalog"]() + self.assertEqual(set(rows), {"traintrack", "optional-small"}) + self.assertEqual(rows["traintrack"]["_runtime_family"], "legacy9d") + self.assertEqual(rows["traintrack"]["artifact_sha256"], "b" * 64) + self.assertEqual(rows["optional-small"]["_runtime_family"], "legacy9d") + self.assertEqual(rows["optional-small"]["artifact_sha256"], "b" * 64) + + def test_legacy_big_forces_legacy_even_with_saved_default_rdf(self): + self.prefs["small"] = "rdf43" + self.entries["traintrack"]["_runtime_family"] = "legacy9d" + self.default["runtime_family"] = "legacy9d" + plan = self.plan() + selected = self.resolve(plan) + self.assertEqual((plan.family, plan.small_id, plan.big_id), ("legacy9d", "rdf43", "traintrack")) + self.assertTrue(selected.allow_big) + self.assertEqual(selected.small_sha256, "c" * 64) + + def test_native_counterpart_switches_new_snapshot_only(self): + self.entries["traintrack"]["_runtime_family"] = "legacy9d" + self.default["runtime_family"] = "legacy9d" + old = self.plan() + self.entries["traintrack"]["_runtime_family"] = "native02e" + self.default["runtime_family"] = "native02e" + new = self.plan() + self.assertEqual((old.family, new.family), ("legacy9d", "native02e")) + self.assertEqual((old.small_id, new.small_id), ("optional-small", "rdf43")) + self.assertTrue(self.resolve(old).allow_big) + self.assertTrue(self.resolve(new).allow_big) + self.assertEqual(self.prefs["small"], "optional-small") + + def test_native_overlay_replaces_only_converted_big_id(self): + doc = self.document(native=False) + doc["models"].append({**doc["models"][0], "id": "unconverted-big"}) + native = self.n["validate_manifest"](self.document(), native=True) + self.n["read_json"] = Mock(side_effect=[doc, FileNotFoundError()]) + self.n["native_catalog"] = Mock(return_value=native) + rows = self.n["catalog"]() + self.assertEqual(set(rows), {"traintrack", "unconverted-big"}) + self.assertEqual(rows["traintrack"]["_runtime_family"], "native02e") + self.assertEqual(rows["unconverted-big"]["_runtime_family"], "legacy9d") + self.assertEqual(rows["unconverted-big"]["artifact_sha256"], "b" * 64) + + def test_legacy_big_missing_hardware_or_payload_uses_same_family_fallback(self): + self.entries["traintrack"]["_runtime_family"] = "legacy9d" + self.default["runtime_family"] = "legacy9d" + plan = self.plan() + for available, installed in ((False, True), (True, False)): + selected = self.resolve(plan, available=available, installed=installed) + self.assertFalse(selected.allow_big) + self.assertEqual(selected.big_id, "traintrack") + self.assertEqual(selected.fallback_sha256, "c" * 64) + self.assertEqual(plan.family, "legacy9d") + + def test_bundled_big_sentinel_does_not_force_a_legacy_session(self): + self.prefs.update(small="rdf43", big="bundled-current") + plan = self.plan() + self.assertEqual((plan.family, plan.small_id, plan.big_id), ("native02e", "rdf43", "")) + + def test_cross_family_big_frozen_row_is_rejected(self): + plan = self.plan() + entries = json.loads(plan.entries_json) + entries["traintrack"]["_runtime_family"] = "legacy9d" + with self.assertRaisesRegex(self.n["ModelError"], "Big artifact does not match"): + self.resolve(replace(plan, entries_json=json.dumps(entries))) + + def test_native_monitoring_stock_is_separate_complete_release(self): + doc = self.document() + names = {"dmonitoring_model_tinygrad.pkl", "dm_warp_1928x1208_tinygrad.pkl", "dm_warp_1344x760_tinygrad.pkl"} + doc["stock"] = {name: {"artifact_sha256": "e" * 64, "artifact_size": 23, "qualification_sha256": "f" * 64} + for name in names} + self.n["read_json"] = lambda _: doc + self.assertEqual(set(self.n["native_stock"]()), names) + del doc["stock"]["dm_warp_1344x760_tinygrad.pkl"] + with self.assertRaisesRegex(self.n["ModelError"], "not qualified"): + self.n["native_stock"]() + + def test_monitoring_prepare_never_freezes_driving_preferences(self): + ns = {"__name__": __name__, "_selection": None, "_plan": None} + extract(MODELS / "runtime_bridge/runtime.py", ["prepare"], ns) + hardware = types.ModuleType("openpilot.common.hardware") + hardware.AGNOS = True + bridge = types.ModuleType("openpilot.starpilot.models.runtime_bridge") + bridge.native = types.SimpleNamespace(prepare=Mock(return_value={"role": "monitoring", "family": "native02e"})) + with patch.dict("sys.modules", {"openpilot.common.hardware": hardware, + "openpilot.starpilot.models.runtime_bridge": bridge}): + selected = ns["prepare"]("monitoring") + bridge.native.prepare.assert_called_once_with("monitoring", None) + self.assertEqual(selected, {"role": "monitoring", "family": "native02e"}) + self.assertIsNone(ns["_plan"]) + + def test_cross_family_small_and_postfreeze_randomization_rejected(self): + self.prefs["big"] = "" + self.default["runtime_family"] = "legacy9d" + plan = self.plan() + bad_entries = json.loads(plan.entries_json) + bad_entries["optional-small"]["_runtime_family"] = "native02e" + with self.assertRaisesRegex(self.n["ModelError"], "does not match"): + self.resolve(replace(plan, entries_json=json.dumps(bad_entries))) + with self.assertRaisesRegex(self.n["ModelError"], "Randomize before freezing"): + self.n["resolve_runtime"](True, plan=plan, randomize=True) + + +if __name__ == "__main__": + unittest.main() diff --git a/openpilot/starpilot/models/tests/test_shipped_default.py b/openpilot/starpilot/models/tests/test_shipped_default.py index 84196f7a01..842613faf3 100644 --- a/openpilot/starpilot/models/tests/test_shipped_default.py +++ b/openpilot/starpilot/models/tests/test_shipped_default.py @@ -1,22 +1,41 @@ import hashlib +import json import pytest from openpilot.common.file_chunker import package_file from openpilot.starpilot.models import manager -from openpilot.starpilot.models.catalog import BUNDLED_CURRENT, DEFAULT_SMALL, DEFAULT_SMALL_SHA256 +from openpilot.starpilot.models.catalog import BUNDLED_CURRENT, DEFAULT_SMALL +from openpilot.starpilot.models.runtime_selection import freeze_plan, selection_family +from openpilot.starpilot.models.tests.native_fixture import native_fixture + + +@pytest.fixture(autouse=True) +def release_metadata(tmp_path, monkeypatch): + data = b"verified fixture" + monkeypatch.setattr(manager, "SHIPPED_MODELS", tmp_path / "shipped") + monkeypatch.setattr(manager, "DEFAULT_SMALL_SHA256", hashlib.sha256(data).hexdigest()) + monkeypatch.setattr(manager, "DEFAULT_SMALL_SIZE", len(data)) + with native_fixture(tmp_path, data): + yield + + +def frozen_plan(root): + prefs, entries = manager.preferences(root), manager.catalog(root) + family = selection_family(prefs, entries) + return freeze_plan(prefs, entries, manager.default_record(family, root)) def test_unset_small_loads_shipped_rdf_v4_with_v15_parser(tmp_path, monkeypatch): artifact = tmp_path / "shipped.pkl" artifact.write_bytes(b"verified fixture") - monkeypatch.setattr(manager, "shipped_default", lambda: artifact) - selected = manager.resolve_runtime(False, root=tmp_path) + monkeypatch.setattr(manager, "shipped_default", lambda plan=None: artifact) + selected = manager.resolve_runtime(False, root=tmp_path, plan=frozen_plan(tmp_path)) assert manager.preferences(tmp_path)["small"] == DEFAULT_SMALL assert selected.small_id == "rdf43" assert selected.small_version == "v15" assert selected.small_path == artifact - assert selected.small_sha256 == DEFAULT_SMALL_SHA256 + assert selected.small_sha256 == manager.default_record("native02e", tmp_path)["artifact_sha256"] assert not selected.allow_big @@ -24,16 +43,16 @@ def test_unset_small_loads_shipped_rdf_v4_with_v15_parser(tmp_path, monkeypatch) def test_legacy_alias_and_missing_selected_artifact_use_rdf_only(tmp_path, monkeypatch, selection): manager.atomic_json(tmp_path / "preferences.json", {"small": selection}) path = tmp_path / "rdf.pkl" - monkeypatch.setattr(manager, "shipped_default", lambda: path) - selected = manager.resolve_runtime(False, root=tmp_path) + monkeypatch.setattr(manager, "shipped_default", lambda plan=None: path) + selected = manager.resolve_runtime(False, root=tmp_path, plan=frozen_plan(tmp_path)) assert selected.small_id == DEFAULT_SMALL and selected.small_path == path assert manager.preferences(tmp_path)["small"] == (DEFAULT_SMALL if selection == BUNDLED_CURRENT else selection) def test_missing_or_corrupt_only_shipped_model_refuses_startup(tmp_path, monkeypatch): - monkeypatch.setattr(manager, "shipped_default", lambda: None) + monkeypatch.setattr(manager, "shipped_default", lambda plan=None: None) with pytest.raises(manager.ModelError, match="Shipped RDFv4 is missing or corrupt"): - manager.resolve_runtime(False, root=tmp_path) + manager.resolve_runtime(False, root=tmp_path, plan=frozen_plan(tmp_path)) def test_big_default_disabled_and_explicit_download_preserved(tmp_path): @@ -48,30 +67,42 @@ def test_verified_download_precedes_shipped_default(tmp_path, monkeypatch): path = tmp_path / "download.pkl" monkeypatch.setattr(manager, "catalog", lambda _: {DEFAULT_SMALL: {"artifact_sha256": "download-hash", "version": "v15"}}) monkeypatch.setattr(manager, "verified_artifact", lambda *args: path) - def unexpected_shipped_default(): - raise AssertionError("download replaced") - monkeypatch.setattr(manager, "shipped_default", unexpected_shipped_default) - selected = manager.resolve_runtime(False, root=tmp_path) + fallback = tmp_path / "fallback.pkl" + def verified_fallback(plan): + assert plan is not None + return fallback + monkeypatch.setattr(manager, "shipped_default", verified_fallback) + selected = manager.resolve_runtime(False, root=tmp_path, plan=frozen_plan(tmp_path)) assert selected.small_path == path assert selected.small_sha256 == "download-hash" + assert selected.fallback_path == fallback + assert selected.small_path != selected.fallback_path +@pytest.mark.parametrize("family", ["native02e", "legacy9d"]) @pytest.mark.parametrize("damage", [None, "bytes", "size", "missing"]) -def test_shipped_parts_require_pinned_hash_and_size(tmp_path, monkeypatch, damage): +def test_shipped_parts_require_pinned_hash_and_size(tmp_path, monkeypatch, damage, family): data = b"small isolated compiled artifact fixture" source = tmp_path / "source.pkl" source.write_bytes(data) - destination = tmp_path / "rdf43_driving_tinygrad.pkl" + destination = tmp_path / ("compat9d/rdf43_driving_tinygrad.pkl" if family == "legacy9d" else "rdf43_driving_tinygrad.pkl") package_file(source, destination) monkeypatch.setattr(manager, "SHIPPED_MODELS", tmp_path) monkeypatch.setattr(manager, "DEFAULT_SMALL_SHA256", hashlib.sha256(data).hexdigest()) monkeypatch.setattr(manager, "DEFAULT_SMALL_SIZE", len(data) + (damage == "size")) - part = tmp_path / "rdf43_driving_tinygrad.pkl.chunk01of01" + with native_fixture(tmp_path, data) as document: + if damage == "size": + document["models"][0]["artifact_size"] += 1 + manager.NATIVE_CATALOG_PATH.write_text(json.dumps(document)) + record = manager.default_record(family, tmp_path) + plan = freeze_plan({"small": "rdf43" if family == "native02e" else "gwm8223", "big": ""}, + {"gwm8223": {"_runtime_family": "legacy9d"}}, record) + part = destination.with_name(destination.name + ".chunk01of01") if damage == "bytes": part.write_bytes(b"x" * len(data)) elif damage == "missing": part.unlink() - result = manager.shipped_default() + result = manager.shipped_default(plan) assert (result is not None) == (damage is None) if result is not None: assert result.read_bytes() == data @@ -86,15 +117,16 @@ def test_shipped_default_is_verified_asynchronously_in_menu(tmp_path, monkeypatc monkeypatch.setattr(manager, "SHIPPED_MODELS", shipped) monkeypatch.setattr(manager, "DEFAULT_SMALL_SHA256", hashlib.sha256(data).hexdigest()) monkeypatch.setattr(manager, "DEFAULT_SMALL_SIZE", len(data)) - owner = manager.ModelManager(root=tmp_path / "preferences", parked=lambda: True, gpu_present=lambda: False) - try: - owner.snapshot() - if owner.verify_worker is not None: - owner.verify_worker.join(2) - row = next(row for row in owner.snapshot()["models"] if row["value"] == DEFAULT_SMALL) - assert row["installed"] and row["selectable"] and not row["checking"] - owner.action("active", {"profile": "small", "model": DEFAULT_SMALL}) - selected = manager.resolve_runtime(False, root=owner.root) - assert selected.small_id == DEFAULT_SMALL and selected.small_path.read_bytes() == data - finally: - owner.close() + with native_fixture(tmp_path, data): + owner = manager.ModelManager(root=tmp_path / "preferences", parked=lambda: True, gpu_present=lambda: False) + try: + owner.snapshot() + if owner.verify_worker is not None: + owner.verify_worker.join(2) + row = next(row for row in owner.snapshot()["models"] if row["value"] == DEFAULT_SMALL) + assert row["installed"] and row["selectable"] and not row["checking"] + owner.action("active", {"profile": "small", "model": DEFAULT_SMALL}) + selected = manager.resolve_runtime(False, root=owner.root, plan=frozen_plan(owner.root)) + assert selected.small_id == DEFAULT_SMALL and selected.small_path.read_bytes() == data + finally: + owner.close() diff --git a/prebuilt.json b/prebuilt.json index 16cbc8caa9..fc24f93851 100644 --- a/prebuilt.json +++ b/prebuilt.json @@ -1 +1 @@ -{"protected_inventory_sha256": "3f83520d0fdaa65f801f3314d8b6e41714090eac5fb8fcd3ed70df2e0dc539b0", "schema_version": 1} +{"protected_inventory_sha256": "513a506b42cd5503d092aa0ae67f235b9db263f46127f1a934dff5af710c5484", "schema_version": 1} diff --git a/scripts/model_compiler.py b/scripts/model_compiler.py index 729e257a42..017d2725ea 100755 --- a/scripts/model_compiler.py +++ b/scripts/model_compiler.py @@ -57,7 +57,7 @@ def sha256_file(path: Path) -> str: return digest.hexdigest() -def compile_env(gpu: bool = False) -> dict[str, str]: +def compile_env(gpu: bool = False, *, native: bool = False) -> dict[str, str]: env = dict(os.environ) env["PYTHONPATH"] = os.pathsep.join((str(REPO_ROOT), str(REPO_ROOT / "tinygrad_repo"), env.get("PYTHONPATH", ""))) defaults = {"DEV": "QCOM", "IMAGE": "1", "FLOAT16": "1", "NOLOCALS": "1", "JIT_BATCH_SIZE": "0", "OPENPILOT_HACKS": "1"} @@ -67,6 +67,8 @@ def compile_env(gpu: bool = False) -> dict[str, str]: for key in ("IMAGE", "NOLOCALS", "OPENPILOT_HACKS"): env.pop(key, None) env.update(DEV="USB+AMD:LLVM", WARP_DEV="QCOM", GMMU="0", TC_OPT="2", TC_MIN_GLOBALS="32") + if native: + env["BEAM"] = "0" return env @@ -92,12 +94,17 @@ def parse_args(argv=None): return args -def bank_compiler_revision() -> str: +def bank_compiler_revision(*, native: bool = False) -> str: # The global runtime can advance while the compiled bank keeps its own ABI. old_path = sys.path[:] try: sys.path.insert(0, str(REPO_ROOT)) from openpilot.starpilot.models import catalog + if native: + from openpilot.starpilot.models import runtime_selection + if Path(runtime_selection.__file__).resolve() != (REPO_ROOT / "openpilot/starpilot/models/runtime_selection.py").resolve(): + raise ValueError("Native compiler identity came from a different checkout") + return runtime_selection.NATIVE_REVISION from openpilot.starpilot.models.runtime_bridge import bootstrap, runtime for module, relative in ((catalog, "catalog.py"), (bootstrap, "runtime_bridge/bootstrap.py"), (runtime, "runtime_bridge/runtime.py")): @@ -126,11 +133,13 @@ def main(argv=None): output_dir = args.output_dir.resolve() output_dir.mkdir(parents=True, exist_ok=True) output = output_dir / f"{args.model}_driving_tinygrad.pkl" - env = compile_env(args.gpu) + native = args.gpu or args.model == "rdf43" + env = compile_env(args.gpu, native=native) with tempfile.TemporaryDirectory(prefix=f".{args.model}-compile-", dir=output_dir) as temporary: env["TMPDIR"] = temporary staged = Path(temporary) / output.name - command = [sys.executable, "-m", "openpilot.starpilot.models.compile", "--model-type", model_type, + compiler_module = "openpilot.starpilot.models.compile_native" if native else "openpilot.starpilot.models.compile" + command = [sys.executable, "-m", compiler_module, "--model-type", model_type, "--model-size", "512x256", "--camera-resolutions", "1928x1208", "1344x760", "--behavior-version", args.version, "--output", str(staged), "--out-of-band", "--image-history-pipeline", args.image_history_pipeline, *source_args] @@ -139,12 +148,26 @@ def main(argv=None): subprocess.run(command, cwd=REPO_ROOT, env=env, check=True) if {path.name: sha256_file(path) for path in sources} != before: raise ValueError("ONNX source changed during compilation") - revision = bank_compiler_revision() + revision = bank_compiler_revision(native=native) receipt = {"model_id": args.model, "behavior_version": args.version, "model_type": model_type, - "artifact_abi": "tinygrad_single_v1_arena", "compiler_revision": revision, + "artifact_abi": "tinygrad_single_v2_arena" if native else "tinygrad_single_v1_arena", "compiler_revision": revision, "source_sha256": before, "artifact_sha256": sha256_file(staged), "artifact_size": staged.stat().st_size, "execution_device": env["DEV"], "warp_device": env.get("WARP_DEV", env["DEV"]), "image_history_pipeline": args.image_history_pipeline, "camera_resolutions": [[1928, 1208], [1344, 760]]} + if native: + receipt["qualification_status"] = "RAW_UNGUARDED_NOT_PUBLISHABLE" + launch, launch_receipt = staged.with_suffix(".launch.pkl"), staged.with_suffix(".launch.json") + companion = json.loads(launch_receipt.read_text()) + if (companion.get("format") != "tinygrad_pre_hcq_v1" or companion.get("compiler_revision") != revision or + companion.get("artifact_abi") != receipt["artifact_abi"] or + companion.get("native_artifact_sha256") != receipt["artifact_sha256"] or + companion.get("launch_sha256") != sha256_file(launch)): + raise ValueError("Native compiler companion identity mismatch") + receipt["launch_sha256"] = companion["launch_sha256"] + # Offline export only; inference never loads the companion. Guard + # preparation and artifact/device qualification remain separate gates. + launch.replace(output.with_suffix(".launch.pkl")) + launch_receipt.replace(output.with_suffix(".launch.json")) staged.replace(output) receipt_path = output.with_suffix(".build.json") temporary_receipt = Path(temporary) / receipt_path.name diff --git a/tools/laptop_device_build/package_model_chunks.py b/tools/laptop_device_build/package_model_chunks.py index d236cea081..f32f52ac54 100644 --- a/tools/laptop_device_build/package_model_chunks.py +++ b/tools/laptop_device_build/package_model_chunks.py @@ -1,6 +1,7 @@ """Package the compiled small-model outputs using established Dom model parts.""" import argparse from pathlib import Path +import sys # Resolve this checkout's stdlib-only owner, even for an absolute CLI invocation @@ -16,9 +17,16 @@ def main(): parser.add_argument('--source', type=Path, required=True) parser.add_argument('--destination', type=Path, required=True) args = parser.parse_args() + root = Path(__file__).resolve().parents[2] + sys.path.insert(0, str(root)) + from tools.laptop_device_build.qcom_artifact_contract import native_records, verified_native_asset + native = native_records(root) if args.source.resolve() == (root / 'openpilot/selfdrive/modeld/models').resolve() else None for name in ('dmonitoring_model_tinygrad.pkl', 'rdf43_driving_tinygrad.pkl'): - source = (_chunk_owner.materialize_file_chunked(args.source / name) - if name == 'rdf43_driving_tinygrad.pkl' else args.source / name) + if native is not None: + source = verified_native_asset(root, name, prefer_regular=True) + else: + source = (_chunk_owner.materialize_file_chunked(args.source / name) + if name == 'rdf43_driving_tinygrad.pkl' or not (args.source / name).is_file() else args.source / name) package_file(source, args.destination / name) if __name__ == '__main__': diff --git a/tools/laptop_device_build/qcom_artifact_contract.py b/tools/laptop_device_build/qcom_artifact_contract.py index 10f27800a9..b34fe3e55b 100644 --- a/tools/laptop_device_build/qcom_artifact_contract.py +++ b/tools/laptop_device_build/qcom_artifact_contract.py @@ -1,6 +1,9 @@ """Exact source and artifact contract for laptop-only DM and warp QCOM imports.""" import argparse +import ast +import importlib +import importlib.util import hashlib import json import os @@ -68,6 +71,140 @@ def compiler_tree(root: Path) -> Path: return legacy / 'tinygrad_repo' + +NATIVE_ASSETS = ("rdf43_driving_tinygrad.pkl", "dmonitoring_model_tinygrad.pkl", + "dm_warp_1344x760_tinygrad.pkl", "dm_warp_1928x1208_tinygrad.pkl") +NATIVE_BUILD_SOURCES = ( + "openpilot/common/transformations/camera.py", + "openpilot/common/transformations/model.py", + "openpilot/system/camerad/cameras/nv12_info.py", + "openpilot/selfdrive/modeld/models/dmonitoring_model.onnx", + "openpilot/starpilot/models/compile_native.py", +) +NATIVE_REVISION = "02e698160eed1751738212144a7ea2cfb160b3f1" + + +def _logical_source(path: Path) -> dict: + if path.is_symlink() or not path.is_file(): + raise ValueError(f"Missing regular native build input: {path}") + with path.open("rb") as stream: + prefix = stream.read(1024) + if prefix.startswith(b"version https://git-lfs.github.com/spec/v1\n"): + match = re.fullmatch(rb"version https://git-lfs.github.com/spec/v1\noid sha256:([0-9a-f]{64})\nsize ([1-9][0-9]*)\n?", prefix) + if match is None or len(prefix) != path.stat().st_size: + raise ValueError(f"Invalid native build LFS pointer: {path}") + return {"sha256": match[1].decode(), "bytes": int(match[2])} + return {"sha256": _sha(path), "bytes": path.stat().st_size} + + +def _native_dm_geometry(root: Path, width: int, height: int) -> dict: + path = root / "openpilot/system/camerad/cameras/nv12_info.py" + spec = importlib.util.spec_from_file_location("_native_build_nv12", path) + if spec is None or spec.loader is None: + raise ValueError("Missing native NV12 source loader") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + tree = ast.parse((root / "openpilot/common/transformations/model.py").read_text()) + sizes = [ast.literal_eval(node.value) for node in tree.body if isinstance(node, ast.Assign) and + any(isinstance(target, ast.Name) and target.id == "DM_INPUT_SIZE" for target in node.targets)] + if len(sizes) != 1: + raise ValueError("Missing native DM target geometry") + return {"camera": [width, height], "nv12": list(module.get_nv12_info(width, height)), + "warp_to": list(sizes[0]), "layout": "luma", "border_fill": 16, "transform_device": "NPY"} + + +def native_records(root: Path, *, verify_runtime: bool = False) -> dict | None: + """Read sealed native defaults separately from the unchanged legacy compiler package.""" + root = root.resolve() + bridge = root / "openpilot/starpilot/models/runtime_bridge" + source, catalog = bridge / "native.py", bridge.parent / "catalog-native02e.json" + if not source.exists() and not catalog.exists(): + return None + for path in (source, catalog, bridge / "native-policy.json"): + if path.is_symlink() or not path.is_file() or path.stat().st_size > 2 * 1024**2: + raise ValueError("Missing or invalid sealed native build contract") + nodes = ast.parse(source.read_text()).body + pins = [ast.literal_eval(node.value) for node in nodes if isinstance(node, ast.Assign) and + any(isinstance(target, ast.Name) and target.id == "POLICY_SHA256" for target in node.targets)] + if len(pins) != 1 or not _valid_sha(pins[0]) or _sha(bridge / "native-policy.json") != pins[0]: + raise ValueError("Native policy is not release-qualified") + policy = json.loads((bridge / "native-policy.json").read_text(), object_pairs_hook=_unique_pairs) + document = json.loads(catalog.read_text(), object_pairs_hook=_unique_pairs) + if (policy.get("compiler_revision") != NATIVE_REVISION or policy.get("catalog_sha256") != _sha(catalog) or + document.get("compiler_revision") != NATIVE_REVISION or document.get("generation") != "native02e-v1" or + document.get("artifact_abi") != "tinygrad_single_v2_arena"): + raise ValueError("Native build runtime/catalog identity changed") + build_sources = policy.get("build_sources") + if not isinstance(build_sources, dict) or set(build_sources) != set(NATIVE_BUILD_SOURCES): + raise ValueError("Native release lacks exact build source qualification") + for name, expected in build_sources.items(): + if _logical_source(root / name) != expected: + raise ValueError("Native build source changed; requalification required: " + name) + rows = document.get("models") + if not isinstance(rows, list): + raise ValueError("Invalid native model catalog") + rdf = [row for row in rows if isinstance(row, dict) and row.get("id") == "rdf43"] + stock = document.get("stock") + if len(rdf) != 1 or not isinstance(stock, dict) or set(stock) != set(NATIVE_ASSETS) - {NATIVE_ASSETS[0]}: + raise ValueError("Native bundled model set changed") + records = {NATIVE_ASSETS[0]: rdf[0], **stock} + for name, row in records.items(): + if (not isinstance(row, dict) or not _valid_sha(row.get("artifact_sha256")) or + type(row.get("artifact_size")) is not int or not 0 < row["artifact_size"] <= 2 * 1024**3 or + not _valid_sha(row.get("qualification_sha256"))): + raise ValueError("Invalid qualified native artifact: " + name) + if name in NATIVE_ASSETS[:2]: + if (not _valid_sha(row.get("source_sha256")) or type(row.get("source_bytes")) is not int or + not 0 < row["source_bytes"] <= 2 * 1024**3): + raise ValueError("Missing native ONNX source identity: " + name) + else: + width, height = map(int, name.removeprefix("dm_warp_").removesuffix("_tinygrad.pkl").split("x")) + if row.get("source_geometry") != _native_dm_geometry(root, width, height): + raise ValueError("Native DM warp geometry changed") + dm = records[NATIVE_ASSETS[1]] + if {"sha256": dm["source_sha256"], "bytes": dm["source_bytes"]} != build_sources[NATIVE_BUILD_SOURCES[3]]: + raise ValueError("Native DM ONNX identity changed") + if verify_runtime: + sys.path.insert(0, str(root)) + native = importlib.import_module("openpilot.starpilot.models.runtime_bridge.native") + if Path(native.__file__).resolve() != source.resolve() or native.ROOT.resolve() != root: + raise ValueError("Native build runtime import escaped this checkout") + if native._verify_policy() != policy: + raise ValueError("Native runtime/vendor/guard contract changed") + return records + + +def verified_native_asset(root: Path, name: str, *, prefer_regular: bool = False) -> Path: + """Authenticate shipped assets; never regenerate them from legacy recipes.""" + records = native_records(root) + if records is None or name not in records: + raise ValueError("Unknown native bundled artifact") + from openpilot.common.file_chunker import materialize_file_chunked + row, path = records[name], root / MODEL_DIR / name + if prefer_regular and path.is_file() and not path.is_symlink() and _sha(path) == row["artifact_sha256"]: + result = path + else: + result = materialize_file_chunked(path, expected_sha256=row["artifact_sha256"]) + if result.is_symlink() or result.stat().st_size != row["artifact_size"] or _sha(result) != row["artifact_sha256"]: + raise ValueError("Native bundled artifact changed: " + name) + return result + + +def verify_native_defaults(root: Path, *, prefer_regular: bool = False) -> dict: + records = native_records(root, verify_runtime=True) + if records is None: + raise ValueError("Native bundle is not selected") + for name in NATIVE_ASSETS: + verified_native_asset(root, name, prefer_regular=prefer_regular) + # Optional legacy models need their separately retained legacy RDF fallback. + from openpilot.common.file_chunker import materialize_file_chunked + from openpilot.starpilot.models.catalog import DEFAULT_SMALL_SHA256, DEFAULT_SMALL_SIZE + compat = materialize_file_chunked(root / MODEL_DIR / "compat9d/rdf43_driving_tinygrad.pkl", DEFAULT_SMALL_SHA256) + if compat.is_symlink() or compat.stat().st_size != DEFAULT_SMALL_SIZE: + raise ValueError("Retained legacy RDF fallback changed") + return records + + def commands(root: Path) -> dict[str, str]: sys.path.insert(0, str(root)) from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye @@ -106,7 +243,8 @@ def _sources(root: Path) -> dict[str, str]: # Logical compiler paths retain the original package provenance after relocation. return ('tinygrad_repo/' + path.relative_to(compiler).as_posix() if path.is_relative_to(compiler) else path.relative_to(root).as_posix()) - return {source_name(path): _sha(path) for path in sorted(paths)} + return {source_name(path): (_logical_source(path)["sha256"] if path.suffix == ".onnx" else _sha(path)) + for path in sorted(paths)} def _tokens(command: str, root: Path) -> list[str]: diff --git a/tools/laptop_device_build/validate_artifacts.py b/tools/laptop_device_build/validate_artifacts.py index 21b259a7c1..eb06956757 100755 --- a/tools/laptop_device_build/validate_artifacts.py +++ b/tools/laptop_device_build/validate_artifacts.py @@ -209,9 +209,13 @@ def validate(root: Path) -> None: raise ValueError(f"camera warp set differs from current camera configs: {sorted(actual_warps)}") for name in (*MODELS, *WARPS): require_qcom_pickle(model_dir / name) - shipped = materialize_file_chunked(model_dir / f"{DEFAULT_SMALL}_driving_tinygrad.pkl", DEFAULT_SMALL_SHA256) - if shipped.stat().st_size != DEFAULT_SMALL_SIZE: - raise ValueError("Shipped default model size differs from the published artifact") + from tools.laptop_device_build.qcom_artifact_contract import native_records, verify_native_defaults + if native_records(root) is not None: + verify_native_defaults(root) + else: + shipped = materialize_file_chunked(model_dir / f"{DEFAULT_SMALL}_driving_tinygrad.pkl", DEFAULT_SMALL_SHA256) + if shipped.stat().st_size != DEFAULT_SMALL_SIZE: + raise ValueError("Shipped default model size differs from the published artifact") def main() -> None: