Skip to content

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.c
index 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 al
diff --git a/c/tests/glm53_serve_harness.py b/c/tests/glm53_serve_harness.py
index 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 = 512
submit(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 += 1
if 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)