ci: move sccache off the GHA backend onto a persisted disk cache (fix cargo-test timeouts)

.github/workflows/test.yml

@@ -112,18 +112,44 @@ jobs:
     timeout-minutes: 30
     env:
       RUSTC_WRAPPER: sccache
-      SCCACHE_GHA_ENABLED: "true"
-      SCCACHE_CACHE_SIZE: "2G"
+      # sccache on a LOCAL DISK cache, persisted as a single tarball via
+      # actions/cache (see the "Cache sccache objects" step) — NOT the GitHub
+      # Actions cache backend (SCCACHE_GHA_ENABLED). The GHA backend stores one
+      # cache object per compilation unit; GitHub's cache service throttled /
+      # LRU-evicted the thousands of tiny entries, so a full build wrote ~3.3k
+      # objects (≈35 min of write time) yet the next run got ~0% Rust hits
+      # (measured: 3 hits / 3209 misses, 613 write errors) — i.e. every run
+      # recompiled the dependency graph cold. A single tarball'd disk cache
+      # restores in one step and gives real cross-run hit rates. Note
+      # SCCACHE_CACHE_SIZE is honoured by the disk backend (it was a silent
+      # no-op under the GHA backend, which is why the old "2G" never mattered).
+      SCCACHE_GHA_ENABLED: "false"
+      SCCACHE_DIR: ${{ github.workspace }}/.sccache
+      SCCACHE_CACHE_SIZE: "12G"
       CARGO_INCREMENTAL: "0"
     steps:
       - uses: actions/checkout@v6
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
 
-      - name: Start sccache
+      - name: Install sccache
         uses: mozilla-actions/sccache-action@v0.0.10
 
+      # Persist the sccache disk cache across runs. The github.job +
+      # github.run_id key makes every run (including PRs) save its own fresh
+      # entry — distinct per job so the three sccache jobs don't collide on
+      # save — while the shared prefix restore-keys pull the most recent prior
+      # cache from ANY of them. The object cache therefore warms continuously
+      # and cross-pollinates instead of starting cold each run.
+      - name: Cache sccache objects
+        uses: actions/cache@v4
+        with:
+          path: ${{ github.workspace }}/.sccache
+          key: sccache-${{ runner.os }}-perry-${{ github.job }}-${{ github.run_id }}
+          restore-keys: |
+            sccache-${{ runner.os }}-perry-
+
       - uses: Swatinem/rust-cache@v2
         with:
           shared-key: "${{ runner.os }}-perry"
@@ -175,13 +201,17 @@ jobs:
     # don't exercise any platform behavior; they're pure logic +
     # codegen.
     runs-on: ubuntu-latest
-    # Was unbounded (the workflow default of 360 min). This gate legitimately
-    # runs ~45-50 min (per-package serial build+prune loop below, plus the big
-    # stdlib links), and a cold sccache run can be a bit slower — so the bound
-    # is set well ABOVE the real runtime: it exists only to cut a true hang
-    # (e.g. a flaky link SIGBUS retry storm) at ~2 h instead of 6 h, never to
-    # fail a normal slow run.
-    timeout-minutes: 120
+    # The per-package serial build+prune loop below (plus the big stdlib links)
+    # takes ~50-60 min with a WARM sccache disk cache. A fully cold cache
+    # (recompiling the whole dependency graph) measured ~90-103 min, and PRs
+    # that invalidate perry-runtime/perry-codegen previously exceeded the old
+    # 120-min bound entirely. The bound is 180 to (a) leave headroom while the
+    # disk cache warms after the sccache-backend fix, and (b) still cut a true
+    # hang (e.g. a flaky link SIGBUS retry storm). Once warm hit rates are
+    # confirmed in CI this can come back down. NOTE: the old "~45-50 min" figure
+    # predated the sccache GHA-backend rot — it was never accurate once that
+    # cache stopped delivering Rust hits.
+    timeout-minutes: 180
     # sccache (compiler-level cache, shared across ALL branches/jobs via the
     # GitHub Actions cache backend) on top of Swatinem/rust-cache (target/ +
     # registry). rust-cache only writes on main (save-if below), so PRs can't
@@ -193,18 +223,44 @@ jobs:
     # loop below).
     env:
       RUSTC_WRAPPER: sccache
-      SCCACHE_GHA_ENABLED: "true"
-      SCCACHE_CACHE_SIZE: "2G"
+      # sccache on a LOCAL DISK cache, persisted as a single tarball via
+      # actions/cache (see the "Cache sccache objects" step) — NOT the GitHub
+      # Actions cache backend (SCCACHE_GHA_ENABLED). The GHA backend stores one
+      # cache object per compilation unit; GitHub's cache service throttled /
+      # LRU-evicted the thousands of tiny entries, so a full build wrote ~3.3k
+      # objects (≈35 min of write time) yet the next run got ~0% Rust hits
+      # (measured: 3 hits / 3209 misses, 613 write errors) — i.e. every run
+      # recompiled the dependency graph cold. A single tarball'd disk cache
+      # restores in one step and gives real cross-run hit rates. Note
+      # SCCACHE_CACHE_SIZE is honoured by the disk backend (it was a silent
+      # no-op under the GHA backend, which is why the old "2G" never mattered).
+      SCCACHE_GHA_ENABLED: "false"
+      SCCACHE_DIR: ${{ github.workspace }}/.sccache
+      SCCACHE_CACHE_SIZE: "12G"
       CARGO_INCREMENTAL: "0"
     steps:
       - uses: actions/checkout@v6
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
 
-      - name: Start sccache
+      - name: Install sccache
         uses: mozilla-actions/sccache-action@v0.0.10
 
+      # Persist the sccache disk cache across runs. The github.job +
+      # github.run_id key makes every run (including PRs) save its own fresh
+      # entry — distinct per job so the three sccache jobs don't collide on
+      # save — while the shared prefix restore-keys pull the most recent prior
+      # cache from ANY of them. The object cache therefore warms continuously
+      # and cross-pollinates instead of starting cold each run.
+      - name: Cache sccache objects
+        uses: actions/cache@v4
+        with:
+          path: ${{ github.workspace }}/.sccache
+          key: sccache-${{ runner.os }}-perry-${{ github.job }}-${{ github.run_id }}
+          restore-keys: |
+            sccache-${{ runner.os }}-perry-
+
       - uses: Swatinem/rust-cache@v2
         with:
           shared-key: "${{ runner.os }}-perry"
@@ -348,18 +404,44 @@ jobs:
     timeout-minutes: 45
     env:
       RUSTC_WRAPPER: sccache
-      SCCACHE_GHA_ENABLED: "true"
-      SCCACHE_CACHE_SIZE: "2G"
+      # sccache on a LOCAL DISK cache, persisted as a single tarball via
+      # actions/cache (see the "Cache sccache objects" step) — NOT the GitHub
+      # Actions cache backend (SCCACHE_GHA_ENABLED). The GHA backend stores one
+      # cache object per compilation unit; GitHub's cache service throttled /
+      # LRU-evicted the thousands of tiny entries, so a full build wrote ~3.3k
+      # objects (≈35 min of write time) yet the next run got ~0% Rust hits
+      # (measured: 3 hits / 3209 misses, 613 write errors) — i.e. every run
+      # recompiled the dependency graph cold. A single tarball'd disk cache
+      # restores in one step and gives real cross-run hit rates. Note
+      # SCCACHE_CACHE_SIZE is honoured by the disk backend (it was a silent
+      # no-op under the GHA backend, which is why the old "2G" never mattered).
+      SCCACHE_GHA_ENABLED: "false"
+      SCCACHE_DIR: ${{ github.workspace }}/.sccache
+      SCCACHE_CACHE_SIZE: "12G"
       CARGO_INCREMENTAL: "0"
     steps:
       - uses: actions/checkout@v6
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
 
-      - name: Start sccache
+      - name: Install sccache
         uses: mozilla-actions/sccache-action@v0.0.10
 
+      # Persist the sccache disk cache across runs. The github.job +
+      # github.run_id key makes every run (including PRs) save its own fresh
+      # entry — distinct per job so the three sccache jobs don't collide on
+      # save — while the shared prefix restore-keys pull the most recent prior
+      # cache from ANY of them. The object cache therefore warms continuously
+      # and cross-pollinates instead of starting cold each run.
+      - name: Cache sccache objects
+        uses: actions/cache@v4
+        with:
+          path: ${{ github.workspace }}/.sccache
+          key: sccache-${{ runner.os }}-perry-${{ github.job }}-${{ github.run_id }}
+          restore-keys: |
+            sccache-${{ runner.os }}-perry-
+
       - uses: Swatinem/rust-cache@v2
         with:
           shared-key: "${{ runner.os }}-perry"

CHANGELOG.md

@@ -1,3 +1,32 @@
+## v0.5.1179 — ci: move sccache off the GHA backend onto a persisted disk cache (fix cargo-test timeouts)
+
+The `cargo-test` gate was timing out at its 120-min cap on PRs that touch
+`perry-runtime`/`perry-codegen`, and even successful runs were taking 90-103 min
+(not the "~45-50 min" the stale comment claimed). Root cause: sccache was using
+the GitHub Actions cache backend (`SCCACHE_GHA_ENABLED=true`), which stores one
+cache object per compilation unit. GitHub's cache service throttled and
+LRU-evicted the thousands of tiny entries, so a full build wrote ~3.3k objects
+(≈35 min of write time) yet the next run got essentially **zero** Rust cache
+hits (measured on a timed-out run: 3 hits / 3209 misses, 613 write errors). Every
+run effectively recompiled the whole dependency graph cold. `SCCACHE_CACHE_SIZE`
+was a silent no-op under the GHA backend, so the old `2G` never mattered.
+
+Changes (all three sccache jobs — `cargo-test`, `api-docs-drift`,
+`compiler-output-regression` — which compile overlapping crate graphs):
+
+- Switch sccache to a **local disk cache** (`SCCACHE_DIR`, `SCCACHE_GHA_ENABLED=false`,
+  `SCCACHE_CACHE_SIZE=12G`) persisted as a single tarball via `actions/cache@v4`.
+  The cache key is `sccache-<os>-perry-<job>-<run_id>` with a shared
+  `sccache-<os>-perry-` restore-keys prefix, so every run (PRs included) saves
+  its own entry while restoring the most recent one from any of the three jobs —
+  the object cache warms continuously and cross-pollinates instead of starting
+  cold each run.
+- Raise the `cargo-test` `timeout-minutes` 120 → 180 as headroom while the disk
+  cache warms (cold runs are ~90-103 min); can be lowered once warm hit rates are
+  confirmed.
+
+No production code changes.
+
 ## v0.5.1178 — perf(codegen): outline per-new-site inline allocator (smaller IR + faster)
 
 `new ClassName(...)` previously emitted the full object-allocation prologue

CLAUDE.md

@@ -8,7 +8,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 Perry is a native TypeScript compiler written in Rust that compiles TypeScript source code directly to native executables. It uses SWC for TypeScript parsing and LLVM for code generation.
 
-**Current Version:** 0.5.1178
+**Current Version:** 0.5.1179
 
 
 ## TypeScript Parity Status