| """Expert-cache policy comparison on the real OLMoE routing trace. |
| |
| Key structural fact: a single token touches k*L distinct expert slots. Under a |
| purely recency-based policy this is a cyclic reference pattern, so any cache |
| smaller than the per-token working set evicts every entry before it is reused |
| and the hit rate collapses to zero. Popularity-pinned policies do not have this |
| failure mode, and their hit rate is exactly the popularity mass of the pinned |
| set -- which is analytically extrapolable. |
| """ |
| import json, os, sys |
| from collections import OrderedDict |
| import numpy as np |
|
|
| sys.path.insert(0, os.path.dirname(__file__)) |
| from project_1t import zipf_fit, zipf_pmf |
|
|
| RES = os.path.join(os.path.dirname(__file__), "..", "results") |
|
|
|
|
| def flat_trace(T, E): |
| L = T.shape[0] |
| return (np.arange(L)[:, None, None] * E + T) |
|
|
|
|
| def lru_like(F, cap, pinned=None): |
| """LRU over the true interleaved access order, optionally with a pinned set |
| that is never evicted. F is [L, N, K] of global slot ids.""" |
| L, N, K = F.shape |
| pinned = pinned if pinned is not None else np.zeros(0, dtype=np.int64) |
| pin = set(pinned.tolist()) |
| dyn_cap = max(0, cap - len(pin)) |
| cache = OrderedDict() |
| hits = tot = 0 |
| for t in range(N): |
| for l in range(L): |
| for s in F[l, t]: |
| s = int(s) |
| tot += 1 |
| if s in pin: |
| hits += 1 |
| continue |
| if s in cache: |
| hits += 1 |
| cache.move_to_end(s) |
| elif dyn_cap > 0: |
| if len(cache) >= dyn_cap: |
| cache.popitem(last=False) |
| cache[s] = True |
| return hits / tot |
|
|
|
|
| def static_hits(F, cap, p_global): |
| keep = np.zeros(p_global.shape[0], dtype=bool) |
| keep[np.argsort(-p_global)[:cap]] = True |
| return float(keep[F].mean()) |
|
|
|
|
| def analytic_static(p, cap): |
| """Hit rate of a popularity-pinned cache = mass of the top-`cap` slots.""" |
| q = np.sort(np.asarray(p, dtype=np.float64))[::-1] |
| q = q / q.sum() |
| return float(q[:cap].sum()) |
|
|
|
|
| def main(): |
| T = np.load(os.path.join(RES, "routing_trace.npy")).astype(np.int64) |
| L, N, K = T.shape |
| E = int(T.max()) + 1 |
| freq = json.load(open(os.path.join(RES, "routing_freq.json"))) |
| Fq = np.array([freq[str(l)] for l in range(L)]) |
| p_global = (Fq / L).reshape(-1) |
| F = flat_trace(T, E) |
| n_slots = L * E |
| ws = K * L |
| s_hat = float(np.median([zipf_fit(Fq[l]) for l in range(L)])) |
|
|
| out = {"layers": L, "experts": E, "topk": K, "tokens": int(N), |
| "n_slots": n_slots, "token_working_set": ws, "zipf_s": s_hat, |
| "ws_frac": ws / n_slots} |
| print(f"L={L} E={E} K={K} slots={n_slots} per-token working set={ws} " |
| f"({ws/n_slots*100:.1f}% of slots); Zipf s={s_hat:.3f}") |
|
|
| |
| p_zipf = np.tile(zipf_pmf(E, s_hat) / L, L) |
| rows = [] |
| for frac in [0.02, 0.05, 0.10, 0.125, 0.15, 0.25, 0.40, 0.60, 0.80]: |
| cap = max(1, int(frac * n_slots)) |
| h_lru = lru_like(F, cap) |
| h_st = static_hits(F, cap, p_global) |
| h_an = analytic_static(p_global, cap) |
| h_az = analytic_static(p_zipf, cap) |
| npin = int(0.75 * cap) |
| pin = np.argsort(-p_global)[:npin] |
| h_hy = lru_like(F, cap, pin) |
| rows.append(dict(frac=frac, cap=cap, lru=h_lru, static=h_st, |
| hybrid=h_hy, analytic_static=h_an, analytic_zipf=h_az)) |
| print(f" cap {frac*100:5.1f}% ({cap:5d}): LRU {h_lru:.4f} | static {h_st:.4f} " |
| f"| hybrid75 {h_hy:.4f} | analytic {h_an:.4f} | analytic-Zipf {h_az:.4f}") |
| out["policies"] = rows |
| out["mae_analytic_static"] = float(np.mean( |
| [abs(r["static"] - r["analytic_static"]) for r in rows])) |
| out["mae_analytic_zipf"] = float(np.mean( |
| [abs(r["static"] - r["analytic_zipf"]) for r in rows])) |
| out["best_gain_hybrid"] = float(max(r["hybrid"] - r["lru"] for r in rows)) |
| print(f"analytic static model MAE vs measured: " |
| f"{out['mae_analytic_static']*100:.2f} pp " |
| f"(Zipf-parameterised: {out['mae_analytic_zipf']*100:.2f} pp)") |
| json.dump(out, open(os.path.join(RES, "cache_policy.json"), "w"), indent=2) |
| print("saved results/cache_policy.json") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
