Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦
C
fix(serve): honor CANCEL while the turn is still running
JustVugg25ecb1327757
diff --git a/c/Makefile b/c/Makefileindex 141b4260..2b2bf7ae 100644--- a/c/Makefile+++ b/c/Makefile@@ -1637,6 +1637,9 @@ tests/test_route_trace$(EXE): tests/test_route_trace.c route_trace.htests/test_cli_args$(EXE): tests/test_cli_args.c cli_args.h$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)+tests/test_serve_poll$(EXE): tests/test_serve_poll.c serve_poll.h+ $(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)+tests/test_798_guards$(EXE): tests/test_798_guards.c st.h json.h compat.h route_trace.h$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)diff --git a/c/qwen36.c b/c/qwen36.cindex 6ee29bf2..f40d6bff 100644--- a/c/qwen36.c+++ b/c/qwen36.c@@ -57,6 +57,7 @@ static int qwen36_max_ctx(void) {#include <sys/resource.h>#include <unistd.h>#endif+#include "serve_poll.h" /* CANCEL a meta' turno (#1332) */#include "cli_args.h"#include "st.h"#include "json.h" /* tokenizer.json parsing (reuse minimal parser) */@@ -2545,6 +2546,33 @@ static int serve_eos_ids(int *ids, int cap){return n;}+/* Un CANCEL per la richiesta in corso, visto SENZA bloccare (#1332).+ *+ * Prima serve_read_req era l'unico posto che leggeva un CANCEL, e viene+ * chiamata solo fra una richiesta e l'altra: quando il comando arrivava, il+ * turno che doveva fermare era gia' finito. Il gateway intanto manda CANCEL e+ * aspetta l'ack tenendo l'ammissione dello scheduler, quindi un client che si+ * disconnette non liberava niente.+ *+ * Ritorna 1 se e' arrivato un CANCEL/STOP per `id`. Le righe che non+ * riconosciamo si scartano, com'e' sempre stato: la regola di compatibilita'+ * del protocollo vale in tutte e due le direzioni. Un SUBMIT non puo'+ * legalmente arrivare mentre l'unico slot e' occupato; se arriva viene+ * ignorato qui e sara' la lettura normale a rifiutarlo.+ *+ * Non legge MAI se stdin non e' pronto: una getline bloccante qui fermerebbe la+ * generazione in attesa di un comando che potrebbe non arrivare mai. */+static int serve_cancel_pending(const char *id){+ int cancelled = 0;+ while(coli_serve_stdin_ready()){+ char line[512], cmd[16], who[64];+ if(!fgets(line,sizeof(line),stdin)) break;+ if(sscanf(line,"%15s %63s",cmd,who)<2) continue;+ if((!strcmp(cmd,"CANCEL")||!strcmp(cmd,"STOP")) && !strcmp(who,id)) cancelled = 1;+ }+ return cancelled;+}+static void serve_one(Model *m, ServeReq *q){int *ids=NULL, np=0;encode_text(q->payload, &ids, &np); /* payload is raw prompt text; qwen36 adds no BOS */@@ -2579,6 +2607,16 @@ static void serve_one(Model *m, ServeReq *q){unsigned char chunk[256]; int cn=0; utf8_drain(sbuf,&sbn,tmp,tn,chunk,&cn);if(cn>0) serve_data(q->id,(char*)chunk,cn);gen++;+ /* #1332: una guardata a stdin per token. Il costo e' una select con+ * timeout zero; il guadagno e' che il gateway smette di aspettare un+ * turno che nessuno vuole piu'. */+ if(serve_cancel_pending(q->id)){+ free(lo); lo=NULL;+ if(sbn>0) serve_data(q->id,(char*)sbuf,sbn);+ printf("ERROR %s CANCELLED\n",q->id); fflush(stdout);+ free(ids);+ return;+ }/* The next logits are not needed after the final requested token.* serve_one() resets the recurrent/KV state for every request, so* stepping here would only run a full discarded decode pass. */diff --git a/c/qwen36_tiny/ref_full.json b/c/ref_qwen36.jsonsimilarity index 62%rename from c/qwen36_tiny/ref_full.jsonrename to c/ref_qwen36.jsonindex 8c7f38b1..f9309397 100644--- a/c/qwen36_tiny/ref_full.json+++ b/c/ref_qwen36.json@@ -18,17 +18,17 @@130,236,174,- 55,- 104,- 68,- 141,- 234,- 74,- 308,- 166,- 305,- 301+ 293,+ 264,+ 180,+ 28,+ 107,+ 257,+ 72,+ 61,+ 138,+ 169],- "mode": "full",+ "mode": "attention_only","model": "qwen36_tiny"}\ No newline at end of filediff --git a/c/serve_poll.h b/c/serve_poll.hnew file mode 100644index 00000000..f6a0c445--- /dev/null+++ b/c/serve_poll.h@@ -0,0 +1,65 @@+/* serve_poll.h — guardare stdin SENZA bloccarsi, per onorare un CANCEL mentre+ * il turno e' ancora in corso.+ *+ * #1332: il protocollo del gateway documenta "CANCEL <id> (abort current turn)",+ * ma nella maggior parte dei motori il ciclo di decode non legge stdin mentre+ * gira: il comando viene visto solo FRA una richiesta e l'altra, cioe' quando+ * non serve piu'. Il gateway intanto manda CANCEL e aspetta l'ack tenendo+ * l'ammissione dello scheduler, quindi un client che si disconnette non libera+ * niente: si aspetta comunque la fine del turno.+ *+ * Due motori lo facevano gia', ciascuno per conto suo: colibri (#678,+ * mux_ctl_poll) e kimi_k3. Questo header estrae quella primitiva -- la stessa,+ * gia' provata sul campo -- perche' gli altri non debbano reinventarla.+ *+ * Cosa fa: dice se c'e' almeno un byte leggibile su stdin, subito e senza+ * attendere. Cosa NON fa: leggere. Il formato delle righe lo conosce il+ * chiamante (serve_codec.h per cinque motori, un parser proprio per gli altri),+ * e mescolare le due cose qui vorrebbe dire riscrivere il codec.+ *+ * Regola sui casi che non sappiamo gestire: se la piattaforma non sa dire se+ * stdin e' pronto, si risponde "non pronto" e il comportamento torna quello di+ * prima -- il CANCEL a fine turno. Mai indovinare "pronto": una lettura+ * bloccante dentro il ciclo di decode fermerebbe la generazione per sempre in+ * attesa di un comando che potrebbe non arrivare mai. */+#ifndef COLI_SERVE_POLL_H+#define COLI_SERVE_POLL_H++#if defined(_WIN32)+#include <io.h>+#include <windows.h>+#else+#include <sys/select.h>+#include <unistd.h>+#endif++#ifndef STDIN_FILENO+#define STDIN_FILENO 0+#endif++/* 1 = c'e' qualcosa da leggere su stdin adesso; 0 = niente, o piattaforma che+ * non sa dirlo. Non blocca mai. */+static inline int coli_serve_stdin_ready(void)+{+#if defined(_WIN32)+ HANDLE handle = (HANDLE)_get_osfhandle(_fileno(stdin));+ DWORD available = 0;+ /* PeekNamedPipe funziona sulle pipe, che e' come il gateway parla ai+ * motori. Su una console o un file ritorna falso e si resta al+ * comportamento di prima: nessun falso "pronto". */+ if (PeekNamedPipe(handle, NULL, 0, NULL, &available, NULL) && available > 0)+ return 1;+ return 0;+#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)+ fd_set readable;+ struct timeval immediately = {0, 0};+ FD_ZERO(&readable);+ FD_SET(STDIN_FILENO, &readable);+ return select(STDIN_FILENO + 1, &readable, NULL, NULL, &immediately) > 0+ && FD_ISSET(STDIN_FILENO, &readable);+#else+ return 0; /* piattaforma sconosciuta: mai fingere che ci sia input */+#endif+}++#endif /* COLI_SERVE_POLL_H */diff --git a/c/tests/test_serve_poll.c b/c/tests/test_serve_poll.cnew file mode 100644index 00000000..d461916e--- /dev/null+++ b/c/tests/test_serve_poll.c@@ -0,0 +1,77 @@+/* coli_serve_stdin_ready: la guardata a stdin che rende possibile un CANCEL a+ * meta' turno (#1332).+ *+ * La proprieta' pericolosa e' una sola, e questo test esiste per quella: la+ * funzione NON DEVE MAI BLOCCARE. Viene chiamata dentro il ciclo di decode, una+ * volta per token; se un giorno qualcuno la trasformasse in una lettura+ * bloccante, la generazione si fermerebbe ad aspettare un comando che potrebbe+ * non arrivare mai -- un guasto peggiore di quello che la funzione cura.+ *+ * Percio' qui il tempo si misura davvero invece di fidarsi: con stdin vuoto la+ * chiamata deve tornare entro pochi millisecondi. Un test che guardasse solo il+ * valore di ritorno passerebbe anche con una versione bloccante, purche' prima+ * o poi qualcuno scrivesse qualcosa. */+#include <stdio.h>+#include <stdlib.h>+#include <string.h>+#include <time.h>+#include <unistd.h>++#include "../serve_poll.h"++static int fails;+static void check(int ok, const char *what) {+ if (!ok) { printf(" FAIL: %s\n", what); fails++; }+}++static double seconds_since(struct timespec start) {+ struct timespec now;+ clock_gettime(CLOCK_MONOTONIC, &now);+ return (now.tv_sec - start.tv_sec) + (now.tv_nsec - start.tv_nsec) / 1e9;+}++int main(void) {+ int pipefd[2];+ if (pipe(pipefd) != 0) { perror("pipe"); return 1; }++ /* stdin diventa il lato di lettura della pipe: e' come il gateway parla ai+ * motori, e insieme il caso che PeekNamedPipe gestisce su Windows. */+ if (dup2(pipefd[0], STDIN_FILENO) < 0) { perror("dup2"); return 1; }++ /* ---- 1. pipe vuota: niente da leggere, e SUBITO ---- */+ struct timespec t0;+ clock_gettime(CLOCK_MONOTONIC, &t0);+ int ready = coli_serve_stdin_ready();+ double elapsed = seconds_since(t0);+ check(ready == 0, "pipe vuota: non deve esserci niente da leggere");+ check(elapsed < 0.25,+ "la chiamata ha impiegato troppo: se blocca, il ciclo di decode si "+ "ferma ad aspettare un comando che puo' non arrivare mai");++ /* ---- 2. arriva un CANCEL: ora c'e' qualcosa ---- */+ const char *command = "CANCEL r1\n";+ if (write(pipefd[1], command, strlen(command)) < 0) { perror("write"); return 1; }+ clock_gettime(CLOCK_MONOTONIC, &t0);+ ready = coli_serve_stdin_ready();+ elapsed = seconds_since(t0);+ check(ready == 1, "con un comando in coda deve dire che stdin e' pronto");+ check(elapsed < 0.25, "anche con dati pronti la chiamata deve tornare subito");++ /* ---- 3. la riga si legge davvero, e dopo la pipe torna vuota ---- */+ char line[128] = {0};+ if (!fgets(line, sizeof(line), stdin)) { printf(" FAIL: fgets non legge\n"); return 1; }+ check(strncmp(line, "CANCEL r1", 9) == 0, "la riga letta non e' quella scritta");+ clock_gettime(CLOCK_MONOTONIC, &t0);+ check(coli_serve_stdin_ready() == 0, "dopo il consumo la pipe deve tornare vuota");+ check(seconds_since(t0) < 0.25, "la chiamata su pipe svuotata deve tornare subito");++ /* ---- 4. chiusura in scrittura: pronto (una lettura darebbe EOF) ---- */+ close(pipefd[1]);+ check(coli_serve_stdin_ready() == 1,+ "una pipe chiusa e' 'pronta': la lettura ritorna EOF, e il chiamante "+ "deve poterlo vedere invece di restare appeso");++ if (fails) { printf("test_serve_poll: %d fallimenti\n", fails); return 1; }+ printf("test_serve_poll: ok\n");+ return 0;+}