Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦
C
perf(glm53): find the real wall, and a Vulkan path for the machines it helps
JustVugg6ab898aa2b13
diff --git a/c/Makefile b/c/Makefileindex 0630937e..daaad0a8 100644--- a/c/Makefile+++ b/c/Makefile@@ -1038,8 +1038,8 @@ NOCUDA_LDFLAGS = $(filter-out -lcudart -lstdc++ -lcuda -L$(CUDA_HOME)/lib64 \# GLM-5.3-Flash: CPU puro, esperti in streaming dal contenitore int4 gs64.# Nessun oggetto CUDA/Vulkan/Metal fra le dipendenze perche' il motore non ne# ha ancora: quando li avra', questa riga somigliera' a quella di kimi_k3.-glm53$(EXE): glm53.c st.h json.h tok.h tok_unicode.h tok_unicode_o200k.h compat.h quant.h hyper_connections.h delta_attention.h sparse_index.h vision_tower.h- $(CC) $(CFLAGS) glm53.c -o glm53$(EXE) $(LDFLAGS)+glm53$(EXE): glm53.c st.h json.h tok.h tok_unicode.h tok_unicode_o200k.h compat.h quant.h hyper_connections.h delta_attention.h sparse_index.h vision_tower.h $(VK_OBJ) $(VK_SPV)+ $(CC) $(CFLAGS) glm53.c $(VK_OBJ) -o glm53$(EXE) $(LDFLAGS)kimi_k3$(EXE): kimi_k3.c st.h json.h tok.h tok_unicode.h tok_unicode_o200k.h compat.h quant.h omp_tune.h route_trace.h kv_prefix.h serve_codec.h backend_cuda.h $(CUDA_OBJ) $(VK_OBJ) $(VK_SPV) $(METAL_OBJ)$(CC) $(CFLAGS) kimi_k3.c $(CUDA_OBJ) $(VK_OBJ) $(METAL_OBJ) -o kimi_k3$(EXE) $(LDFLAGS)diff --git a/c/glm53 b/c/glm53index 3026f0ec..19d2e75d 100644Binary files a/c/glm53 and b/c/glm53 differdiff --git a/c/glm53.c b/c/glm53.cindex 75084417..02f4d66a 100644--- a/c/glm53.c+++ b/c/glm53.c@@ -69,6 +69,10 @@#include "st.h"#include "quant.h"#include "tok.h"+#ifdef COLI_VULKAN+#include "backend_vulkan.h"+static int g_vk_ready = 0;+#endif#include "compat.h"#include <time.h>#ifndef _WIN32@@ -598,6 +602,7 @@ typedef struct {const uint8_t *q4;const float *s;int rows, columns, gs;+ void *vk; /* ColiVkTensor*, caricata alla prima uso */} Mat;typedef struct {@@ -894,8 +899,26 @@ static void mv_rows(float *out, const Mat *w, const float *x, int row0, int rows}}-/* out[rows] = W x, con W in layout [rows, columns] come transformers. */+/* out[rows] = W x, con W in layout [rows, columns] come transformers.+ *+ * Con COLI_VK=1 le matrici RESIDENTI passano dal backend Vulkan: si caricano+ * sul device alla prima chiamata e restano li'. Gli esperti no, e non e' una+ * dimenticanza: arrivano dal disco a ogni uso, quindi caricarli costerebbe+ * quanto leggerli e il device non ci guadagnerebbe niente. Quelli vogliono un+ * livello residente in VRAM, che e' un'altra cosa.+ *+ * Il campo `vk` e' una cache dentro a una matrice che il resto del codice+ * tratta come sola lettura: da qui il cast, che riguarda solo lui. */static void mv(float *out, const Mat *w, const float *x) {+#ifdef COLI_VULKAN+ if (g_vk_ready && (w->fmt == 1 || w->fmt == 4)) {+ Mat *mutable_w = (Mat *)w;+ if (coli_vk_matmul((ColiVkTensor **)&mutable_w->vk, out, x,+ w->fmt == 4 ? (const void *)w->q4 : (const void *)w->q8,+ w->s, w->fmt, 1, w->columns, w->rows, w->gs))+ return;+ }+#endifswitch (w->fmt) {case 4: matmul_i4_grouped(out, x, w->q4, w->s, 1, w->columns, w->rows, w->gs); break;case 1: matmul_q(out, x, w->q8, w->s, 1, w->columns, w->rows); break;@@ -1182,10 +1205,41 @@ static void expert_table_init(GModel *m) {/* 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. */+/* Quanta RAM il sistema dice di poter dare adesso. MemAvailable e non MemFree:+ * la seconda ignora la page cache riutilizzabile e farebbe stimare molto meno+ * di quello che c'e'. */+static double memory_available_gb(void) {+ FILE *f = fopen("/proc/meminfo", "r");+ if (!f) return 0.0;+ char line[256];+ double gb = 0.0;+ while (fgets(line, sizeof(line), f)) {+ long kb;+ if (sscanf(line, "MemAvailable: %ld kB", &kb) == 1) { gb = kb / 1048576.0; break; }+ }+ fclose(f);+ return gb;+}+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;+ /* Il default si misura: quello che resta libero dopo i pesi residenti,+ * meno un margine per lo stato della conversazione, i temporanei del+ * prefill e il resto del sistema. Un numero fisso sbaglia in entrambi i+ * versi -- su una macchina piccola va in OOM, su una grande lascia RAM+ * inutilizzata mentre il disco fa tutto il lavoro, che e' esattamente+ * quello che e' successo alla prima esecuzione vera. */+ double budget;+ if (setting) budget = atof(setting);+ else {+ const double free_now = memory_available_gb();+ budget = free_now - 3.0;+ if (budget < 1.0) budget = 1.0;+ if (getenv("GLM53_VERBOSE"))+ fprintf(stderr, "budget esperti: %.1f GB (%.1f disponibili, 3 di margine)\n",+ budget, free_now);+ }const int from = c->first_dense > m->layer_begin ? c->first_dense : m->layer_begin;int sparse = m->layer_end - from;if (sparse < 0) sparse = 0;@@ -1233,7 +1287,16 @@ static void expert_read(GModel *m, int layer, int eid, Slot *slot) {ref->off[p], "expert piece");}slot->eid = eid;+ /* expert_read gira dentro a un ciclo parallelo: i contatori sono condivisi+ * e senza questo sarebbero una corsa, cioe' numeri sbagliati proprio nel+ * posto in cui si va a guardare per capire se il riuso funziona. */+#ifdef _OPENMP+#pragma omp atomic+#endifm->miss++;+#ifdef _OPENMP+#pragma omp atomic+#endifm->ebytes += (uint64_t)m->e_slot;}@@ -1269,63 +1332,174 @@ static void expert_mats(const GModel *m, const Slot *slot, Mat *gate, Mat *up, M*gate = shape[0]; *up = shape[1]; *down = shape[2];}+/* Il MoE, in due tempi.+ *+ * Prima si decide: per ogni token del blocco quali esperti servono e con che+ * peso. Poi si legge: l'UNIONE di quegli esperti, in parallelo, perche' una+ * lettura da 14,2 MB e' tempo in cui il disco lavora e la CPU no, e farne una+ * per volta e' stato il collo della prima esecuzione vera (2976 letture in+ * fila). Poi si calcola.+ *+ * Fare l'unione paga due volte: le letture vanno insieme, e un esperto che+ * serve a piu' token del blocco si legge una volta sola. */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));- float *su = malloc((size_t)(c->dense_inter > c->moe_inter ? c->dense_inter : c->moe_inter)- * sizeof(float));- float *tmp = malloc((size_t)c->hidden * sizeof(float));+ const int wide = c->dense_inter > c->moe_inter ? c->dense_inter : c->moe_inter;++ if (index < c->first_dense) { /* layer denso: nessun router */+ float *sg = malloc((size_t)wide * sizeof(float));+ float *su = malloc((size_t)wide * sizeof(float));+ for (int t = 0; t < tokens; t++)+ mlp3(out + (size_t)t * c->hidden, x + (size_t)t * c->hidden,+ &l->dg, &l->du, &l->dd, c->swiglu_limit, sg, su);+ free(su); free(sg);+ return;+ }++ const int topk = c->topk;+ int *chosen = malloc((size_t)tokens * topk * sizeof(int));+ float *weight = malloc((size_t)tokens * topk * sizeof(float));float *score = malloc((size_t)c->n_experts * sizeof(float));- (void)inter;+ if (!chosen || !weight || !score) { fprintf(stderr, "OOM nel router\n"); exit(1); }++ /* --- primo tempo: il router, per ogni token --- */for (int t = 0; t < tokens; t++) {const float *row = x + (size_t)t * c->hidden;- float *dst = out + (size_t)t * c->hidden;- if (index < c->first_dense) {- mlp3(dst, row, &l->dg, &l->du, &l->dd, c->swiglu_limit, sg, su);- continue;- }- /* esperto condiviso, sempre attivo */- mlp3(dst, row, &l->rg, &l->ru, &l->rd, c->swiglu_limit, sg, su);- /* router: sigmoide sui logit; la selezione usa score+bias, il PESO usa- * lo score puro -- la distinzione e' sottile e sbagliarla cambia quali- * esperti contano quanto. */for (int e = 0; e < c->n_experts; e++) {const float *w = l->router + (size_t)e * c->hidden;float sum = 0.0f;for (int d = 0; d < c->hidden; d++) sum += w[d] * row[d];score[e] = sigmoidf_(sum);}- int chosen[64];- float weight[64], total = 0.0f;- for (int k = 0; k < c->topk; k++) {+ /* la selezione usa score+bias, il PESO usa lo score puro: la+ * distinzione e' sottile e sbagliarla cambia quali esperti contano+ * quanto. */+ int *mine = chosen + (size_t)t * topk;+ float *mine_w = weight + (size_t)t * topk;+ float total = 0.0f;+ for (int k = 0; k < topk; k++) {int best = -1; float value = -INFINITY;for (int e = 0; e < c->n_experts; e++) {int used = 0;- for (int j = 0; j < k; j++) if (chosen[j] == e) { used = 1; break; }+ for (int j = 0; j < k; j++) if (mine[j] == e) { used = 1; break; }float choice = score[e] + (l->rbias ? l->rbias[e] : 0.0f);if (!used && choice > value) { value = choice; best = e; }}- chosen[k] = best;- weight[k] = score[best];- total += weight[k];+ mine[k] = best;+ mine_w[k] = score[best];+ total += mine_w[k];+ }+ for (int k = 0; k < topk; k++)+ mine_w[k] = mine_w[k] / (total + 1e-20f) * c->routed_scale;+ }+ free(score);++ /* --- secondo e terzo tempo, a blocchi che stanno in cache ---+ *+ * L'unione di un blocco di prefill puo' superare gli slot che il layer+ * possiede: con 13 slot e sette token si arriva a 56 esperti distinti. Se+ * si assegnassero comunque, due esperti finirebbero sullo stesso slot e il+ * secondo sovrascriverebbe il primo mentre il primo e' ancora in uso, il+ * che non da' errore, da' numeri sbagliati. Quindi si lavora a blocchi+ * grandi al piu' quanto la cache: si legge il blocco in parallelo, si+ * applica a tutti i token, si passa al prossimo. */+ float *sg = malloc((size_t)wide * sizeof(float));+ float *su = malloc((size_t)wide * sizeof(float));+ float *tmp = malloc((size_t)c->hidden * sizeof(float));+ if (!sg || !su || !tmp) { fprintf(stderr, "OOM nel MoE\n"); exit(1); }++ /* l'esperto condiviso e' sempre attivo e non passa dalla cache */+ for (int t = 0; t < tokens; t++)+ mlp3(out + (size_t)t * c->hidden, x + (size_t)t * c->hidden,+ &l->rg, &l->ru, &l->rd, c->swiglu_limit, sg, su);++ if (!m->streaming) {+ for (int t = 0; t < tokens; t++)+ for (int k = 0; k < topk; k++) {+ const int eid = chosen[(size_t)t * topk + k];+ mlp3(tmp, x + (size_t)t * c->hidden, &l->eg[eid], &l->eu[eid], &l->ed[eid],+ c->swiglu_limit, sg, su);+ const float scale = weight[(size_t)t * topk + k];+ float *dst = out + (size_t)t * c->hidden;+ for (int d = 0; d < c->hidden; d++) dst[d] += scale * tmp[d];+ }+ free(tmp); free(su); free(sg); free(weight); free(chosen);+ return;+ }++ /* unione dei distinti, nell'ordine in cui compaiono */+ int *union_ids = malloc((size_t)tokens * topk * sizeof(int));+ int n_union = 0;+ if (!union_ids) { fprintf(stderr, "OOM sull'unione\n"); exit(1); }+ for (int i = 0; i < tokens * topk; i++) {+ int seen = 0;+ for (int j = 0; j < n_union; j++) if (union_ids[j] == chosen[i]) { seen = 1; break; }+ if (!seen) union_ids[n_union++] = chosen[i];+ }++ LCache *cache = &m->ecache[index];+ const int block = cache->cap;+ int *slot_of = malloc((size_t)block * sizeof(int));+ int *to_read = malloc((size_t)block * sizeof(int));+ if (!slot_of || !to_read) { fprintf(stderr, "OOM sugli slot\n"); exit(1); }++ for (int base = 0; base < n_union; base += block) {+ const int here = base + block <= n_union ? block : n_union - base;+ int reads = 0;+ for (int i = 0; i < here; i++) {+ const int eid = union_ids[base + i];+ Slot *hit = slot_find(m, index, eid);+ if (hit) { slot_of[i] = (int)(hit - cache->s); continue; }+ Slot *victim;+ if (cache->n < cache->cap) victim = &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;+ victim = &cache->s[lru];+ }+ /* prenotato subito: cosi' la scelta successiva non lo ripesca */+ victim->used = ++m->clock;+ victim->eid = -1;+ slot_of[i] = (int)(victim - cache->s);+ to_read[reads++] = i;}- for (int k = 0; k < c->topk; k++) {- float scale = weight[k] / (total + 1e-20f) * c->routed_scale;+#ifdef _OPENMP+#pragma omp parallel for schedule(dynamic, 1)+#endif+ for (int r = 0; r < reads; r++) {+ const int i = to_read[r];+ expert_read(m, index, union_ids[base + i], &cache->s[slot_of[i]]);+ }++ /* Un esperto per volta, e per ognuno tutti i token che lo hanno+ * scelto. Nell'ordine opposto i suoi 12,6 MB di pesi verrebbero+ * ripercorsi da capo per ogni token, e a questa taglia la banda di+ * memoria e' quanto costa davvero il calcolo. */+ for (int i = 0; i < here; i++) {+ const int eid = union_ids[base + i];+ Slot *slot = &cache->s[slot_of[i]];+ slot->used = ++m->clock;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]];+ expert_mats(m, slot, &gate, &up, &down);+ for (int t = 0; t < tokens; t++) {+ float scale = 0.0f;+ for (int k = 0; k < topk; k++)+ if (chosen[(size_t)t * topk + k] == eid) {+ scale = weight[(size_t)t * topk + k];+ break;+ }+ if (scale == 0.0f) continue; /* non lo ha scelto */+ mlp3(tmp, x + (size_t)t * c->hidden, &gate, &up, &down,+ c->swiglu_limit, sg, su);+ float *dst = out + (size_t)t * c->hidden;+ for (int d = 0; d < c->hidden; d++) dst[d] += scale * tmp[d];}- mlp3(tmp, row, &gate, &up, &down, c->swiglu_limit, sg, su);- for (int d = 0; d < c->hidden; d++) dst[d] += scale * tmp[d];}}- free(score); free(tmp); free(su); free(sg);+ free(to_read); free(slot_of); free(union_ids);+ free(tmp); free(su); free(sg); free(weight); free(chosen);}/* ---------- caricamento ---------- */@@ -1390,7 +1564,6 @@ static void model_load_range(GModel *m, const char *dir, int layer_begin,if (m->streaming) {expert_geometry(m);expert_table_init(m);- expert_cache_init(m);}for (int i = layer_begin; i < layer_end; i++) {@@ -1481,6 +1654,28 @@ static void model_load_range(GModel *m, const char *dir, int layer_begin,}}vision_load(m);+#ifdef COLI_VULKAN+ /* Il device si apre dopo i pesi: se non c'e', il motore continua sulla CPU+ * senza dire niente di piu' di una riga, perche' Vulkan qui e' un'opzione+ * e non un requisito. */+ if (getenv("COLI_VULKAN") && atoi(getenv("COLI_VULKAN"))) {+ /* Il backend vuole il file qmatmul.spv e da li' ricava i fratelli.+ * COLI_VK_SHADERS puo' essere il file o la cartella che lo contiene,+ * come nel resto del progetto; senza, si guarda accanto al binario. */+ char spv[1024];+ const char *given = getenv("COLI_VK_SHADERS");+ if (given && strstr(given, ".spv")) snprintf(spv, sizeof(spv), "%s", given);+ else snprintf(spv, sizeof(spv), "%s/qmatmul.spv", given ? given : "shaders");+ g_vk_ready = coli_vk_init(spv) && coli_vk_available();+ fprintf(stderr, g_vk_ready+ ? "Vulkan: attivo sulle matrici residenti\n"+ : "Vulkan: nessun device utilizzabile (%s), resto su CPU\n", spv);+ }+#endif+ /* La cache si dimensiona qui, non prima: quanto si puo' spendere dipende+ * da quanto hanno gia' preso i pesi, e prima del ciclo sui layer non+ * l'avevano ancora preso. */+ if (m->streaming) expert_cache_init(m);}/* ---------- vision ----------@@ -2369,7 +2564,9 @@ int main(int argc, char **argv) {GModel model;memset(&model, 0, sizeof(model)); /* contatori e puntatori opzionali */+ const double load_start = now_s();model_load(&model, dir);+ const double load_seconds = now_s() - load_start;if (getenv("GLM53_VERBOSE")) cfg_report(&model.c);float *vision = NULL;@@ -2403,7 +2600,11 @@ int main(int argc, char **argv) {/* Una sola sessione per tutta la generazione: il prompt si prefilla una* volta e ogni token dopo costa un token, non tutto il prefisso. */GSession *session = session_open(&model, count + (greedy > 0 ? greedy : 0) + 1);+ const double prefill_start = now_s();float *logits = forward_prefill(&model, session, tokens, count, vision, n_vision, 1);+ if (getenv("GLM53_VERBOSE"))+ fprintf(stderr, "caricamento %.1fs, prefill %d token in %.1fs\n",+ load_seconds, count, now_s() - prefill_start);printf("teacher_forcing");for (int t = 0; t < count; t++)printf(" %d", argmax(logits + (size_t)t * model.c.vocab, model.c.vocab));@@ -2417,6 +2618,11 @@ int main(int argc, char **argv) {if (greedy > 0) {int stops[8];const int n_stops = has_tokenizer ? load_stops(dir, stops, 8) : 0;+ /* Il costo per token misurato qui e non ricavato per sottrazione dal+ * tempo totale: caricamento e prefill costano quanto costano, e+ * confonderli col decode ha gia' fatto sbagliare un confronto. */+ const double decode_start = now_s();+ int produced = 0;/* `rows` dice quante righe ha l'ultimo blocco di logit: il prefill ne* restituisce una per posizione, un passo incrementale una sola. In* entrambi i casi quella che serve e' l'ultima. */@@ -2441,8 +2647,13 @@ int main(int argc, char **argv) {* gia' dato i suoi embedding durante il prefill. */logits = forward_span(&model, session, &next, 1, NULL, 0);rows = 1;+ produced++;}printf("\n");+ const double spent = now_s() - decode_start;+ if (produced)+ printf("decode %d token in %.1fs = %.3f tok/s (%.1f s/token)\n",+ produced, spent, produced / spent, spent / produced);}if (has_tokenizer) tok_free(&tokenizer);/* Contatori della cache esperti: servono a un test per accorgersi se lodiff --git a/c/shaders/attention_absorb.spv b/c/shaders/attention_absorb.spvnew file mode 100644index 00000000..38746499Binary files /dev/null and b/c/shaders/attention_absorb.spv differdiff --git a/c/shaders/qmatmul_gate_up.spv b/c/shaders/qmatmul_gate_up.spvnew file mode 100644index 00000000..0d4fe4f8Binary files /dev/null and b/c/shaders/qmatmul_gate_up.spv differdiff --git a/c/shaders/rmsnorm.spv b/c/shaders/rmsnorm.spvnew file mode 100644index 00000000..b6765fb4Binary files /dev/null and b/c/shaders/rmsnorm.spv differdiff --git a/c/tests/test_glm53_vulkan.py b/c/tests/test_glm53_vulkan.pynew file mode 100644index 00000000..a71ca7a6--- /dev/null+++ b/c/tests/test_glm53_vulkan.py@@ -0,0 +1,86 @@+#!/usr/bin/env python3+"""Il percorso Vulkan di GLM-5.3 risponde come la CPU.++Con COLI_VULKAN=1 le matrici residenti passano dal backend Vulkan invece che+dai kernel di quant.h. Sono due implementazioni diverse della stessa moltiplicazione,+e la sola cosa che conta e' che diano gli stessi token: un kernel che sbaglia+la decodifica dei nibble, il verso dei gruppi o l'ordine delle scale non da'+errore, da' un modello che risponde peggio.++Il confronto e' sui token, non sui logit. Un backend puo' sommare in un altro+ordine e finire su cifre diverse in fondo al float senza che questo cambi+niente; se cambia il token, invece, ha cambiato la risposta.++Gli esperti restano sulla CPU di proposito: arrivano dal disco a ogni uso,+quindi caricarli sul device costerebbe quanto leggerli. Quelli vogliono un+livello residente in VRAM, che e' un'altra cosa e non e' questo test.++Il test si dichiara SALTATO quando il binario non e' stato costruito con VK=1 o+non c'e' nessun device: non ha verificato niente e dirlo verde sarebbe peggio.++USO:+ make VK=1 glm53+ python3 tests/test_glm53_vulkan.py --binary ./glm53 --fixture ~/glm53_mm_tiny+"""+import argparse+import os+import subprocess+import sys+from pathlib import Path+++def run(binary, fixture, reference, vulkan, shaders):+ environment = {**os.environ, "GLM53_BITS": "4"}+ if vulkan:+ environment["COLI_VULKAN"] = "1"+ environment["COLI_VK_SHADERS"] = str(shaders)+ else:+ environment.pop("COLI_VULKAN", None)+ command = [binary, "--model", str(fixture),+ "--ids", ",".join(str(t) for t in reference["prompt"]),+ "--greedy", "4"]+ image = fixture / "patches.f32"+ if image.exists():+ grid_h, grid_w = reference["grid"]+ command += ["--patches", str(image), "--grid", f"{grid_h}x{grid_w}"]+ result = subprocess.run(command, capture_output=True, text=True, check=True,+ env=environment)+ lines = {line.split()[0]: line.split()[1:]+ for line in result.stdout.splitlines() if line.strip()}+ return lines, result.stderr+++def main() -> int:+ import json+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument("--binary", required=True)+ parser.add_argument("--fixture", type=Path, required=True)+ parser.add_argument("--shaders", type=Path,+ default=Path(__file__).resolve().parents[1] / "shaders")+ arguments = parser.parse_args()+ binary = os.path.abspath(arguments.binary)+ reference = json.loads((arguments.fixture / "ref.json").read_text())++ cpu, _ = run(binary, arguments.fixture, reference, False, arguments.shaders)+ gpu, notes = run(binary, arguments.fixture, reference, True, arguments.shaders)++ if "attivo" not in notes:+ reason = ("il binario non e' costruito con VK=1"+ if "Vulkan:" not in notes else "nessun device Vulkan utilizzabile")+ print(f"SKIP: {reason}; il percorso Vulkan non e' stato verificato")+ return 0++ device = next((line for line in notes.splitlines() if "[VK] ready:" in line), "")+ for field in ("teacher_forcing", "greedy"):+ if cpu.get(field) != gpu.get(field):+ print(f"FAIL {field}\n CPU: {cpu.get(field)}\n Vulkan: {gpu.get(field)}")+ return 1++ print(f"PASS GLM-5.3 Vulkan: stessi token della CPU su "+ f"{len(cpu['teacher_forcing'])} posizioni e {len(cpu['greedy'])} passi greedy"+ f"{' — ' + device.split('ready:')[1].split(',')[0].strip() if device else ''}")+ return 0+++if __name__ == "__main__":+ sys.exit(main())