diff --git a/dist/jni/cp_inference.cpp b/dist/jni/cp_inference.cpp new file mode 100644 index 0000000..c679891 --- /dev/null +++ b/dist/jni/cp_inference.cpp @@ -0,0 +1,195 @@ +#include "cp_inference.h" +#include +#include +#include +#include +#include +#include +#include + +// Hyperparams CP (Qwen3-TTS Code Predictor) — fixés par l'architecture du modèle. +static const int N_EMBD = 1024; +static const int N_LAYER = 5; +static const int N_HEAD = 16; +static const int N_KV = 8; +static const int HEAD_DIM = 128; +static const int N_VOCAB = 2048; +static const int N_CB = 15; +static const float ROPE_BASE = 1000000.0f; +static const float RMS_EPS = 1e-6f; + +static std::vector read_floats(const char* path, size_t expect) { + FILE* f = fopen(path, "rb"); + if (!f) { fprintf(stderr, "cp_load: open fail %s\n", path); return {}; } + std::vector v(expect); + if (fread(v.data(), sizeof(float), expect, f) != expect) { + fprintf(stderr, "cp_load: short read %s\n", path); fclose(f); return {}; + } + fclose(f); return v; +} + +bool cp_load(CPState& s, const char* gguf_path, const char* heads_path, const char* embs_path) { + ggml_context* meta = nullptr; + gguf_init_params p; p.no_alloc = true; p.ctx = &meta; + gguf_context* g = gguf_init_from_file(gguf_path, p); + if (!g) { fprintf(stderr, "cp_load: gguf open fail %s\n", gguf_path); return false; } + int64_t n = gguf_get_n_tensors(g); + size_t bytes = 0; + for (int64_t i = 0; i < n; i++) { + ggml_tensor* mt = ggml_get_tensor(meta, gguf_get_tensor_name(g, i)); + bytes += ggml_nelements(mt) * sizeof(float); + } + ggml_init_params ip = { bytes + (size_t)n * ggml_tensor_overhead() + (1u << 20), nullptr, false }; + s.weights_ctx = ggml_init(ip); + + FILE* f = fopen(gguf_path, "rb"); + const size_t off = gguf_get_data_offset(g); + std::vector tmp; + for (int64_t i = 0; i < n; i++) { + const char* name = gguf_get_tensor_name(g, i); + ggml_tensor* mt = ggml_get_tensor(meta, name); + ggml_tensor* t32 = ggml_new_tensor(s.weights_ctx, GGML_TYPE_F32, ggml_n_dims(mt), mt->ne); + size_t nb = ggml_nbytes(mt); + int64_t ne = ggml_nelements(mt); + tmp.resize(nb); + fseek(f, off + gguf_get_tensor_offset(g, i), SEEK_SET); + if (fread(tmp.data(), 1, nb, f) != nb) { fprintf(stderr, "cp_load read fail %s\n", name); fclose(f); return false; } + if (mt->type == GGML_TYPE_F32) memcpy(t32->data, tmp.data(), nb); + else if (mt->type == GGML_TYPE_F16) ggml_fp16_to_fp32_row((const ggml_fp16_t*)tmp.data(), (float*)t32->data, ne); + else { fprintf(stderr, "cp_load unsupported type %s for %s\n", ggml_type_name(mt->type), name); fclose(f); return false; } + s.tensors[name] = t32; + } + fclose(f); + gguf_free(g); + + const size_t TAB = (size_t)N_CB * N_VOCAB * N_EMBD; + s.heads = read_floats(heads_path, TAB); if (s.heads.empty()) return false; + s.codec_embs = read_floats(embs_path, TAB); if (s.codec_embs.empty()) return false; + fprintf(stderr, "cp_load: %lld tensors + heads(%.0f MB) + codec_embs(%.0f MB) OK\n", + (long long)n, TAB * 4 / 1048576.0, TAB * 4 / 1048576.0); + return true; +} + +void cp_free(CPState& s) { + if (s.weights_ctx) ggml_free(s.weights_ctx); + s.weights_ctx = nullptr; + s.tensors.clear(); + s.heads.clear(); + s.codec_embs.clear(); +} + +// Forward un transformer 5L sur X[N_EMBD, L] -> out_hn = hidden après output_norm à la position `last`. +// Architecture identique à cp_runner.cpp (la référence bit-exact validée). +static void cp_forward_lastpos(CPState& s, const std::vector& embeds_flat, int L, int last, + std::vector& out_hn) { + size_t mem = 128ULL * 1024 * 1024; + ggml_init_params p = { mem, nullptr, false }; + ggml_context* ctx = ggml_init(p); + + ggml_tensor* x = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, N_EMBD, L); + memcpy(x->data, embeds_flat.data(), (size_t)N_EMBD * L * sizeof(float)); + ggml_tensor* pos = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, L); + for (int i = 0; i < L; i++) ((int32_t*)pos->data)[i] = i; + ggml_tensor* mask = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, L, L); + { + float* m = (float*)mask->data; + for (int q = 0; q < L; q++) + for (int k = 0; k < L; k++) + m[k + L * q] = (k > q) ? -INFINITY : 0.0f; + } + const float scale = 1.0f / sqrtf((float)HEAD_DIM); + + auto W = [&](const std::string& k) -> ggml_tensor* { + auto it = s.tensors.find(k); + if (it == s.tensors.end()) { fprintf(stderr, "CP missing tensor %s\n", k.c_str()); abort(); } + return it->second; + }; + + for (int L_i = 0; L_i < N_LAYER; L_i++) { + char pre[32]; snprintf(pre, sizeof(pre), "blk.%d", L_i); + std::string b = pre; + ggml_tensor* res = x; + + ggml_tensor* xn = ggml_rms_norm(ctx, x, RMS_EPS); + xn = ggml_mul(ctx, xn, W(b + ".attn_norm.weight")); + + ggml_tensor* Q = ggml_mul_mat(ctx, W(b + ".attn_q.weight"), xn); + ggml_tensor* K = ggml_mul_mat(ctx, W(b + ".attn_k.weight"), xn); + ggml_tensor* V = ggml_mul_mat(ctx, W(b + ".attn_v.weight"), xn); + + Q = ggml_reshape_3d(ctx, Q, HEAD_DIM, N_HEAD, L); + K = ggml_reshape_3d(ctx, K, HEAD_DIM, N_KV, L); + V = ggml_reshape_3d(ctx, V, HEAD_DIM, N_KV, L); + + // q/k-norm AVANT RoPE (gotcha) + Q = ggml_mul(ctx, ggml_rms_norm(ctx, Q, RMS_EPS), W(b + ".attn_q_norm.weight")); + K = ggml_mul(ctx, ggml_rms_norm(ctx, K, RMS_EPS), W(b + ".attn_k_norm.weight")); + + Q = ggml_rope_ext(ctx, Q, pos, NULL, HEAD_DIM, GGML_ROPE_TYPE_NEOX, 0, + ROPE_BASE, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f); + K = ggml_rope_ext(ctx, K, pos, NULL, HEAD_DIM, GGML_ROPE_TYPE_NEOX, 0, + ROPE_BASE, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f); + + Q = ggml_cont(ctx, ggml_permute(ctx, Q, 0, 2, 1, 3)); + K = ggml_cont(ctx, ggml_permute(ctx, K, 0, 2, 1, 3)); + V = ggml_cont(ctx, ggml_permute(ctx, V, 1, 2, 0, 3)); + + ggml_tensor* KQ = ggml_mul_mat(ctx, K, Q); + KQ = ggml_soft_max_ext(ctx, KQ, mask, scale, 0.0f); + ggml_tensor* KQV = ggml_mul_mat(ctx, V, KQ); + KQV = ggml_cont(ctx, ggml_permute(ctx, KQV, 0, 2, 1, 3)); + KQV = ggml_reshape_2d(ctx, KQV, HEAD_DIM * N_HEAD, L); + + ggml_tensor* attn = ggml_mul_mat(ctx, W(b + ".attn_output.weight"), KQV); + x = ggml_add(ctx, res, attn); + + res = x; + ggml_tensor* xn2 = ggml_rms_norm(ctx, x, RMS_EPS); + xn2 = ggml_mul(ctx, xn2, W(b + ".ffn_norm.weight")); + ggml_tensor* g = ggml_silu(ctx, ggml_mul_mat(ctx, W(b + ".ffn_gate.weight"), xn2)); + ggml_tensor* u = ggml_mul_mat(ctx, W(b + ".ffn_up.weight"), xn2); + ggml_tensor* ff = ggml_mul_mat(ctx, W(b + ".ffn_down.weight"), ggml_mul(ctx, g, u)); + x = ggml_add(ctx, res, ff); + } + x = ggml_rms_norm(ctx, x, RMS_EPS); + x = ggml_mul(ctx, x, W("output_norm.weight")); + + ggml_cgraph* gf = ggml_new_graph_custom(ctx, 8192, false); + ggml_build_forward_expand(gf, x); + ggml_graph_compute_with_ctx(ctx, gf, s.n_threads); + + out_hn.resize(N_EMBD); + memcpy(out_hn.data(), (float*)x->data + (size_t)N_EMBD * last, N_EMBD * sizeof(float)); + ggml_free(ctx); +} + +void cp_predict(CPState& s, const float* hidden, const float* cb0_emb, int32_t* out_codes) { + // embeds = [hidden, cb0_emb, codec_embs[0][cb1], codec_embs[1][cb2], ..., codec_embs[13][cb14]] + // step s (1..15) : forward sur les (s+1) tokens, sortir hidden à la position `s`, head[s-1] -> argmax. + std::vector embeds; embeds.reserve((size_t)17 * N_EMBD); + embeds.insert(embeds.end(), hidden, hidden + N_EMBD); + embeds.insert(embeds.end(), cb0_emb, cb0_emb + N_EMBD); + + std::vector hn; + for (int step = 1; step <= N_CB; step++) { + const int L = step + 1; + cp_forward_lastpos(s, embeds, L, step, hn); + + // tête[step-1] : argmax_j sum_k hn[k] * heads[step-1, j, k] + const float* Wh = &s.heads[(size_t)(step - 1) * N_VOCAB * N_EMBD]; + int best = 0; float bv = -1e30f; + for (int j = 0; j < N_VOCAB; j++) { + const float* wj = Wh + (size_t)j * N_EMBD; + float dot = 0.f; + for (int k = 0; k < N_EMBD; k++) dot += hn[k] * wj[k]; + if (dot > bv) { bv = dot; best = j; } + } + out_codes[step - 1] = best; + + // feedback : append codec_embs[step-1][best] aux embeds + if (step < N_CB) { + const float* e = &s.codec_embs[(size_t)(step - 1) * N_VOCAB * N_EMBD + (size_t)best * N_EMBD]; + embeds.insert(embeds.end(), e, e + N_EMBD); + } + } +} diff --git a/dist/jni/cp_inference.h b/dist/jni/cp_inference.h new file mode 100644 index 0000000..b1a68b6 --- /dev/null +++ b/dist/jni/cp_inference.h @@ -0,0 +1,37 @@ +// Code Predictor (Qwen3-TTS) inference, extrait de +// /opt/Kazeia/kazeia-tts-decoder-ggml/src/cp_runner.cpp et exposé en API +// utilisable depuis tts_orchestrate. Architecture : transformer qwen3 5 couches, +// hidden 1024, GQA 16/8, head_dim 128, RMS eps 1e-6, RoPE NEOX theta=1e6. +// q_norm/k_norm AVANT RoPE (gotcha critique). +// +// Forward autoregressif RVQ : 15 passes pour produire CB1..CB15 depuis +// (hidden_Talker[1024], cb0_emb[1024]). Approche "recompute" (T<=16 -> coût +// quadratique négligeable, pas de KV cache manuel). +#pragma once +#include +#include +#include +#include + +struct ggml_context; +struct ggml_tensor; + +struct CPState { + ggml_context * weights_ctx = nullptr; + std::unordered_map tensors; // weights par nom + std::vector heads; // [15, 2048, 1024] f32 + std::vector codec_embs; // [15, 2048, 1024] f32 + int n_threads = 4; +}; + +// Charge cp_f16.gguf + cp_heads.bin + cp_codec_embs.bin. Retourne false en cas d'échec. +bool cp_load(CPState& s, const char* gguf_path, const char* heads_path, const char* embs_path); + +// Libère les ressources. +void cp_free(CPState& s); + +// Prédit CB1..CB15 (15 codes int32) depuis le hidden state du Talker et l'embed de CB0. +// hidden : float[1024] +// cb0_emb: float[1024] +// out_codes : int32_t[15] (CB1..CB15) +void cp_predict(CPState& s, const float* hidden, const float* cb0_emb, int32_t* out_codes); diff --git a/dist/jni/cp_validate.cpp b/dist/jni/cp_validate.cpp new file mode 100644 index 0000000..7d97063 --- /dev/null +++ b/dist/jni/cp_validate.cpp @@ -0,0 +1,70 @@ +// Validation : mon cp_inference (intégré dans tts_orchestrate) doit reproduire +// cp_runner standalone bit-exact. Sur test_cp_input.bin (33 frames hidden+CB0 +// du Talker PyTorch) → comparer codes CB1..15 vs test_codes_greedy.bin +// (golden cp.generate do_sample=False). Cible : 33/33 frames parfaits. +#include "cp_inference.h" +#include +#include +#include +#include +#include +#include + +int main(int argc, char** argv) { + if (argc < 6) { + printf("usage: %s \n", argv[0]); + return 1; + } + CPState s; s.n_threads = 4; + if (!cp_load(s, argv[1], argv[2], argv[3])) { printf("cp_load FAILED\n"); return 1; } + + // input : int32 T, T * (hidden[1024] + cb0_emb[1024]) f32 + FILE* fi = fopen(argv[4], "rb"); if (!fi) { printf("input fail\n"); return 1; } + int32_t T = 0; if (fread(&T, 4, 1, fi) != 1) return 1; + std::vector inbuf((size_t)T * 2 * 1024); + if (fread(inbuf.data(), sizeof(float), inbuf.size(), fi) != inbuf.size()) return 1; + fclose(fi); + + // golden : pour test_codes_greedy.bin pas de header (T * 16 int32 direct, 33 * 16 * 4 = 2112 bytes ≈ 2116) + FILE* fg = fopen(argv[5], "rb"); if (!fg) return 1; + fseek(fg, 0, SEEK_END); long gsz = ftell(fg); fseek(fg, 0, SEEK_SET); + // 2 layouts possibles : (a) header int32+T*16 int32 (size = 4 + T*64), + // (b) raw T*16 int32 (size = T*64). On déduit. + bool has_hdr = (gsz == 4 + (long)T * 64); + if (has_hdr) { int32_t ng = 0; fread(&ng, 4, 1, fg); printf("golden has header, ng=%d\n", ng); } + std::vector gold((size_t)T * 16); + size_t expect = T * 16; + if (fread(gold.data(), sizeof(int32_t), expect, fg) != expect) { + // Maybe golden has fewer or different format + printf("golden short read; size %ld, expected %zu*4=%zu bytes (T=%d)\n", gsz, expect, expect*4, T); + fclose(fg); return 1; + } + fclose(fg); + + printf("running CP on %d frames...\n", T); + long n_match_cb15 = 0, total_codes_cb15 = 0; + int n_perfect_cb15 = 0; + for (int f = 0; f < T; f++) { + const float* hidden = &inbuf[(size_t)f * 2 * 1024]; + const float* cb0_emb = &inbuf[(size_t)f * 2 * 1024 + 1024]; + int32_t codes15[15]; + cp_predict(s, hidden, cb0_emb, codes15); + + // golden format = [CB0 ... CB15] (16 entries per frame) + const int32_t* gf16 = &gold[(size_t)f * 16]; + int match = 0; + for (int c = 0; c < 15; c++) if (codes15[c] == gf16[1 + c]) match++; + n_match_cb15 += match; total_codes_cb15 += 15; + if (match == 15) n_perfect_cb15++; + if (f < 3 || match < 15) { + printf("frame %2d: CB1..15 match %2d/15 -> CP=[%d,%d,%d,%d] PY=[%d,%d,%d,%d]\n", + f, match, codes15[0], codes15[1], codes15[2], codes15[3], + gf16[1], gf16[2], gf16[3], gf16[4]); + } + } + printf("\n=== cp_predict (engine) vs cp.generate greedy (golden) ===\n"); + printf("codes match : %ld/%ld (%.1f%%)\n", n_match_cb15, total_codes_cb15, 100.0 * n_match_cb15 / total_codes_cb15); + printf("frames parfaits : %d/%d\n", n_perfect_cb15, T); + cp_free(s); + return (n_match_cb15 == total_codes_cb15) ? 0 : 5; +} diff --git a/dist/jni/tts_orchestrate.cpp b/dist/jni/tts_orchestrate.cpp index a9c3b63..bcd131e 100644 --- a/dist/jni/tts_orchestrate.cpp +++ b/dist/jni/tts_orchestrate.cpp @@ -21,8 +21,15 @@ #include #include #include +#include #include "llama.h" #include "ggml-backend.h" +#include "cp_inference.h" + +static double now_s() { + using clk = std::chrono::steady_clock; + return std::chrono::duration(clk::now().time_since_epoch()).count(); +} static ggml_backend_dev_t find_htp() { for (size_t i = 0; i < ggml_backend_dev_count(); ++i) { @@ -54,13 +61,23 @@ static std::vector read_i32(const std::string& p, size_t n_expected) { } int main(int argc, char** argv) { - if (argc < 4) { printf("usage: %s [cpu|htp] [max_steps]\n", argv[0]); return 1; } + if (argc < 4) { printf("usage: %s [cpu|htp] [max_steps]\n", argv[0]); return 1; } const char* gguf = argv[1]; std::string D = argv[2]; if (D.back() != '/') D += '/'; const char* out_codes = argv[3]; bool force_cpu = (argc >= 5 && !strcmp(argv[4], "cpu")); int max_steps_arg = (argc >= 6) ? atoi(argv[5]) : 0; + // CP runner : charge cp_f16.gguf + cp_heads.bin + cp_codec_embs.bin depuis dump_dir. + // Si l'un manque -> fallback teacher-forcing (mode legacy de tts_orchestrate). + CPState cp_state; + cp_state.n_threads = 4; + bool cp_ok = cp_load(cp_state, + (D + "cp_f16.gguf").c_str(), + (D + "cp_heads.bin").c_str(), + (D + "cp_codec_embs.bin").c_str()); + printf("CP : %s\n", cp_ok ? "ENABLED" : "DISABLED (teacher-forced CB1..15)"); + // manifest int T_prefill = 0, N_steps_golden = 0, n_embd = 1024, n_vocab = 3072; int N_codebooks = 16, cp_vocab = 2048, codec_eos_token_id = 2150; @@ -123,13 +140,15 @@ int main(int argc, char** argv) { sids[i] = &sid0[i]; } lg[T_prefill - 1] = 1; + const double t_prefill0 = now_s(); { llama_batch b{}; b.n_tokens = T_prefill; b.embd = prefill_embeds.data(); b.pos = pos.data(); b.n_seq_id = nsd.data(); b.seq_id = sids.data(); b.logits = lg.data(); if (llama_decode(ctx, b) != 0) { printf("prefill FAILED\n"); return 1; } } - printf("prefill OK (T=%d)\n", T_prefill); + const double t_prefill = now_s() - t_prefill0; + printf("prefill OK (T=%d) en %.3f s\n", T_prefill, t_prefill); // sample CB0 at prefill output (first step's "input_ids") auto logits = llama_get_logits_ith(ctx, -1); @@ -140,18 +159,43 @@ int main(int argc, char** argv) { // boucle decode std::vector codes_engine(N * N_codebooks, 0); - int n_match_cb0 = 0; + int n_match_cb0 = 0, n_match_full = 0; int n_eos = -1; + double t_compose = 0, t_decode = 0, t_cp = 0; + const double t_loop0 = now_s(); + // capture du hidden state du Talker (pour passer au CP) = ce que renvoie + // llama_get_embeddings_ith(ctx,-1) après chaque decode. On l'a déjà au prefill (h ci-dessous). + const float* h_last = llama_get_embeddings_ith(ctx, -1); + std::vector hidden_for_cp(n_embd); + if (h_last) memcpy(hidden_for_cp.data(), h_last, n_embd * sizeof(float)); + for (int s = 0; s < N; ++s) { - // Codes pour ce frame s : CB0 = engine greedy ; CB1..CB15 = teacher-forced from golden[s, 1..15] + // CB0 = engine greedy codes_engine[s * N_codebooks + 0] = cb0; - for (int i = 1; i < N_codebooks; ++i) { - codes_engine[s * N_codebooks + i] = codes_golden[s * N_codebooks + i]; + // CB1..15 : soit CP réel, soit teacher-forced + const double tcp0 = now_s(); + if (cp_ok) { + const float* cb0_emb = tok_embd.data() + (size_t)cb0 * n_embd; + int32_t out_cb15[15]; + cp_predict(cp_state, hidden_for_cp.data(), cb0_emb, out_cb15); + for (int i = 1; i < N_codebooks; ++i) codes_engine[s * N_codebooks + i] = out_cb15[i - 1]; + } else { + for (int i = 1; i < N_codebooks; ++i) { + codes_engine[s * N_codebooks + i] = codes_golden[s * N_codebooks + i]; + } } + t_cp += now_s() - tcp0; if (cb0 == codes_golden[s * N_codebooks + 0]) n_match_cb0++; + { + int m = 0; + for (int i = 0; i < N_codebooks; ++i) + if (codes_engine[s * N_codebooks + i] == codes_golden[s * N_codebooks + i]) m++; + if (m == N_codebooks) n_match_full++; + } if (cb0 == codec_eos_token_id && n_eos < 0) { n_eos = s; printf(" step %d: EOS atteint\n", s); } // next_embed = tok_embd[cb0] + sum cp_codec_embs[i-1, CB(i)] + tts_pad + const double tc0 = now_s(); std::vector next_embed(n_embd, 0.0f); const float* e_cb0 = tok_embd.data() + (size_t)cb0 * n_embd; for (int d = 0; d < n_embd; ++d) next_embed[d] = e_cb0[d]; @@ -161,6 +205,7 @@ int main(int argc, char** argv) { for (int d = 0; d < n_embd; ++d) next_embed[d] += e[d]; } for (int d = 0; d < n_embd; ++d) next_embed[d] += tts_pad[d]; + t_compose += now_s() - tc0; // valid : next_embed (= input à injecter au decode step s) vs step_inputs_py[s] // (= ce que Python a injecté au decode step s). Si codes_engine[s] == codes_golden[s] @@ -192,15 +237,32 @@ int main(int argc, char** argv) { llama_batch b{}; b.n_tokens = 1; b.embd = next_embed.data(); b.pos = pos1; b.n_seq_id = &n; b.seq_id = &sp; b.logits = &l; + const double td0 = now_s(); if (llama_decode(ctx, b) != 0) { printf("step %d FAILED\n", s); break; } + t_decode += now_s() - td0; - // sample CB0 pour le prochain step + // sample CB0 pour le prochain step + capture hidden pour CP logits = llama_get_logits_ith(ctx, -1); cb0 = 0; mx = logits[0]; for (int i = 1; i < n_vocab; ++i) if (logits[i] > mx) { mx = logits[i]; cb0 = i; } + const float* hh = llama_get_embeddings_ith(ctx, -1); + if (hh) memcpy(hidden_for_cp.data(), hh, n_embd * sizeof(float)); } + const double t_loop = now_s() - t_loop0; - printf("DONE: N=%d, CB0 matches golden = %d/%d (info)\n", N, n_match_cb0, N); + const double audio_s = N / 12.0; // 12 Hz codec + printf("DONE: N=%d (audio %.2f s @ 12Hz)\n", N, audio_s); + printf(" CB0 match golden : %d/%d\n", n_match_cb0, N); + printf(" All 16 codes match : %d/%d (info, dépend du sampling Python)\n", n_match_full, N); + printf("=== TIMING ===\n"); + printf(" Talker prefill (T=%d) : %.3f s\n", T_prefill, t_prefill); + printf(" Loop (N=%d steps) : %.3f s talker_decode=%.3f, cp=%.3f, compose=%.3f, autres=%.3f\n", + N, t_loop, t_decode, t_cp, t_compose, t_loop - t_decode - t_cp - t_compose); + printf(" per-step talker : %.1f ms\n", t_decode * 1000.0 / N); + printf(" per-step CP (15 pass) : %.1f ms\n", t_cp * 1000.0 / N); + printf(" Total Talker+CP : %.3f s -> RTF talker+cp side = %.3f\n", + t_prefill + t_loop, (t_prefill + t_loop) / audio_s); + cp_free(cp_state); // dump codes_engine {