From 93abfb66abb3c4fc0c337a210433f534b134a626 Mon Sep 17 00:00:00 2001 From: firecoperana Date: Sat, 17 Jan 2026 08:42:43 -0600 Subject: [PATCH] Revert kv cache name changes --- common/speculative.cpp | 6 +++--- examples/batched-bench/batched-bench.cpp | 2 +- examples/batched/batched.cpp | 2 +- examples/infill/infill.cpp | 4 ++-- examples/lookahead/lookahead.cpp | 10 +++++----- examples/lookup/lookup.cpp | 2 +- examples/main/main.cpp | 12 ++++++------ examples/mtmd/mtmd-cli.cpp | 4 ++-- examples/parallel/parallel.cpp | 10 +++++----- examples/passkey/passkey.cpp | 12 ++++++------ examples/server/server-context.cpp | 22 +++++++++++----------- examples/speculative/speculative.cpp | 14 +++++++------- examples/sweep-bench/sweep-bench.cpp | 6 +++--- include/llama.h | 8 ++++---- src/llama.cpp | 10 +++++----- 15 files changed, 62 insertions(+), 62 deletions(-) diff --git a/common/speculative.cpp b/common/speculative.cpp index 61ce4459..b450e2a2 100644 --- a/common/speculative.cpp +++ b/common/speculative.cpp @@ -258,14 +258,14 @@ std::vector llama_speculative_gen_draft( } if (reuse_i > 0) { - llama_memory_seq_rm (ctx_dft, 0, 0, reuse_i); - llama_memory_seq_add(ctx_dft, 0, reuse_i, -1, -reuse_i); + llama_kv_cache_seq_rm (ctx_dft, 0, 0, reuse_i); + llama_kv_cache_seq_add(ctx_dft, 0, reuse_i, -1, -reuse_i); prompt_dft.erase(prompt_dft.begin(), prompt_dft.begin() + reuse_i); } if (reuse_n < (int) prompt_dft.size()) { - llama_memory_seq_rm (ctx_dft, 0, reuse_n, -1); + llama_kv_cache_seq_rm (ctx_dft, 0, reuse_n, -1); prompt_dft.erase(prompt_dft.begin() + reuse_n, prompt_dft.end()); } diff --git a/examples/batched-bench/batched-bench.cpp b/examples/batched-bench/batched-bench.cpp index 95dd22c5..676fda41 100644 --- a/examples/batched-bench/batched-bench.cpp +++ b/examples/batched-bench/batched-bench.cpp @@ -164,7 +164,7 @@ int main(int argc, char ** argv) { if (is_pp_shared) { for (int32_t i = 1; i < pl; ++i) { - llama_memory_seq_cp(ctx, 0, i, -1, -1); + llama_kv_cache_seq_cp(ctx, 0, i, -1, -1); } } diff --git a/examples/batched/batched.cpp b/examples/batched/batched.cpp index c9f8fcc1..d7b57c2c 100644 --- a/examples/batched/batched.cpp +++ b/examples/batched/batched.cpp @@ -132,7 +132,7 @@ int main(int argc, char ** argv) { //// assign the system KV cache to all parallel sequences //// this way, the parallel sequences will "reuse" the prompt tokens without having to copy them //for (int32_t i = 1; i < n_parallel; ++i) { - // llama_memory_seq_cp(ctx, 0, i, -1, -1); + // llama_kv_cache_seq_cp(ctx, 0, i, -1, -1); //} if (n_parallel > 1) { diff --git a/examples/infill/infill.cpp b/examples/infill/infill.cpp index 88a1b703..f98b2aba 100644 --- a/examples/infill/infill.cpp +++ b/examples/infill/infill.cpp @@ -385,8 +385,8 @@ int main(int argc, char ** argv) { LOG("context full, swapping: n_past = %d, n_left = %d, n_ctx = %d, n_keep = %d, n_discard = %d\n", n_past, n_left, n_ctx, params.n_keep, n_discard); - llama_memory_seq_rm (ctx, 0, params.n_keep + 1 , params.n_keep + n_discard + 1); - llama_memory_seq_add(ctx, 0, params.n_keep + 1 + n_discard, n_past, -n_discard); + llama_kv_cache_seq_rm (ctx, 0, params.n_keep + 1 , params.n_keep + n_discard + 1); + llama_kv_cache_seq_add(ctx, 0, params.n_keep + 1 + n_discard, n_past, -n_discard); n_past -= n_discard; diff --git a/examples/lookahead/lookahead.cpp b/examples/lookahead/lookahead.cpp index 19548d94..12602257 100644 --- a/examples/lookahead/lookahead.cpp +++ b/examples/lookahead/lookahead.cpp @@ -96,7 +96,7 @@ int main(int argc, char ** argv) { llama_decode(ctx, llama_batch_get_one(&inp.back(), 1, n_input - 1, 0)); for (int s = 1; s < W + G + 1; ++s) { - llama_memory_seq_cp(ctx, 0, s, -1, -1); + llama_kv_cache_seq_cp(ctx, 0, s, -1, -1); } const auto t_enc_end = ggml_time_us(); @@ -438,17 +438,17 @@ int main(int argc, char ** argv) { // KV cache management // if no verification token matched, we simply remove all cells from this batch -> no fragmentation - llama_memory_seq_rm(ctx, -1, n_past, -1); + llama_kv_cache_seq_rm(ctx, -1, n_past, -1); if (seq_id_best != 0) { // if a verification token matched, we keep the best sequence and remove the rest // this leads to some KV cache fragmentation llama_kv_cache_seq_keep(ctx, seq_id_best); - llama_memory_seq_cp (ctx, seq_id_best, 0, -1, -1); - llama_memory_seq_rm (ctx, seq_id_best, -1, -1); + llama_kv_cache_seq_cp (ctx, seq_id_best, 0, -1, -1); + llama_kv_cache_seq_rm (ctx, seq_id_best, -1, -1); for (int s = 1; s < W + G + 1; ++s) { - llama_memory_seq_cp(ctx, 0, s, -1, -1); + llama_kv_cache_seq_cp(ctx, 0, s, -1, -1); } } } diff --git a/examples/lookup/lookup.cpp b/examples/lookup/lookup.cpp index ddc74d64..00bf077c 100644 --- a/examples/lookup/lookup.cpp +++ b/examples/lookup/lookup.cpp @@ -194,7 +194,7 @@ int main(int argc, char ** argv){ // KV cache management // clean the cache of draft tokens that weren't accepted - llama_memory_seq_rm(ctx, 0, n_past, -1); + llama_kv_cache_seq_rm(ctx, 0, n_past, -1); common_batch_clear(batch_tgt); common_batch_add(batch_tgt, draft[0], n_past, { 0 }, true); diff --git a/examples/main/main.cpp b/examples/main/main.cpp index 18136225..6797eef5 100644 --- a/examples/main/main.cpp +++ b/examples/main/main.cpp @@ -366,7 +366,7 @@ int main(int argc, char ** argv) { } // remove any "future" tokens that we might have inherited from the previous session - llama_memory_seq_rm(ctx, -1, n_matching_session_tokens, -1); + llama_kv_cache_seq_rm(ctx, -1, n_matching_session_tokens, -1); } LOGLN( @@ -608,8 +608,8 @@ int main(int argc, char ** argv) { LOG("context full, swapping: n_past = %d, n_left = %d, n_ctx = %d, n_keep = %d, n_discard = %d\n", n_past, n_left, n_ctx, params.n_keep, n_discard); - llama_memory_seq_rm (ctx, 0, params.n_keep , params.n_keep + n_discard); - llama_memory_seq_add(ctx, 0, params.n_keep + n_discard, n_past, -n_discard); + llama_kv_cache_seq_rm (ctx, 0, params.n_keep , params.n_keep + n_discard); + llama_kv_cache_seq_add(ctx, 0, params.n_keep + n_discard, n_past, -n_discard); n_past -= n_discard; @@ -636,9 +636,9 @@ int main(int argc, char ** argv) { LOG("div: [%6d, %6d] / %6d -> [%6d, %6d]\n", ga_i + ib*bd, ga_i + ib*bd + ga_w, ga_n, (ga_i + ib*bd)/ga_n, (ga_i + ib*bd + ga_w)/ga_n); LOG("shift: [%6d, %6d] + %6d -> [%6d, %6d]\n", ga_i + ib*bd + ga_w, n_past + ib*bd, dd, ga_i + ib*bd + ga_w + dd, n_past + ib*bd + dd); - llama_memory_seq_add(ctx, 0, ga_i, n_past, ib*bd); - llama_memory_seq_div(ctx, 0, ga_i + ib*bd, ga_i + ib*bd + ga_w, ga_n); - llama_memory_seq_add(ctx, 0, ga_i + ib*bd + ga_w, n_past + ib*bd, dd); + llama_kv_cache_seq_add(ctx, 0, ga_i, n_past, ib*bd); + llama_kv_cache_seq_div(ctx, 0, ga_i + ib*bd, ga_i + ib*bd + ga_w, ga_n); + llama_kv_cache_seq_add(ctx, 0, ga_i + ib*bd + ga_w, n_past + ib*bd, dd); n_past -= bd; diff --git a/examples/mtmd/mtmd-cli.cpp b/examples/mtmd/mtmd-cli.cpp index 8361ac7a..c7a830cd 100644 --- a/examples/mtmd/mtmd-cli.cpp +++ b/examples/mtmd/mtmd-cli.cpp @@ -383,8 +383,8 @@ int main(int argc, char ** argv) { } if (line == "/clear") { ctx.n_past = 0; - llama_memory_seq_rm(ctx.lctx, 0, 1, -1); - //llama_memory_seq_rm(llama_get_memory(ctx.lctx), 0, 1, -1); // keep BOS + llama_kv_cache_seq_rm(ctx.lctx, 0, 1, -1); + //llama_kv_cache_seq_rm(llama_get_memory(ctx.lctx), 0, 1, -1); // keep BOS LOG_TEE("Chat history cleared\n\n"); continue; } diff --git a/examples/parallel/parallel.cpp b/examples/parallel/parallel.cpp index 39b678c0..b96b3081 100644 --- a/examples/parallel/parallel.cpp +++ b/examples/parallel/parallel.cpp @@ -200,7 +200,7 @@ int main(int argc, char ** argv) { // assign the system KV cache to all parallel sequences for (int32_t i = 1; i <= n_clients; ++i) { - llama_memory_seq_cp(ctx, 0, i, -1, -1); + llama_kv_cache_seq_cp(ctx, 0, i, -1, -1); } LOG_TEE("\n"); @@ -232,9 +232,9 @@ int main(int argc, char ** argv) { if (batch.n_tokens == 0) { // all sequences have ended - clear the entire KV cache for (int i = 1; i <= n_clients; ++i) { - llama_memory_seq_rm(ctx, i, -1, -1); + llama_kv_cache_seq_rm(ctx, i, -1, -1); // but keep the system prompt - llama_memory_seq_cp(ctx, 0, i, -1, -1); + llama_kv_cache_seq_cp(ctx, 0, i, -1, -1); } LOG_TEE("%s: clearing the KV cache\n", __func__); @@ -371,8 +371,8 @@ int main(int argc, char ** argv) { } // delete only the generated part of the sequence, i.e. keep the system prompt in the cache - llama_memory_seq_rm(ctx, client.id + 1, -1, -1); - llama_memory_seq_cp(ctx, 0, client.id + 1, -1, -1); + llama_kv_cache_seq_rm(ctx, client.id + 1, -1, -1); + llama_kv_cache_seq_cp(ctx, 0, client.id + 1, -1, -1); const auto t_main_end = ggml_time_us(); diff --git a/examples/passkey/passkey.cpp b/examples/passkey/passkey.cpp index d001a362..c53c3e48 100644 --- a/examples/passkey/passkey.cpp +++ b/examples/passkey/passkey.cpp @@ -126,8 +126,8 @@ int main(int argc, char ** argv) { const int ib = i/n_batch - 1; const int bd = n_batch_grp*(n_grp - 1); - llama_memory_seq_add (ctx, 0, n_past - n_batch, n_past, ib*bd); - llama_memory_seq_div (ctx, 0, n_past - n_batch + ib*bd, n_past + ib*bd, n_grp); + llama_kv_cache_seq_add (ctx, 0, n_past - n_batch, n_past, ib*bd); + llama_kv_cache_seq_div (ctx, 0, n_past - n_batch + ib*bd, n_past + ib*bd, n_grp); llama_kv_cache_update (ctx); n_past = llama_kv_cache_seq_pos_max(ctx, 0) + 1; @@ -160,8 +160,8 @@ int main(int argc, char ** argv) { LOG_TEE("%s: shifting KV cache with %d\n", __func__, n_discard); - llama_memory_seq_rm (ctx, 0, n_keep , n_keep + n_discard); - llama_memory_seq_add(ctx, 0, n_keep + n_discard, n_ctx, -n_discard); + llama_kv_cache_seq_rm (ctx, 0, n_keep , n_keep + n_discard); + llama_kv_cache_seq_add(ctx, 0, n_keep + n_discard, n_ctx, -n_discard); //llama_kv_cache_defrag (ctx); llama_kv_cache_update (ctx); @@ -191,8 +191,8 @@ int main(int argc, char ** argv) { if (n_discard > 0) { LOG_TEE("%s: shifting KV cache with %d to free space for the answer\n", __func__, n_discard); - llama_memory_seq_rm (ctx, 0, n_keep , n_keep + n_discard); - llama_memory_seq_add(ctx, 0, n_keep + n_discard, n_ctx, -n_discard); + llama_kv_cache_seq_rm (ctx, 0, n_keep , n_keep + n_discard); + llama_kv_cache_seq_add(ctx, 0, n_keep + n_discard, n_ctx, -n_discard); //llama_kv_cache_defrag (ctx); llama_kv_cache_update (ctx); diff --git a/examples/server/server-context.cpp b/examples/server/server-context.cpp index 7f827e95..a3b781c8 100644 --- a/examples/server/server-context.cpp +++ b/examples/server/server-context.cpp @@ -1173,7 +1173,7 @@ void server_context::system_prompt_update() { // assign the system KV cache to all parallel sequences for (int32_t i = 1; i <= params_base.n_parallel; ++i) { - llama_memory_seq_cp(ctx, 0, i, -1, -1); + llama_kv_cache_seq_cp(ctx, 0, i, -1, -1); } } @@ -1935,7 +1935,7 @@ void server_context::process_single_task(server_task&& task) { // Erase token cache const size_t n_erased = slot->cache_tokens.size(); - llama_memory_seq_rm(ctx, slot->id + 1, -1, -1); + llama_kv_cache_seq_rm(ctx, slot->id + 1, -1, -1); slot->cache_tokens.clear(); server_task_result result; @@ -1992,8 +1992,8 @@ void server_context::print_tokens(const server_tokens& prompt, const server_toke } void server_context::discard_n_kv_and_cache_tokens(llama_context* ctx, server_slot& slot, int32_t n_keep, int32_t n_discard) { - llama_memory_seq_rm(ctx, slot.id, n_keep, n_keep + n_discard); - llama_memory_seq_add(ctx, slot.id, n_keep + n_discard, system_tokens.size() + slot.n_past, -n_discard); + llama_kv_cache_seq_rm(ctx, slot.id, n_keep, n_keep + n_discard); + llama_kv_cache_seq_add(ctx, slot.id, n_keep + n_discard, system_tokens.size() + slot.n_past, -n_discard); if (slot.params.cache_prompt) { slot.cache_tokens.discard_n_tokens(n_keep, n_discard); } @@ -2426,14 +2426,14 @@ void server_context::batch_pending_prompt(const int32_t n_ubatch, const int32_t slot.cache_tokens.keep_first(slot.n_past); int p0 = (int)system_tokens.size() + slot.n_past; p0 = system_tokens.size() + slot.cache_tokens.pos_next(); - if (!llama_memory_seq_rm(ctx, slot.id, p0, -1)) { + if (!llama_kv_cache_seq_rm(ctx, slot.id, p0, -1)) { // could not partially delete (likely using a non-Transformer model) - llama_memory_seq_rm(ctx, slot.id, -1, -1); + llama_kv_cache_seq_rm(ctx, slot.id, -1, -1); p0 = (int)system_tokens.size(); if (p0 != 0) { // copy over the system prompt when there is one - llama_memory_seq_cp(ctx, 0, slot.id, -1, -1); + llama_kv_cache_seq_cp(ctx, 0, slot.id, -1, -1); } // there is no common part left (except for the system prompt) @@ -2571,9 +2571,9 @@ void server_context::extend_context(const int32_t n_tokens) { LOG_TEE("div: [%6d, %6d] / %6d -> [%6d, %6d]\n", slot.ga_i + ib * bd, slot.ga_i + ib * bd + slot.ga_w, slot.ga_n, (slot.ga_i + ib * bd) / slot.ga_n, (slot.ga_i + ib * bd + slot.ga_w) / slot.ga_n); LOG_TEE("shift: [%6d, %6d] + %6d -> [%6d, %6d]\n", slot.ga_i + ib * bd + slot.ga_w, slot.n_past_se + ib * bd, dd, slot.ga_i + ib * bd + slot.ga_w + dd, slot.n_past_se + ib * bd + dd); - llama_memory_seq_add(ctx, slot.id, slot.ga_i, slot.n_past_se, ib * bd); - llama_memory_seq_div(ctx, slot.id, slot.ga_i + ib * bd, slot.ga_i + ib * bd + slot.ga_w, slot.ga_n); - llama_memory_seq_add(ctx, slot.id, slot.ga_i + ib * bd + slot.ga_w, slot.n_past_se + ib * bd, dd); + llama_kv_cache_seq_add(ctx, slot.id, slot.ga_i, slot.n_past_se, ib * bd); + llama_kv_cache_seq_div(ctx, slot.id, slot.ga_i + ib * bd, slot.ga_i + ib * bd + slot.ga_w, slot.ga_n); + llama_kv_cache_seq_add(ctx, slot.id, slot.ga_i + ib * bd + slot.ga_w, slot.n_past_se + ib * bd, dd); slot.n_past_se -= bd; @@ -2614,7 +2614,7 @@ void server_context::speculative_decoding_accept() { slot.cache_tokens.insert({ ids.begin(), ids.end() - 1 }); slot.sampled = ids.back(); // last accepted token slot.n_past = slot.cache_tokens.n_tokens(); - llama_memory_seq_rm(ctx, slot.id, slot.n_past, -1); + llama_kv_cache_seq_rm(ctx, slot.id, slot.n_past, -1); for (size_t i = 0; i < ids.size(); ++i) { completion_token_output result; diff --git a/examples/speculative/speculative.cpp b/examples/speculative/speculative.cpp index 45c6267a..8fb1c7d3 100644 --- a/examples/speculative/speculative.cpp +++ b/examples/speculative/speculative.cpp @@ -400,12 +400,12 @@ int main(int argc, char ** argv) { LOG("keeping sequence %d, n_past_tgt = %d, n_past_dft = %d\n", s_keep, n_past_tgt, n_past_dft); llama_kv_cache_seq_keep(ctx_dft, s_keep); - llama_memory_seq_cp (ctx_dft, s_keep, 0, -1, -1); + llama_kv_cache_seq_cp (ctx_dft, s_keep, 0, -1, -1); llama_kv_cache_seq_keep(ctx_dft, 0); - llama_memory_seq_rm (ctx_tgt, s_keep, n_past_tgt, -1); + llama_kv_cache_seq_rm (ctx_tgt, s_keep, n_past_tgt, -1); llama_kv_cache_seq_keep(ctx_tgt, s_keep); - llama_memory_seq_cp (ctx_tgt, s_keep, 0, -1, -1); + llama_kv_cache_seq_cp (ctx_tgt, s_keep, 0, -1, -1); llama_kv_cache_seq_keep(ctx_tgt, 0); } @@ -423,7 +423,7 @@ int main(int argc, char ** argv) { common_batch_clear(batch_dft); common_batch_add (batch_dft, token_id, n_past_dft, { 0 }, true); - llama_memory_seq_rm(ctx_dft, 0, n_past_dft, -1); + llama_kv_cache_seq_rm(ctx_dft, 0, n_past_dft, -1); // LOG("dft batch: %s\n", LOG_BATCH_TOSTR_PRETTY(ctx_dft, batch_dft).c_str()); llama_decode(ctx_dft, batch_dft); @@ -479,8 +479,8 @@ int main(int argc, char ** argv) { if (n_seq_cur < n_seq_dft && cur_p[f].p > p_split) { LOG("splitting seq %3d into %3d\n", s, n_seq_cur); - llama_memory_seq_rm(ctx_dft, n_seq_cur, -1, -1); - llama_memory_seq_cp(ctx_dft, s, n_seq_cur, -1, -1); + llama_kv_cache_seq_rm(ctx_dft, n_seq_cur, -1, -1); + llama_kv_cache_seq_cp(ctx_dft, s, n_seq_cur, -1, -1); // all previous tokens from this branch are now also part of the new branch for (int t = 0; t < batch_tgt.n_tokens; ++t) { @@ -560,7 +560,7 @@ int main(int argc, char ** argv) { { llama_kv_cache_seq_keep(ctx_tgt, 0); for (int s = 1; s < n_seq_dft; ++s) { - llama_memory_seq_cp(ctx_tgt, 0, s, -1, -1); + llama_kv_cache_seq_cp(ctx_tgt, 0, s, -1, -1); } // LOG("target batch: %s\n", LOG_BATCH_TOSTR_PRETTY(ctx_tgt, batch_tgt).c_str()); diff --git a/examples/sweep-bench/sweep-bench.cpp b/examples/sweep-bench/sweep-bench.cpp index 6f1ef121..60b2f265 100644 --- a/examples/sweep-bench/sweep-bench.cpp +++ b/examples/sweep-bench/sweep-bench.cpp @@ -117,7 +117,7 @@ int main(int argc, char ** argv) { } if (params.batch_warmup) { // clean up KV cache after generation - llama_memory_seq_rm(ctx, 0, params.n_ubatch, -1); + llama_kv_cache_seq_rm(ctx, 0, params.n_ubatch, -1); // prepare batch of pp size for prompt processing performance measurement common_batch_clear(batch); @@ -137,7 +137,7 @@ int main(int argc, char ** argv) { for (unsigned int n_kv = 0; n_kv < n_kv_max; n_kv += params.n_ubatch) { // clean up KV cache before generation - llama_memory_seq_rm(ctx, 0, n_kv, -1); + llama_kv_cache_seq_rm(ctx, 0, n_kv, -1); // first measure token generation performance at this context size const auto t_tg_start = ggml_time_us(); @@ -155,7 +155,7 @@ int main(int argc, char ** argv) { const auto t_tg_end = ggml_time_us(); // clean up KV cache after generation - llama_memory_seq_rm(ctx, 0, n_kv, -1); + llama_kv_cache_seq_rm(ctx, 0, n_kv, -1); // prepare batch of pp size for prompt processing performance measurement common_batch_clear(batch); diff --git a/include/llama.h b/include/llama.h index 2a3340c8..801f097f 100644 --- a/include/llama.h +++ b/include/llama.h @@ -771,7 +771,7 @@ extern "C" { // seq_id < 0 : match any sequence // p0 < 0 : [0, p1] // p1 < 0 : [p0, inf) - LLAMA_API bool llama_memory_seq_rm( + LLAMA_API bool llama_kv_cache_seq_rm( struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, @@ -781,7 +781,7 @@ extern "C" { // Note that this does not allocate extra KV cache memory - it simply assigns the tokens to the new sequence // p0 < 0 : [0, p1] // p1 < 0 : [p0, inf) - LLAMA_API void llama_memory_seq_cp( + LLAMA_API void llama_kv_cache_seq_cp( struct llama_context * ctx, llama_seq_id seq_id_src, llama_seq_id seq_id_dst, @@ -799,7 +799,7 @@ extern "C" { // - explicitly with llama_kv_cache_update() // p0 < 0 : [0, p1] // p1 < 0 : [p0, inf) - LLAMA_API void llama_memory_seq_add( + LLAMA_API void llama_kv_cache_seq_add( struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, @@ -812,7 +812,7 @@ extern "C" { // - explicitly with llama_kv_cache_update() // p0 < 0 : [0, p1] // p1 < 0 : [p0, inf) - LLAMA_API void llama_memory_seq_div( + LLAMA_API void llama_kv_cache_seq_div( struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, diff --git a/src/llama.cpp b/src/llama.cpp index 3c0b67f6..f042a751 100644 --- a/src/llama.cpp +++ b/src/llama.cpp @@ -5389,11 +5389,11 @@ void llama_memory_clear(struct llama_context * ctx) { llama_kv_cache_clear(ctx->kv_self); } -bool llama_memory_seq_rm(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1) { +bool llama_kv_cache_seq_rm(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1) { return llama_kv_cache_seq_rm(ctx->kv_self, seq_id, p0, p1); } -void llama_memory_seq_cp(struct llama_context * ctx, llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) { +void llama_kv_cache_seq_cp(struct llama_context * ctx, llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) { if (seq_id_src == seq_id_dst) { return; } @@ -5404,7 +5404,7 @@ void llama_kv_cache_seq_keep(struct llama_context * ctx, llama_seq_id seq_id) { llama_kv_cache_seq_keep(ctx->kv_self, seq_id); } -void llama_memory_seq_add(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos delta) { +void llama_kv_cache_seq_add(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos delta) { if (delta == 0) { return; } @@ -5412,7 +5412,7 @@ void llama_memory_seq_add(struct llama_context * ctx, llama_seq_id seq_id, llama llama_kv_cache_seq_add(ctx->kv_self, seq_id, p0, p1, delta); } -void llama_memory_seq_div(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) { +void llama_kv_cache_seq_div(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) { if (d == 1) { return; } @@ -6041,7 +6041,7 @@ struct llama_data_read { if (seq_id == -1) { llama_memory_clear(ctx); } else { - llama_memory_seq_rm(ctx, seq_id, -1, -1); + llama_kv_cache_seq_rm(ctx, seq_id, -1, -1); } throw std::runtime_error("failed to restore kv cache"); }