bump opendbc

This reverts commit 15e5d2efb9.

.github/workflows/build-default-models.yaml

@@ -47,7 +47,6 @@ jobs:
           if [ "${{ inputs.target }}" = "big" ]; then
             NAME=$(python3 -c "from openpilot.sunnypilot.models.model_name import DEFAULT_BIG_MODEL; print(DEFAULT_BIG_MODEL)")
             HF_DEFAULTS_PATH="models/defaults/big"
-            ONNX_PATH="openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl"
           elif [ "${{ inputs.target }}" = "dm" ]; then
             ONNX_PATH="openpilot/selfdrive/modeld/models/dmonitoring_model.onnx"
             HF_DEFAULTS_PATH="models/defaults/dm"
@@ -117,6 +116,20 @@ jobs:
             ${{ github.workspace }}/${{ env.SMALL_PKL }} \
             --device-input "*" --out-of-band --benchmark-runs 1
 
+      - name: Chunk small pkl
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          python3 -c "
+          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+          import os
+          pkl = '${{ github.workspace }}/${{ env.SMALL_PKL }}'
+          size = os.path.getsize(pkl)
+          targets = get_chunk_targets(pkl, size)
+          chunk_file(pkl, targets)
+          print(f'Chunked into {len(targets)} files')
+          "
+
       - name: Prepare output
         env:
           MODEL_NAME: ${{ needs.resolve.outputs.safe_model_name }}
@@ -128,7 +141,8 @@ jobs:
           PKL_BASE="driving_tinygrad.pkl"
           mkdir -p "$OUTPUT_DIR"
 
-          cp "$MODELS_DIR/${PKL_BASE}" "$OUTPUT_DIR/"
+          cp "$MODELS_DIR/${PKL_BASE}".chunk* "$OUTPUT_DIR/"
+          cp "$MODELS_DIR/${PKL_BASE}.chunkmanifest" "$OUTPUT_DIR/"
 
           ONNX_SHA256=$(git cat-file blob "$(git ls-files -s "${{ github.workspace }}/${{ env.SMALL_ONNX }}" | awk '{print $2}')" | grep '^oid sha256:' | cut -d: -f2)
 
@@ -171,6 +185,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+          lfs: true
 
       - name: Pull big PKL via LFS
         run: git lfs pull -I "${{ env.BIG_PKL }}"
@@ -206,33 +221,19 @@ jobs:
               raise RuntimeError('Chestnut PCIe link not ready after 10 attempts')
           "
 
-      - name: Compile big warp
+      - name: Chunk big pkl
         run: |
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
-          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
-
-          CHESTNUT_TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32"
-          COMPILER="${{ github.workspace }}/tinygrad_repo/examples/openpilot"
-          MODELS_DIR="${{ github.workspace }}/openpilot/selfdrive/modeld/models"
-          MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
-
-          for res in $(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')"); do
-            CAM_W=$(echo $res | cut -d x -f1)
-            CAM_H=$(echo $res | cut -d x -f2)
-            STRIDE_INFO=$(python3 -c "
-          import sys
-          from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
-          s,y,u,sz = get_nv12_info(int(sys.argv[1]), int(sys.argv[2]))
-          print(f'{s},{y},{u},{sz}')
-          " $CAM_W $CAM_H)
-            WARP_PKL="${MODELS_DIR}/big_driving_warp_${res}_tinygrad.pkl"
-            env ${CHESTNUT_TG_FLAGS} python3 "${COMPILER}/compile_warp.py" \
-              --frame ${CAM_W},${CAM_H},${STRIDE_INFO} \
-              --warp-to ${MODEL_SIZE} \
-              --layout yuv420 \
-              --frames 2 \
-              --output "${WARP_PKL}"
-          done
+          export PYTHONPATH=${{ github.workspace }}
+          python3 -c "
+          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+          import os
+          pkl = '${{ github.workspace }}/${{ env.BIG_PKL }}'
+          size = os.path.getsize(pkl)
+          targets = get_chunk_targets(pkl, size)
+          chunk_file(pkl, targets)
+          print(f'Chunked into {len(targets)} files')
+          "
 
       - name: Prepare output
         env:
@@ -245,9 +246,10 @@ jobs:
           PKL_BASE="big_driving_tinygrad.pkl"
           mkdir -p "$OUTPUT_DIR"
 
-          cp "$MODELS_DIR/${PKL_BASE}" "$OUTPUT_DIR/"
+          cp "$MODELS_DIR/${PKL_BASE}".chunk* "$OUTPUT_DIR/"
+          cp "$MODELS_DIR/${PKL_BASE}.chunkmanifest" "$OUTPUT_DIR/"
 
-          PKL_LFS_SHA256=$(git cat-file blob "$(git ls-files -s "${{ github.workspace }}/${{ env.BIG_PKL }}" | awk '{print $2}')" | grep '^oid sha256:' | cut -d: -f2)
+          PKL_LFS_SHA256=$(sha256sum "$MODELS_DIR/${PKL_BASE}" | cut -d' ' -f1)
 
           python3 "${{ github.workspace }}/release/ci/model_generator.py" \
             --model-dir "$MODELS_DIR" \
@@ -256,8 +258,6 @@ jobs:
             --upstream-branch "${{ needs.resolve.outputs.onnx_ref }}" \
             --onnx-sha256 "$PKL_LFS_SHA256"
 
-          cp "$MODELS_DIR"/big_driving_warp_* "$OUTPUT_DIR/" || true
-
           echo "model-${MODEL_NAME}-${{ github.run_number }}" > "$OUTPUT_DIR/artifact_name.txt"
 
       - name: Upload big model artifact
@@ -335,8 +335,6 @@ jobs:
             --hf-defaults-path "${{ needs.resolve.outputs.hf_defaults_path }}" \
             --artifact-name "$ARTIFACT_NAME" \
             --model-dir output \
-            --onnx-path "${{ needs.resolve.outputs.onnx_path }}" \
-            --onnx-ref "${{ needs.resolve.outputs.onnx_ref }}" \
             --model-name "${{ needs.resolve.outputs.model_name }}" \
             --tinygrad-ref "${{ needs.resolve.outputs.tinygrad_ref }}" \
             --run-number "${{ github.run_number }}"
@@ -360,14 +358,24 @@ jobs:
           from datetime import datetime, UTC
 
           dm_dir = Path('dm_output')
-          matches = sorted(dm_dir.glob('dmonitoring_*_tinygrad.pkl'))
-          assert len(matches) == 1, f'expected one DM pkl in {dm_dir}, found {matches}'
-          pkl_name = matches[0].name
+          manifest = list(dm_dir.glob('*.chunkmanifest'))
+          assert manifest, 'No chunkmanifest found'
+          pkl_name = manifest[0].name.removesuffix('.chunkmanifest')
+          num_chunks = int(manifest[0].read_text().strip())
+
+          chunks = []
+          for i in range(num_chunks):
+              chunk = dm_dir / f'{pkl_name}.chunk{i+1:02d}of{num_chunks:02d}'
+              chunks.append({
+                  'file_name': chunk.name,
+                  'sha256': hashlib.sha256(chunk.read_bytes()).hexdigest()
+              })
 
           digest = hashlib.sha256()
-          with open(dm_dir / pkl_name, 'rb') as f:
-              while block := f.read(1024*1024):
-                  digest.update(block)
+          for c in chunks:
+              with open(dm_dir / c['file_name'], 'rb') as f:
+                  while block := f.read(1024*1024):
+                      digest.update(block)
 
           metadata = {
               'bundles': [{
@@ -381,7 +389,8 @@ jobs:
                       'type': 'chunked',
                       'artifact': {
                           'file_name': pkl_name,
-                          'download_uri': {'url': '', 'sha256': digest.hexdigest()}
+                          'download_uri': {'url': '', 'sha256': digest.hexdigest()},
+                          'chunks': chunks
                       }
                   }]
               }]
@@ -444,6 +453,20 @@ jobs:
             ${{ github.workspace }}/${{ env.DM_ONNX }} \
             ${{ github.workspace }}/${{ env.DM_PKL }}
 
+      - name: Chunk DM pkl
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          python3 -c "
+          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+          import os
+          pkl = '${{ github.workspace }}/${{ env.DM_PKL }}'
+          size = os.path.getsize(pkl)
+          targets = get_chunk_targets(pkl, size)
+          chunk_file(pkl, targets)
+          print(f'Chunked {pkl} into {len(targets)} chunks')
+          "
+
       - name: Compile DM warp
         run: |
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
@@ -476,7 +499,8 @@ jobs:
       - name: Prepare DM output
         run: |
           mkdir -p dm_output
-          cp ${{ github.workspace }}/${{ env.DM_PKL }} dm_output/
+          cp ${{ github.workspace }}/${{ env.DM_PKL }}.chunk* dm_output/
+          cp ${{ github.workspace }}/${{ env.DM_PKL }}.chunkmanifest dm_output/
           cp ${{ github.workspace }}/openpilot/selfdrive/modeld/models/dm_warp_* dm_output/
 
       - name: Upload DM artifact
@@ -490,3 +514,4 @@ jobs:
         run: |
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
           PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
+

.github/workflows/build-single-tinygrad-model.yaml

@@ -137,7 +137,6 @@ jobs:
     needs: build_model
     runs-on: ubuntu-latest
     permissions:
-      actions: read
       id-token: write
       contents: write
     steps:
@@ -180,21 +179,18 @@ jobs:
           echo "artifact_name=$ARTIFACT_NAME" >> $GITHUB_OUTPUT
 
       - name: Download and extract model artifact
-        env:
-          GH_TOKEN: ${{ github.token }}
-          ARTIFACT_NAME: ${{ steps.read-artifact-name.outputs.artifact_name }}
-        run: |
-          id=$(gh api -X GET "repos/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID/artifacts" -f name="$ARTIFACT_NAME" --jq '.artifacts[0].id')
-          url=$(curl -sf -o /dev/null -w '%{redirect_url}' -H "Authorization: Bearer $GH_TOKEN" "https://api.github.com/repos/$GITHUB_REPOSITORY/actions/artifacts/$id/zip")
-          sudo apt-get install -y -qq aria2 > /dev/null
-          aria2c -q -x16 -s16 -k8M --max-tries=5 --file-allocation=none -o model.zip "$url" && unzip -q model.zip -d output && rm model.zip
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ steps.read-artifact-name.outputs.artifact_name }}
+          path: output
 
       - name: Create models folder
         env:
           ARTIFACT_NAME: ${{ steps.read-artifact-name.outputs.artifact_name }}
         run: |
           mkdir -p "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}"
-          cp output/metadata.json "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/"
+          cp -r output/* "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/"
+          rm -f "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/artifact_name.txt"
 
       - name: Upload to Hugging Face
         env:

.github/workflows/compile-warp-kernels.yaml

@@ -2,6 +2,8 @@ name: Compile warp for sunnypilot modeld
 
 on:
   workflow_dispatch:
+  schedule:
+    - cron: '0 0 * * 0'
 
 jobs:
   compile_warps:
@@ -41,13 +43,13 @@ jobs:
 
             WARP_PKL="openpilot/sunnypilot/modeld_v2/models/driving_warp_${res}_tinygrad.pkl"
             echo "Compiling $WARP_PKL on QCOM"
-            taskset -c 7 env DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1 python3 openpilot/sunnypilot/modeld_v2/compile_warp.py \
-              --frame ${FRAME_PARAM} --warp-to ${MODEL_SIZE} --output "${WARP_PKL}"
+            taskset -c 7 env DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1 python3 tinygrad_repo/examples/openpilot/compile_warp.py \
+              --frame ${FRAME_PARAM} --warp-to ${MODEL_SIZE} --layout yuv420 --frames 2 --output "${WARP_PKL}"
 
             BIG_WARP_PKL="openpilot/sunnypilot/modeld_v2/models/big_driving_warp_${res}_tinygrad.pkl"
             echo "Compiling $BIG_WARP_PKL on AMD"
-            taskset -c 7 env DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32 python3 openpilot/sunnypilot/modeld_v2/compile_warp.py \
-              --frame ${FRAME_PARAM} --warp-to ${MODEL_SIZE} --output "${BIG_WARP_PKL}"
+            taskset -c 7 env DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32 python3 tinygrad_repo/examples/openpilot/compile_warp.py \
+              --frame ${FRAME_PARAM} --warp-to ${MODEL_SIZE} --layout yuv420 --frames 2 --output "${BIG_WARP_PKL}"
           done
 
       - name: Re-enable powersave

.github/workflows/download-hf-model-chunks/action.yml

@@ -1,5 +1,5 @@
-name: Download HF model
-description: Resolve and download models from HuggingFace in parallel
+name: Download HF model chunks
+description: Resolve and download model chunks from HuggingFace in parallel
 
 inputs:
   hf_repo:
@@ -19,7 +19,7 @@ inputs:
 runs:
   using: composite
   steps:
-    - name: Download models
+    - name: Download model chunks
       shell: bash
       env:
         HF_REPO: ${{ inputs.hf_repo }}
@@ -33,7 +33,7 @@ runs:
         resolve_chunks() {
           local HF_PATH="$1" ONNX_HASH="$2" CANONICAL="$3" DEST_DIR="$4"
           local JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_PATH}/default_models.json"
-          local DEFAULTS BUNDLE ARTIFACT FILE_URL BASE_URL
+          local DEFAULTS BUNDLE ARTIFACT BASE_URL NUM_CHUNKS
           DEFAULTS=$(curl -fsSL "$JSON_URL")
           if [ -n "$TINYGRAD_REF" ]; then
             BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" --arg tg "$TINYGRAD_REF" '
@@ -51,23 +51,26 @@ runs:
           fi
 
           ARTIFACT=$(echo "$BUNDLE" | jq -r '.models[0].artifact')
-          FILE_URL=$(echo "$ARTIFACT" | jq -r '.download_uri.url')
-          BASE_URL=$(echo "$FILE_URL" | sed 's|/[^/]*$||')
+          BASE_URL=$(echo "$ARTIFACT" | jq -r '.download_uri.url' | sed 's|/[^/]*$||')
+          NUM_CHUNKS=$(echo "$ARTIFACT" | jq -r '.chunks | length')
 
           mkdir -p "$DEST_DIR"
-          ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${FILE_URL}', safe=':/'))")
-          printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${CANONICAL}" >> "$DOWNLOAD_LIST"
+          while IFS= read -r CHUNK_NAME; do
+            CHUNK_IDX=$(echo "$CHUNK_NAME" | grep -oP 'chunk\K[0-9]+of[0-9]+' || true)
+            if [ -z "$CHUNK_IDX" ]; then
+              echo "::error::Failed to parse chunk index from: $CHUNK_NAME"
+              return 1
+            fi
+            ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${BASE_URL}/${CHUNK_NAME}', safe=':/'))")
+            printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${CANONICAL}.chunk${CHUNK_IDX}" >> "$DOWNLOAD_LIST"
+          done < <(echo "$ARTIFACT" | jq -r '.chunks[].file_name')
+          echo "$NUM_CHUNKS" > "${DEST_DIR}/${CANONICAL}.chunkmanifest"
 
           if [ "$CANONICAL" = "dmonitoring_model_tinygrad.pkl" ]; then
             for warp in dm_warp_1928x1208_tinygrad.pkl dm_warp_1344x760_tinygrad.pkl; do
               ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${BASE_URL}/${warp}', safe=':/'))")
               printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${warp}" >> "$DOWNLOAD_LIST"
             done
-          elif [ "$CANONICAL" = "big_driving_tinygrad.pkl" ]; then
-            for warp in big_driving_warp_1928x1208_tinygrad.pkl big_driving_warp_1344x760_tinygrad.pkl; do
-              ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${BASE_URL}/${warp}', safe=':/'))")
-              printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${warp}" >> "$DOWNLOAD_LIST"
-            done
           fi
         }
 
@@ -79,7 +82,7 @@ runs:
         done
 
         TOTAL=$(wc -l < "$DOWNLOAD_LIST")
-        echo "Downloading $TOTAL files with 8 parallel connections..."
+        echo "Downloading $TOTAL chunks with 8 parallel connections..."
         xargs -P8 -d'\n' -I{} bash -c '
           URL="${1%%	*}"
           DEST="${1#*	}"

.github/workflows/sunnypilot-build-model.yaml

@@ -102,39 +102,56 @@ jobs:
           cat $GITHUB_OUTPUT
 
       - name: Fetch Models
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
         run: |
           cd ${{ github.workspace }}/openpilot/openpilot
-          fetch_lfs() {
-            sudo apt-get install -y -qq aria2 > /dev/null # Parallel ranges because gh is flaky
-            LFS_URL=$(git config -f "$(git rev-parse --show-toplevel)/.lfsconfig" lfs.url)
-            for f in "$@"; do
-              grep -qs "^version https://git-lfs" "$f" || continue
-              OID=$(awk -F'sha256:' '/^oid/{print $2}' "$f"); SIZE=$(awk '/^size/{print $2}' "$f")
-              HREF=$(curl -fsSL --retry 3 -X POST -H "Accept: application/vnd.git-lfs+json" -H "Content-Type: application/vnd.git-lfs+json" "$LFS_URL/objects/batch" \
-                -d "{\"operation\":\"download\",\"transfer\":[\"basic\"],\"objects\":[{\"oid\":\"$OID\",\"size\":$SIZE}]}" | jq -r '.objects[0].actions.download.href')
-              aria2c -x 16 -s 16 -k 16M --max-tries=5 --retry-wait=5 --file-allocation=none --summary-interval=30 --allow-overwrite=true \
-                -d "$(dirname "$f")" -o "$(basename "$f")" "$HREF"
-              echo "$OID  $f" | sha256sum -c -
-            done
-          }
-          UPSTREAM_PKL=selfdrive/modeld/models/big_driving_tinygrad.pkl
           if [ "${{ inputs.target_hardware }}" != "chestnut" ]; then
-            git lfs pull -X "**/selfdrive/modeld/models/big_*.onnx,**/selfdrive/modeld/models/dmonitoring_*.onnx,**/selfdrive/modeld/models/big_*.pkl,**/selfdrive/modeld/models/dmonitoring_*.pkl"
-            rm -f selfdrive/modeld/models/big_*.onnx selfdrive/modeld/models/dmonitoring_*.onnx selfdrive/modeld/models/big_*.pkl selfdrive/modeld/models/dmonitoring_*.pkl
-          elif compgen -G "selfdrive/modeld/models/big_*.onnx" > /dev/null; then
-            fetch_lfs selfdrive/modeld/models/big_*.onnx selfdrive/modeld/models/big_*.pkl
-            find selfdrive/modeld/models -type f \( -name "*.onnx" -o -name "*.pkl" \) ! -name "big_*.onnx" ! -name "big_*.pkl" -delete
-          elif [ -f "$UPSTREAM_PKL" ]; then
-            echo "No big model ONNX tracked: converting commaai's precompiled $UPSTREAM_PKL, with the tinygrad it was built with"
-            fetch_lfs "$UPSTREAM_PKL"
-            find selfdrive/modeld/models -type f \( -name "*.onnx" -o -name "*.pkl" \) ! -path "$UPSTREAM_PKL" -delete
-            GITMODULES="$(git rev-parse --show-toplevel)/.gitmodules"
-            TG_NAME=$(git config -f "$GITMODULES" --get-regexp '^submodule\..*\.path$' | awk '$2 == "tinygrad_repo" {sub(/^submodule\./, "", $1); sub(/\.path$/, "", $1); print $1}')
-            TG_URL=$(git config -f "$GITMODULES" "submodule.$TG_NAME.url" | sed 's|^\.\./\.\./|https://github.com/|')
-            echo "$TG_URL $(git rev-parse HEAD:tinygrad_repo) $(sha256sum "$UPSTREAM_PKL" | cut -d' ' -f1)" > selfdrive/modeld/models/upstream_pkl.txt
+            ONNX_COUNT=$(find selfdrive/modeld/models -maxdepth 1 -type f -name "*.onnx" ! -name "big_*.onnx" ! -name "dmonitoring_*.onnx" 2>/dev/null | wc -l)
           else
-            echo "::error::no big model ONNX or precompiled big_driving_tinygrad.pkl at this ref"
-            exit 1
+            ONNX_COUNT=$(find selfdrive/modeld/models -maxdepth 1 -type f -name "big_*.onnx" 2>/dev/null | wc -l)
+          fi
+          if [ "$ONNX_COUNT" -eq 0 ]; then
+            echo "Detected NEW stock architecture (no ONNX files tracked). Fetching from HF and skipping LFS pull."
+            COMMIT_MSG=$(git log -1 --pretty=%B)
+            HF_HASH=$(echo "$COMMIT_MSG" | grep -oE '[a-f0-9]{8}' | head -n 1)
+
+            if [ -n "$HF_HASH" ]; then
+              echo "Downloading ONNX for hash $HF_HASH from HuggingFace."
+              pip install huggingface_hub
+              rm -f selfdrive/modeld/models/*.onnx
+              python3 - <<EOF
+          import sys, os, shutil
+          from huggingface_hub import HfApi, hf_hub_download
+          short_hash = "$HF_HASH"
+          target_dir = "selfdrive/modeld/models"
+          repo = "commaai/openpilot_driving_models"
+          api = HfApi()
+          files = list(api.list_repo_tree(repo, repo_type="model", recursive=True))
+          matching_folder = next((f.path.split("/")[0] for f in files if f.path.startswith(short_hash)), None)
+          if not matching_folder:
+            print(f"Could not find HF folder for hash {short_hash}")
+            sys.exit(1)
+          os.makedirs(target_dir, exist_ok=True)
+          for f in files:
+            if f.path.startswith(matching_folder) and f.path.endswith(".onnx"):
+              p = hf_hub_download(repo_id=repo, repo_type="model", filename=f.path)
+              shutil.copy2(p, os.path.join(target_dir, os.path.basename(f.path)))
+          EOF
+              rm -f selfdrive/modeld/models/*.pkl
+              touch selfdrive/modeld/models/new_arch.txt
+            else
+              echo "Could not parse HuggingFace hash from commit message."
+              exit 1
+            fi
+          else
+            if [ "${{ inputs.target_hardware }}" != "chestnut" ]; then
+              git lfs pull -X "**/selfdrive/modeld/models/big_*.onnx,**/selfdrive/modeld/models/dmonitoring_*.onnx,**/selfdrive/modeld/models/big_*.pkl,**/selfdrive/modeld/models/dmonitoring_*.pkl"
+              rm -f selfdrive/modeld/models/big_*.onnx selfdrive/modeld/models/dmonitoring_*.onnx selfdrive/modeld/models/big_*.pkl selfdrive/modeld/models/dmonitoring_*.pkl
+            else
+              git lfs pull -I "**/selfdrive/modeld/models/big_*.onnx,**/selfdrive/modeld/models/big_*.pkl" -X ""
+              find selfdrive/modeld/models -type f \( -name "*.onnx" -o -name "*.pkl" \) ! -name "big_*.onnx" ! -name "big_*.pkl" -delete
+            fi
           fi
 
           if grep -lIF "version https://git-lfs.github.com/spec/v1" selfdrive/modeld/models/*.onnx selfdrive/modeld/models/*.pkl 2>/dev/null; then
@@ -145,11 +162,10 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: models-${{ env.REF }}${{ inputs.artifact_suffix  }}
-          compression-level: 0
           path: |
             ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/*.onnx
             ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/*.pkl
-            ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/upstream_pkl.txt
+            ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/new_arch.txt
           if-no-files-found: error
 
   build_model:
@@ -208,11 +224,11 @@ jobs:
           MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
           CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")
 
-          TG_FLAGS_QCOM="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 OPENPILOT_HACKS=1"
+          TG_FLAGS_QCOM="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
           if [ "${{ inputs.target_hardware }}" == "chestnut" ]; then
             echo "CHESTNUT build"
             export CHESTNUT=1
-            TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32"
+            TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32"
             OUTPUT_PKL="${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl"
           else
             echo "QCOM build"
@@ -222,20 +238,20 @@ jobs:
 
           NATIVE_PKL=$(find "${{ env.MODELS_DIR }}" -maxdepth 1 -name "*.pkl" -print -quit)
 
-          if [ -f "${{ env.MODELS_DIR }}/upstream_pkl.txt" ]; then
-            read -r TG_URL TG_SHA _ < "${{ env.MODELS_DIR }}/upstream_pkl.txt"
-            echo "Converting commaai's precompiled model with tinygrad $TG_SHA"
-            UPSTREAM_TG="${{ runner.temp }}/upstream_tinygrad"
-            rm -rf "$UPSTREAM_TG" && git init -q "$UPSTREAM_TG" && git -C "$UPSTREAM_TG" fetch -q --depth 1 "$TG_URL" "$TG_SHA" && git -C "$UPSTREAM_TG" checkout -q FETCH_HEAD
-            CONVERTED="${{ runner.temp }}/big_driving_tinygrad_plain.pkl"
-            env DEV=USB+AMD PYTHONPATH="$UPSTREAM_TG:${{ github.workspace }}" taskset -c 7 python3 openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py \
-              "${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl" "$CONVERTED"
-            mv "$CONVERTED" "$OUTPUT_PKL"
-          elif NEW_ARCH_ONNX=$(find "${{ env.MODELS_DIR }}" -maxdepth 1 -name "${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}*driving*.onnx" -print -quit) &&
-               [ -n "$NEW_ARCH_ONNX" ] && grep -qa new_img "$NEW_ARCH_ONNX"; then # the new architecture: one ONNX taking the warped frames as new_img
-            echo "Compiling new architecture ONNX: $NEW_ARCH_ONNX"
-            env ${TG_FLAGS} taskset -c 7 python3 openpilot/sunnypilot/modeld_v2/compile_modeld_v2.py \
-              "$NEW_ARCH_ONNX" "$OUTPUT_PKL" --device-input "*" --benchmark-runs 1
+          if [ -f "${{ env.MODELS_DIR }}/new_arch.txt" ]; then
+            echo "Detected new arch"
+            DOWNLOADED_ONNX=$(find "${{ env.MODELS_DIR }}" -maxdepth 1 -name "*driving*.onnx" -print -quit)
+            if [ -n "$DOWNLOADED_ONNX" ]; then
+              echo "Compiling ONNX: $DOWNLOADED_ONNX"
+              env ${TG_FLAGS} taskset -c 7 python3 openpilot/sunnypilot/modeld_v2/compile_modeld_v2.py \
+                "$DOWNLOADED_ONNX" "$OUTPUT_PKL" --device-input "*" --out-of-band --benchmark-runs 1
+
+              echo "Chunking pkl"
+              python3 -c "from openpilot.common.file_chunker import chunk_file, get_chunk_targets; import os; p='$OUTPUT_PKL'; chunk_file(p, get_chunk_targets(p, os.path.getsize(p)))"
+            else
+              echo "Failed to find downloaded ONNX."
+              exit 1
+            fi
           else
             echo "Detected onnx architecture. Routing to native compile_modeld.py."
             # Detect model type and build compile args
@@ -301,7 +317,8 @@ jobs:
           # Copy the model files
           rsync -avm \
             --include='*.dlc' \
-            --include='/${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}driving_tinygrad.pkl' \
+            --include='*.chunk*' \
+            --include='*.chunkmanifest' \
             --exclude='*' \
             --delete-excluded \
             --chown=comma:comma \
@@ -312,7 +329,6 @@ jobs:
             --output-dir "${{ env.OUTPUT_DIR }}" \
             --custom-name "${{ env.MODEL_NAME }}" \
             --upstream-branch "${{ inputs.upstream_branch }}" \
-            $([ -f "${{ env.MODELS_DIR }}/upstream_pkl.txt" ] && echo "--onnx-sha256 $(cut -d' ' -f3 "${{ env.MODELS_DIR }}/upstream_pkl.txt")") \
             ${{ inputs.is_20hz && '--is-20hz' || '' }}
 
       - name: Write artifact name to file
@@ -324,7 +340,6 @@ jobs:
         with:
           name: model-${{ env.MODEL_NAME }}${{ inputs.artifact_suffix }}-${{ github.run_number }}
           path: ${{ env.OUTPUT_DIR }}
-          compression-level: 0
 
       - name: Upload artifact name file
         uses: actions/upload-artifact@v4

.github/workflows/sunnypilot-build-prebuilt.yaml

@@ -503,8 +503,8 @@ jobs:
           mkdir -p ${{ env.OUTPUT_DIR }}
           tar xzf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }}
 
-      - name: Download models from HF
-        uses: ./.github/workflows/download-hf-model
+      - name: Download model chunks from HF
+        uses: ./.github/workflows/download-hf-model-chunks
         with:
           hf_repo: sunnypilot/sunnypilot_models_v1
           dest_dir: ${{ env.OUTPUT_DIR }}/openpilot/selfdrive/modeld/models
@@ -573,8 +573,8 @@ jobs:
           mkdir -p ${{ env.OUTPUT_DIR }}
           tar xzf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }}
 
-      - name: Download models from HF
-        uses: ./.github/workflows/download-hf-model
+      - name: Download model chunks from HF
+        uses: ./.github/workflows/download-hf-model-chunks
         with:
           hf_repo: sunnypilot/sunnypilot_models_v1
           dest_dir: ${{ env.OUTPUT_DIR }}/openpilot/selfdrive/modeld/models

.github/workflows/test_models.yml

@@ -47,22 +47,38 @@ jobs:
         with:
           submodules: true
 
-      - name: Download model
+      - name: Download Model Chunks in Parallel
         env:
           HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          MODEL_URL: ${{ matrix.artifact.download_uri.url }}
-          MODEL_FILE: ${{ matrix.artifact.file_name }}
-        shell: bash
         run: |
-          mkdir -p /tmp/models
-          AUTH=()
-          if [ -n "$HF_TOKEN" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi
-          curl --retry 3 --retry-all-errors -s -S -f -L "${AUTH[@]}" -o "/tmp/models/$MODEL_FILE" "$MODEL_URL"
+          mkdir -p /tmp/model_chunks
+          echo '${{ toJson(matrix.artifact.chunks) }}' > chunks.json
+
+          BASE_URL="${{ matrix.artifact.download_uri.url }}"
+          export BASE_DIR=$(dirname "$BASE_URL")
+
+          python3 -c '
+          import json, os
+          with open("chunks.json") as f:
+            chunks = json.load(f)
+          manifest_path = f"/tmp/model_chunks/${{ matrix.artifact.file_name }}.chunkmanifest"
+          with open(manifest_path, "w") as f:
+            f.write(str(len(chunks)))
+          base_dir = os.environ["BASE_DIR"]
+          hf_token = os.environ.get("HF_TOKEN", "")
+          with open("/tmp/curl_config.txt", "w") as f:
+            for c in chunks:
+              fn = c["file_name"]
+              f.write(f"url = \"{base_dir}/{fn}\"\noutput = \"/tmp/model_chunks/{fn}\"\n")
+              if hf_token:
+                f.write(f"header = \"Authorization: Bearer {hf_token}\"\n")
+          '
+          curl -Z --parallel-immediate --parallel-max 12 --retry 3 --retry-all-errors -s -S -f -L -K /tmp/curl_config.txt
 
       - name: Run Model Compatibility Test
         env:
           MODEL_BASE_NAME: ${{ matrix.artifact.file_name }}
-          MODEL_DIR: "/tmp/models"
+          MODEL_CHUNK_DIR: "/tmp/model_chunks"
         run: |
           export PYTHONPATH="$GITHUB_WORKSPACE/tinygrad_repo:$GITHUB_WORKSPACE:$PYTHONPATH"
           python3 -m pip uninstall -y tinygrad || uv pip uninstall -y tinygrad --system || true

openpilot/cereal/custom.capnp

@@ -196,6 +196,7 @@ struct ModelManagerSP @0xaedffd8f31e7b55d {
 }
 
 struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
+  dec @0 :DynamicExperimentalControl;
   longitudinalPlanSource @1 :LongitudinalPlanSource;
   smartCruiseControl @2 :SmartCruiseControl;
   speedLimit @3 :SpeedLimit;
@@ -204,11 +205,7 @@ struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
   events @6 :List(OnroadEventSP.Event);
   e2eAlerts @7 :E2eAlerts;
 
-  deprecated :group {
-    dec @0 :DynamicExperimentalControlDEPRECATED;
-  }
-
-  struct DynamicExperimentalControlDEPRECATED {
+  struct DynamicExperimentalControl {
     state @0 :DynamicExperimentalControlState;
     enabled @1 :Bool;
     active @2 :Bool;

openpilot/common/params_keys.h

@@ -240,6 +240,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ToyotaEnforceStockLongitudinal", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ToyotaStopAndGoHack", {PERSISTENT | BACKUP, BOOL, "0"}},
 
+    {"DynamicExperimentalControl", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"BlindSpot", {PERSISTENT | BACKUP, BOOL, "0"}},
 
     // sunnypilot model params

openpilot/selfdrive/car/card.py

@@ -127,6 +127,9 @@ class Car:
     set_alternative_experience(self.CP, self.CP_SP, self.params)
     set_car_specific_params(self.CP, self.CP_SP, self.params)
 
+    # Dynamic Experimental Control
+    self.dynamic_experimental_control = self.params.get_bool("DynamicExperimentalControl")
+
     openpilot_enabled_toggle = self.params.get_bool("OpenpilotEnabledToggle")
     controller_available = self.CI.CC is not None and openpilot_enabled_toggle and not self.CP.dashcamOnly
     self.CP.passive = not controller_available or self.CP.dashcamOnly
@@ -211,7 +214,7 @@ class Car:
     self.v_cruise_helper.update_v_cruise(CS, self.sm['carControl'].enabled, self.is_metric)
     if self.sm['carControl'].enabled and not self.CC_prev.enabled:
       # Use CarState w/ buttons from the step selfdrived enables on
-      self.v_cruise_helper.initialize_v_cruise(self.CS_prev, self.experimental_mode)
+      self.v_cruise_helper.initialize_v_cruise(self.CS_prev, self.experimental_mode, self.dynamic_experimental_control)
 
     # TODO: mirror the carState.cruiseState struct?
     CS.vCruise = float(self.v_cruise_helper.v_cruise_kph)
@@ -299,6 +302,7 @@ class Car:
       self.experimental_mode = self.params.get_bool("ExperimentalMode") and self.CP.openpilotLongitudinalControl
 
       # sunnypilot
+      self.dynamic_experimental_control = self.params.get_bool("DynamicExperimentalControl")
       self.v_cruise_helper.read_custom_set_speed_params()
 
       time.sleep(0.1)

openpilot/selfdrive/car/cruise.py

@@ -138,12 +138,13 @@ class VCruiseHelper(VCruiseHelperSP):
         self.button_timers[b.type.raw] = 1 if b.pressed else 0
         self.button_change_states[b.type.raw] = {"standstill": CS.cruiseState.standstill, "enabled": enabled}
 
-  def initialize_v_cruise(self, CS, experimental_mode: bool) -> None:
+  def initialize_v_cruise(self, CS, experimental_mode: bool, dynamic_experimental_control: bool) -> None:
     # initializing is handled by the PCM
     if self.CP.pcmCruise:
       return
 
-    initial = V_CRUISE_INITIAL_EXPERIMENTAL_MODE if experimental_mode else V_CRUISE_INITIAL
+    initial_experimental_mode = experimental_mode and not dynamic_experimental_control
+    initial = V_CRUISE_INITIAL_EXPERIMENTAL_MODE if initial_experimental_mode else V_CRUISE_INITIAL
 
     if any(b.type in (ButtonType.accelCruise, ButtonType.resumeCruise) for b in CS.buttonEvents) and self.v_cruise_initialized:
       self.v_cruise_kph = self.v_cruise_kph_last

openpilot/selfdrive/car/tests/test_cruise_speed.py

@@ -59,16 +59,16 @@ class TestVCruiseHelper(OpenpilotTestCase):
     for _ in range(2):
       self.v_cruise_helper.update_v_cruise(car.CarState(cruiseState={"available": False}), enabled=False, is_metric=False)
 
-  def enable(self, v_ego, experimental_mode):
+  def enable(self, v_ego, experimental_mode, dynamic_experimental_control):
     # Simulates user pressing set with a current speed
-    self.v_cruise_helper.initialize_v_cruise(car.CarState(vEgo=v_ego), experimental_mode)
+    self.v_cruise_helper.initialize_v_cruise(car.CarState(vEgo=v_ego), experimental_mode, dynamic_experimental_control)
 
   def test_adjust_speed(self):
     """
     Asserts speed changes on falling edges of buttons.
     """
 
-    self.enable(V_CRUISE_INITIAL * CV.KPH_TO_MS, False)
+    self.enable(V_CRUISE_INITIAL * CV.KPH_TO_MS, False, False)
 
     for btn in (ButtonType.accelCruise, ButtonType.decelCruise):
       for pressed in (True, False):
@@ -92,7 +92,7 @@ class TestVCruiseHelper(OpenpilotTestCase):
       CS.buttonEvents = [ButtonEvent(type=ButtonType.decelCruise, pressed=pressed)]
       self.v_cruise_helper.update_v_cruise(CS, enabled=enabled, is_metric=False)
       if pressed:
-        self.enable(V_CRUISE_INITIAL * CV.KPH_TO_MS, False)
+        self.enable(V_CRUISE_INITIAL * CV.KPH_TO_MS, False, False)
 
       # Expected diff on enabling. Speed should not change on falling edge of pressed
       assert (not pressed) == (self.v_cruise_helper.v_cruise_kph == self.v_cruise_helper.v_cruise_kph_last)
@@ -102,7 +102,7 @@ class TestVCruiseHelper(OpenpilotTestCase):
     Asserts we don't increment set speed if user presses resume/accel to exit cruise standstill.
     """
 
-    self.enable(0, False)
+    self.enable(0, False, False)
 
     for standstill in (True, False):
       for pressed in (True, False):
@@ -122,7 +122,7 @@ class TestVCruiseHelper(OpenpilotTestCase):
 
     for v_ego in np.linspace(0, 100, 101):
       self.reset_cruise_speed_state()
-      self.enable(V_CRUISE_INITIAL * CV.KPH_TO_MS, False)
+      self.enable(V_CRUISE_INITIAL * CV.KPH_TO_MS, False, False)
 
       # first decrement speed, then perform gas pressed logic
       expected_v_cruise_kph = self.v_cruise_helper.v_cruise_kph - IMPERIAL_INCREMENT
@@ -144,10 +144,11 @@ class TestVCruiseHelper(OpenpilotTestCase):
     """
 
     for experimental_mode in (True, False):
-      for v_ego in np.linspace(0, 100, 101):
-        self.reset_cruise_speed_state()
-        assert not self.v_cruise_helper.v_cruise_initialized
+      for dynamic_experimental_control in (True, False):
+        for v_ego in np.linspace(0, 100, 101):
+          self.reset_cruise_speed_state()
+          assert not self.v_cruise_helper.v_cruise_initialized
 
-        self.enable(float(v_ego), experimental_mode)
-        assert V_CRUISE_INITIAL <= self.v_cruise_helper.v_cruise_kph <= V_CRUISE_MAX
-        assert self.v_cruise_helper.v_cruise_initialized
+          self.enable(float(v_ego), experimental_mode, dynamic_experimental_control)
+          assert V_CRUISE_INITIAL <= self.v_cruise_helper.v_cruise_kph <= V_CRUISE_MAX
+          assert self.v_cruise_helper.v_cruise_initialized

openpilot/selfdrive/controls/lib/longitudinal_planner.py

@@ -138,16 +138,16 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
     output_a_target_e2e = sm['modelV2'].action.desiredAcceleration
     output_should_stop_e2e = sm['modelV2'].action.shouldStop
 
-    experimental_mode = sm['selfdriveState'].experimentalMode
+    is_e2e = self.is_e2e(sm)
 
-    self.a_cruise = get_cruise_accel(experimental_mode, v_cruise, v_ego,
+    self.a_cruise = get_cruise_accel(is_e2e, v_cruise, v_ego,
                                      self.a_cruise, steer_angle_without_offset, self.CP, self.dt,
                                      accel_coast, self.allow_throttle)
     cruise_should_stop = should_stop(v_ego, self.a_cruise)
 
     candidates = [(output_a_target_mpc, self.mpc.source, output_should_stop_mpc),
                   (self.a_cruise, LongitudinalPlanSource.cruise, cruise_should_stop)]
-    if experimental_mode:
+    if is_e2e:
       candidates.append((output_a_target_e2e, LongitudinalPlanSource.e2e, output_should_stop_e2e))
 
     output_a_target, self.mpc.source, _ = min(candidates, key=lambda c: c[0])

openpilot/selfdrive/modeld/SConscript

@@ -55,7 +55,7 @@ def chestnut_action(command):
 def compile_model(onnx_path, pkl_path):
   onnx_path, target_pkl_path = File(onnx_path).abspath, File(pkl_path).abspath
   cmd = (f'{tg_flags} {mac_brew_string} {taskset}python3 "{compiler}/compile_onnx.py" '
-         f'"{onnx_path}" "{target_pkl_path}" --out-of-band --benchmark-runs 1')
+         f'"{onnx_path}" "{target_pkl_path}" --device-input "*" --out-of-band --benchmark-runs 1')
   lenv.Command(
     target_pkl_path,
     tinygrad_files + [onnx_path, Value(cmd)],

openpilot/selfdrive/modeld/dmonitoringmodeld.py

@@ -16,6 +16,7 @@ from openpilot.common.realtime import config_realtime_process
 from openpilot.common.transformations.model import dmonitoringmodel_intrinsics
 from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
 from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+from openpilot.common.file_chunker import open_file_chunked
 from openpilot.selfdrive.modeld.parse_model_outputs import sigmoid, safe_exp
 
 SEND_RAW_PRED = os.getenv('SEND_RAW_PRED')
@@ -27,7 +28,7 @@ class ModelState:
   output: np.ndarray
 
   def __init__(self, cam_w: int, cam_h: int):
-    jits = load_oob(MODEL_PKL_PATH)
+    jits = load_oob(open_file_chunked(MODEL_PKL_PATH))
     self.DEV = jits['input_specs']['input_img'][2]
     self.input_shapes = jits['metadata']['input_shapes']
     self.output_slices = pickle.loads(base64.b64decode(jits['metadata']['metadata']['output_slices']))

openpilot/selfdrive/modeld/helpers.py

@@ -1,12 +1,9 @@
 import io
-import os
 import pickle
 import struct
-import sys
 from pathlib import Path
 
-from openpilot.common.file_chunker import get_chunk_name, get_manifest_path, open_file_chunked
-from openpilot.common.hardware import AGNOS
+from openpilot.common.file_chunker import get_manifest_path
 from openpilot.common.hardware.usb import CHESTNUT_USB_PRODUCT, USB_DEVICES_PATH, is_chestnut_usb_id
 
 MODELS_DIR = Path(__file__).resolve().parent / 'models'
@@ -16,19 +13,15 @@ def modeld_pkl_path(chestnut: bool):
   prefix = 'big_' if chestnut else ''
   return MODELS_DIR / f'{prefix}driving_tinygrad.pkl'
 
-def load_oob(path, chestnut=False):
-  from tinygrad import Context, Device
-  from tinygrad.device import Buffer
-  device = 'USB+AMD:LLVM' if chestnut else 'QCOM' if AGNOS else 'METAL' if sys.platform == 'darwin' else 'CPU:LLVM'
-  chunks = 0 if os.path.isfile(path) else int(Path(get_manifest_path(path)).read_text())
-  paths = [get_chunk_name(path, i, chunks) for i in range(chunks)] or [path]
-  with Context(DEV=device), open_file_chunked(path) as f:
-    opcodes = f.read(struct.unpack('<q', f.read(8))[0])
-    buffers, stage = Buffer(Device.DEFAULT, sum(map(os.path.getsize, paths)) - 8 - len(opcodes)).ensure_allocated(), bytearray(64 << 20)
-    for offset in range(0, buffers.nbytes, len(stage)):
-      n = f.readinto(piece := memoryview(stage)[:min(len(stage), buffers.nbytes - offset)])
-      buffers.view(n, offset).ensure_allocated().copy_from(Buffer("PYTHON", n, initial_value=piece[:n]))
-    return type("_Unpickler", (pickle.Unpickler,), {"persistent_load": lambda self, pid: buffers.view(*pid)})(io.BytesIO(opcodes)).load()
+def load_oob(f):
+  opcodes = f.read(struct.unpack('<q', f.read(8))[0])
+  def buffers():
+    while (h := f.read(8)):
+      pb = pickle.PickleBuffer(bytearray(struct.unpack('<q', h)[0]))
+      if f.readinto(pb) != pb.raw().nbytes:
+        raise EOFError("incomplete model buffer")
+      yield pb
+  return pickle.load(io.BytesIO(opcodes), buffers=buffers())
 
 def chestnut_present() -> bool:
   for d in USB_DEVICES_PATH.glob("*"):

openpilot/selfdrive/modeld/modeld.py

@@ -6,7 +6,6 @@ from functools import cached_property
 import os
 os.environ['GMMU'] = '0' # for chestnut fast loading, noop for qcom
 from tinygrad.device import Buffer, Device
-from tinygrad.engine.realize import lower_and_compile
 from tinygrad.dtype import DType, dtypes
 from tinygrad.tensor import Tensor
 from tinygrad.helpers import round_up
@@ -35,6 +34,7 @@ from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.selfdrive.controls.lib.drive_helpers import get_accel_from_plan, should_stop, smooth_value, get_curvature_from_plan
 from openpilot.selfdrive.modeld.parse_model_outputs import Parser
 from openpilot.selfdrive.modeld.fill_model_msg import fill_model_msg, fill_driving_model_data, fill_pose_msg, PublishState
+from openpilot.common.file_chunker import open_file_chunked
 from openpilot.selfdrive.modeld.constants import ModelConstants, Plan
 from openpilot.selfdrive.modeld.helpers import MODELS_DIR, chestnut_present, chestnut_compiled, modeld_pkl_path, load_oob
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
@@ -134,8 +134,8 @@ class FrameMeta:
 
 
 def input_view(buffer: Buffer, shape: tuple[int, ...], dtype: DType, offset: int) -> Tensor:
-  view = buffer.view(math.prod(shape) * dtype.itemsize, offset).ensure_allocated()
-  return Tensor(UOp.from_buffer(view, dtype)).reshape(shape)
+  view = buffer.view(math.prod(shape), dtype, offset).ensure_allocated()
+  return Tensor(UOp.from_buffer(view)).reshape(shape)
 
 
 class ModelState(ModelStateBase):
@@ -143,7 +143,7 @@ class ModelState(ModelStateBase):
 
   def __init__(self, cam_w: int, cam_h: int, chestnut: bool):
     ModelStateBase.__init__(self)
-    jits = load_oob(modeld_pkl_path(chestnut), chestnut)
+    jits = load_oob(open_file_chunked(modeld_pkl_path(chestnut)))
     self.model_device = jits['input_specs']['new_img'][2]
     self.input_shapes = {name: (shape, np.dtype(dtype)) for name, (shape, dtype, _) in jits['input_specs'].items()}
     self.state_pairs = {name: f'next_{name}' for name in self.input_shapes if f'next_{name}' in jits['metadata']['output_shapes']}
@@ -158,9 +158,7 @@ class ModelState(ModelStateBase):
     self.pack_inputs()
     with open(MODELS_DIR / f'{"big_" if chestnut else ""}driving_warp_{cam_w}x{cam_h}_tinygrad.pkl', 'rb') as f:
       self.run_warp = pickle.load(f)['run']
-    self.run_warp.captured._linear = lower_and_compile(self.run_warp.captured._linear)
     self.run_model = jits['run']
-    self.run_model.captured._linear = lower_and_compile(self.run_model.captured._linear)
     self.outputs = {name: Tensor(np.zeros(shape, dtype=dtype), device=device).realize() for name, (shape, dtype, device) in jits['output_specs'].items()}
     for name, next_name in self.state_pairs.items():
       state = self.input_queues[name]
@@ -232,8 +230,7 @@ def main(demo=False):
 
   CHESTNUT = chestnut_present() and chestnut_compiled()
   if CHESTNUT:
-    from tinygrad.runtime.ops_amd import AMDDevice
-    AMDDevice.wait_timeout_ms = 3000
+    os.environ['HCQDEV_WAIT_TIMEOUT_MS'] = '3000'
   params = Params()
   params.put_bool("ChestnutLoading", CHESTNUT)
   params.remove("ChestnutActive")

openpilot/selfdrive/navigation/helpers.py

@@ -1,43 +0,0 @@
-import time
-from typing import Any
-
-import numpy as np
-
-
-def latest_gps_source(sm) -> str | None:
-  """The service with the freshest usable GPS fix, or None."""
-  now = time.monotonic()
-  sources = [s for s in ('gpsLocation', 'gpsLocationExternal')
-             if sm.valid[s] and sm[s].hasFix and 0 <= now - sm.recv_time[s] < 2]
-  return max(sources, key=lambda s: sm.logMonoTime[s]) if sources else None
-
-
-# convert mapbox steps to valhalla enums the model was trained on
-VALHALLA_COMMAND_COUNT = 46
-VALHALLA_SIDED_TYPES = {  # (straight, right, left)
-  'depart': (1, 2, 3), 'arrive': (4, 5, 6),
-  'on ramp': (17, 18, 19), 'off ramp': (20, 20, 21), 'fork': (22, 23, 24),
-  'roundabout': (26, 26, 26), 'rotary': (26, 26, 26), 'roundabout turn': (26, 26, 26),
-  'exit roundabout': (27, 27, 27), 'exit rotary': (27, 27, 27), 'notification': (28, 28, 28),
-}
-VALHALLA_TURN_TYPES = {'straight': 8, 'slight right': 9, 'right': 10, 'sharp right': 11, 'uturn': 13,
-                       'sharp left': 14, 'left': 15, 'slight left': 16}  # turn, continue, new name, end of road
-
-
-def valhalla_type(maneuver_type: str, modifier: str) -> int | None:
-  if maneuver_type == 'merge':
-    return None  # Valhalla gives no maneuver at a merge, so the model never saw one
-  if maneuver_type in VALHALLA_SIDED_TYPES:
-    straight, right, left = VALHALLA_SIDED_TYPES[maneuver_type]
-    return right if 'right' in modifier else left if 'left' in modifier else straight
-  return VALHALLA_TURN_TYPES.get(modifier, 8)
-
-
-def navigation_input(maneuvers: Any, traveled: float) -> np.ndarray:
-  navigation = np.zeros(VALHALLA_COMMAND_COUNT + 1, dtype=np.float32)
-  for maneuver in maneuvers:
-    command, distance = valhalla_type(maneuver.type, maneuver.modifier), maneuver.distance - traveled
-    if command is not None and command > 6 and distance >= 0:
-      navigation[command], navigation[-1] = 1, distance / 100
-      break
-  return navigation

openpilot/selfdrive/selfdrived/selfdrived.py

@@ -577,7 +577,7 @@ class SelfdriveD(CruiseHelper):
     clear_event_types = set()
     if ET.WARNING not in self.state_machine.current_alert_types:
       clear_event_types.add(ET.WARNING)
-    if self.enabled or (ET.NO_ENTRY not in (c := self.state_machine.current_alert_types) and (ET.ENABLE in c or ET.USER_DISABLE in c)):
+    if self.enabled:
       clear_event_types.add(ET.NO_ENTRY)
 
     pers = LONGITUDINAL_PERSONALITY_MAP[self.personality]

openpilot/selfdrive/ui/sunnypilot/layouts/settings/cruise.py

@@ -82,8 +82,14 @@ class CruiseLayout(Widget):
       callback=lambda: self._set_current_panel(PanelType.SLA)
     )
 
+    self.dec_toggle = toggle_item_sp(
+      title=tr("Enable Dynamic Experimental Control"),
+      description=tr("Enable toggle to allow the model to determine when to use sunnypilot ACC or sunnypilot End to End Longitudinal."),
+      param="DynamicExperimentalControl")
+
     items = [
       self.icbm_toggle,
+      self.dec_toggle,
       self.scc_v_toggle,
       self.scc_m_toggle,
       self.custom_acc_toggle,
@@ -138,13 +144,16 @@ class CruiseLayout(Widget):
 
       if has_long or has_icbm:
         self.custom_acc_toggle.action_item.set_enabled(((has_long and not ui_state.CP.pcmCruise) or has_icbm) and ui_state.is_offroad())
+        self.dec_toggle.action_item.set_enabled(has_long)
         self.scc_v_toggle.action_item.set_enabled(True)
         self.scc_m_toggle.action_item.set_enabled(True)
       else:
         ui_state.params.remove("CustomAccIncrementsEnabled")
+        ui_state.params.remove("DynamicExperimentalControl")
         ui_state.params.remove("SmartCruiseControlVision")
         ui_state.params.remove("SmartCruiseControlMap")
         self.custom_acc_toggle.action_item.set_enabled(False)
+        self.dec_toggle.action_item.set_enabled(False)
         self.scc_v_toggle.action_item.set_enabled(False)
         self.scc_m_toggle.action_item.set_enabled(False)
 

openpilot/selfdrive/ui/sunnypilot/mici/onroad/hud_renderer.py

@@ -8,24 +8,17 @@ import pyray as rl
 
 from openpilot.selfdrive.ui.mici.onroad.hud_renderer import HudRenderer
 from openpilot.selfdrive.ui.sunnypilot.onroad.blind_spot_indicators import BlindSpotIndicators
-from openpilot.selfdrive.ui.ui_state import ui_state
 
 
 class HudRendererSP(HudRenderer):
   def __init__(self):
     super().__init__()
     self.blind_spot_indicators = BlindSpotIndicators()
-    self._sp_engaged: bool = False
 
   def _update_state(self) -> None:
     super()._update_state()
     self.blind_spot_indicators.update()
 
-    sp_engaged = ui_state.engaged
-    if sp_engaged != self._sp_engaged:
-      self._chestnut_fade_time = rl.get_time() if sp_engaged else 0
-    self._sp_engaged = sp_engaged
-
   def _render(self, rect: rl.Rectangle) -> None:
     super()._render(rect)
     self.blind_spot_indicators.render(rect)

openpilot/selfdrive/ui/sunnypilot/ui_state.py

@@ -221,9 +221,10 @@ class UIStateSP:
       self.params.remove("LateralJerkTorqueController")
       self.params.remove("AlphaLongitudinalEnabled")
 
-    # No longitudinal control: no experimental mode
+    # No longitudinal control: no experimental mode or DEC
     if not has_long:
       self.params.remove("ExperimentalMode")
+      self.params.remove("DynamicExperimentalControl")
 
     # ICBM: clear if not available or if full longitudinal control is active
     if self.CP_SP is not None:

openpilot/sunnypilot/modeld_v2/compile_modeld.py

@@ -7,12 +7,14 @@ See the LICENSE.md file in the root directory for more details.
 """
 
 import argparse
+import atexit
 import codecs
 import gc
 import math
 import multiprocessing as mp
 import os
 import pickle
+import shutil
 import tempfile
 import time
 from functools import partial
@@ -20,8 +22,8 @@ from typing import Any
 
 import numpy as np
 
-from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, patch_fetch_fw, read_parts, write_bundle
-from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame, record_kernel_linear, serialize_jit
+from openpilot.common.file_chunker import chunk_file, get_chunk_targets, open_file_chunked
+from openpilot.sunnypilot.modeld_v2.helpers import dump_oob, load_oob
 import openpilot.sunnypilot.modeld_v2.stock_dependencies as stock
 from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
 
@@ -34,7 +36,34 @@ from tinygrad.tensor import Tensor
 
 os.environ['GMMU'] = '0'
 
-patch_fetch_fw()
+def _patch_tinygrad_fetch_fw():
+  try:
+    import hashlib
+    import pathlib
+    import zstandard
+    from tinygrad import helpers
+    _orig_fetch_fw = helpers.fetch_fw
+    def fetch_fw(path, name, sha256):
+      p = pathlib.Path(f"/lib/firmware/{path}/{name}.zst")
+      if p.is_file():
+        blob = zstandard.ZstdDecompressor().stream_reader(p.read_bytes()).read()
+        if hashlib.sha256(blob).hexdigest() == sha256:
+          return blob
+      return _orig_fetch_fw(path, name, sha256)
+    helpers.fetch_fw = fetch_fw
+  except ImportError:
+    pass
+_patch_tinygrad_fetch_fw()
+
+def _patch_ops_serialization():
+  try:
+    from tinygrad.uop.ops import Ops
+    def __reduce_ex__(self, proto):
+      return (getattr, (self.__class__, self.name))
+    Ops.__reduce_ex__ = __reduce_ex__
+  except ImportError:
+    pass
+_patch_ops_serialization()
 
 MODEL_TYPES = ('vision_policy', 'supercombo', 'vision_multi_policy')
 WARP_INPUTS = ['tfm', 'big_tfm']
@@ -43,7 +72,6 @@ POLICY_INPUTS = ['img_q', 'big_img_q', 'feat_q', 'desire_q', 'packed_npy_inputs'
 class MetadataOnnxPBParser(OnnxPBParser):
   def _parse_ModelProto(self) -> dict:
     obj: dict[str, Any] = {"graph": {"input": [], "output": []}, "metadata_props": []}
-    self.opset_imports = {}
     for fid, wire_type in self._parse_message(self.reader.len):
       match fid:
         case 7:
@@ -122,10 +150,6 @@ def get_policy_npy_shapes(input_shapes: dict, is_supercombo: bool = False) -> tu
   return shapes, sizes
 
 
-def host_view(tensor: Tensor) -> np.ndarray: # QCOM -> CPU round trip of tfm takes 5ms longer than host memory view
-  return np.frombuffer(tensor._buffer()._host_mv(), dtype=np.float32).reshape(tensor.shape)
-
-
 def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = Device.DEFAULT,
                             is_supercombo: bool = False) -> tuple[dict, dict]:
   road_key, _ = _detect_vision_keys(input_shapes)
@@ -161,7 +185,7 @@ def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = D
     'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), 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_npy_inputs, device=device).realize(),
+    'packed_npy_inputs': Tensor(packed_npy_inputs, device=device if os.getenv('CHESTNUT') else 'NPY').realize(),
   }
 
   if features_buffer:
@@ -173,11 +197,9 @@ def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = D
   for key in ('tfm', 'big_tfm'):
     if key not in npy_arrays:
       npy_arrays[key] = np.eye(3, dtype=np.float32)
-    queues[key] = Tensor(npy_arrays[key], device=device).realize()
+    queues[key] = Tensor(npy_arrays[key], device='NPY').realize()
 
-  packed = host_view(queues['packed_npy_inputs'])
-  npy_arrays |= {k: v.reshape(s) for (k, s), v in zip(shapes.items(), np.split(packed, split_indices) if sizes else [], strict=True)}
-  return queues, npy_arrays | {k: host_view(queues[k]) for k in ('tfm', 'big_tfm')}
+  return queues, npy_arrays
 
 
 def make_split_input_queues(vision_input_shapes: dict, policy_input_shapes: dict,
@@ -199,8 +221,8 @@ def make_warp_queues(device=Device.DEFAULT):
     'tfm': np.zeros((3, 3), dtype=np.float32),
     'big_tfm': np.zeros((3, 3), dtype=np.float32),
   }
-  queues = {k: Tensor(v, device=device).realize() for k, v in npy.items()}
-  return queues, {k: host_view(v) for k, v in queues.items()}
+  queues = {k: Tensor(v, device='NPY').realize() for k, v in npy.items()}
+  return queues, npy
 
 
 def make_run_policy(vision_runner, policy_runners: list, features_slice: slice, frame_skip: int, input_shapes: dict):
@@ -260,19 +282,8 @@ def make_run_policy(vision_runner, policy_runners: list, features_slice: slice,
   return run_policy
 
 
-class _CheckFrameRecorder:
-  def __init__(self, jit):
-    self.jit, self.frame = jit, None
-
-  def __call__(self, *args, **kwargs):
-    if self.frame is not None or args or self.jit.cnt < 2:
-      return self.jit(*args, **kwargs)
-    self.frame, result = capture_frame(self.jit, kwargs, None)
-    return result
-
-
 def compile_jit(jit_or_fn, input_keys_or_make_inputs, make_queues=None, make_random_inputs=None,
-                benchmark_runs: int = 1, clear_refs=None):
+                benchmark_runs: int = 1, clear_refs=None, return_loaded: bool = True):
   if callable(input_keys_or_make_inputs) and make_queues is None:
     fn = jit_or_fn
     make_inputs = input_keys_or_make_inputs
@@ -323,23 +334,22 @@ def compile_jit(jit_or_fn, input_keys_or_make_inputs, make_queues=None, make_ran
 
   print('capture + replay')
   gc.collect()
-  recorder = _CheckFrameRecorder(jit)
-  with record_kernel_linear() as recorded:
-    test_val = run_eval(recorder, 42, 3)
-  assert len(recorded) == 1, f"expected one captured kernel list, got {len(recorded)}"
-  part = serialize_jit(jit, recorded[0], recorder.frame)
-  print(f'plain artifact round trip ({benchmark_runs} runs per seed)')
-  if clear_refs:
-    clear_refs()
-  gc.collect()
-  loaded_jit = PlainJit(part[0], memoryview(part[1]))
+  test_val = run_eval(jit, 42, 3)
+  print(f'pickle round trip ({benchmark_runs} runs per seed)')
+  with tempfile.TemporaryFile(dir=".") as f:
+    dump_oob(jit, f)
+    if clear_refs:
+      clear_refs()
+    gc.collect()
+    f.seek(0)
+    loaded_jit = load_oob(f)
 
   for seed in (42, 43):
     reference = test_val if seed == 42 else run_eval(jit_or_fn, seed, 1)
     actual = run_eval(loaded_jit, seed, benchmark_runs)
     for ref, val in zip(reference, actual, strict=True):
       np.testing.assert_array_equal(ref, val)
-  return part
+  return loaded_jit if return_loaded else jit
 
 
 def _parse_size(size_str: str) -> tuple[int, int]:
@@ -347,6 +357,16 @@ def _parse_size(size_str: str) -> tuple[int, int]:
   return int(width), int(height)
 
 
+def read_file_chunked_to_disk(path):
+  if not path:
+    return None
+  tmp_path = f'{path}.unchunked'
+  with open(tmp_path, 'wb') as f, open_file_chunked(path) as src:
+    shutil.copyfileobj(src, f)
+  atexit.register(lambda: os.path.exists(tmp_path) and os.remove(tmp_path))
+  return tmp_path
+
+
 def _load_policy_runners(args: argparse.Namespace) -> tuple[list, list]:
   runners, keys = [], []
   for name, onnx_arg in [('policy', args.policy_onnx), ('off_policy', args.off_policy_onnx), ('on_policy', args.on_policy_onnx)]:
@@ -367,7 +387,10 @@ def _compile_warp_resolution_worker(cam_w, cam_h, model_w, model_h, benchmark_ru
     warp = None
   compiled_jit = compile_jit(warp, WARP_INPUTS, make_warp_queues, make_random_inputs=make_random_warp_inputs,
                             benchmark_runs=benchmark_runs, clear_refs=cleanup_warp)
-  write_bundle(result_path, {(cam_w, cam_h): compiled_jit}, {'device': Device.DEFAULT})
+
+  result_data = (compiled_jit, Device.DEFAULT)
+  with open(result_path, "wb") as f:
+    dump_oob(result_data, f)
 
 
 if __name__ == "__main__":
@@ -398,6 +421,12 @@ if __name__ == "__main__":
   model_w, model_h = args.model_size
   output_data = {}
 
+  args.vision_onnx = read_file_chunked_to_disk(args.vision_onnx)
+  args.policy_onnx = read_file_chunked_to_disk(args.policy_onnx)
+  args.off_policy_onnx = read_file_chunked_to_disk(args.off_policy_onnx)
+  args.on_policy_onnx = read_file_chunked_to_disk(args.on_policy_onnx)
+  args.supercombo_onnx = read_file_chunked_to_disk(args.supercombo_onnx)
+
   is_unified_supercombo = False
   if args.model_type == 'supercombo':
     assert args.supercombo_onnx
@@ -420,10 +449,8 @@ if __name__ == "__main__":
                                   frame_copy_size=frame_copy_size)
       warp = stock.make_warp(nv12, model_w, model_h)
       run_model_jit = TinyJit(stock.make_run_model(warp, run_policy, model_metadata, frame_copy_size), prune=True)
-      write_bundle(part_path := f"{args.output}.{cam_w}x{cam_h}", {(cam_w, cam_h): compile_jit(run_model_jit, stock.MODELD_INPUTS, make_model_queues,
-                                                                                               benchmark_runs=args.benchmark_runs)})
-      output_data[(cam_w, cam_h)] = read_parts(part_path)[0][(cam_w, cam_h)]
-      os.remove(part_path)
+      compiled_jit = compile_jit(run_model_jit, stock.MODELD_INPUTS, make_model_queues, benchmark_runs=args.benchmark_runs, return_loaded=False)
+      output_data[(cam_w, cam_h)] = compiled_jit
       gc.collect()
     del model_runner, run_policy
     gc.collect()
@@ -491,12 +518,18 @@ if __name__ == "__main__":
 
       tmp_files.append((cam_w, cam_h, tmp_res.name))
     for cam_w, cam_h, tmp_name in tmp_files:
-      warp_parts, warp_extras = read_parts(tmp_name)
-      output_data[(cam_w, cam_h)] = warp_parts[(cam_w, cam_h)]
-      output_data['input_devices']['warp'] = warp_extras['device']
+      with open(tmp_name, "rb") as f:
+        compiled_jit, dev_name = load_oob(f)
+      output_data[(cam_w, cam_h)] = compiled_jit
+      output_data['input_devices']['warp'] = dev_name
       os.remove(tmp_name)
     output_data['metadata']['warp_dev'] = Device.DEFAULT
 
-  parts = {key: output_data.pop(key) for key in [key for key, value in output_data.items() if isinstance(value, tuple)]}
-  write_bundle(args.output, parts, output_data)
-  print(f"Saved model to {args.output} ({os.path.getsize(args.output) / 1e6:.2f} MB, {len(parts)} JITs)")
+  with open(args.output, "wb") as file:
+    dump_oob(output_data, file)
+
+  pkl_size = os.path.getsize(args.output)
+  print(f"Saved combined JIT to {args.output} ({pkl_size / 1e6:.2f} MB)")
+  chunk_targets = get_chunk_targets(args.output, pkl_size)
+  chunk_file(args.output, chunk_targets)
+  print(f"Chunked into {len(chunk_targets) - 1} file(s)")

openpilot/sunnypilot/modeld_v2/compile_modeld_v2.py

@@ -1,59 +1,11 @@
 #!/usr/bin/env python3
-import argparse
+import runpy
 import os
-import sys
 
-import numpy as np
-
-from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, write_bundle
-from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame, record_kernel_linear, serialize_jit
-
-
-def initialize_check_inputs(arrays: dict):
-  rng = np.random.default_rng(7)
-  for value in arrays.values():
-    value[...] = rng.standard_normal(value.shape) if value.dtype.kind == "f" else rng.integers(0, 2 if value.dtype == np.bool_ else 16, value.shape)
+from openpilot.sunnypilot.modeld_v2.compile_modeld import _patch_ops_serialization
 
 
 if __name__ == "__main__":
-  sys.path.insert(0, os.environ.get("TINYGRAD_PATH", "tinygrad_repo"))
-  from examples.openpilot.compile_onnx import onnx_metadata
-  from examples.openpilot.helpers import allocate_inputs, benchmark
-  from tinygrad import Device, Tensor, TinyJit
-  from tinygrad.dtype import _to_np_dtype
-  from tinygrad.nn.onnx import OnnxRunner
-
-  parser = argparse.ArgumentParser(description="Compile a native-architecture ONNX model into a plain tinygrad artifact")
-  parser.add_argument('onnx')
-  parser.add_argument('output')
-  parser.add_argument('--device-input', action='append', default=[])
-  parser.add_argument('--benchmark-runs', type=int, default=20)
-  args = parser.parse_args()
-
-  runner, (properties, output_shapes) = OnnxRunner(args.onnx), onnx_metadata(args.onnx)
-  device_inputs = runner.graph_inputs.keys() if '*' in args.device_input else args.device_input
-  metadata = {'metadata': properties} | {f'{kind}_shapes': {name: tuple(d if isinstance(d, int) else 0 for d in shape) for name, shape in shapes.items()}
-                                         for kind, shapes in [('input', {name: spec.shape for name, spec in runner.graph_inputs.items()}),
-                                                              ('output', output_shapes)]}
-  input_specs = {name: (tuple(s if isinstance(s, int) else 1 for s in spec.shape), np.dtype(_to_np_dtype(spec.dtype)).str,
-                        Device.DEFAULT if name in device_inputs else 'NPY') for name, spec in runner.graph_inputs.items()}
-
-  def model(inputs):
-    return {name: value.contiguous() for name, value in runner({name: value.to(Device.DEFAULT) for name, value in inputs.items()}).items()}
-  output_specs = {name: (value.shape, np.dtype(_to_np_dtype(value.dtype)).name, Device.DEFAULT) for name, value in model(allocate_inputs(input_specs)).items()}
-
-  @TinyJit(prune=True)
-  def jit(output_buffers, **inputs):
-    Tensor.realize(*(output_buffers[name].assign(value) for name, value in model(inputs).items()))
-
-  check_inputs = allocate_inputs(input_specs, initialize_check_inputs) | {'output_buffers': allocate_inputs(output_specs)}
-  with record_kernel_linear() as recorded:
-    for i in range(2 + args.benchmark_runs):
-      benchmark(jit, cb=lambda t, i=i: print(f"  [{i + 1}/{2 + args.benchmark_runs}] {t * 1e3:.2f} ms"), **check_inputs)
-  assert len(recorded) == 1, f"expected one captured kernel list, got {len(recorded)}"
-
-  frame, _ = capture_frame(jit, check_inputs, 'output_buffers')
-  part = serialize_jit(jit, recorded[0], frame)
-  PlainJit(part[0], memoryview(part[1]))
-  write_bundle(args.output, {'run': part}, {'metadata': metadata, 'input_specs': input_specs, 'output_specs': output_specs})
-  print(f"Saved model to {args.output} ({os.path.getsize(args.output) / 1e6:.2f} MB, {len(part[0]['calls'])} kernels)")
+  _patch_ops_serialization()
+  upstream_script = os.path.join(os.environ.get("TINYGRAD_PATH", "tinygrad_repo"), "examples/openpilot/compile_onnx.py")
+  runpy.run_path(upstream_script, run_name="__main__")

openpilot/sunnypilot/modeld_v2/compile_warp.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import argparse
-import numpy as np
-
-from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, write_bundle
-from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame, record_kernel_linear, serialize_jit
-
-
-def main():
-  parser = argparse.ArgumentParser(description="Compile the two-frame yuv420 camera warp into a plain tinygrad artifact")
-  parser.add_argument("--frame", required=True, help="width,height,stride,y_height,uv_height,buffer_size")
-  parser.add_argument("--warp-to", required=True, help="model input WxH")
-  parser.add_argument("--output", required=True)
-  args = parser.parse_args()
-
-  from examples.openpilot.compile_warp import make_frame_prepare, parse_frame, parse_size
-  from tinygrad import Device, Tensor, TinyJit
-  frame = parse_frame(args.frame)
-  warp = make_frame_prepare(frame, *parse_size(args.warp_to))
-  run = TinyJit(lambda input_frame, M_inv: Tensor.stack(*(warp(input_frame[i], M_inv[i]) for i in range(2))), prune=True)
-  rng = np.random.default_rng(42)
-  inputs = {"input_frame": Tensor(rng.integers(0, 256, (2, frame.size), dtype=np.uint8), device=Device.DEFAULT).realize(),
-            "M_inv": Tensor((rng.standard_normal((2, 3, 3)) * 8).astype(np.float32), device=Device.DEFAULT).realize()}
-  with record_kernel_linear() as recorded:
-    run(**inputs)
-    run(**inputs)
-    check, _ = capture_frame(run, inputs)
-  assert len(recorded) == 1, f"expected one captured kernel list, got {len(recorded)}"
-  part = serialize_jit(run, recorded[0], check)
-  PlainJit(*part)
-  specs = {"input_frame": ((2, frame.size), "|u1", Device.DEFAULT), "M_inv": ((2, 3, 3), "<f4", Device.DEFAULT)}
-  write_bundle(args.output, {"run": part}, {"input_specs": specs, "metadata": {}})
-  print(f"Saved warp to {args.output} ({len(part[0]['calls'])} kernels)")
-
-
-if __name__ == "__main__":
-  main()

openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py

@@ -1,214 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import argparse
-import dataclasses
-import itertools
-import mmap
-import re
-import struct
-import tempfile
-import numpy as np
-
-from openpilot.sunnypilot.modeld_v2.helpers import ALIGNMENT, Blob, PlainJit, flatten, patch_fetch_fw, write_bundle
-from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame
-
-
-def _root(u):
-  from tinygrad.uop.ops import Ops
-  while u.op in (Ops.AFTER, Ops.BITCAST, Ops.SHRINK, Ops.INDEX):
-    u = u.src[0]
-  return u
-
-
-def _view(u) -> tuple[int, int | None]:
-  from tinygrad.uop.ops import Ops
-  start, size = 0, None
-  while u.op in (Ops.AFTER, Ops.BITCAST, Ops.SHRINK):
-    if u.op is Ops.SHRINK:
-      start, size = start + u.src[1].arg, u.src[2].arg if size is None else size
-    u = u.src[0]
-  return start, size
-
-
-def _address(v):
-  from tinygrad.uop.ops import Ops
-  add = 0
-  while v.op is not Ops.GETADDR:
-    add += v.src[1].arg if v.op is Ops.ADD else 0
-    v = v.src[0]
-  start, size = _view(v.src[0])
-  return _root(v.src[0]), add + start, size
-
-
-def _patched(buf, topo) -> tuple[bytearray, dict]:
-  from tinygrad.uop.ops import Ops
-  blob, rows = bytearray(buf.max_numel() * buf.dtype.itemsize), {}
-  for u in topo:
-    if u.op is not Ops.STORE or _root(u.src[0]) is not buf:
-      continue
-    if (value := u.src[1]).op is Ops.BINARY or value.src[0].op is Ops.BINARY:
-      data = (value if value.op is Ops.BINARY else value.src[0]).arg
-      blob[:len(data)] = data
-    else:
-      view, offsets = u.src[0].src
-      rows |= {_view(view)[0] + o.arg * view.dtype.itemsize: w for o, w in zip(offsets.src, value.src, strict=True)}
-  return blob, rows
-
-
-def _evaluate(u, env):
-  from tinygrad.uop.ops import GroupOp, Ops, exec_alu
-  if u.op in (Ops.AFTER, Ops.CAST, Ops.BITCAST):
-    return _evaluate(u.src[0], env)
-  if u.op is Ops.CONST:
-    return u.arg
-  if u.op in (Ops.PARAM, Ops.RANGE):
-    return env.get(u.arg.slot if u.op is Ops.PARAM else u)
-  if u.op is Ops.LOAD:
-    table, index = _root(u.src[0].src[0]), _evaluate(u.src[0].src[1], env)
-    return struct.unpack_from(u.dtype.fmt, table.arg, index * u.dtype.itemsize)[0] if table.op is Ops.BINARY and index is not None else None
-  if u.op in GroupOp.ALU and None not in (values := [_evaluate(x, env) for x in u.src]):
-    return exec_alu(u.op, u.dtype, values, False)
-  return None
-
-
-def _input_pokes(submit, kernargs) -> dict[int, tuple[int, int]]:
-  from tinygrad.uop.ops import Ops
-  outer = dict(enumerate(submit.src[1:]))
-  kernargs_params = {i for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]) is kernargs}
-  inputs = {i: _root(a.src[0]).arg.slot for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]).op is Ops.PARAM}
-  pokes = {}
-  for call in (u for u in submit.src[0].src[0].toposort() if u.op is Ops.CALL and len(u.src) > 3):
-    _, address, value, *_ = call.src[1:]
-    used = list({x.arg.slot for x in value.toposort() if x.op is Ops.PARAM} & inputs.keys())
-    if len(used) != 1 or not kernargs_params & {x.arg.slot for x in address.toposort() if x.op is Ops.PARAM}:
-      continue
-    ranges = list(dict.fromkeys(x for x in (*address.toposort(), *value.toposort()) if x.op is Ops.RANGE))
-    for trip in itertools.product(*[range(int(r.vmax) + 1) for r in ranges]):
-      env = dict.fromkeys(outer, 0) | dict(zip(ranges, trip, strict=True))
-      if (offset := _evaluate(address, env)) % 8 == 0:
-        pokes[offset] = (inputs[used[0]], _evaluate(value, env))
-  return pokes
-
-
-def _elf(image: bytes, rodata: int) -> bytes:
-  names, offset, data, headers = b"\0.text\0.rodata\0.shstrtab\0", 64, b"", []
-  for name, kind, address, content in [(0, 0, 0, b""), (1, 1, ALIGNMENT, image[:rodata]), (7, 1, ALIGNMENT + rodata, image[rodata:]), (15, 3, 0, names)]:
-    headers.append(struct.pack("<IIQQQQIIQQ", name, kind, 2 if kind == 1 else 0, address, offset, len(content), 0, 0, 1, 0))
-    data, offset = data + content, offset + len(content)
-  return b"\x7fELF\x02\x01\x01" + bytes(9) + struct.pack("<HHIQQQIHHHHHH", 1, 0xe0, 1, 0, 0, offset, 0, 64, 0, 0, 64, 4, 3) + data + b"".join(headers)
-
-
-def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
-  import tinygrad.runtime.autogen.am.pm4_nv as pm4
-  import tinygrad.runtime.autogen.amd_gpu as amd_gpu
-  from tinygrad.dtype import dtypes
-  from tinygrad.engine.jit import _prepare_jit_inputs
-  from tinygrad.helpers import unwrap
-  from tinygrad.uop.ops import Ops
-  submit = jit.captured._linear.src[0].without_after
-  kernels, topo = submit.arg.aux.kernels, list(jit.captured._linear.toposort(enter_calls=True))
-  allocs = {str(u.tag): u for u in topo if u.op is Ops.ALLOC and u.tag is not None}
-  (commands, patched), kernargs = _patched(allocs["cmdbuf_compute_0"], topo), allocs["kernargs_compute_0"]
-  argument_words, pokes = _patched(kernargs, topo)[1], _input_pokes(submit, kernargs)
-  sh = {name: getattr(amd_gpu, f"reg{name}") + amd_gpu.GC_BASE__INST0_SEG0 - pm4.PACKET3_SET_SH_REG_START
-        for name in ("COMPUTE_PGM_LO", "COMPUTE_USER_DATA_0", "COMPUTE_NUM_THREAD_X")} if hasattr(amd_gpu, "regCOMPUTE_PGM_LO") else \
-       {"COMPUTE_PGM_LO": 0x20c, "COMPUTE_USER_DATA_0": 0x240, "COMPUTE_NUM_THREAD_X": 0x207}
-
-  dispatches, registers, offset = [], {}, 0
-  while offset < len(commands):
-    word = lambda o: patched.get(o, struct.unpack_from("<I", commands, o)[0])  # noqa: E731
-    if not isinstance(header := word(offset), int) or header >> 30 != 3:
-      offset += 4
-      continue
-    count, opcode = ((header >> 16) & 0x3fff) + 1, (header >> 8) & 0xff
-    body = [word(offset + 4 + 4 * i) for i in range(count)]
-    if opcode == pm4.PACKET3_SET_SH_REG:
-      registers |= {body[0] + i: v for i, v in enumerate(body[1:])}
-    elif opcode == pm4.PACKET3_DISPATCH_DIRECT:
-      local = [registers[sh["COMPUTE_NUM_THREAD_X"] + i] for i in range(3)]
-      dispatches.append((registers[sh["COMPUTE_PGM_LO"]], registers[sh["COMPUTE_USER_DATA_0"]], local, body[:3]))
-    offset += 4 + 4 * count
-  assert len(dispatches) == len(kernels), f"decoded {len(dispatches)} dispatches, the JIT has {len(kernels)} kernels"
-
-  sink = tempfile.TemporaryFile(dir=".")
-  blob, buffers, programs = Blob(sink), {}, {}
-  u8 = repr(dtypes.uint8)
-
-  def store(array) -> dict:
-    array = np.ascontiguousarray(array)
-    return {"data": blob.add(array.tobytes()), "dtype": array.dtype.str, "shape": list(array.shape)}
-
-  calls, written, needs_init = [], set(), set()
-  for (program, arguments, local, grid), kernel in zip(dispatches, kernels, strict=True):
-    image_alloc, entry, _ = _address(program)
-    if image_alloc not in programs:
-      image = bytes(_patched(image_alloc, topo)[0])
-      rodata = next(r for r in range(0, len(image) - 24, 64) if r + struct.unpack_from("<q", image, r + 16)[0] == entry)
-      programs[image_alloc] = blob.add(_elf(image, rodata))
-    start, size = _view(arguments.src[0])
-    args = []
-    for slot in range(start, start + unwrap(size), 8):
-      if slot in pokes:
-        assert pokes[slot][1] == 0, "the plain format passes whole inputs, this kernel takes a view into one"
-        args.append({"input": pokes[slot][0]})
-      elif slot in argument_words:
-        base, at, nbytes = _address(argument_words[slot])
-        args.append({"buffer": buffers.setdefault(base, len(buffers)), "offset": at, "nbytes": nbytes or base.arg.buffer.nbytes, "dtype": u8})
-    outs, ins = kernel[6]
-    calls.append({"kind": "program", "name": re.sub(r"\x1b\[[0-9;]*m", "", kernel[1]), "lib": programs[image_alloc], "target": dataclasses.asdict(target),
-                  "signature": [[f"data{i}", i, u8, [a.get("nbytes", 1)]] for i, a in enumerate(args)], "global_size": grid, "local_size": local,
-                  "globals": list(range(len(args))), "outs": list(outs), "ins": list(ins), "args": args})
-    needs_init |= {args[i]["buffer"] for i in ins if "buffer" in args[i] and args[i]["buffer"] not in written}
-    written |= {args[i]["buffer"] for i in outs if "buffer" in args[i]}
-
-  names = list(jit.captured.expected_names)
-  inputs = [{"slot": slot, "name": names[slot] if slot < len(names) else None, "dtype": repr(u.dtype), "numel": int(u.max_numel()), "device": u.device}
-            for slot, u in enumerate(_prepare_jit_inputs((), kwargs)[0])]
-  header = {"input_names": names, "calls": calls, "returns": {"kind": "NoneType", "tensors": []}, "inputs": inputs,
-            "buffers": [{"nbytes": b.arg.buffer.nbytes, "device": b.arg.buffer.device, "dtype": u8}
-                        | ({"init": blob.add(b.arg.buffer.ensure_allocated().as_memoryview())} if i in needs_init else {}) for b, i in buffers.items()],
-            "check": {"inputs": [[path, store(array), device] for path, array, device in frame["inputs"]],
-                      "outputs": [store(array) for array in frame["outputs"]], "output_container": frame["output_container"]}}
-  with sink:
-    sink.flush()
-    return header, memoryview(mmap.mmap(sink.fileno(), 0, access=mmap.ACCESS_READ))
-
-
-def main():
-  parser = argparse.ArgumentParser(description="Convert commaai's precompiled chestnut driving model into a plain tinygrad artifact")
-  parser.add_argument("pkl", help="big_driving_tinygrad.pkl")
-  parser.add_argument("output")
-  args = parser.parse_args()
-
-  patch_fetch_fw()
-  from examples.openpilot.helpers import allocate_inputs, load_pickle
-  from tinygrad import Device, Tensor
-  from tinygrad.engine.realize import lower_and_compile
-  artifact = load_pickle(args.pkl, out_of_band=True)
-  artifact["run"].captured._linear = lower_and_compile(artifact["run"].captured._linear)
-  rng = np.random.default_rng(7)
-
-  def initialize(arrays: dict):
-    for value in arrays.values():
-      value[...] = rng.standard_normal(value.shape) if value.dtype.kind == "f" else rng.integers(0, 2 if value.dtype == np.bool_ else 16, value.shape)
-  kwargs = allocate_inputs(artifact["input_specs"], initialize) | {"output_buffers": allocate_inputs(artifact["output_specs"])}
-  frame, _ = capture_frame(artifact["run"], kwargs, "output_buffers")
-  part = convert(artifact["run"], kwargs, frame, Device[Device.DEFAULT].renderer.target)
-
-  plain = PlainJit(*part)  # replays the frame, within tolerance
-  replay = {path[0]: Tensor(array, device=device).realize() for path, array, device in frame["inputs"] if len(path) == 1}
-  replay["output_buffers"] = {path[1]: Tensor(array, device=device).realize() for path, array, device in frame["inputs"] if len(path) == 2}
-  flatten(plain(**replay))
-  for index, (got, expected) in enumerate(zip([t.numpy() for t in replay["output_buffers"].values()], frame["outputs"], strict=True)):
-    assert np.array_equal(got, expected), f"output {index} of the plain artifact differs from the pickle"
-  write_bundle(args.output, {"run": part}, {key: artifact[key] for key in ("metadata", "input_specs", "output_specs")})
-  print(f"converted {len(part[0]['calls'])} kernels, bit-exact with the pickle: {args.output}")
-
-
-if __name__ == "__main__":
-  main()

openpilot/sunnypilot/modeld_v2/frame_fusion.py

@@ -1,71 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import bisect
-import itertools
-import math
-from functools import partial
-
-import numpy as np
-
-from openpilot.common.basedir import BASEDIR
-from openpilot.sunnypilot.modeld_v2.helpers import _dtype, read_parts
-
-
-def pack_layout(specs: dict[str, tuple], frame_size: int) -> tuple[dict[str, int], int]:
-  offsets, offset = {}, 0
-  for name, (shape, dtype) in ({"tfm": ((2, 3, 3), np.float32)} | specs).items():
-    offsets[name], offset = offset, offset + -(-math.prod(shape) * np.dtype(dtype).itemsize // 128) * 128
-  return offsets | {"frames": offset}, offset + 2 * frame_size
-
-
-class _Blobs:  # the model's and the warp's blobs as one address space, for a part whose ranges span both files
-  def __init__(self, *blobs):
-    self.blobs, self.starts = blobs, list(itertools.accumulate([0] + [len(blob) for blob in blobs[:-1]]))
-
-  def __getitem__(self, span: slice):
-    index = bisect.bisect_right(self.starts, span.start) - 1
-    return self.blobs[index][span.start - self.starts[index]:span.stop - self.starts[index]]
-
-
-def fused_with_warp(cam_w: int, cam_h: int, chestnut: bool):  # load_model's extend: a native model runs upload, warp and model as one submit
-  return partial(frame_part, f"{BASEDIR}/openpilot/sunnypilot/modeld_v2/models/{'big_' if chestnut else ''}driving_warp_{cam_w}x{cam_h}_tinygrad.pkl")
-
-
-def frame_part(warp_path: str, parts: dict, extras: dict) -> dict:
-  if "input_specs" not in extras:  # a legacy model warps in its own parts
-    return {}
-  (model, model_blob), (warp, warp_blob) = parts["run"], read_parts(warp_path)[0]["run"]
-  states = sorted(name for name in extras["input_specs"] if f"next_{name}" in extras["metadata"]["output_shapes"])
-  host = {name: (shape, dtype) for name, (shape, dtype, _) in extras["input_specs"].items() if name not in states and name != "new_img"}
-  frame_size = next(s["numel"] for s in warp["inputs"] if s["name"] == "input_frame") // 2
-  offsets, packed = pack_layout(host, frame_size)
-  shift, upload, u8 = len(model_blob), len(model["buffers"]) + len(warp["buffers"]), repr(_dtype("dtypes.uint8"))
-
-  def view(name: str, nbytes: int, dtype: str) -> dict:
-    return {"buffer": upload, "offset": offsets[name], "nbytes": nbytes, "dtype": dtype}
-  outputs = sorted(s["slot"] for s in model["inputs"] if s["name"] is None)
-  names = sorted(["host", *states])
-  slots = {s["slot"]: names.index(s["name"]) for s in model["inputs"] if s["name"] in states} | \
-          {slot: len(names) + i for i, slot in enumerate(outputs)}
-  returned = warp["returns"]["tensors"][0]
-  model_inputs = {s["slot"]: {"input": slots[s["slot"]]} if s["slot"] in slots else
-                  {k: v for k, v in returned.items() if k != "shape"} | {"buffer": returned["buffer"] + len(model["buffers"])} if s["name"] == "new_img" else
-                  view(s["name"], s["numel"] * _dtype(s["dtype"]).itemsize, s["dtype"]) for s in model["inputs"]}
-  warp_inputs = {s["slot"]: view("frames" if s["name"] == "input_frame" else "tfm", s["numel"] * _dtype(s["dtype"]).itemsize, s["dtype"])
-                 for s in warp["inputs"]}
-
-  def remap(calls: list, inputs: dict, buffers: int, lib: int) -> list:
-    return [call | ({"lib": [call["lib"][0] + lib, call["lib"][1] + lib]} if "lib" in call else {}) |
-            {"args": [dict(inputs[a["input"]]) if "input" in a else a | {"buffer": a["buffer"] + buffers} for a in call["args"]]} for call in calls]
-  header = {"input_names": names, "returns": {"kind": "NoneType", "tensors": []}, "check": None,
-            "inputs": [{"slot": names.index("host"), "name": "host", "dtype": u8, "numel": packed, "device": "NPY"}] +
-                      [s | {"slot": slots[s["slot"]]} for s in model["inputs"] if s["slot"] in slots],
-            "buffers": model["buffers"] + [b | ({"init": [b["init"][0] + shift, b["init"][1] + shift]} if "init" in b else {}) for b in warp["buffers"]] +
-                       [{"nbytes": packed, "device": model["inputs"][0]["device"], "dtype": u8}],
-            "calls": [{"kind": "copy", "args": [{"buffer": upload, "offset": 0, "nbytes": packed, "dtype": u8}, {"input": names.index("host")}]}] +
-                     remap(warp["calls"], warp_inputs, len(model["buffers"]), shift) + remap(model["calls"], model_inputs, 0, 0)}
-  return {"run": (header, _Blobs(model_blob, warp_blob))}  # replaces the model's run: one set of buffers, no separate warp

openpilot/sunnypilot/modeld_v2/helpers.py

@@ -5,25 +5,14 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 
-import bisect
-import builtins
-import contextlib
-import dataclasses
-import functools
-import hashlib
 import io
-import itertools
-import json
-import math
-import mmap
-import os
-import pickle
 import struct
-
-MAGIC = b"SPTGPLN1"
-ALIGNMENT = 256
-METADATA_TYPES = ("slice", "tuple", "list", "dict", "set", "frozenset", "complex")
-RUNTIME_ENVIRONMENT = ("GMMU", "AMD_AQL", "AMD_DISABLE_SDMA", "GRAPH_ONE_KERNEL")
+import pickle
+import inspect
+import importlib
+import tempfile
+import shutil
+import enum
 
 
 def _patch_system_flock_acquire():
@@ -43,289 +32,86 @@ def _patch_system_flock_acquire():
     pass
 _patch_system_flock_acquire()
 
-
-def patch_fetch_fw() -> None:
+def _pad_args(func, args, kwargs):
   try:
-    import zstandard
-  except ImportError:
-    return
-  zstandard.decompress = lambda data, *_: zstandard.ZstdDecompressor().stream_reader(data).read()  # ty: ignore[invalid-assignment]
-
-
-class ArtifactMismatch(RuntimeError):
-  pass
-
-
-class Blob:
-  def __init__(self, sink=None):
-    self.chunks: list = []
-    self.locations: dict[bytes, list[int]] = {}
-    self.size, self.write = 0, sink.write if sink else self.chunks.append
-
-  def add(self, data) -> list[int]:
-    if (key := hashlib.blake2b(data, digest_size=16).digest()) not in self.locations:
-      start = self.size + -self.size % ALIGNMENT
-      self.write(bytes(start - self.size)), self.write(data)
-      self.locations[key], self.size = [start, start + memoryview(data).nbytes], start + memoryview(data).nbytes
-    return self.locations[key]
-
-
-class _MetadataUnpickler(pickle.Unpickler):
-  def find_class(self, module, name):
-    if module == "builtins" and name in METADATA_TYPES:
-      return getattr(builtins, name)
-    raise pickle.UnpicklingError(f"{module}.{name} is not allowed in model metadata")
-
-
-def flatten(value) -> list:
-  if isinstance(value, (tuple, list)):
-    return [tensor for item in value for tensor in flatten(item)]
-  return [] if value is None else [value]
-
-
-def _relocate(value, part_blob: memoryview, blob: Blob):
-  if isinstance(value, dict):
-    return {k: blob.add(part_blob[slice(*v)]) if k in ("lib", "init", "data") else _relocate(v, part_blob, blob) for k, v in value.items()}
-  return [_relocate(v, part_blob, blob) for v in value] if isinstance(value, list) else value
-
-
-def write_bundle(path: str, parts: dict, extras: dict | None = None):
-  blob = Blob()
-  headers = {key: _relocate(part_header, memoryview(part_blob), blob) for key, (part_header, part_blob) in parts.items()}
-  extras_location = blob.add(pickle.dumps(extras or {}, protocol=4))
-  entries = [{"key": list(key) if isinstance(key, tuple) else key, "blob": [0, blob.size], "header": header} for key, header in headers.items()]
-  header = json.dumps({"parts": entries, "extras": extras_location}).encode()
-  with open(path, "wb") as file:
-    file.write(MAGIC + struct.pack("<Q", len(header)) + header + bytes(-(len(MAGIC) + 8 + len(header)) % ALIGNMENT))
-    file.writelines(blob.chunks)
-
-
-def read_parts(path: str) -> tuple[dict, dict]:
-  with open(path, "rb") as file:
-    data = memoryview(mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_COPY))
-  if bytes(data[:len(MAGIC)]) != MAGIC:
-    raise ValueError(f"{path} is not a plain tinygrad model, recompile it with compile_modeld.py")
-  start = len(MAGIC) + 8 + struct.unpack_from("<Q", data, len(MAGIC))[0]
-  header, blob = json.loads(bytes(data[len(MAGIC) + 8:start])), data[start + -start % ALIGNMENT:]
-  parts = {tuple(e["key"]) if isinstance(e["key"], list) else e["key"]: (e["header"], blob[slice(*e["blob"])]) for e in header["parts"]}
-  return parts, _MetadataUnpickler(io.BytesIO(bytes(blob[slice(*header["extras"])]))).load()
-
-
-def _extended(path: str, extend) -> tuple[dict, dict, str]:
-  parts, extras = read_parts(path)
-  added = extend(parts, extras) if extend else {}
-  return parts | added, extras, _parts_digest(added) if added else ""
-
-
-def load_model(path: str, device_map: dict | None = None, verify: bool = True, cache: bool = True, extend=None) -> dict:
-  parts, extras, extra = _extended(path, extend)
-  if cache and (cached := _read_cache(path, parts, device_map, extra)) is not None:
-    return extras | cached
-  shared: dict = {}
-  jits = {key: PlainJit(header, blob, device_map, verify, shared) for key, (header, blob) in parts.items()}
-  if cache:
-    _write_cache(path, jits, device_map, extra)
-  return extras | jits
-
-
-@functools.cache
-def tinygrad_identity() -> str:
-  import tinygrad
-  root, digest = os.path.dirname(tinygrad.__file__), hashlib.sha256()
-  for directory, _, files in sorted(os.walk(root)):
-    for name in sorted(file for file in files if file.endswith(".py")):
-      with open(path := os.path.join(directory, name), "rb") as file:
-        digest.update(f"{os.path.relpath(path, root)}:".encode() + file.read())
-  return digest.hexdigest()
-
-
-def _parts_digest(parts: dict) -> str:
-  digest = hashlib.sha256()
-  for _, (header, blob) in sorted(parts.items(), key=lambda item: repr(item[0])):
-    digest.update(json.dumps(header, sort_keys=True).encode())
-    for call in header["calls"]:
-      if call["kind"] == "program":
-        digest.update(blob[slice(*call["lib"])])
-  return digest.hexdigest()
-
-
-def _cache_key(path: str, device_map: dict | None, extra: str = "") -> bytes:
-  stat = os.stat(path)
-  return json.dumps({"format": MAGIC.decode(), "tinygrad": tinygrad_identity(), "size": stat.st_size, "mtime_ns": stat.st_mtime_ns,
-                     "extra": extra, "device_map": sorted((device_map or {}).items()),
-                     "env": [os.environ.get(name, "") for name in RUNTIME_ENVIRONMENT]}).encode()
-
-
-def _cache_header_matches(file, path: str, device_map: dict | None, extra: str = "") -> bool:
-  return file.read(struct.unpack("<Q", file.read(8))[0]) == _cache_key(path, device_map, extra)
-
-
-def cache_is_fresh(path: str, device_map: dict | None = None) -> bool: # entry point for warmup proc
-  try:
-    with open(f"{path}.cache", "rb") as file:
-      return _cache_header_matches(file, path, device_map)
-  except (OSError, struct.error):
-    return False
-
-
-def _read_cache(path: str, parts: dict, device_map: dict | None, extra: str = "") -> dict | None:
-  try:
-    with open(f"{path}.cache", "rb") as file:
-      if not _cache_header_matches(file, path, device_map, extra):
-        return None
-      shared: dict = {}
-      buffers = {repr(key): _allocate_buffers(header, blob, device_map, shared) for key, (header, blob) in parts.items()}
-      return type("_Unpickler", (pickle.Unpickler,), {"persistent_load": lambda self, pid: buffers[pid[0]][pid[1]]})(file).load()
+    sig = inspect.signature(func)
   except Exception:
-    return None
+    return args, kwargs
+  params = list(sig.parameters.values())
+  if inspect.isfunction(func) and params and params[0].name in ('cls', 'self'):
+    params = params[1:]
 
+  new_args = list(args)
+  has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params)
+  if len(new_args) > len(params) and not has_varargs:
+    new_args = new_args[:len(params)]
 
-def _write_cache(path: str, jits: dict, device_map: dict | None, extra: str = "") -> None:
-  from tinygrad.device import Buffer
-  owners = {id(buffer): (repr(key), index) for key, jit in jits.items() for index, buffer in enumerate(jit.buffers)}
-
-  class _Pickler(pickle.Pickler):
-    def persistent_id(self, obj):
-      return owners.get(id(obj)) if isinstance(obj, Buffer) else None
-
-  key, tmp_path = _cache_key(path, device_map, extra), f"{path}.cache.{os.getpid()}.tmp"
-  with contextlib.suppress(Exception):
-    with open(tmp_path, "wb") as file:
-      file.write(struct.pack("<Q", len(key)) + key)
-      _Pickler(file, protocol=5).dump({name: _Jit(jit.captured, jit.input_names, jit.buffers) for name, jit in jits.items()})
-    os.replace(tmp_path, f"{path}.cache")
-
-
-# Everything below this comment block calls tinygrad internals, so after a tinygrad bump this
-# is the only code to update, and models are not recompiled. How to do this when discountchubbs is not available:
-#   1. run modeld_v2/tests/test_plain_artifact.py on the new tinygrad and fix each failing call against the new API: Buffer,
-#      UOp.from_buffer/param (ParamArg), ProgramInfo, Target, KernelInfo, compile_linear, CapturedJit and
-#      _prepare_jit_inputs in tinygrad/engine/jit.py
-#   2. load a real model with verify=True: ArtifactMismatch means the rebuilt graph still differs from the one that was compiled
-# The boot cache is keyed on the tinygrad source, so it rebuilds itself. Only a change in how the device runs kernel binaries needs a recompile.
-# Honestly, I would just have your clanker try it because you likely have zero idea what you are looking at lol..
-
-def _dtype(text: str):
-  from tinygrad.dtype import dtypes
-  return eval(text, {"__builtins__": {}}, {"dtypes": dtypes})
-
-
-def _device(recorded: str, device_map: dict | None) -> str:
-  from tinygrad import Device
-  device_map = device_map or {}
-  return Device.canonicalize(device_map.get(recorded, device_map.get(recorded.split(":", 1)[0], recorded)))
-
-
-def _upload(buffer, data: memoryview, chunk: int = 16 << 20) -> None:
-  from tinygrad.device import Buffer
-  source, chunk = Buffer("NPY", len(data), opaque=memoryview(bytearray(data)) if data.readonly else data), min(chunk, len(data))
-  for offset in sorted({*range(0, len(data) - chunk, chunk), len(data) - chunk}):
-    buffer.view(chunk, offset).ensure_allocated().copy_from(source.view(chunk, offset).ensure_allocated())
-
-
-def _allocate_buffers(header: dict, blob: memoryview, device_map: dict | None, shared: dict) -> list:
-  import numpy as np
-  from tinygrad.device import Buffer
-  written = {call["args"][i]["buffer"] for call in header["calls"] for i in (call["outs"] if call["kind"] == "program" else (0,))
-             if "buffer" in call["args"][i]}
-  entries = [(_device(entry["device"], device_map), blob[slice(*entry["init"])] if "init" in entry else None, entry) for entry in header["buffers"]]
-  keys = [(device, entry["dtype"], np.frombuffer(data, np.uint8).ctypes.data, len(data)) if data and index not in written else object()
-          for index, (device, data, entry) in enumerate(entries)]
-  for device in {key[0] for key in keys if isinstance(key, tuple) and key not in shared}:
-    if shared.setdefault(("mapped", device), Buffer(device, 1).ensure_allocated().get_storage().host is not None):
+  for i in range(len(new_args), len(params)):
+    param = params[i]
+    if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
       continue
-    spans = [(entry["init"], entry["nbytes"], key) for (_, _, entry), key in zip(entries, keys, strict=True)
-             if isinstance(key, tuple) and key[0] == device and key not in shared]
-    files = getattr(blob, "starts", [0])  # a part read from several files (frame_fusion's) is uploaded a block per file
-    for _, group in itertools.groupby(sorted(spans, key=lambda span: span[0][0]), key=lambda span: bisect.bisect_right(files, span[0][0])):
-      group = list(group)
-      start, end = min(span[0] for span, _, _ in group), max(span[1] for span, _, _ in group)
-      _upload(block := Buffer(device, end - start).ensure_allocated(), blob[start:end])
-      shared |= {key: block.view(nbytes, span[0] - start).ensure_allocated() for span, nbytes, key in group}
-  buffers = []
-  for (device, data, entry), key in zip(entries, keys, strict=True):
-    if key not in shared:
-      shared[key] = Buffer(device, entry["nbytes"], initial_value=pickle.PickleBuffer(data) if data else None).ensure_allocated()
-    buffers.append(shared[key])
-  return buffers
+    val = param.default if param.default is not inspect.Parameter.empty else None
+    new_args.append(val)
+  return new_args, kwargs
 
 
-def _program_uop(call: dict, lib: bytes):
-  from tinygrad.helpers import Target
-  from tinygrad.uop.ops import KernelInfo, Ops, ProgramInfo, UOp
-  parameters = []
-  for name, compact_slot, dtype, shape in call["signature"]:
-    parameter = UOp.param(call["globals"][compact_slot], _dtype(dtype), math.prod(shape))
-    image = (shape[0], shape[1]) if len(shape) == 3 and shape[2] == 4 else None
-    parameters.append(parameter.replace(arg=dataclasses.replace(parameter.arg, name=name, image=image)))
-  info = ProgramInfo(global_size=tuple(call["global_size"]), local_size=tuple(call["local_size"]), vars=(), globals=tuple(call["globals"]),
-                     outs=tuple(call["outs"]), ins=tuple(call["ins"]), target=Target(**call["target"]))
-  return UOp(Ops.PROGRAM, src=(UOp(Ops.SINK, arg=KernelInfo(name=call["name"])), UOp(Ops.LINEAR, src=tuple(parameters)),
-                               UOp(Ops.SOURCE, arg=""), UOp(Ops.BINARY, arg=lib)), arg=info)
+def _dynamic_factory(real_class):
+  if isinstance(real_class, type) and issubclass(real_class, enum.Enum):
+    return real_class
+
+  def factory(*args, **kwargs):
+    try:
+      return real_class(*args, **kwargs)
+    except TypeError:
+      new_args, new_kwargs = _pad_args(real_class, args, kwargs)
+      return real_class(*new_args, **new_kwargs)
+
+  class DynamicMeta(type(real_class)):
+    def __call__(cls, *args, **kwargs):
+      return factory(*args, **kwargs)
+
+  class DynamicProxy(real_class, metaclass=DynamicMeta):
+    __slots__ = ()
+
+    def __new__(cls, *args, **kwargs):
+      return factory(*args, **kwargs)
+
+  DynamicProxy.__name__ = real_class.__name__
+  DynamicProxy.__module__ = real_class.__module__
+  return DynamicProxy
 
 
-class _Jit:
-  def __init__(self, captured, input_names: list, buffers: list):
-    self.captured, self.input_names, self.buffers = captured, input_names, buffers
-
-  def __call__(self, *args, **kwargs):
-    import tinygrad.engine.jit as jit
-    input_uops, var_vals, names, _ = jit._prepare_jit_inputs(args, kwargs)
-    if names != self.input_names:
-      raise ValueError(f"expected inputs {self.input_names}, got {names}")
-    return self.captured(input_uops, var_vals)
+class DynamicTinygradUnpickler(pickle.Unpickler):
+  def find_class(self, module, name):
+    real_class = getattr(importlib.import_module(module), name)
+    if module.startswith("tinygrad"):
+      return _dynamic_factory(real_class)
+    return real_class
 
 
-class PlainJit(_Jit):
-  def __init__(self, header: dict, blob: memoryview, device_map: dict | None = None, verify: bool = True, shared: dict | None = None):
-    import numpy as np
-    import tinygrad.engine.jit as jit
-    from tinygrad import Tensor
-    from tinygrad.device import Buffer
-    from tinygrad.dtype import dtypes
-    from tinygrad.uop.ops import Ops, UOp
+def load_oob(f):
+  opcodes = f.read(struct.unpack('<q', f.read(8))[0])
+  def buffers():
+    while (h := f.read(8)):
+      pb = pickle.PickleBuffer(bytearray(struct.unpack('<q', h)[0]))
+      f.readinto(pb)
+      yield pb
+  return DynamicTinygradUnpickler(io.BytesIO(opcodes), buffers=buffers()).load()
 
-    inputs = {spec["slot"]: spec for spec in header["inputs"]}
-    buffers = _allocate_buffers(header, blob, device_map, {} if shared is None else shared)
-    bases = [UOp.from_buffer(buffer, _dtype(entry["dtype"])) for buffer, entry in zip(buffers, header["buffers"], strict=True)]
 
-    def argument(described: dict):
-      if "input" in described:
-        spec = inputs[described["input"]]
-        return UOp.param(described["input"], _dtype(spec["dtype"]), spec["numel"], _device(spec["device"], device_map))
-      base, dtype, offset, nbytes = bases[described["buffer"]], _dtype(described["dtype"]), described["offset"], described["nbytes"]
-      if offset == 0 and nbytes == header["buffers"][described["buffer"]]["nbytes"] and dtype == base.dtype:
-        return base
-      return (base if base.dtype.itemsize == 1 else base.bitcast(dtypes.uint8)).shrink(((offset, offset + nbytes),)).bitcast(dtype)
+def dump_oob(obj, f):
+  with tempfile.TemporaryFile(dir=".") as tmp:
+    def buffer_cb(buffer):
+      data = buffer.raw()
+      tmp.write(struct.pack('<q', len(data)))
+      tmp.write(data)
+      buffer.release()
+      return False
 
-    calls = []
-    for call in header["calls"]:
-      arguments = [argument(described) for described in call["args"]]
-      if call["kind"] == "program":
-        calls.append(_program_uop(call, bytes(blob[slice(*call["lib"])])).call(*arguments))
-      else:
-        calls.append(arguments[0].store_call(arguments[1]))
-    # stand-ins for JIT inputs: copy staging to GPU is decided from the input buffers, the real ones bind per call
-    stand_ins = {slot: UOp.from_buffer(Buffer(_device(spec["device"], device_map), spec["numel"] * _dtype(spec["dtype"]).itemsize).ensure_allocated(),
-                                       _dtype(spec["dtype"])) for slot, spec in inputs.items()}
-    input_uops = tuple(stand_ins.get(slot, next(iter(stand_ins.values()), None)) for slot in range(max(stand_ins, default=-1) + 1))
-    linear = jit.compile_linear(UOp(Ops.LINEAR, src=tuple(calls)), beam=0, input_uops=input_uops, cache=False)
-
-    returned = [Tensor(argument(t)).reshape(tuple(t["shape"])) for t in header["returns"]["tensors"]]
-    ret = {"NoneType": None, "Tensor": returned[0] if returned else None, "tuple": tuple(returned), "list": returned}[header["returns"]["kind"]]
-    super().__init__(jit.CapturedJit(ret, linear, header["input_names"], []), header["input_names"], buffers)
-
-    if not verify or not (check := header.get("check")):
-      return
-    def array(stored):
-      return np.frombuffer(blob[slice(*stored["data"])], dtype=np.dtype(stored["dtype"])).reshape(stored["shape"]).copy()
-    kwargs: dict = {}
-    for path, stored, device in check["inputs"]:
-      tensor = Tensor(array(stored), device=_device(device, device_map)).realize()
-      kwargs[path[0]] = tensor if len(path) == 1 else {**kwargs.get(path[0], {}), path[1]: tensor}
-    result = self(**kwargs)
-    outputs = kwargs[check["output_container"]].values() if check["output_container"] else flatten(result)
-    for index, (got, stored) in enumerate(zip([t.numpy() for t in outputs], check["outputs"], strict=True)):
-      expected = array(stored)
-      if got.shape != expected.shape or not np.allclose(got, expected, rtol=1e-3, atol=1e-3, equal_nan=True):
-        raise ArtifactMismatch(f"output {index} differs from the compile-time reference frame; recompile the model")
+    stream = io.BytesIO()
+    pickle.Pickler(stream, protocol=5, buffer_callback=buffer_cb).dump(obj)
+    opcodes = stream.getvalue()
+    f.write(struct.pack('<q', len(opcodes)))
+    f.write(opcodes)
+    tmp.seek(0)
+    shutil.copyfileobj(tmp, f)

openpilot/sunnypilot/modeld_v2/model_adapters.py

@@ -11,21 +11,20 @@ import pickle
 import numpy as np
 
 from openpilot.common.basedir import BASEDIR
-from openpilot.sunnypilot.modeld_v2.frame_fusion import pack_layout
-from openpilot.sunnypilot.modeld_v2.helpers import load_model
 from openpilot.sunnypilot.modeld_v2.compile_modeld import (POLICY_INPUTS, derive_frame_skip,
                                                            make_split_input_queues, make_supercombo_input_queues)
 from openpilot.sunnypilot.modeld_v2.stock_dependencies import make_input_queues as stock_make_input_queues, nv12_copy_size
 from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
 from tinygrad.device import Buffer
-from tinygrad.dtype import DType
+from tinygrad.dtype import DType, dtypes
+from tinygrad.helpers import round_up
 from tinygrad.tensor import Tensor
 from tinygrad.uop.ops import UOp
 
 
 def input_view(buffer: Buffer, shape: tuple[int, ...], dtype: DType, offset: int) -> Tensor:
-  view = buffer.view(math.prod(shape) * dtype.itemsize, offset).ensure_allocated()
-  return Tensor(UOp.from_buffer(view, dtype)).reshape(shape)
+  view = buffer.view(math.prod(shape), dtype, offset).ensure_allocated()
+  return Tensor(UOp.from_buffer(view)).reshape(shape)
 
 
 class BaseModelAdapter:
@@ -65,10 +64,16 @@ class BaseModelAdapter:
       self.warp_frame_size = self.nv12_info[3]
       return self.jits[(self.cam_w, self.cam_h)]
 
+    warp_dir = Path(BASEDIR) / "openpilot/sunnypilot/modeld_v2/models"
     warp_name = f'{"big_" if self.chestnut else ""}driving_warp_{self.cam_w}x{self.cam_h}_tinygrad.pkl'
-    warp = load_model(str(Path(BASEDIR) / "openpilot/sunnypilot/modeld_v2/models" / warp_name), cache=False)
-    self.warp_frame_size = warp['input_specs']['input_frame'][0][1]
-    return warp['run']
+    with open(warp_dir / warp_name, 'rb') as f:
+      warp_data = pickle.load(f)
+      run_warp = warp_data['run']
+      if 'input_specs' in warp_data and 'input_frame' in warp_data['input_specs']:
+        self.warp_frame_size = warp_data['input_specs']['input_frame'][0][1]
+      else:
+        self.warp_frame_size = self.nv12_info[3] if self.chestnut else self.frame_copy_size
+      return run_warp
 
 
 class LegacyModelAdapter(BaseModelAdapter):
@@ -163,22 +168,31 @@ class NativeTinygradAdapter(BaseModelAdapter):
     stride, y_height, uv_height, _ = get_nv12_info(self.cam_w, self.cam_h)
     self.frame_copy_size = stride * (y_height + uv_height)
 
-    self._vision_input_names = ['img', 'big_img']
+    self.input_shapes_orig = self.jits['metadata']['input_shapes']
+    self._vision_input_names = [k for k in self.input_shapes_orig if 'img' in k]
     self.vision_output_slices = pickle.loads(codecs.decode(self.jits['metadata']['metadata']['output_slices'].encode(), 'base64'))
 
-    self.warp_frame_size = self.frame_copy_size
+    self.run_warp = self._load_warp()
     self._init_common()
     self.run_model = self.jits['run']
 
+    warp_frame_size = getattr(self, 'warp_frame_size', self.nv12_info[3])
     self.input_queues = {name: Tensor(np.zeros(shape, dtype=dtype), device=self.model_device).realize()
                          for name, (shape, dtype) in self.input_shapes.items() if name in self.state_pairs}
-    specs = {name: spec for name, spec in self.input_shapes.items() if name not in self.state_pairs and name != 'new_img'}
-    offsets, packed = pack_layout(specs, self.warp_frame_size)
-    self.packed_input = np.zeros(packed, dtype=np.uint8)
-    self.host = Tensor(self.packed_input, device='NPY')
-    self.numpy_inputs = {name: np.ndarray(shape, dtype=dtype, buffer=self.packed_input, offset=offsets[name])
-                         for name, (shape, dtype) in ({'tfm': ((2, 3, 3), np.dtype(np.float32))} | specs).items()}
-    self.frames = self.packed_input[offsets['frames']:].reshape(2, self.warp_frame_size)
+    shapes = {'tfm': (2, 3, 3)} | {name: shape for name, (shape, _) in self.input_shapes.items()
+                                   if name not in self.state_pairs and name != 'new_img'}
+    npy_size = sum(round_up(math.prod(shape) * 4, 128) for shape in shapes.values())
+    self.packed_input = np.zeros(npy_size + 2 * warp_frame_size, dtype=np.uint8)
+    self.input_host = Tensor(self.packed_input, device='NPY')._buffer()
+    self.input_device = Tensor(self.packed_input, device=self.model_device)._buffer()
+    self.numpy_inputs = {}
+    offset = 0
+    for name, shape in shapes.items():
+      self.numpy_inputs[name] = np.ndarray(shape, dtype=np.float32, buffer=self.packed_input, offset=offset)
+      self.input_queues[name] = input_view(self.input_device, shape, dtypes.float32, offset)
+      offset += round_up(self.numpy_inputs[name].nbytes, 128)
+    self.frames = self.packed_input[npy_size:].reshape(2, warp_frame_size)
+    self.warp_inputs = {'input_frame': input_view(self.input_device, self.frames.shape, dtypes.uint8, npy_size), 'M_inv': self.input_queues.pop('tfm')}
 
     self.outputs = {name: Tensor(np.zeros(shape, dtype=dtype), device=device).realize() for name, (shape, dtype, device) in self.jits['output_specs'].items()}
     for name, next_name in self.state_pairs.items():
@@ -197,7 +211,9 @@ class NativeTinygradAdapter(BaseModelAdapter):
       self.input_queues[key].assign(0).realize()
 
   def run(self):
-    self.run_model(host=self.host, **self.input_queues, output_buffers=self.outputs)
+    self.input_device.copy_from(self.input_host)
+    self.input_queues['new_img'] = self.run_warp(**self.warp_inputs)
+    self.run_model(output_buffers=self.outputs, **self.input_queues)
     return self.outputs['outputs']
 
 

openpilot/sunnypilot/modeld_v2/modeld.py

@@ -24,6 +24,7 @@ from openpilot.cereal.messaging import PubMaster, SubMaster
 from openpilot.cereal.visionipc import VisionStreamType
 from msgq.visionipc import VisionIpcClient, VisionBuf
 from opendbc.car.car_helpers import get_demo_car_params
+from openpilot.common.file_chunker import open_file_chunked
 from openpilot.common.swaglog import cloudlog
 from openpilot.common.params import Params
 from openpilot.common.filter_simple import FirstOrderFilter
@@ -32,7 +33,6 @@ from openpilot.common.transformations.camera import DEVICE_CAMERAS
 from openpilot.common.transformations.model import get_warp_matrix
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.selfdrive.controls.lib.drive_helpers import get_accel_from_plan, smooth_value
-from openpilot.selfdrive.navigation.helpers import navigation_input
 from openpilot.selfdrive.modeld.modeld import ChestnutGpuState
 
 from openpilot.sunnypilot.modeld_v2.fill_model_msg import fill_model_msg, fill_pose_msg, PublishState, get_curvature_from_output
@@ -42,8 +42,7 @@ from openpilot.sunnypilot.modeld_v2.meta_helper import load_meta_constants
 from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
-from openpilot.sunnypilot.modeld_v2.helpers import load_model
-from openpilot.sunnypilot.modeld_v2.frame_fusion import fused_with_warp
+from openpilot.sunnypilot.modeld_v2.helpers import load_oob
 from openpilot.sunnypilot.modeld_v2.model_adapters import get_model_adapter
 from openpilot.sunnypilot.models.helpers import get_active_bundle
 from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
@@ -53,7 +52,8 @@ BIG_MODEL_TIMEOUT = 60
 
 
 def _pkl_exists(path):
-  return os.path.exists(path)
+  from openpilot.common.file_chunker import get_manifest_path
+  return os.path.exists(path) or os.path.exists(get_manifest_path(path))
 
 
 def _find_driving_pkl(bundle):
@@ -108,7 +108,7 @@ class ModelState(ModelStateBase):
 
   def _init_combined(self, pkl_path, cam_w, cam_h, bundle):
     cloudlog.warning(f"loading combined pkl: {pkl_path}")
-    jits = load_model(pkl_path, extend=fused_with_warp(cam_w, cam_h, self.chestnut))
+    jits = load_oob(open_file_chunked(pkl_path))
 
     metadata = jits['metadata']
     self.WARP_DEV = metadata.get('warp_dev', 'QCOM') if COMMA_HARDWARE else 'CPU'
@@ -170,9 +170,6 @@ class ModelState(ModelStateBase):
     for key in ('traffic_convention', 'lateral_control_params', 'action_t'):
       if key in self.numpy_inputs and key in inputs:
         self.numpy_inputs[key][:] = inputs[key]
-    for name in ('nav_map', 'navigation'):
-      if name in self.numpy_inputs:
-        self.numpy_inputs[name][:] = inputs.get(name, 0)
 
     if self.adapter.is_native:
       for i, key in enumerate(self._vision_input_names):
@@ -252,10 +249,6 @@ class ModelState(ModelStateBase):
     return log.ModelDataV2.Action(desiredCurvature=float(desired_curvature), desiredAcceleration=float(desired_accel), shouldStop=bool(stop))
 
 
-def takes_nav(*models) -> bool:
-  return any(name in m.numpy_inputs for m in models if m is not None for name in ('nav_map', 'navigation'))
-
-
 def main(demo=False):
   cloudlog.warning("modeld init")
 
@@ -265,8 +258,7 @@ def main(demo=False):
 
   CHESTNUT = chestnut_present()
   if CHESTNUT:
-    from tinygrad.runtime.ops_amd import AMDDevice
-    AMDDevice.wait_timeout_ms = 3000
+    os.environ['HCQDEV_WAIT_TIMEOUT_MS'] = '3000'
 
   params = Params()
   params.put_bool("ChestnutLoading", CHESTNUT)
@@ -284,7 +276,6 @@ def main(demo=False):
   vipc_client_main_stream = VisionStreamType.VISION_STREAM_WIDE_ROAD if main_wide_camera else VisionStreamType.VISION_STREAM_NARROW_ROAD
   vipc_client_main = VisionIpcClient("camerad", vipc_client_main_stream, True)
   vipc_client_extra = VisionIpcClient("camerad", VisionStreamType.VISION_STREAM_WIDE_ROAD, False)
-  vipc_client_map = VisionIpcClient("mapsd", VisionStreamType.VISION_STREAM_MAP, True)
   cloudlog.warning(f"vision stream set up, main_wide_camera: {main_wide_camera}, use_extra_client: {use_extra_client}")
 
   while not vipc_client_main.connect(False):
@@ -326,9 +317,7 @@ def main(demo=False):
   # messaging
   pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutGpuState"] if CHESTNUT else [])
   pm = PubMaster(pub_socks)
-  nav = takes_nav(model, small_model)
-  sm = SubMaster(["deviceState", "carState", "narrowRoadCameraState", "extrinsicsCalibration", "driverMonitoringState", "carControl", "lateralDelay"] +
-                 (["navInstruction"] if nav else []))
+  sm = SubMaster(["deviceState", "carState", "narrowRoadCameraState", "extrinsicsCalibration", "driverMonitoringState", "carControl", "lateralDelay"])
 
   publish_state = PublishState()
   chestnut_state = ChestnutGpuState(pm, model.chestnut) if CHESTNUT else None
@@ -361,7 +350,6 @@ def main(demo=False):
   DH = DesireHelper()
   meta_constants = load_meta_constants()
   RELC = RoadEdgeLaneChangeController()
-  nav_map, nav_map_time = None, 0.
 
   while True:
     # Keep receiving frames until we are at least 1 frame ahead of previous extra frame
@@ -451,16 +439,6 @@ def main(demo=False):
     if 'action_t' in model.numpy_inputs:
       inputs['action_t'] = np.array([lat_action_t, long_action_t], dtype=np.float32)
 
-    now = time.monotonic()
-    if nav and (vipc_client_map.is_connected() or vipc_client_map.connect(False)):
-      if (buf_map := vipc_client_map.recv(0)) is not None:
-        nav_map = np.frombuffer(buf_map.data, dtype=np.uint8, count=buf_map.width * buf_map.height).reshape(buf_map.height, buf_map.width).copy()
-        nav_map_time = now
-    if nav_map is not None and now - nav_map_time < 0.5: # map timeout
-      inputs['nav_map'] = nav_map
-    if nav and sm.valid['navInstruction'] and now - sm.recv_time['navInstruction'] < 2:
-      inputs['navigation'] = navigation_input(sm['navInstruction'].allManeuvers, v_ego * (now - sm.recv_time['navInstruction']))
-
     mt1 = time.perf_counter()
     try:
       send_chestnut = (chestnut_state is not None and

openpilot/sunnypilot/modeld_v2/models/big_driving_warp_1344x760_tinygrad.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f1689356ff8e516f87e3d75f6b53e66953a11ee5a97e859b4808c9a16bfe671b
-size 3677806
+oid sha256:ebac006f5e35ddb9c7da8ab38f9af87d6d0a87a3299b07cd118f88581f0f561f
+size 872573

openpilot/sunnypilot/modeld_v2/models/big_driving_warp_1928x1208_tinygrad.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:56cc9690e0e9fb719323d2c6646c1305e8bc6bbdfdc807724a605a0d0a37554b
-size 7904366
+oid sha256:d8eab79e53ebe1bbc3c633acc2a6bee80612cfe7fb5246afff6e0b7259c3a0d3
+size 872317

openpilot/sunnypilot/modeld_v2/models/driving_warp_1344x760_tinygrad.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4b22fd6bcb3a3e8a642e6866449dd9c30c12e694ff0741cad9e34e4b00d8c5fa
-size 3698799
+oid sha256:c48c9150afd01bd7071641415a248308c9a7b3cb47e7095862ef66c9f0429e43
+size 838183

openpilot/sunnypilot/modeld_v2/models/driving_warp_1928x1208_tinygrad.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9a17fd6acece4fab23784ef0f3f8bba28a049e9599e5e9e5ee7b36e4b1d24a6f
-size 7924847
+oid sha256:59564a7d214fe13dbb30cdd068437c4bf35ec071789c922288046636f711cdfa
+size 837991

openpilot/sunnypilot/modeld_v2/plain_artifact_compiler.py

@@ -1,90 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import dataclasses
-import mmap
-import tempfile
-from contextlib import contextmanager
-from unittest import mock
-
-import numpy as np
-
-from openpilot.sunnypilot.modeld_v2.helpers import Blob, flatten
-
-# Compile time only/ see discountchubbs 4 assistance: turns a captured TinyJit into plain data that helpers.load_model rebuilds. It reads internals of the
-# tinygrad that compiles the model, so a tinygrad bump that breaks it blocks new builds, never loading already built models.
-@contextmanager
-def record_kernel_linear():
-  import tinygrad.engine.jit as jit
-  import tinygrad.engine.realize as realize
-  recorded, hcq_compile, compile_linear = [], realize.hcq_compile, jit.compile_linear
-
-  def recording_compile_linear(*args, **kwargs):
-    with mock.patch.object(realize, "hcq_compile", lambda linear, *a, **k: (recorded.append(linear), hcq_compile(linear, *a, **k))[1]):
-      return compile_linear(*args, **kwargs)
-
-  with mock.patch.object(jit, "compile_linear", recording_compile_linear):
-    yield recorded
-
-
-def capture_frame(jit, kwargs: dict, output_container: str | None = None):
-  inputs = [([name] if key is None else [name, key], tensor.numpy().copy(), tensor.device)
-            for name, value in kwargs.items() for key, tensor in (value.items() if isinstance(value, dict) else [(None, value)])]
-  result = jit(**kwargs)
-  outputs = kwargs[output_container].values() if output_container else flatten(result)
-  return {"inputs": inputs, "outputs": [tensor.numpy().copy() for tensor in outputs], "output_container": output_container}, result
-
-
-def serialize_jit(jit, kernel_linear, check: dict | None = None) -> tuple[dict, memoryview]:
-  from tinygrad.uop.ops import Ops
-  sink = tempfile.TemporaryFile(dir=".")
-  blob, bases, input_specs = Blob(sink), {}, {}
-
-  def store(array) -> dict:
-    array = np.ascontiguousarray(array)
-    return {"data": blob.add(array.tobytes()), "dtype": array.dtype.str, "shape": list(array.shape)}
-
-  def describe(uop) -> dict:
-    if uop.op is Ops.PARAM:
-      input_specs.setdefault(uop.arg.slot, {"dtype": repr(uop.dtype), "numel": int(uop.max_numel()), "device": uop.device})
-      return {"input": uop.arg.slot}
-    buffer = uop.buffer
-    root = buffer._base if buffer._base is not None else buffer
-    base = bases.setdefault(id(root), (len(bases), root, uop.base.dtype if buffer._base is None else uop.dtype))
-    return {"buffer": base[0], "offset": buffer.offset if buffer._base is not None else 0, "nbytes": buffer.nbytes, "dtype": repr(uop.dtype)}
-
-  calls, written, needs_init = [], set(), set()
-  for call in kernel_linear.src:
-    ast, arguments = call.src[0], [describe(argument) for argument in call.src[1:]]
-    if ast.op is Ops.PROGRAM:
-      elf, info = ast.to_elf(), ast.arg
-      global_size, local_size = info.launch_dims({})
-      calls.append({"kind": "program", "name": elf.name, "lib": blob.add(bytes(elf.lib)), "target": dataclasses.asdict(elf.target),
-                    "signature": [[name, slot, repr(dtype), [int(x) for x in shape]] for name, slot, dtype, shape in elf.signature],
-                    "global_size": [int(x) for x in global_size], "local_size": [int(x) for x in local_size],
-                    "globals": list(info.globals), "outs": list(info.outs), "ins": list(info.ins), "args": arguments})
-      outs, ins = info.outs, info.ins
-    elif ast.op is Ops.STORE:  # a copy: STORE(PARAM dst, PARAM src)
-      calls.append({"kind": "copy", "args": arguments})
-      outs, ins = (0,), (1,)
-    else:
-      raise ValueError(f"unsupported call {ast.op} {ast.arg}")
-    needs_init |= {arguments[i]["buffer"] for i in ins if "buffer" in arguments[i] and arguments[i]["buffer"] not in written}
-    written |= {arguments[i]["buffer"] for i in outs if "buffer" in arguments[i]}
-
-  ret = jit.captured.ret
-  returns = {"kind": type(ret).__name__, "tensors": [describe(t.uop.base) | {"shape": [int(x) for x in t.shape]} for t in flatten(ret)]}
-  buffers = [{"nbytes": base.nbytes, "device": base.device, "dtype": repr(dtype)}
-             | ({"init": blob.add(base.as_memoryview())} if index in needs_init else {}) for index, base, dtype in bases.values()]
-  names = list(jit.captured.expected_names)
-  if check is not None:
-    check = {"inputs": [[path, store(array), device] for path, array, device in check["inputs"]], "outputs": [store(array) for array in check["outputs"]],
-             "output_container": check["output_container"]}
-  header = {"input_names": names, "buffers": buffers, "calls": calls, "returns": returns, "check": check,
-            "inputs": [{"slot": slot, "name": names[slot] if slot < len(names) else None} | input_specs[slot] for slot in sorted(input_specs)]}
-  with sink:
-    sink.flush()
-    return header, memoryview(mmap.mmap(sink.fileno(), 0, access=mmap.ACCESS_READ) if blob.size else b"")

openpilot/sunnypilot/modeld_v2/tests/helpers.py

@@ -188,8 +188,10 @@ def make_pkl_data(archetype):
 
 
 def write_pkl(tmp_path, archetype):
+  from openpilot.sunnypilot.modeld_v2.helpers import dump_oob
   pkl_path = tmp_path / 'driving_test_tinygrad.pkl'
-  pkl_path.write_bytes(pickle.dumps(make_pkl_data(archetype)))
+  with open(pkl_path, 'wb') as f:
+    dump_oob(make_pkl_data(archetype), f)
   return pkl_path
 
 
@@ -209,7 +211,6 @@ def patch_modeld(monkeypatch):
   def _patch(bundle):
     monkeypatch.setattr(helpers, 'get_active_bundle', lambda params=None, *, chestnut=None: bundle)
     monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None, *, chestnut=None: bundle)
-    monkeypatch.setattr(modeld_module, 'load_model', lambda path, **_: pickle.loads(pathlib.Path(path).read_bytes()))
 
   return _patch
 

openpilot/sunnypilot/modeld_v2/tests/test_combined_pkl_loader.py

@@ -90,6 +90,7 @@ class TestStockEquivalence(OpenpilotTestCase):
 
   def test_unified_run_model(self, tmp_path, monkeypatch, patch_modeld):
     from openpilot.common.hardware import hw
+    from openpilot.sunnypilot.modeld_v2.helpers import dump_oob
     shapes = {'img': (1, 12, 128, 256), 'big_img': (1, 12, 128, 256), 'features_buffer': (1, 24, 32, 512),
               'desire_pulse': (1, 25, 8), 'traffic_convention': (1, 2), 'action_t': (1, 2)}
     import codecs
@@ -101,7 +102,8 @@ class TestStockEquivalence(OpenpilotTestCase):
       (CAM_W, CAM_H): tests_helpers._noop_jit,
       'run_policy': tests_helpers._noop_jit,
     }
-    (tmp_path / 'driving_test_tinygrad.pkl').write_bytes(pickle.dumps(pkl_data))
+    with open(tmp_path / 'driving_test_tinygrad.pkl', 'wb') as f:
+      dump_oob(pkl_data, f)
     bundle = DummyBundle(models=[DummyModel('supercombo', 'driving_test_tinygrad.pkl')])
     patch_modeld(bundle)
     monkeypatch.setattr(hw.Paths, 'model_root', staticmethod(lambda: str(tmp_path)))

openpilot/sunnypilot/modeld_v2/tests/test_compile_modeld.py

@@ -5,12 +5,16 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 
+import os
+import tempfile
 import unittest
+from pathlib import Path
 
 import numpy as np
 from openpilot.common.parameterized import parameterized
 
-from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, _detect_desire_key
+from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, _detect_desire_key, read_file_chunked_to_disk
 from openpilot.common.test import OpenpilotTestCase
 
 
@@ -164,6 +168,36 @@ class TestOutputSlicePreservation(OpenpilotTestCase):
       "vision and policy slices should not overlap in keys"
 
 
+class TestReadFileChunkedToDisk(OpenpilotTestCase):
+  def test_none_passthrough(self):
+    assert read_file_chunked_to_disk(None) is None
+
+  def test_unchunked_source_staged_on_disk(self):
+    with tempfile.TemporaryDirectory() as d:
+      src = Path(d) / "driving_supercombo.onnx"
+      payload = os.urandom(1024)
+      src.write_bytes(payload)
+
+      out = Path(read_file_chunked_to_disk(str(src)))
+
+      assert out.parent == Path(d)
+      assert out.name == "driving_supercombo.onnx.unchunked"
+      assert out.read_bytes() == payload
+
+  def test_chunked_source_reassembled_on_disk(self):
+    with tempfile.TemporaryDirectory() as d:
+      src = Path(d) / "driving_supercombo.onnx"
+      payload = os.urandom(4096)
+      src.write_bytes(payload)
+      chunk_file(str(src), get_chunk_targets(str(src), len(payload)))
+      assert not src.exists()
+
+      out = Path(read_file_chunked_to_disk(str(src)))
+
+      assert out.parent == Path(d)
+      assert out.read_bytes() == payload
+
+
 class Test4DFeaturesBuffer(OpenpilotTestCase):
   def test_get_policy_npy_shapes_4d(self):
     from openpilot.sunnypilot.modeld_v2.compile_modeld import get_policy_npy_shapes

openpilot/sunnypilot/modeld_v2/tests/test_fallback.py

@@ -5,11 +5,13 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 
-import pickle
+import io
 import requests
 
+from openpilot.common.file_chunker import get_chunk_name
 from openpilot.common.hardware import hw
 from openpilot.common.test import OpenpilotTestCase
+from openpilot.sunnypilot.modeld_v2.helpers import dump_oob
 import openpilot.sunnypilot.modeld_v2.modeld as modeld_module
 from openpilot.sunnypilot.modeld_v2.tests import helpers as tests_helpers
 from openpilot.sunnypilot.modeld_v2.tests.helpers import DummyModel, DummyBundle, CAM_W, CAM_H
@@ -41,11 +43,14 @@ class TestFallback(OpenpilotTestCase):
     small_json = requests.get(ModelFetcher.MODEL_URL).json()
     small_bundle = ModelParser.parse_models(small_json)[-1]
 
-    oob_bytes = pickle.dumps(tests_helpers.make_pkl_data(tests_helpers.ARCHETYPES['supercombo_non20hz']))
-    monkeypatch.setattr(modeld_module, 'load_model', lambda path, **_: pickle.loads(open(path, 'rb').read()))
+    buf = io.BytesIO()
+    dump_oob(tests_helpers.make_pkl_data(tests_helpers.ARCHETYPES['supercombo_non20hz']), buf)
+    oob_bytes = buf.getvalue()
 
     for bundle in (big_bundle, small_bundle):
-      (tmp_path / bundle.models[0].artifact.fileName).write_bytes(oob_bytes)
+      artifact = bundle.models[0].artifact
+      for i in range(len(artifact.chunks)):
+        (tmp_path / get_chunk_name(artifact.fileName, i, len(artifact.chunks))).write_bytes(oob_bytes if i == 0 else b"")
 
     monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None, *, chestnut=None: small_bundle)
     assert modeld_module.ModelState(CAM_W, CAM_H, chestnut=False).chestnut is False

openpilot/sunnypilot/modeld_v2/tests/test_models.py

@@ -7,14 +7,71 @@ See the LICENSE.md file in the root directory for more details.
 
 import os
 import unittest
-
-from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, load_model
+from unittest.mock import patch
+from openpilot.common.file_chunker import open_file_chunked
+from openpilot.sunnypilot.modeld_v2.helpers import load_oob
+from tinygrad.device import Device
 
 
-class TestRegistryModels(unittest.TestCase):
-  def test_model_loads(self):
-    if not (base_name := os.environ.get("MODEL_BASE_NAME")):
-      self.skipTest("MODEL_BASE_NAME env var not set, skipping integration test.")
-    bundle = load_model(os.path.join(os.environ.get("MODEL_DIR", "/tmp/models"), base_name), {"QCOM": "CPU", "AMD": "CPU"}, verify=False, cache=False)
-    jits = [value for value in bundle.values() if isinstance(value, PlainJit)]
-    assert "metadata" in bundle and jits and all(len(jit.captured.linear.src) > 0 for jit in jits)
+class TestLegacyModels(unittest.TestCase):
+  def test_legacy_model_load(self):
+    base_name = os.environ.get("MODEL_BASE_NAME")
+    if not base_name:
+      raise unittest.SkipTest("MODEL_BASE_NAME env var not set, skipping integration test.")
+    chunk_dir = os.environ.get("MODEL_CHUNK_DIR", "/tmp/model_chunks")
+    base_path = os.path.join(chunk_dir, base_name)
+
+    try:
+      f = open_file_chunked(base_path)
+    except Exception as error:
+      self.fail(f"Failed to open chunked file {base_path}: {error}")
+    self.addCleanup(f.close)
+
+    real_getitem = Device.__class__.__getitem__
+
+    def safe_getitem(device_self, ix):
+      if ix == "QCOM" and not os.path.exists("/dev/kgsl-3d0"):
+        return real_getitem(device_self, "CPU")
+      if ix == "AMD" and not os.path.exists("/dev/kfd"):
+        return real_getitem(device_self, "CPU")
+      return real_getitem(device_self, ix)
+
+    with patch.object(Device.__class__, "__getitem__", safe_getitem):
+      obj = load_oob(f)
+
+      assert isinstance(obj, dict), "Parsed object is not a dictionary"
+      assert "metadata" in obj, "Metadata key is missing"
+
+      def traverse_jits(d):
+        if hasattr(d, "captured") and d.captured is not None:
+          linear_attr = getattr(d.captured, "_linear", None)
+          if linear_attr is None:
+            try:
+              linear_attr = getattr(d.captured, "linear", None)
+            except AssertionError as e:
+              if "alloc size must be positive" in str(e):
+                return
+              raise
+
+          if linear_attr is not None:
+            stack = [linear_attr]
+            visited = set()
+            while stack:
+              node = stack.pop()
+              if id(node) in visited:
+                continue
+              visited.add(id(node))
+              if hasattr(node, "src") and node.src is not None:
+                for child in node.src:
+                  stack.append(child)
+        elif isinstance(d, dict):
+          for v in d.values():
+            traverse_jits(v)
+        elif isinstance(d, (list, tuple)):
+          for v in d:
+            traverse_jits(v)
+
+      if "run_model" in obj:
+        traverse_jits(obj["run_model"])
+      if "run_policy" in obj:
+        traverse_jits(obj["run_policy"])

openpilot/sunnypilot/modeld_v2/warmup.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import os
-os.environ['GMMU'] = '0'
-import multiprocessing
-import time
-from openpilot.common.hardware.hw import Paths
-from openpilot.common.params import Params
-from openpilot.common.swaglog import cloudlog
-from openpilot.sunnypilot.modeld_v2.helpers import cache_is_fresh, load_model, read_parts
-from openpilot.sunnypilot.models.helpers import get_selected_bundle
-
-
-def main():
-  """
-  The main entry point for offroad cache creation.
-  Runs every 10 seconds and checks for a stale qcom model cache.
-  """
-  params, failed, native, spawn = Params(), set(), set(), multiprocessing.get_context("spawn")
-  while True:
-    bundle = get_selected_bundle(params, "qcom")
-    path = os.path.join(Paths.model_root(), bundle.models[0].artifact.fileName) if bundle and bundle.models else ""
-    if os.path.isfile(path) and not cache_is_fresh(path) and (attempt := (path, os.stat(path).st_mtime_ns)) not in failed | native:
-      if "input_specs" in read_parts(path)[1]:  # native models are fused
-        native.add(attempt)
-      else:
-        (worker := spawn.Process(target=load_model, args=(path,), daemon=True)).start()
-        worker.join()
-        if not cache_is_fresh(path):
-          cloudlog.error(f"model cache warmup failed for {path} with exit code {worker.exitcode}")
-          failed.add(attempt)
-    time.sleep(10)
-
-
-if __name__ == "__main__":
-  main()

openpilot/sunnypilot/models/fetcher.py

@@ -6,10 +6,12 @@ See the LICENSE.md file in the root directory for more details.
 """
 
 import time
+import os
 import requests
 from requests.exceptions import (SSLError, RequestException, HTTPError)
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
+from openpilot.common.hardware.hw import Paths
 from openpilot.sunnypilot.models.helpers import is_bundle_version_compatible
 from openpilot.cereal import custom
 
@@ -24,11 +26,35 @@ class ModelParser:
     download_uri.sha256 = download_uri_data.get("sha256")
     return download_uri
 
+  @staticmethod
+  def _parse_chunk(chunk_data) -> custom.ModelManagerSP.Chunk:
+    chunk = custom.ModelManagerSP.Chunk()
+    chunk.fileName = chunk_data.get("file_name")
+    chunk.sha256 = chunk_data.get("sha256")
+    return chunk
+
   @staticmethod
   def _parse_artifact(artifact_data) -> custom.ModelManagerSP.Artifact:
     artifact = custom.ModelManagerSP.Artifact()
     artifact.fileName = artifact_data.get("file_name")
     artifact.downloadUri = ModelParser._parse_download_uri(artifact_data.get("download_uri", {}))
+
+    if "chunks" in artifact_data:
+      artifact.chunks = [ModelParser._parse_chunk(chunk_data) for chunk_data in artifact_data["chunks"]]
+
+      try:
+        model_dir = Paths.model_root()
+        os.makedirs(model_dir, exist_ok=True)
+        manifest_path = os.path.join(model_dir, f"{artifact.fileName}.chunkmanifest")
+        num_chunks = str(len(artifact.chunks))
+
+        if not os.path.exists(manifest_path) or open(manifest_path).read().strip() != num_chunks:
+          with open(manifest_path, "w") as f:
+            f.write(num_chunks)
+          cloudlog.info(f"Wrote chunk manifest for {artifact.fileName}: {num_chunks} chunks")
+      except Exception as e:
+        cloudlog.warning(f"Failed to write chunk manifest for {artifact.fileName}: {e}")
+
     return artifact
 
   @staticmethod
@@ -112,8 +138,8 @@ class ModelCache:
 
 class ModelFetcher:
   """Handles fetching and caching of model data from remote source"""
-  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v25.json"
-  MODEL_URL_CHESTNUT = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_chestnut_v28.json"
+  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v23.json"
+  MODEL_URL_CHESTNUT = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_chestnut_v27.json"
 
   MODEL_SOURCES = {
     "qcom": (MODEL_URL, ""),
@@ -244,3 +270,5 @@ if __name__ == "__main__":
       model_overrides = {override.key: override.value for override in bundle.overrides}
       print(f"Bundle: {bundle.internalName}, Type: {model.type}, Status: {bundle.status}, Overrides: {model_overrides}")
       print(f"Artifact: {model.artifact.fileName}, Download URI: {model.artifact.downloadUri.uri}")
+      if model.artifact.chunks:
+        print(f"Contains {len(model.artifact.chunks)} chunks.")

openpilot/sunnypilot/models/helpers.py

@@ -16,7 +16,7 @@ from openpilot.common.hardware.hw import Paths
 from openpilot.selfdrive.modeld.helpers import chestnut_present
 
 # SET ME TO THE EXACT JSON VERSION WE SET IN SUNNYPILOT_MODELS REPO
-REQUIRED_JSON_VERSION = 21
+REQUIRED_JSON_VERSION = 20
 
 CUSTOM_MODEL_PATH = Paths.model_root()
 ModelManager = custom.ModelManagerSP
@@ -29,8 +29,9 @@ _LAST_VALIDATED_RAW: dict[str, dict | None] = {}
 
 
 def _compute_hash(file_path: str) -> str | None:
+  from openpilot.common.file_chunker import open_file_chunked
   try:
-    with open(file_path, 'rb') as file:
+    with open_file_chunked(file_path) as file:
       return hashlib.file_digest(file, "sha256").hexdigest().lower()
   except FileNotFoundError:
     return None
@@ -57,11 +58,20 @@ def is_bundle_version_compatible(bundle: dict) -> bool:
 
 def _bundle_artifacts(bundle: custom.ModelManagerSP.ModelBundle) -> list[tuple[str, str]]:
   artifacts = []
+  from openpilot.common.file_chunker import get_chunk_name
   for model in getattr(bundle, 'models', []) or []:
-    artifact = getattr(model, 'artifact', None)
-    if artifact and getattr(artifact, 'fileName', None) and getattr(artifact, 'downloadUri', None):
-      if sha256 := getattr(artifact.downloadUri, 'sha256', None):
-        artifacts.append((artifact.fileName, sha256))
+    for artifact in (getattr(model, 'artifact', None),):
+      if artifact and getattr(artifact, 'fileName', None):
+        if len(artifact.chunks) > 0:
+          for i, chunk in enumerate(artifact.chunks):
+            chunk_name = get_chunk_name(artifact.fileName, i, len(artifact.chunks))
+            if getattr(chunk, 'sha256', None):
+              artifacts.append((chunk_name, chunk.sha256))
+        else:
+          if getattr(artifact, 'downloadUri', None):
+            sha256 = getattr(artifact.downloadUri, 'sha256', None)
+            if sha256:
+              artifacts.append((artifact.fileName, sha256))
   return artifacts
 
 

openpilot/sunnypilot/models/manager.py

@@ -109,6 +109,50 @@ class ModelManagerSP:
     # Clean up start time after download completes
     del self._download_start_times[model.fileName]
 
+  async def _download_chunked(self, base_url: str, base_path: str, artifact, skip: frozenset[int] | set[int] = frozenset()) -> None:
+    from openpilot.common.file_chunker import get_chunk_name, get_manifest_path
+
+    num_chunks = len(artifact.chunks)
+    if num_chunks == 0:
+      raise ValueError("No chunks defined in artifact")
+
+    manifest_path = get_manifest_path(base_path)
+    self._download_start_times[artifact.fileName] = time.monotonic()
+
+    # Shared connection saves a TCP+TLS handshake per chunk.
+    # Keep sequential: the link saturates on one stream and Session is not thread-safe.
+    completed = len(skip)
+    with requests.Session() as session:
+      for i, _ in enumerate(artifact.chunks):
+        if i in skip:
+          continue
+        chunk_url = get_chunk_name(base_url, i, num_chunks)
+        chunk_path = get_chunk_name(base_path, i, num_chunks)
+        chunk_downloaded = 0
+        with session.get(chunk_url, stream=True, timeout=DOWNLOAD_TIMEOUT) as response:
+          response.raise_for_status()
+          chunk_size = int(response.headers.get("content-length", 0))
+          with open(chunk_path, 'wb') as f:  # noqa: ASYNC230
+            for data in response.iter_content(chunk_size=self._chunk_size):
+              f.write(data)
+              chunk_downloaded += len(data)
+              if self._download_interrupted():
+                raise DownloadCancelled("Download cancelled")
+              intra = chunk_downloaded / max(chunk_size, 1)
+              progress = min(99.0, ((completed + intra) / num_chunks) * 100)
+              artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloading
+              artifact.downloadProgress.progress = progress
+              artifact.downloadProgress.eta = self._calculate_eta(artifact.fileName, progress)
+              self._sync_artifact_progress(artifact)
+              self._report_status()
+        completed += 1
+
+    with open(manifest_path, 'w') as f:  # noqa: ASYNC230
+      f.write(str(num_chunks))
+    if os.path.isfile(base_path):  # noqa: ASYNC240
+      os.remove(base_path)
+    del self._download_start_times[artifact.fileName]
+
   async def _process_artifact(self, artifact, destination_path: str) -> None:
     if not artifact.downloadUri.uri:
       return None
@@ -121,7 +165,28 @@ class ModelManagerSP:
     full_path = os.path.join(destination_path, filename)
 
     try:
-      if await verify_file(full_path, expected_hash):
+      # progress counts only valid chunks so a resumed download continues the
+      # bar from where verification left it, instead of falling back to zero
+      is_cached = False
+      valid_chunks: set[int] = set()
+      if len(artifact.chunks) > 0:
+        from openpilot.common.file_chunker import get_chunk_name
+        num_chunks = len(artifact.chunks)
+        for i, chunk in enumerate(artifact.chunks):
+          if self._download_interrupted():
+            raise DownloadCancelled("Download cancelled")
+          if await verify_file(get_chunk_name(full_path, i, num_chunks), chunk.sha256):
+            valid_chunks.add(i)
+          artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.verifying
+          artifact.downloadProgress.progress = (len(valid_chunks) / num_chunks) * 100
+          self._sync_artifact_progress(artifact)
+          self._report_status()
+        is_cached = len(valid_chunks) == num_chunks
+      else:
+        if await verify_file(full_path, expected_hash):
+          is_cached = True
+
+      if is_cached:
         artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.cached
         artifact.downloadProgress.progress = 100
         artifact.downloadProgress.eta = 0
@@ -129,9 +194,17 @@ class ModelManagerSP:
         self._report_status()
         return
 
-      await self._download_file(url, full_path, artifact)
-      if not await verify_file(full_path, expected_hash):
-        raise ValueError(f"Hash validation failed for {filename}")
+      if len(artifact.chunks) > 0:
+        await self._download_chunked(url, full_path, artifact, skip=valid_chunks)
+        from openpilot.common.file_chunker import get_chunk_name
+        for i, chunk in enumerate(artifact.chunks):
+          chunk_path = get_chunk_name(full_path, i, len(artifact.chunks))
+          if not await verify_file(chunk_path, chunk.sha256):
+            raise ValueError(f"Hash validation failed for chunk {i+1} of {filename}")
+      else:
+        await self._download_file(url, full_path, artifact)
+        if not await verify_file(full_path, expected_hash):
+          raise ValueError(f"Hash validation failed for {filename}")
 
       artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloaded
       artifact.downloadProgress.progress = 100
@@ -140,6 +213,7 @@ class ModelManagerSP:
       self._report_status()
 
     except DownloadCancelled:
+      # a cancel keeps whatever is on disk: complete chunks resume the next attempt
       self._download_start_times.pop(artifact.fileName, None)
       artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.failed
       artifact.downloadProgress.eta = 0
@@ -151,8 +225,9 @@ class ModelManagerSP:
 
     except Exception as e:
       cloudlog.error(f"Error downloading {filename}: {str(e)}")
-      if os.path.isfile(full_path):  # noqa: ASYNC240
-        os.remove(full_path)
+      for f in [full_path] + [p for p in (os.path.join(destination_path, f) for f in os.listdir(destination_path)) if filename in p]:
+        if os.path.isfile(f):  # noqa: ASYNC240
+          os.remove(f)
       artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.failed
       artifact.downloadProgress.eta = 0
       self._sync_artifact_progress(artifact)
@@ -285,11 +360,12 @@ class ModelManagerSP:
           if model.artifact.fileName:
             active_files.append(model.artifact.fileName)
 
-    # Remove all files except active ones
+    # Remove all files except active ones (including their chunk files)
     model_dir = Paths.model_root()
     try:
       for filename in os.listdir(model_dir):
-        if filename not in active_files:
+        base = filename.split('.chunk')[0] if '.chunk' in filename else filename
+        if base not in active_files and filename not in active_files:
           file_path = os.path.join(model_dir, filename)
           if os.path.isfile(file_path):
             os.remove(file_path)

openpilot/sunnypilot/models/tests/test_manager_download.py

@@ -17,9 +17,11 @@ from typing import Any
 from unittest import mock
 
 import requests
+from urllib3.connectionpool import HTTPConnectionPool
 
 from openpilot.cereal import custom
 from openpilot.common.test import OpenpilotTestCase
+from openpilot.common.file_chunker import get_chunk_name, get_manifest_path
 from openpilot.selfdrive.test.helpers import http_server_context
 from openpilot.sunnypilot.models import manager as manager_module
 from openpilot.sunnypilot.models.fetcher import ModelFetcher, get_cached_bundles
@@ -28,6 +30,7 @@ from openpilot.sunnypilot.models.helpers import (get_active_bundle, get_active_s
                                                   resolve_bundle_by_ref, validate_active_bundles)
 from openpilot.sunnypilot.models.manager import ModelManagerSP
 
+CHUNK_BODIES = [b'A' * 5000, b'B' * 5000, b'C' * 3000]
 WHOLE_BODY = b'Z' * 9000
 
 
@@ -46,7 +49,12 @@ class DownloadHandler(http.server.BaseHTTPRequestHandler):
     pass
 
   def _body_for(self, path):
-    return WHOLE_BODY if path.endswith('.pkl') else None
+    if path.endswith('.whole'):
+      return WHOLE_BODY
+    for i in range(len(CHUNK_BODIES)):
+      if path.endswith(get_chunk_name('', i, len(CHUNK_BODIES))):
+        return CHUNK_BODIES[i]
+    return None
 
   def do_GET(self):
     type(self).request_paths.append(self.path)
@@ -111,19 +119,35 @@ class ManagerDownloadTestBase(OpenpilotTestCase):
     if artifact is not None:
       self.reported.append(float(artifact.downloadProgress.progress))
 
-  def make_artifact(self):
+  def make_artifact(self, chunked: bool):
     bundle = custom.ModelManagerSP.ModelBundle.new_message()
     bundle.init('models', 1)
     artifact = bundle.models[0].artifact
     artifact.fileName = 'driving_test_tinygrad.pkl'
-    artifact.downloadUri.uri = self.base_url + '/driving_test_tinygrad.pkl'
-    artifact.downloadUri.sha256 = sha256(WHOLE_BODY)
+    if chunked:
+      artifact.downloadUri.uri = self.base_url + '/driving_test_tinygrad.pkl'
+      artifact.downloadUri.sha256 = sha256(b''.join(CHUNK_BODIES))
+      artifact.init('chunks', len(CHUNK_BODIES))
+      for i, body in enumerate(CHUNK_BODIES):
+        artifact.chunks[i].sha256 = sha256(body)
+    else:
+      artifact.downloadUri.uri = self.base_url + '/driving_test_tinygrad.pkl.whole'
+      artifact.downloadUri.sha256 = sha256(WHOLE_BODY)
     self._bundle = bundle
     self.artifact = artifact
     return artifact
 
+  def chunk_paths(self, base_path):
+    return [get_chunk_name(base_path, i, len(CHUNK_BODIES)) for i in range(len(CHUNK_BODIES))]
+
+  def assert_no_partials(self, base_path):
+    leftovers = [p for p in [base_path, get_manifest_path(base_path)] + self.chunk_paths(base_path)
+                 if os.path.isfile(p)]
+    assert leftovers == [], f"partial files left behind: {leftovers}"
+
+
 class TestManagerDownload(ManagerDownloadTestBase):
-  """Exercises the real _download_file against a local server."""
+  """Exercises the real _download_file / _download_chunked against a local server."""
 
   def run_with_server(self, fn):
     with http_server_context(handler=DownloadHandler) as (host, port):
@@ -132,7 +156,7 @@ class TestManagerDownload(ManagerDownloadTestBase):
 
   def test_download_file_writes_exact_bytes(self):
     def body():
-      artifact = self.make_artifact()
+      artifact = self.make_artifact(chunked=False)
       path = os.path.join(self.dest, artifact.fileName)
       asyncio.run(self.manager._download_file(artifact.downloadUri.uri, path, artifact))
       with open(path, 'rb') as f:
@@ -142,67 +166,111 @@ class TestManagerDownload(ManagerDownloadTestBase):
       assert artifact.fileName not in self.manager._download_start_times
     self.run_with_server(body)
 
+  def test_download_chunked_writes_all_chunks_and_manifest(self):
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+      asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
+
+      for i, expected in enumerate(CHUNK_BODIES):
+        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'rb') as f:
+          assert f.read() == expected, f"chunk {i} body mismatch"
+
+      with open(get_manifest_path(base_path)) as f:
+        assert f.read() == str(len(CHUNK_BODIES))
+
+      assert not os.path.isfile(base_path), "base file should be removed after chunking"
+      assert artifact.fileName not in self.manager._download_start_times
+    self.run_with_server(body)
+
   def test_progress_is_monotonic_and_bounded(self):
     def body():
-      artifact = self.make_artifact()
+      artifact = self.make_artifact(chunked=True)
       base_path = os.path.join(self.dest, artifact.fileName)
-      asyncio.run(self.manager._download_file(artifact.downloadUri.uri, base_path, artifact))
+      asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
 
       assert self.reported, "expected progress reports"
       for a, b in zip(self.reported, self.reported[1:], strict=False):
         assert b >= a, f"progress went backwards: {a} -> {b}"
+      assert max(self.reported) <= 99.0, f"chunked progress must stay <=99 until verify, got {max(self.reported)}"
+    self.run_with_server(body)
+
+  def test_session_is_reused_across_chunks(self):
+    """One connection pool shared across every chunk."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+
+      pools = []
+      original = HTTPConnectionPool.urlopen
+
+      def tracked(pool_self, *args, **kwargs):
+        pools.append(id(pool_self))
+        return original(pool_self, *args, **kwargs)
+
+      with mock.patch.object(HTTPConnectionPool, 'urlopen', tracked):
+        asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
+
+      assert len(pools) == len(CHUNK_BODIES), f"expected one request per chunk, got {len(pools)}"
+      assert len(set(pools)) == 1, f"connection pool not reused across chunks: {len(set(pools))} pools"
     self.run_with_server(body)
 
   def test_http_error_propagates(self):
     def body():
-      artifact = self.make_artifact()
+      artifact = self.make_artifact(chunked=True)
       base_path = os.path.join(self.dest, artifact.fileName)
-      DownloadHandler.fail_paths = {'/' + artifact.fileName: 404}
+      failing = '/' + os.path.basename(get_chunk_name(artifact.downloadUri.uri, 1, len(CHUNK_BODIES)))
+      DownloadHandler.fail_paths = {failing: 404}
 
       with self.assertRaises(requests.exceptions.HTTPError):
-        asyncio.run(self.manager._download_file(artifact.downloadUri.uri, base_path, artifact))
-      assert not os.path.isfile(base_path)
+        asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
+
+      # chunk 1 failed, so its file and the manifest must not exist
+      assert not os.path.isfile(get_chunk_name(base_path, 1, len(CHUNK_BODIES)))
+      assert not os.path.isfile(get_manifest_path(base_path))
     self.run_with_server(body)
 
   def test_cancellation_mid_transfer(self):
     """Cancellation is checked inside the byte loop; it must still fire after the port."""
     def body():
-      artifact = self.make_artifact()
+      artifact = self.make_artifact(chunked=True)
       base_path = os.path.join(self.dest, artifact.fileName)
       self.manager.params.get.return_value = None  # cancelled
 
       with self.assertRaises(Exception) as ctx:
-        asyncio.run(self.manager._download_file(artifact.downloadUri.uri, base_path, artifact))
+        asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
       assert 'cancelled' in str(ctx.exception).lower()
+      assert not os.path.isfile(get_manifest_path(base_path))
     self.run_with_server(body)
 
   def test_repeat_downloads_are_stable(self):
     """Back-to-back runs must produce identical bytes and leak no start-time state."""
     def body():
       for _ in range(2):
-        artifact = self.make_artifact()
+        artifact = self.make_artifact(chunked=True)
         base_path = os.path.join(self.dest, artifact.fileName)
-        asyncio.run(self.manager._download_file(artifact.downloadUri.uri, base_path, artifact))
-        with open(base_path, 'rb') as f:
-          assert f.read() == WHOLE_BODY
+        asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
+        for i, expected in enumerate(CHUNK_BODIES):
+          with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'rb') as f:
+            assert f.read() == expected
         assert self.manager._download_start_times == {}
     self.run_with_server(body)
 
   def test_download_ref_present_keeps_download_alive(self):
     """A pending download request (DownloadRef set) must not be cancelled mid-transfer."""
     def body():
-      artifact = self.make_artifact()
+      artifact = self.make_artifact(chunked=True)
       base_path = os.path.join(self.dest, artifact.fileName)
       self.manager.params.get.side_effect = lambda key: b"ref" if key == "ModelManager_DownloadRef" else None
       self.manager._download_ref = b"ref"
-      asyncio.run(self.manager._download_file(artifact.downloadUri.uri, base_path, artifact))
-      assert os.path.isfile(base_path)
+      asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
+      assert os.path.isfile(get_manifest_path(base_path))
     self.run_with_server(body)
 
   def test_cancellation_via_download_ref(self):
     """Removing DownloadRef mid-transfer cancels the download."""
     def body():
-      artifact = self.make_artifact()
+      artifact = self.make_artifact(chunked=True)
       base_path = os.path.join(self.dest, artifact.fileName)
       checks = {"n": 0}
 
@@ -215,19 +283,20 @@ class TestManagerDownload(ManagerDownloadTestBase):
       self.manager.params.get.side_effect = get
       self.manager._download_ref = b"ref"
       with self.assertRaises(Exception) as ctx:
-        asyncio.run(self.manager._download_file(artifact.downloadUri.uri, base_path, artifact))
+        asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
       assert 'cancelled' in str(ctx.exception).lower()
+      assert not os.path.isfile(get_manifest_path(base_path))
     self.run_with_server(body)
 
   def test_replaced_download_ref_queues_instead_of_cancelling(self):
     """Selecting another model mid-transfer lets the running download finish."""
     def body():
-      artifact = self.make_artifact()
+      artifact = self.make_artifact(chunked=True)
       base_path = os.path.join(self.dest, artifact.fileName)
       self.manager.params.get.side_effect = lambda key: b"other-ref" if key == "ModelManager_DownloadRef" else None
       self.manager._download_ref = b"ref"
-      asyncio.run(self.manager._download_file(artifact.downloadUri.uri, base_path, artifact))
-      assert os.path.isfile(base_path)
+      asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
+      assert os.path.isfile(get_manifest_path(base_path))
     self.run_with_server(body)
 
   def test_replaced_download_ref_is_kept(self):
@@ -246,10 +315,11 @@ class TestManagerDownload(ManagerDownloadTestBase):
   def test_cached_bundle_cancel_skips_slot_write(self):
     """A cancel must stop an already-on-disk bundle before it is applied to the slot."""
     def body():
-      artifact = self.make_artifact()
+      artifact = self.make_artifact(chunked=True)
       base_path = os.path.join(self.dest, artifact.fileName)
-      with open(base_path, 'wb') as f:
-        f.write(WHOLE_BODY)
+      for i, data in enumerate(CHUNK_BODIES):
+        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'wb') as f:
+          f.write(data)
       self._bundle.ref = "test-ref"
       params, store = self._make_params_with_store()
       store["ModelManager_DownloadRef"] = None  # removed -> cancelled
@@ -259,7 +329,42 @@ class TestManagerDownload(ManagerDownloadTestBase):
         asyncio.run(self.manager._download_bundle(self._bundle, self.dest, "qcom"))
       assert 'cancelled' in str(ctx.exception).lower()
       assert "ModelManager_ActiveBundle" not in store
-      assert os.path.isfile(base_path), "cancel must not delete the cached model"
+      assert all(os.path.isfile(p) for p in self.chunk_paths(base_path)), "cancel must not delete cached chunks"
+    self.run_with_server(body)
+
+  def test_resume_skips_valid_chunks(self):
+    """A chunk already on disk is kept and not re-downloaded; progress starts above its share."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+      with open(get_chunk_name(base_path, 0, len(CHUNK_BODIES)), 'wb') as f:
+        f.write(CHUNK_BODIES[0])
+
+      asyncio.run(self.manager._process_artifact(artifact, self.dest))
+
+      chunk0_suffix = get_chunk_name('', 0, len(CHUNK_BODIES))
+      assert not any(p.endswith(chunk0_suffix) for p in DownloadHandler.request_paths), "valid chunk was re-downloaded"
+      for i, expected in enumerate(CHUNK_BODIES):
+        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'rb') as f:
+          assert f.read() == expected
+      assert os.path.isfile(get_manifest_path(base_path))
+      assert min(self.reported) >= (1 / len(CHUNK_BODIES)) * 100 - 1, "progress must not restart below the resumed share"
+    self.run_with_server(body)
+
+  def test_verify_reports_valid_fraction_then_cached(self):
+    """A fully cached bundle publishes climbing verify progress and ends cached."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+      for i, data in enumerate(CHUNK_BODIES):
+        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'wb') as f:
+          f.write(data)
+
+      asyncio.run(self.manager._process_artifact(artifact, self.dest))
+
+      assert DownloadHandler.request_paths == [], "cached bundle must not hit the network"
+      assert [round(p) for p in self.reported[:3]] == [33, 67, 100]
+      assert artifact.downloadProgress.status == custom.ModelManagerSP.DownloadStatus.cached
     self.run_with_server(body)
 
   def _make_params_with_store(self):
@@ -279,7 +384,7 @@ class TestManagerDownload(ManagerDownloadTestBase):
   def test_download_writes_qcom_slot(self):
     """A download resolved to the qcom source writes the qcom active bundle slot only."""
     def body():
-      artifact = self.make_artifact()
+      artifact = self.make_artifact(chunked=True)
       self._bundle.ref = "test-ref"
       self._bundle.minimumSelectorVersion = helpers.REQUIRED_JSON_VERSION
       params, store = self._make_params_with_store()
@@ -291,13 +396,15 @@ class TestManagerDownload(ManagerDownloadTestBase):
       assert self.manager.selected_bundle.status == custom.ModelManagerSP.DownloadStatus.downloaded
       assert self.manager.active_bundle is not None and self.manager.active_bundle.ref == "test-ref"
       assert self.manager.active_bundle.status == custom.ModelManagerSP.DownloadStatus.downloaded
-      assert os.path.isfile(os.path.join(self.dest, artifact.fileName))
+      chunk_names = [get_chunk_name(artifact.fileName, i, len(artifact.chunks)) for i in range(len(artifact.chunks))]
+      missing = [c for c in chunk_names if not os.path.isfile(os.path.join(self.dest, c))]
+      assert missing == [], f"chunks missing from the cache: {missing}"
     self.run_with_server(body)
 
   def test_download_writes_chestnut_slot(self):
     """A download resolved to the chestnut source writes the chestnut active bundle slot only."""
     def body():
-      self.make_artifact()
+      self.make_artifact(chunked=True)
       self._bundle.ref = "big-ref"
       self._bundle.minimumSelectorVersion = helpers.REQUIRED_JSON_VERSION
       params, store = self._make_params_with_store()
@@ -675,7 +782,7 @@ class TestEffectiveSource(OpenpilotTestCase):
 
 @unittest.skipUnless(os.environ.get('RUN_INTEGRATION_TESTS'), 'requires external network')
 class TestLiveModelManifest(OpenpilotTestCase):
-  """Every artifact URL in the published manifest must resolve."""
+  """Every artifact and chunk URL in the published manifest must resolve."""
 
   def test_all_manifest_urls_available(self):
     from openpilot.sunnypilot.models.fetcher import ModelFetcher
@@ -687,7 +794,10 @@ class TestLiveModelManifest(OpenpilotTestCase):
     for bundle in manifest.get('bundles', []):
       for model in bundle.get('models', []):
         artifact = model['artifact']
-        urls = [artifact['download_uri']['url']]
+        url = artifact['download_uri']['url']
+        chunks = artifact.get('chunks', [])
+        urls = ([url] if not chunks
+                else [get_chunk_name(url, i, len(chunks)) for i in range(len(chunks))])
         for u in urls:
           try:
             r = session.head(u, timeout=15, allow_redirects=True)

openpilot/sunnypilot/selfdrive/car/interfaces.py

@@ -81,6 +81,7 @@ def _cleanup_unsupported_params(CP: structs.CarParams, CP_SP: structs.CarParamsS
 
   if not CP.openpilotLongitudinalControl and CP_SP.pcmCruiseSpeed:
     cloudlog.warning("openpilot Longitudinal Control and ICBM not available, cleaning up params")
+    params.remove("DynamicExperimentalControl")
     params.remove("CustomAccIncrementsEnabled")
     params.remove("SmartCruiseControlVision")
     params.remove("SmartCruiseControlMap")

openpilot/sunnypilot/selfdrive/car/tests/test_custom_cruise.py

@@ -57,7 +57,7 @@ class TestCustomAccIncrements(TestVCruiseHelper):
   def test_default_behavior_when_disabled(self):
     """Test that default increments are used when custom ACC is disabled"""
     self.set_custom_increments(enabled=False, short_inc=5, long_inc=10)
-    self.enable(V_CRUISE_INITIAL * CV.KPH_TO_MS, False)
+    self.enable(V_CRUISE_INITIAL * CV.KPH_TO_MS, False, False)
 
     initial_speed = self.v_cruise_helper.v_cruise_kph
 
@@ -69,7 +69,7 @@ class TestCustomAccIncrements(TestVCruiseHelper):
   def test_custom_short_press_increments(self, increment):
     """Test custom short press increments (1-10)"""
     self.set_custom_increments(enabled=True, short_inc=increment, long_inc=5)
-    self.enable(50 * CV.KPH_TO_MS, False)
+    self.enable(50 * CV.KPH_TO_MS, False, False)
 
     initial_speed = self.v_cruise_helper.v_cruise_kph
     self.press_button_short(ButtonType.accelCruise)
@@ -86,7 +86,7 @@ class TestCustomAccIncrements(TestVCruiseHelper):
   def test_custom_long_press_increments(self, increment):
     """Test custom long press increments (1, 5, 10)"""
     self.set_custom_increments(enabled=True, short_inc=1, long_inc=increment)
-    self.enable(50 * CV.KPH_TO_MS, False)
+    self.enable(50 * CV.KPH_TO_MS, False, False)
 
     initial_speed = self.v_cruise_helper.v_cruise_kph
     self.press_button_long(ButtonType.accelCruise)
@@ -103,7 +103,7 @@ class TestCustomAccIncrements(TestVCruiseHelper):
   def test_accel_decel_symmetry(self, button_type):
     """Test that acceleration and deceleration work symmetrically"""
     self.set_custom_increments(enabled=True, short_inc=3, long_inc=5)
-    self.enable(50 * CV.KPH_TO_MS, False)
+    self.enable(50 * CV.KPH_TO_MS, False, False)
 
     initial_speed = self.v_cruise_helper.v_cruise_kph
     self.press_button_short(button_type)
@@ -123,7 +123,7 @@ class TestCustomAccIncrements(TestVCruiseHelper):
     for initial, increment, expected in test_cases:
       self.set_custom_increments(enabled=True, short_inc=increment, long_inc=increment)
       self.reset_cruise_speed_state()
-      self.enable(initial * CV.KPH_TO_MS, False)
+      self.enable(initial * CV.KPH_TO_MS, False, False)
 
       self.press_button_short(ButtonType.accelCruise)
       assert self.v_cruise_helper.v_cruise_kph == expected
@@ -132,7 +132,7 @@ class TestCustomAccIncrements(TestVCruiseHelper):
     """Test that invalid values fallback to safe defaults"""
     # Test invalid short increment
     self.set_custom_increments(enabled=True, short_inc=-1, long_inc=5)
-    self.enable(50 * CV.KPH_TO_MS, False)
+    self.enable(50 * CV.KPH_TO_MS, False, False)
 
     initial_speed = self.v_cruise_helper.v_cruise_kph
     self.press_button_short(ButtonType.accelCruise)
@@ -141,7 +141,7 @@ class TestCustomAccIncrements(TestVCruiseHelper):
     # Test invalid long increment
     self.reset_cruise_speed_state()
     self.set_custom_increments(enabled=True, short_inc=1, long_inc=99)
-    self.enable(50 * CV.KPH_TO_MS, False)
+    self.enable(50 * CV.KPH_TO_MS, False, False)
 
     initial_speed = self.v_cruise_helper.v_cruise_kph
     self.press_button_long(ButtonType.accelCruise)

openpilot/sunnypilot/selfdrive/controls/lib/dec/constants.py

@@ -0,0 +1,17 @@
+class WMACConstants:
+  # Lead detection parameters
+  LEAD_WINDOW_SIZE = 6  # Stable detection window
+  LEAD_PROB = 0.45  # Balanced threshold for lead detection
+
+  # Slow down detection parameters
+  SLOW_DOWN_WINDOW_SIZE = 5  # Responsive but stable
+  SLOW_DOWN_PROB = 0.3  # Balanced threshold for slow down scenarios
+
+  # Optimized slow down distance curve - smooth and progressive
+  SLOW_DOWN_BP = [0., 10., 20., 30., 40., 50., 55., 60.]
+  SLOW_DOWN_DIST = [32., 46., 64., 86., 108., 130., 145., 165.]
+
+  # Slowness detection parameters
+  SLOWNESS_WINDOW_SIZE = 10  # Stable slowness detection
+  SLOWNESS_PROB = 0.55  # Clear threshold for slowness
+  SLOWNESS_CRUISE_OFFSET = 1.025  # Conservative cruise speed offset

openpilot/sunnypilot/selfdrive/controls/lib/dec/dec.py

@@ -0,0 +1,388 @@
+"""
+Copyright (c) 2021-, rav4kumar, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+# Version = 2025-6-30
+
+from openpilot.cereal import messaging
+from opendbc.car import structs
+from numpy import interp
+from openpilot.common.params import Params
+from openpilot.common.realtime import DT_MDL
+from openpilot.sunnypilot.selfdrive.controls.lib.dec.constants import WMACConstants
+from typing import Literal
+
+# d-e2e, from modeldata.h
+TRAJECTORY_SIZE = 33
+SET_MODE_TIMEOUT = 15
+
+# Define the valid mode types
+ModeType = Literal['acc', 'blended']
+
+
+class SmoothKalmanFilter:
+  """Enhanced Kalman filter with smoothing for stable decision making."""
+
+  def __init__(self, initial_value=0, measurement_noise=0.1, process_noise=0.01,
+               alpha=1.0, smoothing_factor=0.85):
+    self.x = initial_value
+    self.P = 1.0
+    self.R = measurement_noise
+    self.Q = process_noise
+    self.alpha = alpha
+    self.smoothing_factor = smoothing_factor
+    self.initialized = False
+    self.history = []
+    self.max_history = 10
+    self.confidence = 0.0
+
+  def add_data(self, measurement):
+    if len(self.history) >= self.max_history:
+      self.history.pop(0)
+    self.history.append(measurement)
+
+    if not self.initialized:
+      self.x = measurement
+      self.initialized = True
+      self.confidence = 0.1
+      return
+
+    self.P = self.alpha * self.P + self.Q
+
+    K = self.P / (self.P + self.R)
+    effective_K = K * (1.0 - self.smoothing_factor) + self.smoothing_factor * 0.1
+
+    innovation = measurement - self.x
+    self.x = self.x + effective_K * innovation
+    self.P = (1 - effective_K) * self.P
+
+    if abs(innovation) < 0.1:
+      self.confidence = min(1.0, self.confidence + 0.05)
+    else:
+      self.confidence = max(0.1, self.confidence - 0.02)
+
+  def get_value(self):
+    return self.x if self.initialized else None
+
+  def get_confidence(self):
+    return self.confidence
+
+  def reset_data(self):
+    self.initialized = False
+    self.history = []
+    self.confidence = 0.0
+
+
+class ModeTransitionManager:
+  """Manages smooth transitions between driving modes with hysteresis."""
+
+  def __init__(self):
+    self.current_mode: ModeType = 'acc'
+    self.mode_confidence = {'acc': 1.0, 'blended': 0.0}
+    self.transition_timeout = 0
+    self.min_mode_duration = 10
+    self.mode_duration = 0
+    self.emergency_override = False
+
+  def request_mode(self, mode: ModeType, confidence: float = 1.0, emergency: bool = False):
+    # Emergency override for critical situations (stops, collisions)
+    if emergency:
+      self.emergency_override = True
+      self.current_mode = mode
+      self.transition_timeout = SET_MODE_TIMEOUT
+      self.mode_duration = 0
+      return
+
+    self.mode_confidence[mode] = min(1.0, self.mode_confidence[mode] + 0.1 * confidence)
+    for m in self.mode_confidence:
+      if m != mode:
+        self.mode_confidence[m] = max(0.0, self.mode_confidence[m] - 0.05)
+
+    # Require minimum duration in current mode (unless emergency)
+    if self.mode_duration < self.min_mode_duration and not self.emergency_override:
+      return
+
+    # Hysteresis: higher threshold for mode changes
+    confidence_threshold = 0.6 if mode != self.current_mode else 0.3  # Lower threshold for faster response
+
+    if self.mode_confidence[mode] > confidence_threshold:
+      if mode != self.current_mode and self.transition_timeout == 0:
+        self.transition_timeout = SET_MODE_TIMEOUT
+        self.current_mode = mode
+        self.mode_duration = 0
+
+  def update(self):
+    if self.transition_timeout > 0:
+      self.transition_timeout -= 1
+    self.mode_duration += 1
+
+    # Reset emergency override after some time
+    if self.emergency_override and self.mode_duration > 20:
+      self.emergency_override = False
+
+    # Gradual confidence decay
+    for mode in self.mode_confidence:
+      self.mode_confidence[mode] *= 0.98
+
+  def get_mode(self) -> ModeType:
+    return self.current_mode
+
+
+class DynamicExperimentalController:
+  def __init__(self, CP: structs.CarParams, mpc, params=None):
+    self._CP = CP
+    self._mpc = mpc
+    self._params = params or Params()
+    self._enabled: bool = self._params.get_bool("DynamicExperimentalControl")
+    self._active: bool = False
+    self._frame: int = 0
+    self._urgency = 0.0
+
+    self._mode_manager = ModeTransitionManager()
+
+    # Smooth filters for stable decision making with faster response for critical scenarios
+    self._lead_filter = SmoothKalmanFilter(
+      measurement_noise=0.15,
+      process_noise=0.05,
+      alpha=1.02,
+      smoothing_factor=0.8
+    )
+
+    self._slow_down_filter = SmoothKalmanFilter(
+      measurement_noise=0.1,
+      process_noise=0.1,
+      alpha=1.05,
+      smoothing_factor=0.7
+    )
+
+    self._slowness_filter = SmoothKalmanFilter(
+      measurement_noise=0.1,
+      process_noise=0.06,
+      alpha=1.015,
+      smoothing_factor=0.92
+    )
+
+    self._mpc_fcw_filter = SmoothKalmanFilter(
+      measurement_noise=0.2,
+      process_noise=0.1,
+      alpha=1.1,
+      smoothing_factor=0.5
+    )
+    self._has_lead_filtered = False
+    self._has_slow_down = False
+    self._has_slowness = False
+    self._has_mpc_fcw = False
+    self._v_ego_kph = 0.0
+    self._v_cruise_kph = 0.0
+    self._has_standstill = False
+    self._mpc_fcw_crash_cnt = 0
+    self._standstill_count = 0
+    # debug
+    self._endpoint_x = float('inf')
+    self._expected_distance = 0.0
+    self._trajectory_valid = False
+
+  def _read_params(self) -> None:
+    if self._frame % int(1. / DT_MDL) == 0:
+      self._enabled = self._params.get_bool("DynamicExperimentalControl")
+
+  def mode(self) -> str:
+    return self._mode_manager.get_mode()
+
+  def enabled(self) -> bool:
+    return self._enabled
+
+  def active(self) -> bool:
+    return self._active
+
+  def set_mpc_fcw_crash_cnt(self) -> None:
+    """Set MPC FCW crash count"""
+    self._mpc_fcw_crash_cnt = self._mpc.crash_cnt
+
+  def _update_calculations(self, sm: messaging.SubMaster) -> None:
+    car_state = sm['carState']
+    lead_one = sm['radarState'].leadOne
+    md = sm['modelV2']
+
+    self._v_ego_kph = car_state.vEgo * 3.6
+    self._v_cruise_kph = car_state.vCruise
+    self._has_standstill = car_state.standstill
+
+    # standstill detection
+    if self._has_standstill:
+      self._standstill_count = min(20, self._standstill_count + 1)
+    else:
+      self._standstill_count = max(0, self._standstill_count - 1)
+
+    # Lead detection
+    self._lead_filter.add_data(float(lead_one.present))
+    lead_value = self._lead_filter.get_value() or 0.0
+    self._has_lead_filtered = lead_value > WMACConstants.LEAD_PROB
+
+    # MPC FCW detection
+    fcw_filtered_value = self._mpc_fcw_filter.get_value() or 0.0
+    self._mpc_fcw_filter.add_data(float(self._mpc_fcw_crash_cnt > 0))
+    self._has_mpc_fcw = fcw_filtered_value > 0.5
+
+    # Slow down detection
+    self._calculate_slow_down(md)
+
+    # Slowness detection
+    if not (self._standstill_count > 5) and not self._has_slow_down:
+      current_slowness = float(self._v_ego_kph <= (self._v_cruise_kph * WMACConstants.SLOWNESS_CRUISE_OFFSET))
+      self._slowness_filter.add_data(current_slowness)
+      slowness_value = self._slowness_filter.get_value() or 0.0
+
+      # Hysteresis for slowness
+      threshold = WMACConstants.SLOWNESS_PROB * (0.8 if self._has_slowness else 1.1)
+      self._has_slowness = slowness_value > threshold
+
+  def _calculate_slow_down(self, md):
+    """Calculate urgency based on trajectory endpoint vs expected distance."""
+
+    # Reset to safe defaults
+    urgency = 0.0
+    self._endpoint_x = float('inf')
+    self._trajectory_valid = False
+
+    #Require exact trajectory size
+    position_valid = len(md.position.x) == TRAJECTORY_SIZE
+    orientation_valid = len(md.orientation.x) == TRAJECTORY_SIZE
+
+    if not (position_valid and orientation_valid):
+      # Invalid trajectory - this itself might indicate a stop scenario
+      # Apply moderate urgency for incomplete trajectories at speed
+      if self._v_ego_kph > 20.0:
+        urgency = 0.3
+
+      self._slow_down_filter.add_data(urgency)
+      urgency_filtered = self._slow_down_filter.get_value() or 0.0
+      self._has_slow_down = urgency_filtered > WMACConstants.SLOW_DOWN_PROB
+      self._urgency = urgency_filtered
+      return
+
+    # We have a valid full trajectory
+    self._trajectory_valid = True
+
+    # Use the exact endpoint (33rd point, index 32)
+    endpoint_x = md.position.x[TRAJECTORY_SIZE - 1]
+    self._endpoint_x = endpoint_x
+
+    # Get expected distance based on current speed using tuned constants
+    expected_distance = interp(self._v_ego_kph,
+                               WMACConstants.SLOW_DOWN_BP,
+                               WMACConstants.SLOW_DOWN_DIST)
+    self._expected_distance = expected_distance
+
+    # Calculate urgency based on trajectory shortage
+    if endpoint_x < expected_distance:
+      shortage = expected_distance - endpoint_x
+      shortage_ratio = shortage / expected_distance
+
+      # Base urgency on shortage ratio
+      urgency = min(1.0, shortage_ratio * 2.0)
+
+      # Increase urgency for very short trajectories (imminent stops)
+      critical_distance = expected_distance * 0.3
+      if endpoint_x < critical_distance:
+        urgency = min(1.0, urgency * 2.0)
+
+      # Speed-based urgency adjustment
+      if self._v_ego_kph > 25.0:
+        speed_factor = 1.0 + (self._v_ego_kph - 25.0) / 80.0
+        urgency = min(1.0, urgency * speed_factor)
+
+    # Apply filtering but with less smoothing for stops
+    self._slow_down_filter.add_data(urgency)
+    urgency_filtered = self._slow_down_filter.get_value() or 0.0
+
+    # Update state with lower threshold for better stop detection
+    self._has_slow_down = urgency_filtered > (WMACConstants.SLOW_DOWN_PROB * 0.8)
+    self._urgency = urgency_filtered
+
+  def _radarless_mode(self) -> None:
+    """Radarless mode decision logic with emergency handling."""
+
+    # EMERGENCY: MPC FCW - immediate blended mode
+    if self._has_mpc_fcw:
+      self._mode_manager.request_mode('blended', confidence=1.0, emergency=True)
+      return
+
+    # Standstill: use blended
+    if self._standstill_count > 3:
+      self._mode_manager.request_mode('blended', confidence=0.9)
+      return
+
+    # Slow down scenarios: emergency for high urgency, normal for lower urgency
+    if self._has_slow_down:
+      if self._urgency > 0.7:
+        # Emergency: immediate blended mode for high urgency stops
+        self._mode_manager.request_mode('blended', confidence=1.0, emergency=True)
+      else:
+        # Normal: blended with urgency-based confidence
+        confidence = min(1.0, self._urgency * 1.5)
+        self._mode_manager.request_mode('blended', confidence=confidence)
+      return
+
+    # Driving slow: use ACC (but not if actively slowing down)
+    if self._has_slowness and not self._has_slow_down:
+      self._mode_manager.request_mode('acc', confidence=0.8)
+      return
+
+    # Default: ACC
+    self._mode_manager.request_mode('acc', confidence=0.7)
+
+  def _radar_mode(self) -> None:
+    """Radar mode with emergency handling."""
+
+    # EMERGENCY: MPC FCW - immediate blended mode
+    if self._has_mpc_fcw:
+      self._mode_manager.request_mode('blended', confidence=1.0, emergency=True)
+      return
+
+    # If lead detected and not in standstill: always use ACC
+    if self._has_lead_filtered and not (self._standstill_count > 3):
+      self._mode_manager.request_mode('acc', confidence=1.0)
+      return
+
+    # Slow down scenarios: emergency for high urgency, normal for lower urgency
+    if self._has_slow_down:
+      if self._urgency > 0.7:
+        # Emergency: immediate blended mode for high urgency stops
+        self._mode_manager.request_mode('blended', confidence=1.0, emergency=True)
+      else:
+        # Normal: blended with urgency-based confidence
+        confidence = min(1.0, self._urgency * 1.3)
+        self._mode_manager.request_mode('blended', confidence=confidence)
+      return
+
+    # Standstill: use blended
+    if self._standstill_count > 3:
+      self._mode_manager.request_mode('blended', confidence=0.9)
+      return
+
+    # Driving slow: use ACC (but not if actively slowing down)
+    if self._has_slowness and not self._has_slow_down:
+      self._mode_manager.request_mode('acc', confidence=0.8)
+      return
+
+    # Default: ACC
+    self._mode_manager.request_mode('acc', confidence=0.7)
+
+  def update(self, sm: messaging.SubMaster) -> None:
+    self._read_params()
+
+    self.set_mpc_fcw_crash_cnt()
+
+    self._update_calculations(sm)
+
+    if self._CP.radarUnavailable:
+      self._radarless_mode()
+    else:
+      self._radar_mode()
+
+    self._mode_manager.update()
+    self._active = sm['selfdriveState'].experimentalMode and self._enabled
+    self._frame += 1

openpilot/sunnypilot/selfdrive/controls/lib/dec/tests/test_dec_planner_gate.py

@@ -0,0 +1,112 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from typing import cast
+
+from openpilot.cereal import custom, messaging
+from opendbc.car import structs
+from openpilot.common.test import OpenpilotTestCase
+from openpilot.selfdrive.controls.lib.longitudinal_planner import LongitudinalPlanner, LongitudinalPlanSource
+from openpilot.sunnypilot.selfdrive.controls.lib.dec.dec import DynamicExperimentalController
+
+V_EGO = 20.0
+E2E_ACCEL = -3.0  # low enough that e2e wins the min() whenever it is a candidate
+
+
+class MockDec:
+  def __init__(self, active: bool, mode: str):
+    self._active = active
+    self._mode = mode
+
+  def update(self, sm):
+    pass
+
+  def active(self) -> bool:
+    return self._active
+
+  def mode(self) -> str:
+    return self._mode
+
+  def enabled(self) -> bool:
+    return True
+
+
+class MockSubMaster(dict):
+  def __init__(self, services: dict):
+    super().__init__(services)
+    self.valid = dict.fromkeys(services, True)
+    self.logMonoTime = dict.fromkeys(services, 0)
+    self.updated = dict.fromkeys(services, True)
+    self.recv_frame = dict.fromkeys(services, 1)
+
+  def all_checks(self, service_list=None) -> bool:
+    return True
+
+
+def build_sm(experimental_mode: bool) -> MockSubMaster:
+  services = {}
+  for service in ("radarState", "controlsState", "vehicleParameters", "carStateSP",
+                  "liveMapDataSP", "gpsLocationExternal", "gpsLocation"):
+    services[service] = getattr(messaging.new_message(service), service)
+
+  car_state = messaging.new_message('carState')
+  car_state.carState.vEgo = V_EGO
+  car_state.carState.vCruise = 100.0
+  car_state.carState.vCruiseCluster = 100.0
+  services['carState'] = car_state.carState.as_reader()
+
+  selfdrive_state = messaging.new_message('selfdriveState')
+  selfdrive_state.selfdriveState.experimentalMode = experimental_mode
+  selfdrive_state.selfdriveState.enabled = True
+  services['selfdriveState'] = selfdrive_state.selfdriveState.as_reader()
+
+  car_control = messaging.new_message('carControl')
+  car_control.carControl.enabled = True
+  services['carControl'] = car_control.carControl.as_reader()
+
+  model = messaging.new_message('modelV2')
+  model.modelV2.orientationRate.z = [0.01] * 33  # nonzero: a straight path divides by zero in SCC vision
+  model.modelV2.velocity.x = [V_EGO] * 33
+  model.modelV2.position.x = [float(i) for i in range(33)]
+  model.modelV2.action.desiredAcceleration = E2E_ACCEL
+  services['modelV2'] = model.modelV2.as_reader()
+
+  return MockSubMaster(services)
+
+
+def build_planner(dec_active: bool, dec_mode: str) -> LongitudinalPlanner:
+  CP = structs.CarParams()
+  CP.steerRatio = 15.0
+  CP.wheelbase = 2.7
+  CP.longitudinalActuatorDelay = 0.2
+  CP_SP = custom.CarParamsSP.new_message().as_reader()
+
+  planner = LongitudinalPlanner(CP, CP_SP, init_v=V_EGO)
+  planner.dec = cast(DynamicExperimentalController, MockDec(dec_active, dec_mode))
+  return planner
+
+
+class TestDecPlannerGate(OpenpilotTestCase):
+  """The e2e candidate must be gated on is_e2e(), not raw experimentalMode."""
+
+  def _source(self, experimental_mode: bool, dec_active: bool, dec_mode: str) -> LongitudinalPlanSource:
+    planner = build_planner(dec_active, dec_mode)
+    planner.update(build_sm(experimental_mode))
+    return planner.mpc.source
+
+  def test_no_e2e_when_experimental_mode_off(self):
+    assert self._source(False, False, 'acc') != LongitudinalPlanSource.e2e
+
+  def test_e2e_when_dec_inactive(self):
+    # DEC off: behavior must match upstream
+    assert self._source(True, False, 'acc') == LongitudinalPlanSource.e2e
+
+  def test_e2e_when_dec_blended(self):
+    assert self._source(True, True, 'blended') == LongitudinalPlanSource.e2e
+
+  def test_no_e2e_when_dec_holds_acc(self):
+    # the regression
+    assert self._source(True, True, 'acc') != LongitudinalPlanSource.e2e

openpilot/sunnypilot/selfdrive/controls/lib/dec/tests/test_dynamic_controller.py

@@ -0,0 +1,91 @@
+from openpilot.common.test import OpenpilotTestCase
+from openpilot.sunnypilot.selfdrive.controls.lib.dec.dec import DynamicExperimentalController
+
+class MockLeadOne:
+  def __init__(self, present=0.0):
+    self.present = present
+
+class MockRadarState:
+  def __init__(self, present=0.0):
+    self.leadOne = MockLeadOne(present=present)
+
+class MockCarState:
+  def __init__(self, vEgo=0.0, vCruise=0.0, standstill=False):
+    self.vEgo = vEgo
+    self.vCruise = vCruise
+    self.standstill = standstill
+
+class MockModelData:
+  def __init__(self, valid=True):
+    size = 33 if valid else 10  # incomplete if invalid
+    self.position = type("Pos", (), {"x": [0.0] * size})()
+    self.orientation = type("Ori", (), {"x": [0.0] * size})()
+
+class MockSelfDriveState:
+  def __init__(self, experimentalMode=False):
+    self.experimentalMode = experimentalMode
+
+class MockParams:
+  def get_bool(self, name):
+    return True
+
+def default_sm():
+  sm = {
+    'carState': MockCarState(vEgo=10.0, vCruise=20.0),
+    'radarState': MockRadarState(present=1.0),
+    'modelV2': MockModelData(valid=True),
+    'selfdriveState': MockSelfDriveState(experimentalMode=True),
+  }
+  return sm
+
+def mock_cp():
+  class CP:
+    radarUnavailable = False
+  return CP()
+
+def mock_mpc():
+  class MPC:
+    crash_cnt = 0
+  return MPC()
+
+# Fake Kalman Filter that always returns a given value
+class FakeKalman:
+  def __init__(self, value=1.0):
+    self.value = value
+  def add_data(self, v): pass
+  def get_value(self): return self.value
+  def get_confidence(self): return 1.0
+  def reset_data(self): pass
+
+class TestDynamicExperimentalController(OpenpilotTestCase):
+  def test_initial_mode_is_acc(self, mock_cp, mock_mpc):
+    controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
+    assert controller.mode() == "acc"
+
+  def test_standstill_triggers_blended(self, mock_cp, mock_mpc, default_sm):
+    controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
+    default_sm['carState'].standstill = True
+    for _ in range(10):
+      controller.update(default_sm)
+    assert controller.mode() == "blended"
+
+  def test_emergency_blended_on_fcw(self, mock_cp, mock_mpc, default_sm):
+    controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
+    mock_mpc.crash_cnt = 1  # simulate FCW
+    for _ in range(2):
+      controller.update(default_sm)
+    assert controller.mode() == "blended"
+
+  def test_radarless_slowdown_triggers_blended(self, mock_cp, mock_mpc, default_sm):
+    mock_cp.radarUnavailable = True
+    controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
+
+    # Force conditions to simulate slowdown
+    controller._slow_down_filter = FakeKalman(value=1.0)  # ty: ignore[invalid-assignment]
+    controller._v_ego_kph = 35.0
+    default_sm['modelV2'] = MockModelData(valid=False)  # Incomplete trajectory
+
+    for _ in range(3):
+      controller.update(default_sm)
+
+    assert controller.mode() == "blended"

openpilot/sunnypilot/selfdrive/controls/lib/longitudinal_planner.py

@@ -9,6 +9,7 @@ from openpilot.cereal import messaging, custom
 from opendbc.car import structs
 from openpilot.common.constants import CV
 from openpilot.selfdrive.car.cruise import V_CRUISE_MAX
+from openpilot.sunnypilot.selfdrive.controls.lib.dec.dec import DynamicExperimentalController
 from openpilot.sunnypilot.selfdrive.controls.lib.e2e_alerts_helper import E2EAlertsHelper
 from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.smart_cruise_control import SmartCruiseControl
 from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_assist import SpeedLimitAssist
@@ -16,6 +17,7 @@ from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_resolve
 from openpilot.sunnypilot.selfdrive.selfdrived.events import EventsSP
 from openpilot.sunnypilot.models.helpers import get_active_bundle
 
+DecState = custom.LongitudinalPlanSP.DynamicExperimentalControl.DynamicExperimentalControlState
 LongitudinalPlanSource = custom.LongitudinalPlanSP.LongitudinalPlanSource
 
 
@@ -23,6 +25,7 @@ class LongitudinalPlannerSP:
   def __init__(self, CP: structs.CarParams, CP_SP: structs.CarParamsSP, mpc):
     self.events_sp = EventsSP()
     self.resolver = SpeedLimitResolver()
+    self.dec = DynamicExperimentalController(CP, mpc)
     self.scc = SmartCruiseControl()
     self.resolver = SpeedLimitResolver()
     self.sla = SpeedLimitAssist(CP, CP_SP)
@@ -33,6 +36,13 @@ class LongitudinalPlannerSP:
     self.output_v_target = 0.
     self.output_a_target = 0.
 
+  def is_e2e(self, sm: messaging.SubMaster) -> bool:
+    experimental_mode = sm['selfdriveState'].experimentalMode
+    if not self.dec.active():
+      return experimental_mode
+
+    return experimental_mode and self.dec.mode() == "blended"
+
   def update_targets(self, sm: messaging.SubMaster, v_ego: float, a_ego: float, v_cruise: float) -> tuple[float, float]:
     CS = sm['carState']
     v_cruise_cluster_kph = min(CS.vCruiseCluster, V_CRUISE_MAX)
@@ -65,6 +75,7 @@ class LongitudinalPlannerSP:
 
   def update(self, sm: messaging.SubMaster) -> None:
     self.events_sp.clear()
+    self.dec.update(sm)
     self.e2e_alerts_helper.update(sm, self.events_sp)
 
   def publish_longitudinal_plan_sp(self, sm: messaging.SubMaster, pm: messaging.PubMaster) -> None:
@@ -78,6 +89,12 @@ class LongitudinalPlannerSP:
     longitudinalPlanSP.aTarget = float(self.output_a_target)
     longitudinalPlanSP.events = self.events_sp.to_msg()
 
+    # Dynamic Experimental Control
+    dec = longitudinalPlanSP.dec
+    dec.state = DecState.blended if self.dec.mode() == 'blended' else DecState.acc
+    dec.enabled = self.dec.enabled()
+    dec.active = self.dec.active()
+
     # Smart Cruise Control
     smartCruiseControl = longitudinalPlanSP.smartCruiseControl
     # Vision Control

openpilot/sunnypilot/sunnylink/docs/README.md

@@ -367,8 +367,8 @@ enablement:
 enablement:
   - type: any
     conditions:
-      - {type: param, key: SmartCruiseControlVision, equals: true}
-      - {type: param, key: SmartCruiseControlMap, equals: true}
+      - {type: param, key: ExperimentalMode, equals: true}
+      - {type: param, key: DynamicExperimentalControl, equals: true}
 ```
 
 **Mixed: capability AND param** (only on longitudinal cars when ShowAdvancedControls is on):

openpilot/sunnypilot/sunnylink/settings_ui.json

@@ -599,6 +599,26 @@
                 }
               ]
             },
+            {
+              "key": "DynamicExperimentalControl",
+              "widget": "toggle",
+              "title": "Dynamic Experimental Control",
+              "description": "Let the model decide when to use sunnypilot ACC or sunnypilot End to End Longitudinal.",
+              "visibility": [
+                {
+                  "type": "capability",
+                  "field": "has_longitudinal_control",
+                  "equals": true
+                }
+              ],
+              "enablement": [
+                {
+                  "type": "capability",
+                  "field": "has_longitudinal_control",
+                  "equals": true
+                }
+              ]
+            },
             {
               "key": "DisengageOnAccelerator",
               "widget": "toggle",

openpilot/sunnypilot/sunnylink/settings_ui_src/pages/cruise.yaml

@@ -16,6 +16,14 @@ sections:
     title: Experimental Mode
     enablement:
     - $ref: '#/macros/longitudinal'
+  - key: DynamicExperimentalControl
+    widget: toggle
+    title: Dynamic Experimental Control
+    description: Let the model decide when to use sunnypilot ACC or sunnypilot End to End Longitudinal.
+    visibility:
+    - $ref: '#/macros/longitudinal'
+    enablement:
+    - $ref: '#/macros/longitudinal'
   - key: DisengageOnAccelerator
     widget: toggle
     title: Disengage Cruise on Accelerator Pedal

openpilot/sunnypilot/sunnylink/tests/test_settings_changes.py

@@ -201,6 +201,11 @@ class TestSpuriousOffroadGatesDropped(OpenpilotTestCase):
     assert item is not None
     assert "offroad_only" not in _flatten_rule_types(item.get("enablement"))
 
+  def test_dynamic_experimental_has_no_offroad_only(self, schema):
+    item = _find_item(schema, "DynamicExperimentalControl")
+    assert item is not None
+    assert "offroad_only" not in _flatten_rule_types(item.get("enablement"))
+
 
 class TestNotEngagedReplacement(OpenpilotTestCase):
   @parameterized.expand([

openpilot/system/manager/process_config.py

@@ -170,7 +170,6 @@ procs += [
   # Models
   PythonProcess("models_manager", "openpilot.sunnypilot.models.manager", only_offroad),
   NativeProcess("modeld_tinygrad", "openpilot/sunnypilot/modeld_v2", ["./modeld"], and_(only_onroad, is_tinygrad_model)),
-  PythonProcess("modeld_warmup", "openpilot.sunnypilot.modeld_v2.warmup", only_offroad),
 
   # Backup
   PythonProcess("backup_manager", "openpilot.sunnypilot.sunnylink.backups.manager", and_(only_offroad, sunnylink_ready_shim)),

release/ci/model_generator.py

@@ -54,10 +54,18 @@ def create_pkl_name(full_name: str) -> str:
 
 
 def _hash_pkl(pkl_path: Path) -> str:
+  manifest = Path(f"{pkl_path}.chunkmanifest")
+  if manifest.exists():
+    num_chunks = int(manifest.read_text().strip())
+    paths = [Path(f"{pkl_path}.chunk{i + 1:02d}of{num_chunks:02d}") for i in range(num_chunks)]
+  else:
+    paths = [pkl_path]
+
   digest = hashlib.sha256()
-  with pkl_path.open('rb') as f:
-    while block := f.read(1024 * 1024):
-      digest.update(block)
+  for path in paths:
+    with path.open('rb') as f:
+      while block := f.read(1024 * 1024):
+        digest.update(block)
   return digest.hexdigest()
 
 
@@ -66,9 +74,22 @@ def _find_driving_pkl(output_path: Path) -> Path | None:
     matches = sorted(output_path.glob(pattern))
     if matches:
       return matches[0]
+  for pattern in ('*driving_tinygrad.pkl.chunkmanifest', '*driving_*_tinygrad.pkl.chunkmanifest'):
+    matches = sorted(output_path.glob(pattern))
+    if matches:
+      return Path(str(matches[0]).removesuffix('.chunkmanifest'))
   return None
 
 
+def _rename_pkl_with_chunks(old_pkl: Path, new_pkl: Path) -> Path:
+  manifest = Path(f"{old_pkl}.chunkmanifest")
+  if manifest.exists():
+    for f in sorted(old_pkl.parent.glob(f"{old_pkl.name}.chunk*")):
+      f.rename(old_pkl.parent / f.name.replace(old_pkl.name, new_pkl.name, 1))
+    return new_pkl
+  return old_pkl.rename(new_pkl)
+
+
 def _hash_onnx_files(model_dir: Path) -> str | None:
   onnx_files = [f for f in sorted(model_dir.glob("*.onnx")) if f.stat().st_size > 1024]
   if not onnx_files:
@@ -81,9 +102,22 @@ def _hash_onnx_files(model_dir: Path) -> str | None:
   return digest.hexdigest()
 
 
-def generate_model(driving_pkl: Path) -> dict:
+def generate_chunked_model(driving_pkl: Path) -> dict:
   tinygrad_hash = _hash_pkl(driving_pkl)
 
+  chunks_config = []
+  manifest_file = Path(f"{driving_pkl}.chunkmanifest")
+  if manifest_file.exists():
+    num_chunks = int(manifest_file.read_text().strip())
+    for i in range(num_chunks):
+      chunk_path = Path(f"{driving_pkl}.chunk{i + 1:02d}of{num_chunks:02d}")
+      if chunk_path.exists():
+        chunk_hash = hashlib.sha256(chunk_path.read_bytes()).hexdigest()
+        chunks_config.append({
+          "file_name": chunk_path.name,
+          "sha256": chunk_hash
+        })
+
   artifact_data = {
     "file_name": driving_pkl.name,
     "download_uri": {
@@ -92,6 +126,9 @@ def generate_model(driving_pkl: Path) -> dict:
     }
   }
 
+  if chunks_config:
+    artifact_data["chunks"] = chunks_config
+
   return {
     "type": "chunked",
     "artifact": artifact_data,
@@ -156,11 +193,11 @@ if __name__ == "__main__":
   if _pkl:
     new_pkl = _output_dir / f"driving_{_pkl}_tinygrad.pkl"
     if not new_pkl.exists():
-      _driving_pkl = _driving_pkl.rename(new_pkl)
+      _driving_pkl = _rename_pkl_with_chunks(_driving_pkl, new_pkl)
     else:
       _driving_pkl = new_pkl
 
-  _model_metadata = generate_model(_driving_pkl)
+  _model_metadata = generate_chunked_model(_driving_pkl)
   _onnx_sha256 = args.onnx_sha256 or _hash_onnx_files(Path(args.model_dir))
   create_metadata_json([_model_metadata], _output_dir, args.custom_name, _short_name, args.is_20hz, args.upstream_branch,
                        onnx_sha256=_onnx_sha256, is_big=is_big)

release/ci/upload_default_model.py

@@ -79,6 +79,8 @@ def main():
   artifact = bundle['models'][0]['artifact']
   hf_base = f"https://huggingface.co/datasets/{args.hf_repo}/resolve/main/{args.hf_defaults_path}/{folder_name}"
   artifact['download_uri']['url'] = f"{hf_base}/{artifact['file_name']}"
+  for chunk in artifact.get('chunks', []):
+    chunk['url'] = f"{hf_base}/{chunk['file_name']}"
 
   print(f"Uploading model to {args.hf_defaults_path}/{folder_name}/")
   api.upload_folder(