Buckets:
| // engine/engine.c - engine_api.h for every model: eng_open takes the qwen4 engine (engine/qwen4_api.c) when config.json | |
| // is a qwen4_exp configuration, else the MoVA engine (mova_ext.h too). engine_mova.h and engine_qwen4.h rename each. | |
| typedef struct MovaEng MovaEng; | |
| struct Q4Api; | |
| struct Eng { | |
| int qwen; | |
| void* h; | |
| }; | |
| Eng* eng_open(const EngOpts* o, char* err, int errlen) { | |
| Qwen4Cfg c; | |
| Eng* e = (Eng*) calloc(1, sizeof *e); | |
| e->qwen = o && o->model_dir && !qwen4_cfg_load(&c, o->model_dir, err, errlen); | |
| err[0] = 0; | |
| e->h = e->qwen ? (void*) q4_eng_open(o, err, errlen) : (void*) mova_eng_open(o, err, errlen); | |
| if (!e->h) { free(e); return NULL; } | |
| return e; | |
| } | |
| void eng_close(Eng* e) { | |
| if (!e) return; | |
| CALL0(eng_close); | |
| free(e); | |
| } | |
| const char* eng_describe(Eng* e) { return CALL0(eng_describe); } | |
| int eng_vocab(Eng* e) { return CALL0(eng_vocab); } | |
| void eng_mem(Eng* e, EngMem* m) { CALL(eng_mem, m); } | |
| int eng_prefill(Eng* e, int seq, const int32_t* ids, int n) { return CALL(eng_prefill, seq, ids, n); } | |
| int eng_prefill_cached(Eng* e, int seq, const int32_t* ids, int n, int* reused) { | |
| return CALL(eng_prefill_cached, seq, ids, n, reused); | |
| } | |
| int eng_prefill_begin(Eng* e, int seq, const int32_t* ids, int n, int* reused) { | |
| return CALL(eng_prefill_begin, seq, ids, n, reused); | |
| } | |
| int eng_prefill_next(Eng* e, int seq, int max_rows) { return CALL(eng_prefill_next, seq, max_rows); } | |
| int eng_rewind(Eng* e, int seq, int n) { return CALL(eng_rewind, seq, n); } | |
| int eng_fork(Eng* e, int dst, int src) { return CALL(eng_fork, dst, src); } | |
| void eng_free(Eng* e, int seq) { CALL(eng_free, seq); } | |
| int eng_len(Eng* e, int seq) { return CALL(eng_len, seq); } | |
| int eng_generate(Eng* e, const int* seqs, int nseq, int n_new, int mode, int32_t* out, EngStats* st) { | |
| return CALL(eng_generate, seqs, nseq, n_new, mode, out, st); | |
| } | |
| int eng_step(Eng* e, int seq, float* logits) { return CALL(eng_step, seq, logits); } | |
| int eng_push(Eng* e, int seq, int32_t tok) { return CALL(eng_push, seq, tok); } | |
| int eng_step_batch(Eng* e, const int* seqs, int n, float* logits) { return CALL(eng_step_batch, seqs, n, logits); } | |
| int64_t eng_kv_bytes(Eng* e) { return CALL0(eng_kv_bytes); } | |
| int eng_kv_read(Eng* e, int seq, int p0, int p1, void* dst) { return CALL(eng_kv_read, seq, p0, p1, dst); } | |
| int eng_kv_write(Eng* e, int seq, const int32_t* ids, int p0, int p1, const void* src) { | |
| return CALL(eng_kv_write, seq, ids, p0, p1, src); | |
| } | |
| int eng_score(Eng* e, int seq, const int32_t* ids, int from, int count, float* logits) { | |
| return CALL(eng_score, seq, ids, from, count, logits); | |
| } | |
| int eng_mova_routes(Eng* e, int on, int max_rows) { return MOVA(eng_mova_routes, on, max_rows); } | |
| int eng_mova_routes_read(Eng* e, int rows, int32_t* mlp, int32_t* val, float* mlp_sel, float* val_sel) { | |
| return MOVA(eng_mova_routes_read, rows, mlp, val, mlp_sel, val_sel); | |
| } | |
| int eng_mla_capture(Eng* e, int on) { return MOVA(eng_mla_capture, on); } | |
| int eng_mla_capture_read(Eng* e, int l, double* x, double* v, double* q, double* o, int64_t* rows) { | |
| return MOVA(eng_mla_capture_read, l, x, v, q, o, rows); | |
| } | |
| int eng_mla_capture_xtx(Eng* e, int l, int site, float* h) { return MOVA(eng_mla_capture_xtx, l, site, h); } | |
| int eng_mova_timing(Eng* e, int on) { return MOVA(eng_mova_timing, on); } | |
| int eng_mova_timing_read(Eng* e, double* seconds) { return MOVA(eng_mova_timing_read, seconds); } | |
Xet Storage Details
- Size:
- 3.93 kB
- Xet hash:
- a58abea570a5c5f50b29658f1b5ab0e8c7cc80d33d6934b093cd87df3acc0ab4
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.