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

fix(serve): honor CANCEL while the turn is still running

JustVugg25ecb1327757
diff --git a/c/Makefile b/c/Makefile
index 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.h
tests/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.c
index 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.json
similarity index 62%
rename from c/qwen36_tiny/ref_full.json
rename to c/ref_qwen36.json
index 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 file
diff --git a/c/serve_poll.h b/c/serve_poll.h
new file mode 100644
index 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.c
new file mode 100644
index 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;
+}