Run frontier MoE models on hardware you already own β pure C, zero deps, experts streamed from disk. Tiny engine, immense model. π¦
C
feat(omp): size the OpenMP team by physical cores on kimi_k3 and olmoe
JustVuggfd8fae93a08e
diff --git a/c/Makefile b/c/Makefileindex 9e550b89..11615113 100644--- a/c/Makefile+++ b/c/Makefile@@ -458,13 +458,13 @@ cuda-bench: backend_cuda.cu backend_cuda.h backend_gpu_compat.h tests/bench_tens"$(GPUCC)" $(GPUFLAGS) backend_cuda.cu tests/bench_tensor_core.cu -o backend_cuda_bench$(EXE) $(ANS_NVCC_LIBS)./backend_cuda_bench$(EXE)-olmoe$(EXE): olmoe.c st.h json.h compat.h sample.h tok.h tok_unicode.h tok_unicode_o200k.h+olmoe$(EXE): olmoe.c st.h json.h compat.h sample.h tok.h tok_unicode.h tok_unicode_o200k.h omp_tune.h$(CC) $(CFLAGS) olmoe.c -o olmoe$(EXE) $(LDFLAGS)inkling$(EXE): inkling.c st.h json.h compat.h $(INK_CUDA_OBJ)$(CC) $(CFLAGS) inkling.c $(INK_CUDA_OBJ) -o inkling$(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 route_trace.h $(VK_OBJ) $(VK_SPV)+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 $(VK_OBJ) $(VK_SPV)$(CC) $(CFLAGS) kimi_k3.c $(VK_OBJ) -o kimi_k3$(EXE) $(LDFLAGS)# Use a baseline that matches the compiler target. macOS already targets adiff --git a/c/kimi_k3.c b/c/kimi_k3.cindex 31c65f41..9049bafc 100644--- a/c/kimi_k3.c+++ b/c/kimi_k3.c@@ -80,6 +80,7 @@#include "st.h"#include "tok.h"#include "quant.h"+#include "omp_tune.h"#include "route_trace.h" /* shared routing telemetry (#700) *//* ---------- config ---------- */@@ -1564,6 +1565,7 @@ static void serve_loop(Model *m, Tok *T){}int main(int argc, char **argv){+ coli_omp_tune_threads("kimi_k3"); /* squadra sui core fisici, niente spin-wait: vedi omp_tune.h */int serving=getenv("SERVE")&&getenv("SERVE")[0]=='1';if(!serving&&argc<2){fprintf(stderr,"usage: %s <model_dir> [prompt] [--ids \"1 2 3\"] [--ngen N]\n",argv[0]);diff --git a/c/olmoe.c b/c/olmoe.cindex 28cf79f3..bb7ac1b8 100644--- a/c/olmoe.c+++ b/c/olmoe.c@@ -32,6 +32,10 @@#include <unistd.h>#endif#include "st.h"+#ifdef _OPENMP+#include <omp.h> /* omp_set_num_threads/omp_get_max_threads per omp_tune.h */+#endif+#include "omp_tune.h"#ifdef _WIN32#include <windows.h>@@ -1085,6 +1089,7 @@ static int *read_int_array(jval *o, const char *key, int *n_out) {}int main(int argc, char **argv) {+ coli_omp_tune_threads("olmoe"); /* squadra sui core fisici, niente spin-wait: vedi omp_tune.h */const char *snap = getenv("SNAP");if (!snap) { fprintf(stderr, "set SNAP=<snapshot directory>\n"); return 1; }g_pilot = getenv("PILOT") ? atoi(getenv("PILOT")) : 0;diff --git a/c/omp_tune.h b/c/omp_tune.hnew file mode 100644index 00000000..eaa42fb1--- /dev/null+++ b/c/omp_tune.h@@ -0,0 +1,141 @@+/* omp_tune.h β dimensionamento della squadra OpenMP sui CORE FISICI.+ *+ * PERCHE' SOLO IL DIMENSIONAMENTO, E NON LO SPIN-WAIT.+ * Il blocco di tuning in colibri.c fa due cose che hanno profili di rischio+ * OPPOSTI, e vanno tenute separate:+ *+ * dimensionamento OMP_NUM_THREADS = core fisici (niente SMT)+ * #718: +2.3x su Zen3 (5950X, 16C/32T) solo cambiando+ * il numero di thread. Il guadagno e' cosi' grande che+ * "sommerge la maggior parte dei delta che si citano qui".+ *+ * spin-wait OMP_WAIT_POLICY=active, GOMP_SPINCOUNT, KMP_BLOCKTIME+ * #707: -2.2x sul decode di un host a bassa residenza+ * (M1 Max 32 GB, ~10% di expert residenti)+ * #116: -39% su Metal #159: ~3x su x86+CUDA+ * #341: 3000% di CPU su FreeBSD con la squadra ferma+ * Meccanismo: dove il token e' fatto di byte dal disco,+ * una squadra che gira a vuoto ruba i core al pool di I/O+ * che sta facendo il lavoro vero.+ *+ * Kimi K3 e OLMoE non avevano NESSUNA delle due. Qui prendono solo la prima:+ * Kimi e' il motore piu' disk-bound del progetto (misurato: 6.7% di hit,+ * 891 GB letti per 32 token), cioe' esattamente il regime in cui la seconda+ * meta' fa danno. Aggiungergliela sarebbe stato un peggioramento misurabile.+ *+ * PERCHE' QUI NON SERVE IL RE-EXEC.+ * colibri.c si ri-esegue perche' OMP_WAIT_POLICY & co. le legge il COSTRUTTORE+ * di libgomp, prima di main(): un setenv() dentro main() arriva tardi. Il numero+ * di thread no: omp_set_num_threads() e' una API di runtime e ha effetto subito.+ * La meta' sicura e' anche la meta' semplice.+ *+ * REGOLA SUI FALLIMENTI: se il conteggio dei core fisici non e' determinabile,+ * NON si indovina β si lascia il default di OpenMP. Un conteggio sbagliato e'+ * peggio di nessun conteggio (cfr. #325, dove un fallback silenzioso a 1+ * inchiodava il decode su un core solo).+ */+#ifndef COLI_OMP_TUNE_H+#define COLI_OMP_TUNE_H++#include <stdio.h>+#include <stdlib.h>+#include <string.h>++#if defined(_WIN32)+#include <windows.h>+#elif defined(__APPLE__)+#include <sys/sysctl.h>+#else+#include <dirent.h>+#endif++/* Numero di core FISICI, o 0 se non determinabile. Mai un valore inventato. */+static int coli_physical_cores(void)+{+#if defined(_WIN32)+ DWORD need = 0;+ GetLogicalProcessorInformationEx(RelationProcessorCore, NULL, &need);+ if (!need) return 0;+ void *buf = malloc(need);+ if (!buf) return 0;+ int cores = 0;+ if (GetLogicalProcessorInformationEx(RelationProcessorCore, buf, &need)) {+ char *p = (char *)buf, *end = p + need;+ while (p + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX) <= end) {+ SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *e =+ (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *)p;+ if (!e->Size) break; /* mai avanzare di 0: loop infinito */+ if (e->Relationship == RelationProcessorCore) cores++;+ p += e->Size;+ }+ }+ free(buf);+ return cores;++#elif defined(__APPLE__)+ /* hw.perflevel0.logicalcpu = i core PERFORMANCE. Su Apple Silicon+ * hw.physicalcpu li conta tutti, E-core compresi (10 su un M1 Max), e con+ * una barriera per matmul e' il thread piu' lento a dettare il passo: gli+ * E-core rallentano la squadra invece di aiutarla (#707, -4.2% decode).+ * Su Intel Mac perflevel* non esiste: li' hw.physicalcpu e' corretto. */+ int v = 0; size_t sz = sizeof(v);+ if (sysctlbyname("hw.perflevel0.logicalcpu", &v, &sz, NULL, 0) == 0 && v > 0) return v;+ v = 0; sz = sizeof(v);+ if (sysctlbyname("hw.physicalcpu", &v, &sz, NULL, 0) == 0 && v > 0) return v;+ return 0;++#else+ /* Linux: un core fisico = una lista di thread_siblings distinta. Contare le+ * liste uniche deduplica l'SMT senza dover interpretare la topologia. */+ DIR *d = opendir("/sys/devices/system/cpu");+ if (!d) return 0;+ char seen[1024][64];+ int n = 0;+ struct dirent *e;+ while ((e = readdir(d)) && n < 1024) {+ if (strncmp(e->d_name, "cpu", 3) != 0 || e->d_name[3] < '0' || e->d_name[3] > '9')+ continue;+ char path[256], line[64];+ snprintf(path, sizeof(path),+ "/sys/devices/system/cpu/%s/topology/thread_siblings_list", e->d_name);+ FILE *f = fopen(path, "r");+ if (!f) continue;+ if (fgets(line, sizeof(line), f)) {+ line[strcspn(line, "\n")] = 0;+ int dup = 0;+ for (int i = 0; i < n; i++) if (strcmp(seen[i], line) == 0) { dup = 1; break; }+ if (!dup) { snprintf(seen[n], sizeof(seen[0]), "%s", line); n++; }+ }+ fclose(f);+ }+ closedir(d);+ return n;+#endif+}++/* Dimensiona la squadra OpenMP sui core fisici. Rispetta OMP_NUM_THREADS se+ * l'utente l'ha impostata, e non fa nulla se il conteggio non e' affidabile.+ * `engine` finisce solo nella riga di log. */+static void coli_omp_tune_threads(const char *engine)+{+#ifdef _OPENMP+ const char *off = getenv("COLI_NO_OMP_TUNE");+ if (off) return; /* stesso kill-switch degli altri motori */+ if (getenv("OMP_NUM_THREADS")) return; /* l'utente comanda */++ int phys = coli_physical_cores();+ if (phys <= 0) return; /* sconosciuto -> default di OpenMP */+ int logical = omp_get_max_threads();+ if (phys >= logical) return; /* niente SMT da evitare: silenzio */++ omp_set_num_threads(phys);+ fprintf(stderr, "[OMP] %s: %d thread (core fisici) invece di %d logici β "+ "l'SMT dimezza il decode su alcune CPU (#718); "+ "OMP_NUM_THREADS=<n> per decidere tu\n",+ engine, phys, logical);+#else+ (void)engine;+#endif+}++#endif /* COLI_OMP_TUNE_H */