Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦
C
feat(glm53): say why REUSE did or didn't reuse the slot
eni562dd2d34292
diff --git a/c/glm53.c b/c/glm53.cindex 825d96ca..3b8b1b13 100644--- a/c/glm53.c+++ b/c/glm53.c@@ -3246,15 +3246,24 @@ static int serve_one(GModel *m, Tok *tokenizer, ServeReq *q) {* e ne ha almeno una in piu': lo stato ricorrente dei layer KDA non si* riavvolge, quindi una divergenza a meta' cache obbliga a rifare. */const int cached = slot->session ? slot->session->filled : 0;+ const int common = slot_shared(slot, sequence, total);int shared = 0;- if (cached > 0 && cached < total && slot_shared(slot, sequence, total) >= cached)+ if (cached > 0 && cached < total && common >= cached)shared = cached;+ /* Perche' il riuso e' andato com'e' andato, per la riga REUSE: "0 riusati"+ * da solo non distingue un prompt che diverge (un token perso, uno spazio+ * tolto dal gateway) da uno identico alla cache, che fallisce solo perche'+ * non resta nessun token da macinare. */+ const char *why = cached == 0 ? "cold"+ : total <= cached && common == total ? (total == cached ? "equal" : "shorter")+ : common < cached ? "diverged"+ : "extend";/* La fotografia si prova sempre, non solo quando il riuso in avanti* fallisce: se lo stato vivo e gia il prompt condiviso, il riuso normale* scatterebbe lo stesso ma il primo token fresco resterebbe senza* predittore, e quindi senza logprob, proprio quello che serve. */int pinned = slot_pin_restore(m, slot, sequence, total);- if (pinned > 0) shared = pinned;+ if (pinned > 0) { shared = pinned; why = "pin"; }if (shared <= 0) {slot_reset(m, slot);slot->session = session_open(m, room);@@ -3276,6 +3285,7 @@ static int serve_one(GModel *m, Tok *tokenizer, ServeReq *q) {return 0;}if (shared) { /* niente riuso con un'immagine */+ why = "image";slot_reset(m, slot);slot->session = session_open(m, room);shared = 0;@@ -3355,11 +3365,19 @@ static int serve_one(GModel *m, Tok *tokenizer, ServeReq *q) {* senza guardia questa riga compare a schermo dopo ogni risposta, sotto gli* occhi di chi voleva solo la risposta.*+ * REUSE <id> <riusati> <prompt> <in cache> <in comune> <perche'>: i primi+ * tre campi sono quelli di sempre, gli altri dicono perche' il riuso non+ * e' scattato (cold, equal, shorter, diverged, extend, pin, image).+ * <in comune> si ferma a <in cache>: dopo un limite di token la storia+ * dello slot ha un token in piu' di quelli macinati, e contarlo farebbe+ * leggere "combacia piu' di quanto c'e' in cache".+ ** Prima del ramo del CANCEL, non dopo: anche un turno interrotto ha* riusato (o no) il suo prefisso, e un turno che non lascia righe non si* puo' confrontare con quello che lo riprende. */if (getenv("GLM53_VERBOSE"))- fprintf(stderr, "REUSE %llu %d %d\n", q->id, reused, prompt_tokens);+ fprintf(stderr, "REUSE %llu %d %d %d %d %s\n", q->id, reused, prompt_tokens,+ cached, common < cached ? common : cached, why);/* Il turno e' stato interrotto: si risponde col frame che il gateway* aspetta per rilasciare l'ammissione dello scheduler (openai_server.py* accetta ERROR <id> CANCELLED oppure un DONE, ma il DONE direbbe aldiff --git a/c/tests/glm53_serve_harness.py b/c/tests/glm53_serve_harness.pyindex 5f59b478..91b7bc1f 100644--- a/c/tests/glm53_serve_harness.py+++ b/c/tests/glm53_serve_harness.py@@ -35,6 +35,18 @@ def reuse_reported():if line.startswith("REUSE "))+def reuse_line(request_id):+ """La riga REUSE di una richiesta, spezzata in campi (vuota se non c'e')."""+ try:+ text = open(NOTES, "r", errors="replace").read()+ except OSError:+ return []+ for line in text.splitlines():+ if line.startswith(f"REUSE {request_id} "):+ return line.split()+ return []++def engine(binary, fixture, extra=None):# GLM53_VERBOSE: il riuso del prefisso si racconta solo su richiesta,# perche' `coli chat` eredita lo stderr del server e quella riga finirebbe@@ -174,6 +186,17 @@ def main() -> int:print("FAIL: lo slot non ha riusato niente su un prompt che estende ""quello di prima")return 1+ if reuse_line(7)[-1:] != ["cold"] or reuse_line(10)[-1:] != ["extend"]:+ print(f"FAIL: motivi del riuso {reuse_line(7)!r} / {reuse_line(10)!r}, "+ f"attesi cold e extend")+ return 1+ # Il turno 7 si e' fermato al limite di token: la storia dello slot ha+ # un token in piu' di quelli in cache, e il prompt del turno 10 combacia+ # anche con quello. <in comune> non deve superare <in cache>.+ if reuse_line(10)[5] != reuse_line(10)[4]:+ print(f"FAIL: REUSE 10 dice {reuse_line(10)[5]} in comune ma "+ f"{reuse_line(10)[4]} in cache: {reuse_line(10)!r}")+ return 1# --- CANCEL a meta' turno (#1332) ---#@@ -192,6 +215,7 @@ def main() -> int:budget = 512submit(process, 12, prompt, max_tokens=budget)emitted_before = 0+ cancelled_text = b""while True:line = read_line(process.stdout)if line.startswith("DONE ") or line.startswith("ERROR "):@@ -201,7 +225,7 @@ def main() -> int:_, got_id, count = line.split()if int(got_id) != 12:raise AssertionError(f"DATA per {got_id}, atteso 12")- process.stdout.read(int(count) + 1)+ cancelled_text += process.stdout.read(int(count) + 1)[:int(count)]emitted_before += 1if emitted_before == 1:process.stdin.write(b"CANCEL 12\n")@@ -239,6 +263,22 @@ def main() -> int:print("FAIL: il turno interrotto non ha lasciato la sua riga REUSE")return 1+ # Il Continue di un client che ha ricevuto tutto: il prompt di prima+ # piu' esattamente i token arrivati. Coincide con la cache, token per+ # token, e il riuso salta lo stesso perche' non resta niente da+ # macinare. La riga REUSE deve dirlo ("equal"), non confonderlo con un+ # prompt che diverge.+ submit_bytes(process, 20, prompt.encode() + cancelled_text, max_tokens=1)+ _, done20, _ = collect(process, 20)+ if not done20.startswith("DONE 20 "):+ print(f"FAIL: Continue dopo il CANCEL -> {done20!r}")+ return 1+ why20 = reuse_line(20)+ if why20[3:] != [str(cancel_filled)] * 3 + ["equal"]:+ print(f"FAIL: Continue identico alla cache -> REUSE {why20!r}, atteso "+ f"prompt, cache e comune tutti {cancel_filled} con motivo equal")+ return 1+# Dopo un CANCEL lo stream deve restare allineato come dopo un errore:# il gateway riusa la stessa pipa per la richiesta successiva.submit(process, 13, prompt, max_tokens=1)