Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦
C
feat(glm53): stream the routed experts from disk
JustVugg21bcf68df884
diff --git a/c/glm53.c b/c/glm53.cindex bf9d4be4..a09eca36 100644--- a/c/glm53.c+++ b/c/glm53.c@@ -619,6 +619,13 @@ typedef struct {Mat head;GLayer *layer;char prefix[64];+ /* esperti: o residenti (checkpoint f32) o in streaming (container int4) */+ int streaming;+ struct ERef *eref;+ struct LCache *ecache;+ int64_t e_len[6], e_at[6], e_slot;+ uint64_t clock, ebytes;+ long hits, miss;/* torre vision: presente solo se il checkpoint la porta */int has_vision;ColiVisionTower vision;@@ -927,8 +934,176 @@ static void mla_layer(const Cfg *c, const GLayer *l, const float *x, int tokens,}/* ---------- FFN: denso oppure MoE ---------- */-static void ffn_layer(const Cfg *c, const GLayer *l, int index, const float *x,+/* ================= streaming degli esperti =================+ *+ * 288 esperti per 42 layer sparsi, 14,2 MB l'uno in int4 gs64: 171 GB, che+ * stanno su disco e non in RAM. Per ogni token se ne toccano 8 per layer, e la+ * stessa manciata torna spesso, quindi ogni layer tiene una cache LRU di slot+ * e il resto arriva con una lettura quando serve.+ *+ * Uno slot e' un blocco unico che contiene i sei pezzi dell'esperto nell'ordine+ * in cui li vuole il calcolo. Le Mat che ne escono puntano dentro allo slot,+ * cosi' il codice del MoE non sa da dove arrivi il peso e resta quello di+ * prima. */+#define GLM53_EXPERT_PIECES 6++typedef struct ERef {+ int fd[GLM53_EXPERT_PIECES];+ int64_t off[GLM53_EXPERT_PIECES];+ int contig; /* i sei pezzi sono consecutivi in un file */+} ERef;++typedef struct { int eid; uint8_t *base; uint64_t used; } Slot;+typedef struct LCache { Slot *s; int n, cap; } LCache;++/* Lunghezze e posizioni dei sei pezzi dentro allo slot. Gate e up sono+ * [moe_inter, hidden], down e' [hidden, moe_inter]: stessi byte, forme+ * scambiate. */+static void expert_geometry(GModel *m) {+ const int64_t hidden = m->c.hidden, inter = m->c.moe_inter;+ const int64_t packed = inter * hidden / 2;+ const int64_t scales = inter * hidden / 64 * (int64_t)sizeof(float);+ const int64_t length[GLM53_EXPERT_PIECES] = { packed, scales, packed, scales, packed, scales };+ int64_t at = 0;+ for (int p = 0; p < GLM53_EXPERT_PIECES; p++) {+ m->e_len[p] = length[p];+ m->e_at[p] = at;+ at += length[p];+ }+ m->e_slot = at;+}++/* Indirizzi su disco di ogni esperto. Le lunghezze dichiarate dal file devono+ * combaciare con la geometria: un checkpoint che dice altro non e' questo+ * modello, e leggerlo lo stesso vorrebbe dire calcolare su byte a caso. */+static void expert_table_init(GModel *m) {+ const Cfg *c = &m->c;+ static const char *piece[GLM53_EXPERT_PIECES] = {+ "gate_proj.weight", "gate_proj.weight.qs",+ "up_proj.weight", "up_proj.weight.qs",+ "down_proj.weight", "down_proj.weight.qs",+ };+ m->eref = calloc((size_t)c->n_layers * c->n_experts, sizeof(*m->eref));+ if (!m->eref) { fprintf(stderr, "OOM sulla tabella degli esperti\n"); exit(1); }++ for (int i = c->first_dense; i < c->n_layers; i++) {+ for (int e = 0; e < c->n_experts; e++) {+ ERef *ref = &m->eref[(size_t)i * c->n_experts + e];+ for (int p = 0; p < GLM53_EXPERT_PIECES; p++) {+ char name[512];+ snprintf(name, sizeof(name), "%slayers.%d.mlp.experts.%d.%s",+ m->prefix, i, e, piece[p]);+ st_tensor *t = st_find(&m->S, name);+ if (!t) { fprintf(stderr, "manca %s\n", name); exit(1); }+ if (t->nbytes != m->e_len[p]) {+ fprintf(stderr, "%s: %lld byte, attesi %lld\n", name,+ (long long)t->nbytes, (long long)m->e_len[p]);+ exit(1);+ }+ ref->fd[p] = t->fd;+ ref->off[p] = t->off;+ }+ /* Sei letture per esperto costano sei code invece di una. Vale la+ * pena accorgersi quando il file le ha gia' messe in fila. */+ ref->contig = 1;+ for (int p = 1; p < GLM53_EXPERT_PIECES; p++)+ if (ref->fd[p] != ref->fd[0] ||+ ref->off[p] != ref->off[p - 1] + m->e_len[p - 1]) { ref->contig = 0; break; }+ }+ }+}++/* Quanti slot per layer: il budget diviso i layer sparsi. Il pavimento e' 1 e+ * non topk, perche' un pavimento a topk impegnerebbe topk*layer slot comunque,+ * cioe' molti GB, a dispetto del budget chiesto. */+static void expert_cache_init(GModel *m) {+ const Cfg *c = &m->c;+ const char *setting = getenv("GLM53_EXPERT_GB");+ double budget = setting ? atof(setting) : 8.0;+ const int sparse = c->n_layers - c->first_dense;+ int cap = (int)((budget * 1e9) / ((double)m->e_slot * (sparse > 0 ? sparse : 1)));+ if (cap < 1) cap = 1;+ if (cap > c->n_experts) cap = c->n_experts;++ m->ecache = calloc((size_t)c->n_layers, sizeof(*m->ecache));+ if (!m->ecache) { fprintf(stderr, "OOM sulla cache degli esperti\n"); exit(1); }+ for (int i = c->first_dense; i < c->n_layers; i++) {+ LCache *cache = &m->ecache[i];+ cache->cap = cap;+ cache->s = calloc((size_t)cap, sizeof(*cache->s));+ if (!cache->s) { fprintf(stderr, "OOM sugli slot del layer %d\n", i); exit(1); }+ for (int j = 0; j < cap; j++) cache->s[j].eid = -1;+ }+ if (getenv("GLM53_VERBOSE"))+ fprintf(stderr, "esperti: slot da %.1f MB, %d per layer su %d layer sparsi "+ "(%.1f GB residenti)\n",+ m->e_slot / 1e6, cap, sparse, (double)cap * sparse * m->e_slot / 1e9);+}++static Slot *slot_find(GModel *m, int layer, int eid) {+ LCache *cache = &m->ecache[layer];+ for (int j = 0; j < cache->n; j++)+ if (cache->s[j].eid == eid) {+ cache->s[j].used = ++m->clock;+ m->hits++;+ return &cache->s[j];+ }+ return NULL;+}++static void expert_read(GModel *m, int layer, int eid, Slot *slot) {+ const ERef *ref = &m->eref[(size_t)layer * m->c.n_experts + eid];+ if (!slot->base) {+ slot->base = malloc((size_t)m->e_slot);+ if (!slot->base) { fprintf(stderr, "OOM su uno slot esperto\n"); exit(1); }+ }+ if (ref->contig) {+ st_pread_full(ref->fd[0], slot->base, m->e_slot, ref->off[0], "expert");+ } else {+ for (int p = 0; p < GLM53_EXPERT_PIECES; p++)+ st_pread_full(ref->fd[p], slot->base + m->e_at[p], m->e_len[p],+ ref->off[p], "expert piece");+ }+ slot->eid = eid;+ m->miss++;+ m->ebytes += (uint64_t)m->e_slot;+}++/* Lo slot dell'esperto chiesto, letto se non c'e'. La vittima e' quella usata+ * meno di recente. */+static Slot *expert_slot(GModel *m, int layer, int eid) {+ Slot *slot = slot_find(m, layer, eid);+ if (slot) return slot;+ LCache *cache = &m->ecache[layer];+ if (cache->n < cache->cap) slot = &cache->s[cache->n++];+ else {+ int lru = 0;+ for (int j = 1; j < cache->n; j++)+ if (cache->s[j].used < cache->s[lru].used) lru = j;+ slot = &cache->s[lru];+ }+ expert_read(m, layer, eid, slot);+ slot->used = ++m->clock;+ return slot;+}++/* Le tre matrici di un esperto, che puntano dentro al suo slot. */+static void expert_mats(const GModel *m, const Slot *slot, Mat *gate, Mat *up, Mat *down) {+ const int hidden = m->c.hidden, inter = m->c.moe_inter;+ const Mat shape[3] = {+ { 4, NULL, NULL, slot->base + m->e_at[0], (const float *)(slot->base + m->e_at[1]),+ inter, hidden, 64 },+ { 4, NULL, NULL, slot->base + m->e_at[2], (const float *)(slot->base + m->e_at[3]),+ inter, hidden, 64 },+ { 4, NULL, NULL, slot->base + m->e_at[4], (const float *)(slot->base + m->e_at[5]),+ hidden, inter, 64 },+ };+ *gate = shape[0]; *up = shape[1]; *down = shape[2];+}++static void ffn_layer(GModel *m, const GLayer *l, int index, const float *x,int tokens, float *out) {+ const Cfg *c = &m->c;const int inter = index < c->first_dense ? c->dense_inter : c->moe_inter;float *sg = malloc((size_t)(c->dense_inter > c->moe_inter ? c->dense_inter : c->moe_inter)* sizeof(float));@@ -971,8 +1146,14 @@ static void ffn_layer(const Cfg *c, const GLayer *l, int index, const float *x,}for (int k = 0; k < c->topk; k++) {float scale = weight[k] / (total + 1e-20f) * c->routed_scale;- mlp3(tmp, row, &l->eg[chosen[k]], &l->eu[chosen[k]], &l->ed[chosen[k]],- c->swiglu_limit, sg, su);+ Mat gate, up, down;+ if (m->streaming) {+ Slot *slot = expert_slot(m, index, chosen[k]);+ expert_mats(m, slot, &gate, &up, &down);+ } else {+ gate = l->eg[chosen[k]]; up = l->eu[chosen[k]]; down = l->ed[chosen[k]];+ }+ mlp3(tmp, row, &gate, &up, &down, c->swiglu_limit, sg, su);for (int d = 0; d < c->hidden; d++) dst[d] += scale * tmp[d];}}@@ -981,6 +1162,9 @@ static void ffn_layer(const Cfg *c, const GLayer *l, int index, const float *x,/* ---------- caricamento ---------- */static void vision_load(GModel *m);+static void expert_geometry(GModel *m);+static void expert_table_init(GModel *m);+static void expert_cache_init(GModel *m);static void model_load(GModel *m, const char *dir) {load_cfg(&m->c, dir);@@ -1010,6 +1194,22 @@ static void model_load(GModel *m, const char *dir) {}m->layer = calloc((size_t)m->c.n_layers, sizeof(*m->layer));+ /* Streaming o residenti: lo decide il contenitore, non una variabile+ * d'ambiente. Si guarda il primo esperto del primo layer sparso. */+ if (m->c.first_dense < m->c.n_layers) {+ char first[512];+ snprintf(first, sizeof(first), "%slayers.%d.mlp.experts.0.gate_proj.weight",+ P, m->c.first_dense);+ st_tensor *probe_expert = st_find(&m->S, first);+ if (!probe_expert) { fprintf(stderr, "manca %s\n", first); exit(1); }+ m->streaming = probe_expert->dtype == 3;+ }+ if (m->streaming) {+ expert_geometry(m);+ expert_table_init(m);+ expert_cache_init(m);+ }+for (int i = 0; i < m->c.n_layers; i++) {GLayer *l = &m->layer[i];l->in_ln = load_f32(m, "%slayers.%d.input_layernorm.weight", P, i);@@ -1077,13 +1277,18 @@ static void model_load(GModel *m, const char *dir) {l->rg = load_mat(m, "%slayers.%d.mlp.shared_experts.gate_proj.weight", P, i);l->ru = load_mat(m, "%slayers.%d.mlp.shared_experts.up_proj.weight", P, i);l->rd = load_mat(m, "%slayers.%d.mlp.shared_experts.down_proj.weight", P, i);- l->eg = malloc((size_t)m->c.n_experts * sizeof(Mat));- l->eu = malloc((size_t)m->c.n_experts * sizeof(Mat));- l->ed = malloc((size_t)m->c.n_experts * sizeof(Mat));- for (int e = 0; e < m->c.n_experts; e++) {- l->eg[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.gate_proj.weight", P, i, e);- l->eu[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.up_proj.weight", P, i, e);- l->ed[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.down_proj.weight", P, i, e);+ /* Gli esperti quantizzati restano su disco: sono il 97% dei byte+ * e nessuna macchina li tiene in RAM. Un checkpoint f32, come le+ * fixture degli oracoli, e' piccolo e si carica tutto. */+ if (!m->streaming) {+ l->eg = malloc((size_t)m->c.n_experts * sizeof(Mat));+ l->eu = malloc((size_t)m->c.n_experts * sizeof(Mat));+ l->ed = malloc((size_t)m->c.n_experts * sizeof(Mat));+ for (int e = 0; e < m->c.n_experts; e++) {+ l->eg[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.gate_proj.weight", P, i, e);+ l->eu[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.up_proj.weight", P, i, e);+ l->ed[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.down_proj.weight", P, i, e);+ }}}}@@ -1257,7 +1462,7 @@ static float *forward(GModel *m, const int *tokens, int n,kda_layer(c, l, normed, n, branch, state, window, scratch);}} else {- ffn_layer(c, l, i, normed, n, branch);+ ffn_layer(m, l, i, normed, n, branch);}for (int t = 0; t < n; t++)coli_hc_post(next + (size_t)t * H * D, branch + (size_t)t * D,@@ -1332,6 +1537,7 @@ int main(int argc, char **argv) {if (!count) { fprintf(stderr, "nessun id nel prompt\n"); return 2; }GModel model;+ memset(&model, 0, sizeof(model)); /* contatori e puntatori opzionali */model_load(&model, dir);if (getenv("GLM53_VERBOSE")) cfg_report(&model.c);@@ -1391,6 +1597,11 @@ int main(int argc, char **argv) {printf("\n");free(sequence);}+ /* Contatori della cache esperti: servono a un test per accorgersi se lo+ * streaming e' stato aggirato invece che esercitato. */+ if (model.streaming)+ printf("experts hits %ld miss %ld bytes %llu\n",+ model.hits, model.miss, (unsigned long long)model.ebytes);free(logits);free(vision);free(tokens);diff --git a/c/tests/test_glm53_streaming.py b/c/tests/test_glm53_streaming.pynew file mode 100644index 00000000..5473903c--- /dev/null+++ b/c/tests/test_glm53_streaming.py@@ -0,0 +1,97 @@+#!/usr/bin/env python3+"""Lo streaming degli esperti legge davvero i byte giusti.++Sul modello vero gli esperti sono 171 GB e non entrano in RAM: il motore tiene+una tabella dei loro indirizzi, una cache LRU per layer, e costruisce le+matrici puntando dentro allo slot appena letto. Un offset sbagliato, una forma+scambiata fra gate e down, una vittima scelta male: nessuna di queste cose+fa cadere il programma. Calcola su altri byte e risponde lo stesso.++Il confronto e' fra due fixture con gli stessi identici numeri, uno col+contenitore int4 che il motore legge in streaming e uno con quegli stessi+valori gia' dequantizzati, che il motore carica residenti. La quantizzazione e'+avvenuta in entrambi, quindi l'unica differenza rimasta e' da dove arrivano i+byte, e le risposte devono coincidere.++Si esegue due volte sul contenitore int4: con un budget largo, dove ogni+esperto si legge una volta sola, e con un budget da uno slot, dove la cache+sbatte e gli stessi esperti vengono riletti in continuazione. Se il secondo+giro rispondesse diverso, sarebbe l'eviction a sbagliare.++Il conteggio dei miss viene controllato perche' sia diverso da zero: un motore+che avesse silenziosamente caricato tutto in RAM passerebbe ogni altro+controllo di questo test.+"""+import argparse+import json+import os+import subprocess+import sys+from pathlib import Path+++def run(binary, fixture, patches, grid, budget=None):+ environment = {**os.environ, "GLM53_BITS": "32"}+ if budget is not None:+ environment["GLM53_EXPERT_GB"] = budget+ command = [binary, "--model", str(fixture), "--ids", patches["ids"]]+ if patches["file"]:+ command += ["--patches", patches["file"], "--grid", grid]+ command += ["--greedy", "3"]+ result = subprocess.run(command, capture_output=True, text=True, check=True,+ env=environment)+ parsed = {}+ for line in result.stdout.splitlines():+ if line.strip():+ parsed[line.split()[0]] = line.split()[1:]+ return parsed+++def main() -> int:+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument("--binary", required=True)+ parser.add_argument("--quantized", type=Path, required=True,+ help="fixture con gli esperti nel contenitore int4")+ parser.add_argument("--dequantized", type=Path, required=True,+ help="fixture con quegli stessi valori in f32")+ arguments = parser.parse_args()++ reference = json.loads((arguments.quantized / "ref.json").read_text())+ grid_h, grid_w = reference.get("grid", (0, 0))+ image = arguments.quantized / "patches.f32"+ patches = {"ids": ",".join(str(t) for t in reference["prompt"]),+ "file": str(image) if image.exists() else None}+ grid = f"{grid_h}x{grid_w}"++ resident = run(arguments.binary, arguments.dequantized, patches, grid)+ wide = run(arguments.binary, arguments.quantized, patches, grid, budget="8")+ narrow = run(arguments.binary, arguments.quantized, patches, grid, budget="0.000001")++ if "experts" not in wide or "experts" not in narrow:+ print("FAIL: il motore non ha usato lo streaming sul contenitore int4")+ return 1+ misses = {"largo": int(wide["experts"][3]), "stretto": int(narrow["experts"][3])}+ if misses["largo"] < 1:+ print("FAIL: nessuna lettura da disco, gli esperti non sono stati streammati")+ return 1+ if misses["stretto"] <= misses["largo"]:+ print(f"FAIL: con un solo slot i miss non aumentano "+ f"({misses['stretto']} contro {misses['largo']}): la cache non sfratta")+ return 1++ for label, run_output in (("budget largo", wide), ("budget stretto", narrow)):+ for field in ("teacher_forcing", "greedy"):+ if run_output[field] != resident[field]:+ print(f"FAIL {field} con {label}\n"+ f" streaming: {run_output[field]}\n"+ f" residente: {resident[field]}")+ return 1++ print(f"PASS GLM-5.3 streaming: stessi token dei pesi residenti, "+ f"{misses['largo']} letture col budget largo e {misses['stretto']} "+ f"con un solo slot per layer")+ return 0+++if __name__ == "__main__":+ sys.exit(main())diff --git a/c/tools/make_glm53_streaming_pair.py b/c/tools/make_glm53_streaming_pair.pynew file mode 100644index 00000000..1e2905ce--- /dev/null+++ b/c/tools/make_glm53_streaming_pair.py@@ -0,0 +1,110 @@+#!/usr/bin/env python3+"""Da un fixture GLM-5.3 f32, la coppia che prova lo streaming degli esperti.++Il motore ha due strade per gli esperti. Con un checkpoint f32 li carica tutti+in RAM; col contenitore int4 li lascia su disco e ne legge uno slot per volta,+con tabella degli indirizzi, cache LRU per layer e matrici che puntano dentro+allo slot. La seconda strada e' quella che serve sul modello vero, ed e' anche+quella dove si sbaglia un offset, una forma o una vittima della cache senza che+il programma se ne accorga: legge byte diversi e continua a rispondere.++Qui si scrivono due fixture con gli stessi identici numeri:++ <out>-i4 gli esperti nel contenitore int4 gs64 (`nome` U8 + `nome.qs` F32)+ <out>-deq gli stessi esperti in f32, dequantizzati da quel contenitore++Il resto dei pesi non viene toccato. Il motore deve rispondere allo stesso modo+sui due: la differenza fra le due esecuzioni non e' la quantizzazione, che e'+gia' avvenuta in entrambe, ma solo da dove arrivano i byte.++USO:+ python3 tools/make_glm53_streaming_pair.py --fixture ~/glm53_mm_tiny \\+ --output ~/glm53_stream+"""+from __future__ import annotations++import argparse+import json+import shutil+from pathlib import Path++EXPERT_MARK = ".mlp.experts."+GROUP = 64+++def quantize(weight, numpy):+ """int4 con una scala ogni 64 colonne, la stessa di convert_glm53.py."""+ rows, columns = weight.shape+ groups = (columns + GROUP - 1) // GROUP+ padded = numpy.zeros((rows, groups * GROUP), numpy.float32)+ padded[:, :columns] = weight+ blocks = padded.reshape(rows, groups, GROUP)+ amax = numpy.abs(blocks).max(axis=2, keepdims=True)+ step = numpy.maximum(amax / 7.0, 1e-8)+ level = numpy.clip(numpy.rint(blocks / step), -8, 7).astype(numpy.int32)+ level = level.reshape(rows, groups * GROUP)[:, :columns]++ packed = numpy.zeros((rows, (columns + 1) // 2), numpy.uint8)+ low = (level[:, 0::2] + 8).astype(numpy.uint8)+ packed[:, :low.shape[1]] = low+ if columns > 1:+ high = (level[:, 1::2] + 8).astype(numpy.uint8)+ packed[:, :high.shape[1]] |= (high << 4)+ dequantized = (level * step.reshape(rows, groups).repeat(GROUP, axis=1)[:, :columns])+ return packed.reshape(-1), step[:, :, 0].astype(numpy.float32).reshape(-1), \+ dequantized.astype(numpy.float32)+++def build(fixture: Path, output: Path) -> int:+ import numpy+ import torch+ from safetensors import safe_open+ from safetensors.torch import save_file++ quantized_dir = Path(str(output) + "-i4")+ dequantized_dir = Path(str(output) + "-deq")+ for directory in (quantized_dir, dequantized_dir):+ directory.mkdir(parents=True, exist_ok=True)++ quantized, dequantized = {}, {}+ experts = 0+ with safe_open(str(fixture / "model.safetensors"), "pt") as handle:+ for name in handle.keys():+ tensor = handle.get_tensor(name)+ if EXPERT_MARK not in name or not name.endswith(".weight") or tensor.dim() != 2:+ quantized[name] = tensor+ dequantized[name] = tensor+ continue+ packed, step, plain = quantize(tensor.float().numpy(), numpy)+ quantized[name] = torch.from_numpy(packed)+ quantized[name + ".qs"] = torch.from_numpy(step)+ dequantized[name] = torch.from_numpy(plain)+ experts += 1++ if not experts:+ print(f"{fixture}: nessun esperto da convertire")+ return 2++ save_file(quantized, str(quantized_dir / "model.safetensors"), metadata={"format": "pt"})+ save_file(dequantized, str(dequantized_dir / "model.safetensors"), metadata={"format": "pt"})+ for directory in (quantized_dir, dequantized_dir):+ for extra in ("config.json", "ref.json", "patches.f32"):+ source = fixture / extra+ if source.exists():+ shutil.copy(source, directory / extra)++ print(f"scritti {quantized_dir.name} e {dequantized_dir.name} "+ f"({experts} matrici di esperti)")+ return 0+++def main() -> int:+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument("--fixture", type=Path, required=True)+ parser.add_argument("--output", type=Path, required=True)+ arguments = parser.parse_args()+ return build(arguments.fixture, arguments.output)+++if __name__ == "__main__":+ raise SystemExit(main())