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(rss): count the memory we own, not what the kernel can reclaim

JustVugg1e87fb3d3be4
diff --git a/c/Makefile b/c/Makefile
index 22bf1c69..85e9afb2 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -1659,6 +1659,11 @@ tests/test_qwen36_tier_int8$(EXE): tests/test_qwen36_tier_int8.c qwen36_tier.c q
tests/test_serve_poll$(EXE): tests/test_serve_poll.c serve_poll.h
$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
+# Linux-only: legge /proc/self/status. La regola c'e' comunque, il test si
+# salta da solo dove /proc non esiste.
+tests/test_rss_anon$(EXE): tests/test_rss_anon.c
+ $(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/colibri.c b/c/colibri.c
index f3118872..6958dd8e 100644
--- a/c/colibri.c
+++ b/c/colibri.c
@@ -810,17 +810,44 @@ static double current_rss_gb(void) {
return rss_gb(); /*Return peak memory usage if we can't measure current usage*/
}
- char line[256];
- unsigned long long kb = 0;
+ char line[256];
+ unsigned long long kb = 0, anon_kb = 0, vmrss_kb = 0;
+ int have_anon = 0, have_vmrss = 0;
- while (fgets(line, sizeof(line), f)) {
- if (strncmp(line, "VmRSS:", 6) == 0) {
- if (sscanf(line + 6, "%llu", &kb) == 1) {
- fclose(f);
- return (double)kb / (1024.0 * 1024.0);
+ /* RssAnon, non VmRSS: sono le pagine che il processo POSSIEDE davvero.
+ *
+ * VmRSS conta anche le pagine di file mappate, che il kernel recupera da
+ * solo quando serve memoria. Con COLI_MAP_EXPERTS=1 (#1325) gli esperti
+ * arrivano da una mappatura invece che da una copia, quindi VmRSS sale di
+ * gigabyte senza che un byte in piu' sia sottratto al sistema -- e
+ * rss_guard, che SFRATTA esperti quando la misura supera il budget, si
+ * metterebbe a sfrattare per liberare memoria che non stava occupando.
+ * Non un avviso cosmetico: cache distrutta e lavoro rifatto.
+ *
+ * Misurato su GLM-5.3 (391 GB di container, 25 GB di RAM): con la
+ * mappatura accesa il pianificatore riportava 18.2 GB e avvisava di uno
+ * sforamento di 0.8 GB che non esisteva.
+ *
+ * Senza mappatura RssAnon e VmRSS coincidono quasi esattamente, perche' la
+ * memoria degli esperti e' malloc'ata e quindi anonima: questo cambio NON
+ * altera il comportamento del percorso pread di oggi, ed e' la ragione per
+ * cui e' sicuro farlo PRIMA di accendere la mappatura.
+ *
+ * RssAnon esiste da Linux 4.5; se manca si torna a VmRSS, cioe' al
+ * comportamento precedente, che resta corretto quando nulla e' mappato. */
+ while (fgets(line, sizeof(line), f)) {
+ if (!have_anon && strncmp(line, "RssAnon:", 8) == 0) {
+ if (sscanf(line + 8, "%llu", &anon_kb) == 1) have_anon = 1;
+ } else if (!have_vmrss && strncmp(line, "VmRSS:", 6) == 0) {
+ if (sscanf(line + 6, "%llu", &vmrss_kb) == 1) have_vmrss = 1;
}
+ if (have_anon && have_vmrss) break;
+ }
+ if (have_anon || have_vmrss) {
+ kb = have_anon ? anon_kb : vmrss_kb;
+ fclose(f);
+ return (double)kb / (1024.0 * 1024.0);
}
- }
fclose(f);
if(!announced_proc_failure) {
diff --git a/c/tests/test_rss_anon.c b/c/tests/test_rss_anon.c
new file mode 100644
index 00000000..21e8805c
--- /dev/null
+++ b/c/tests/test_rss_anon.c
@@ -0,0 +1,107 @@
+/* La guardia RSS deve contare la memoria che il processo POSSIEDE, non quella
+ * che il kernel puo' riprendersi da solo.
+ *
+ * rss_guard() sfratta esperti quando la misura supera il budget. Leggendo
+ * VmRSS, che include le pagine di file mappate, con COLI_MAP_EXPERTS=1 (#1325)
+ * la misura sale di gigabyte senza che un byte in piu' sia stato sottratto al
+ * sistema: la guardia si metterebbe a sfrattare per liberare memoria che non
+ * stava occupando.
+ *
+ * Il test mappa un file vero e pretende le DUE cose che rendono sicura la
+ * correzione: la misura non deve seguire la mappatura, e deve invece seguire
+ * una allocazione anonima -- se non facesse la seconda, avremmo reso la guardia
+ * cieca invece che precisa, che sarebbe peggio del difetto. */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+static int fails;
+static void check(int ok, const char *what) {
+ if (!ok) { printf(" FAIL: %s\n", what); fails++; }
+}
+
+/* La stessa lettura che fa current_rss_gb in colibri.c: RssAnon con VmRSS come
+ * ripiego. Duplicata qui e non inclusa perche' colibri.c e' un'unita' enorme e
+ * questo test deve restare veloce; il contratto verificato e' identico. */
+static double rss_anon_gb(void) {
+ FILE *f = fopen("/proc/self/status", "r");
+ if (!f) return -1;
+ char line[256];
+ unsigned long long anon = 0, vm = 0;
+ int ha = 0, hv = 0;
+ while (fgets(line, sizeof line, f)) {
+ if (!ha && !strncmp(line, "RssAnon:", 8)) { if (sscanf(line+8, "%llu", &anon)==1) ha=1; }
+ else if (!hv && !strncmp(line, "VmRSS:", 6)) { if (sscanf(line+6, "%llu", &vm)==1) hv=1; }
+ if (ha && hv) break;
+ }
+ fclose(f);
+ if (!ha && !hv) return -1;
+ return (double)(ha ? anon : vm) / (1024.0 * 1024.0);
+}
+
+static double vmrss_gb(void) {
+ FILE *f = fopen("/proc/self/status", "r");
+ if (!f) return -1;
+ char line[256]; unsigned long long kb = 0;
+ while (fgets(line, sizeof line, f))
+ if (!strncmp(line, "VmRSS:", 6)) { sscanf(line+6, "%llu", &kb); break; }
+ fclose(f);
+ return (double)kb / (1024.0 * 1024.0);
+}
+
+int main(void) {
+ if (rss_anon_gb() < 0) { printf("test_rss_anon: /proc non leggibile, salto\n"); return 0; }
+
+ const size_t MAPPED = 256u << 20; /* 256 MB: ben oltre il rumore */
+ char path[] = "/tmp/coli_rss_anon_XXXXXX";
+ int fd = mkstemp(path);
+ if (fd < 0) { perror("mkstemp"); return 1; }
+ if (ftruncate(fd, (off_t)MAPPED) != 0) { perror("ftruncate"); return 1; }
+
+ double anon_before = rss_anon_gb(), vm_before = vmrss_gb();
+
+ /* ---- 1. una mappatura di file toccata NON deve muovere la misura ---- */
+ char *m = mmap(NULL, MAPPED, PROT_READ, MAP_PRIVATE, fd, 0);
+ if (m == MAP_FAILED) { perror("mmap"); return 1; }
+ volatile char sink = 0;
+ for (size_t i = 0; i < MAPPED; i += 4096) sink ^= m[i]; /* falla residente */
+ (void)sink;
+
+ double anon_mapped = rss_anon_gb(), vm_mapped = vmrss_gb();
+
+ check(vm_mapped - vm_before > 0.15,
+ "il test non ha reso residente la mappatura: senza questo non prova nulla");
+ check(anon_mapped - anon_before < 0.05,
+ "la misura segue le pagine di file mappate: la guardia sfratterebbe "
+ "esperti per liberare memoria che il kernel puo' recuperare da solo");
+
+ munmap(m, MAPPED);
+ close(fd); unlink(path);
+
+ /* ---- 2. una allocazione ANONIMA deve invece muoverla ---- */
+ double anon_pre = rss_anon_gb();
+ const size_t ANON = 256u << 20;
+ char *a = malloc(ANON);
+ if (!a) { printf(" FAIL: malloc\n"); return 1; }
+ /* volatile e letta dopo: senza questo il compilatore elimina la scrittura
+ * (la memoria non viene mai riletta prima della free) e le pagine non
+ * vengono mai toccate davvero -- misurato: RssAnon fermo a +4 kB su 256 MB
+ * allocati. Un test che alloca senza toccare non misura niente. */
+ volatile char *va = (volatile char *)a;
+ for (size_t i = 0; i < ANON; i += 4096) va[i] = (char)(i & 0x7f);
+ volatile char keep = 0;
+ for (size_t i = 0; i < ANON; i += (4096 * 64)) keep ^= va[i];
+ (void)keep;
+ double anon_post = rss_anon_gb();
+ check(anon_post - anon_pre > 0.15,
+ "la misura NON segue la memoria anonima: la guardia sarebbe cieca, "
+ "che e' peggio del difetto che stiamo correggendo");
+ free(a);
+
+ if (fails) { printf("test_rss_anon: %d fallimenti\n", fails); return 1; }
+ printf("test_rss_anon: ok\n");
+ return 0;
+}