Mirrors/llama.cpp
1
0
Fork 0
mirror of https://github.com/ggerganov/llama.cpp.git synced 2025-01-01 00:39:00 +01:00
Code Issues Packages Projects Releases Wiki Activity

llama : rename llama_cache to llama_past

Browse Source 
This can be changed back later if the name change is wrong.
I was renaming the functions anyway to generalize kv-cache-related
functions to hybrid and recurrent model architectures.
I think llama_past is a better name than llama_cache for a combined
kv cache and recurrent state cache, because the states it contains
pretty much always come before the newly-added ones for any particular
sequence. Also 'llama_past_clear' sounds more obvious in what it does
than 'llama_kv_cache_clear'. The future is what the models generate.
(For embeddings, the kv cache isn't really used anyway)

Still, I'm open to better suggestions.
This commit is contained in:
Francis Couture-Harpin 2024-06-08 17:58:40 -04:00
parent 6840ac0bca
commit 372482dffe
1 changed files with 52 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
llama.cpp
View File

@ -2877,7 +2877,7 @@ struct llama_rs_cache {
} }
}; };
struct llama_cache { struct llama_past {
// key + value cache for self attention // key + value cache for self attention
llama_kv_cache kv; llama_kv_cache kv;
@ -2896,7 +2896,7 @@ struct llama_cache {
return size; return size;
} }
~llama_cache() { ~llama_past() {
for (struct ggml_context * ctx : ctxs) { for (struct ggml_context * ctx : ctxs) {
ggml_free(ctx); ggml_free(ctx);
} }
@ -3426,7 +3426,7 @@ struct llama_context {
const llama_model & model; const llama_model & model;
// key + value cache for self-attention, and/or recurrent state cache // key + value cache for self-attention, and/or recurrent state cache
struct llama_cache cache; struct llama_past cache;
// sequence-length-aware batch splitting // sequence-length-aware batch splitting
llama_sbatch sbatch; llama_sbatch sbatch;
@ -3604,8 +3604,8 @@ static size_t llama_get_device_memory(const llama_model & model, int device) {
// kv and rs cache helpers // kv and rs cache helpers
// //
static bool llama_cache_init( static bool llama_past_init(
struct llama_cache & cache, struct llama_past & cache,
const llama_context * ctx, const llama_context * ctx,
ggml_type type_k, ggml_type type_k,
ggml_type type_v, ggml_type type_v,
@ -3713,11 +3713,11 @@ static bool llama_cache_init(
// no buffer was needed, so this is fine // no buffer was needed, so this is fine
return true; return true;
} }
LLAMA_LOG_ERROR("%s: failed to allocate buffer for kv cache\n", __func__); LLAMA_LOG_ERROR("%s: failed to allocate buffer for past cache\n", __func__);
return false; return false;
} }
ggml_backend_buffer_clear(buf, 0); ggml_backend_buffer_clear(buf, 0);
LLAMA_LOG_INFO("%s: %10s cache buf size = %8.2f MiB\n", __func__, ggml_backend_buffer_name(buf), ggml_backend_buffer_get_size(buf)/1024.0/1024.0); LLAMA_LOG_INFO("%s: %10s past cache size = %8.2f MiB\n", __func__, ggml_backend_buffer_name(buf), ggml_backend_buffer_get_size(buf)/1024.0/1024.0);
cache.bufs.push_back(buf); cache.bufs.push_back(buf);
} }
@ -3728,8 +3728,8 @@ static bool llama_cache_init(
// updates the cache head // updates the cache head
// Note: On success, it's important that cache.head points // Note: On success, it's important that cache.head points
// to the first cell of the slot. // to the first cell of the slot.
static bool llama_cache_find_slot( static bool llama_past_find_slot(
struct llama_cache & cache, struct llama_past & cache,
const struct llama_ubatch & batch) { const struct llama_ubatch & batch) {
const uint32_t kv_size = cache.kv.size; const uint32_t kv_size = cache.kv.size;
const uint32_t rs_size = cache.rs.size; const uint32_t rs_size = cache.rs.size;
@ -4001,7 +4001,7 @@ static uint32_t llama_rs_cache_cell_max(const struct llama_rs_cache & cache) {
return 0; return 0;
} }
static void llama_cache_clear(struct llama_cache & cache) { static void llama_past_clear(struct llama_past & cache) {
if (cache.kv.size > 0) { if (cache.kv.size > 0) {
for (uint32_t i = 0; i < cache.kv.size; ++i) { for (uint32_t i = 0; i < cache.kv.size; ++i) {
llama_kv_cell & kv_cell = cache.kv.cells[i]; llama_kv_cell & kv_cell = cache.kv.cells[i];
@ -4035,8 +4035,8 @@ static void llama_cache_clear(struct llama_cache & cache) {
} }
} }
static llama_pos llama_cache_seq_rm( static llama_pos llama_past_seq_rm(
struct llama_cache & cache, struct llama_past & cache,
llama_seq_id seq_id, llama_seq_id seq_id,
llama_pos p0, llama_pos p0,
llama_pos p1) { llama_pos p1) {
@ -4134,8 +4134,8 @@ static llama_pos llama_cache_seq_rm(
return n_past; return n_past;
} }
static llama_pos llama_cache_seq_cp( static llama_pos llama_past_seq_cp(
struct llama_cache & cache, struct llama_past & cache,
llama_seq_id seq_id_src, llama_seq_id seq_id_src,
llama_seq_id seq_id_dst, llama_seq_id seq_id_dst,
llama_pos p0, llama_pos p0,
@ -4199,7 +4199,7 @@ static llama_pos llama_cache_seq_cp(
return n_past; return n_past;
} }
static void llama_cache_seq_keep(struct llama_cache & cache, llama_seq_id seq_id) { static void llama_past_seq_keep(struct llama_past & cache, llama_seq_id seq_id) {
if (cache.rs.size > 0) { if (cache.rs.size > 0) {
uint32_t new_head = cache.rs.size; uint32_t new_head = cache.rs.size;
@ -4249,8 +4249,8 @@ static void llama_cache_seq_keep(struct llama_cache & cache, llama_seq_id seq_id
} }
} }
static void llama_cache_seq_add( static void llama_past_seq_add(
struct llama_cache & cache, struct llama_past & cache,
llama_seq_id seq_id, llama_seq_id seq_id,
llama_pos p0, llama_pos p0,
llama_pos p1, llama_pos p1,
@ -4317,8 +4317,8 @@ static void llama_cache_seq_add(
} }
} }
static void llama_cache_seq_div( static void llama_past_seq_div(
struct llama_cache & cache, struct llama_past & cache,
llama_seq_id seq_id, llama_seq_id seq_id,
llama_pos p0, llama_pos p0,
llama_pos p1, llama_pos p1,
@ -4358,7 +4358,7 @@ static void llama_cache_seq_div(
} }
} }
static llama_pos llama_cache_seq_pos_max(struct llama_cache & cache, llama_seq_id seq_id) { static llama_pos llama_past_seq_pos_max(struct llama_past & cache, llama_seq_id seq_id) {
llama_pos result = -1; llama_pos result = -1;
if (cache.rs.size > 0) { if (cache.rs.size > 0) {
@ -13911,7 +13911,7 @@ static int llama_decode_internal(
if (hparams.causal_attn) { if (hparams.causal_attn) {
llama_kv_cache_update(&lctx); llama_kv_cache_update(&lctx);
if (!llama_cache_find_slot(lctx.cache, u_batch)) { if (!llama_past_find_slot(lctx.cache, u_batch)) {
return 1; return 1;
} }
@ -17981,7 +17981,7 @@ struct llama_context * llama_new_context_with_model(
} }
ctx->backends.push_back(ctx->backend_cpu); ctx->backends.push_back(ctx->backend_cpu);
if (!llama_cache_init(ctx->cache, ctx, type_k, type_v, cparams.offload_kqv)) { if (!llama_past_init(ctx->cache, ctx, type_k, type_v, cparams.offload_kqv)) {
LLAMA_LOG_ERROR("%s: llama_kv_cache_init() failed for self-attention cache\n", __func__); LLAMA_LOG_ERROR("%s: llama_kv_cache_init() failed for self-attention cache\n", __func__);
llama_free(ctx); llama_free(ctx);
return nullptr; return nullptr;
@ -18515,85 +18515,85 @@ int32_t llama_get_rs_cache_used_cells(const struct llama_context * ctx) {
return ctx->cache.rs.used; return ctx->cache.rs.used;
} }
void llama_cache_clear(struct llama_context * ctx) { void llama_past_clear(struct llama_context * ctx) {
llama_cache_clear(ctx->cache); llama_past_clear(ctx->cache);
} }
// deprecated // deprecated
void llama_kv_cache_clear(struct llama_context * ctx) { void llama_kv_cache_clear(struct llama_context * ctx) {
llama_cache_clear(ctx); llama_past_clear(ctx);
} }
llama_pos llama_cache_seq_rm(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1) { llama_pos llama_past_seq_rm(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1) {
if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return 0; } if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return 0; }
return llama_cache_seq_rm(ctx->cache, seq_id, p0, p1); return llama_past_seq_rm(ctx->cache, seq_id, p0, p1);
} }
// deprecated // deprecated
bool llama_kv_cache_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) {
llama_pos n_past = llama_cache_seq_rm(ctx, seq_id, p0, p1); llama_pos n_past = llama_past_seq_rm(ctx, seq_id, p0, p1);
return n_past >= p0; return n_past >= p0;
} }
llama_pos llama_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) { llama_pos llama_past_seq_cp(struct llama_context * ctx, llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) {
uint32_t n_seq_max = llama_n_seq_max(ctx); uint32_t n_seq_max = llama_n_seq_max(ctx);
if (seq_id_src < 0 || seq_id_dst < 0 || (uint32_t) seq_id_src >= n_seq_max || (uint32_t) seq_id_dst >= n_seq_max) { if (seq_id_src < 0 || seq_id_dst < 0 || (uint32_t) seq_id_src >= n_seq_max || (uint32_t) seq_id_dst >= n_seq_max) {
return 0; return 0;
} }
if (seq_id_src == seq_id_dst) { if (seq_id_src == seq_id_dst) {
return llama_cache_seq_pos_max(ctx->cache, seq_id_dst) + 1; return llama_past_seq_pos_max(ctx->cache, seq_id_dst) + 1;
} }
return llama_cache_seq_cp(ctx->cache, seq_id_src, seq_id_dst, p0, p1); return llama_past_seq_cp(ctx->cache, seq_id_src, seq_id_dst, p0, p1);
} }
// deprecated // deprecated
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) { 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) {
llama_cache_seq_cp(ctx, seq_id_src, seq_id_dst, p0, p1); llama_past_seq_cp(ctx, seq_id_src, seq_id_dst, p0, p1);
} }
void llama_cache_seq_keep(struct llama_context * ctx, llama_seq_id seq_id) { void llama_past_seq_keep(struct llama_context * ctx, llama_seq_id seq_id) {
if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return; } if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return; }
llama_cache_seq_keep(ctx->cache, seq_id); llama_past_seq_keep(ctx->cache, seq_id);
} }
// deprecated // deprecated
void llama_kv_cache_seq_keep(struct llama_context * ctx, llama_seq_id seq_id) { void llama_kv_cache_seq_keep(struct llama_context * ctx, llama_seq_id seq_id) {
llama_cache_seq_keep(ctx, seq_id); llama_past_seq_keep(ctx, seq_id);
} }
void llama_cache_seq_add(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos delta) { void llama_past_seq_add(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos delta) {
if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return; } if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return; }
if (delta == 0) { return; } if (delta == 0) { return; }
llama_cache_seq_add(ctx->cache, seq_id, p0, p1, delta); llama_past_seq_add(ctx->cache, seq_id, p0, p1, delta);
} }
// deprecated // deprecated
void llama_kv_cache_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) {
llama_cache_seq_add(ctx, seq_id, p0, p1, delta); llama_past_seq_add(ctx, seq_id, p0, p1, delta);
} }
void llama_cache_seq_div(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) { void llama_past_seq_div(struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) {
if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return; } if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return; }
if (d == 1) { return; } if (d == 1) { return; }
llama_cache_seq_div(ctx->cache, seq_id, p0, p1, d); llama_past_seq_div(ctx->cache, seq_id, p0, p1, d);
} }
// deprecated // deprecated
void llama_kv_cache_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) {
llama_cache_seq_div(ctx, seq_id, p0, p1, d); llama_past_seq_div(ctx, seq_id, p0, p1, d);
} }
llama_pos llama_cache_seq_pos_max(struct llama_context * ctx, llama_seq_id seq_id) { llama_pos llama_past_seq_pos_max(struct llama_context * ctx, llama_seq_id seq_id) {
if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return -1; } if (seq_id < 0 || (uint32_t) seq_id >= llama_n_seq_max(ctx)) { return -1; }
return llama_cache_seq_pos_max(ctx->cache, seq_id); return llama_past_seq_pos_max(ctx->cache, seq_id);
} }
// deprecated // deprecated
llama_pos llama_kv_cache_seq_pos_max(struct llama_context * ctx, llama_seq_id seq_id) { llama_pos llama_kv_cache_seq_pos_max(struct llama_context * ctx, llama_seq_id seq_id) {
llama_pos max_pos = llama_cache_seq_pos_max(ctx, seq_id); llama_pos max_pos = llama_past_seq_pos_max(ctx, seq_id);
return max_pos < 0 ? 0 : max_pos; return max_pos < 0 ? 0 : max_pos;
} }
@ -19345,7 +19345,7 @@ size_t llama_state_seq_set_data(struct llama_context * ctx, const uint8_t * src,
GGML_ASSERT(cache.rs.size == 0); // not implemented GGML_ASSERT(cache.rs.size == 0); // not implemented
// Wipe the slot // Wipe the slot
llama_cache_seq_rm(cache, dest_seq_id, -1, -1); llama_past_seq_rm(cache, dest_seq_id, -1, -1);
const uint8_t * inp = src; const uint8_t * inp = src;
@ -19402,7 +19402,7 @@ size_t llama_state_seq_set_data(struct llama_context * ctx, const uint8_t * src,
} }
batch.n_seq_id[0] = 1; batch.n_seq_id[0] = 1;
batch.seq_id[0] = &dest_seq_id; batch.seq_id[0] = &dest_seq_id;
if (!llama_cache_find_slot(cache, batch)) { if (!llama_past_find_slot(cache, batch)) {
LLAMA_LOG_ERROR("%s: failed to find available cells in kv cache\n", __func__); LLAMA_LOG_ERROR("%s: failed to find available cells in kv cache\n", __func__);
return 0; return 0;
} }
@ -19427,7 +19427,7 @@ size_t llama_state_seq_set_data(struct llama_context * ctx, const uint8_t * src,
inp += sizeof(k_type_i_ref); inp += sizeof(k_type_i_ref);
const int32_t k_type_i = (int32_t)kv_self.k_l[il]->type; const int32_t k_type_i = (int32_t)kv_self.k_l[il]->type;
if (k_type_i != k_type_i_ref) { if (k_type_i != k_type_i_ref) {
llama_cache_seq_rm(cache, dest_seq_id, -1, -1); llama_past_seq_rm(cache, dest_seq_id, -1, -1);
LLAMA_LOG_ERROR("%s: mismatched key type (%d != %d, layer %d)\n", __func__, k_type_i, k_type_i_ref, il); LLAMA_LOG_ERROR("%s: mismatched key type (%d != %d, layer %d)\n", __func__, k_type_i, k_type_i_ref, il);
return 0; return 0;
} }
@ -19438,7 +19438,7 @@ size_t llama_state_seq_set_data(struct llama_context * ctx, const uint8_t * src,
inp += sizeof(k_size_row_ref); inp += sizeof(k_size_row_ref);
const size_t k_size_row = ggml_row_size(kv_self.k_l[il]->type, n_embd_k_gqa); const size_t k_size_row = ggml_row_size(kv_self.k_l[il]->type, n_embd_k_gqa);
if (k_size_row != k_size_row_ref) { if (k_size_row != k_size_row_ref) {
llama_cache_seq_rm(cache, dest_seq_id, -1, -1); llama_past_seq_rm(cache, dest_seq_id, -1, -1);
LLAMA_LOG_ERROR("%s: mismatched key row size (%zu != %zu, layer %d)\n", __func__, k_size_row, k_size_row_ref, il); LLAMA_LOG_ERROR("%s: mismatched key row size (%zu != %zu, layer %d)\n", __func__, k_size_row, k_size_row_ref, il);
return 0; return 0;
} }
@ -19459,7 +19459,7 @@ size_t llama_state_seq_set_data(struct llama_context * ctx, const uint8_t * src,
inp += sizeof(v_type_i_ref); inp += sizeof(v_type_i_ref);
const int32_t v_type_i = (int32_t)kv_self.v_l[il]->type; const int32_t v_type_i = (int32_t)kv_self.v_l[il]->type;
if (v_type_i != v_type_i_ref) { if (v_type_i != v_type_i_ref) {
llama_cache_seq_rm(cache, dest_seq_id, -1, -1); llama_past_seq_rm(cache, dest_seq_id, -1, -1);
LLAMA_LOG_ERROR("%s: mismatched value type (%d != %d, layer %d)\n", __func__, v_type_i, v_type_i_ref, il); LLAMA_LOG_ERROR("%s: mismatched value type (%d != %d, layer %d)\n", __func__, v_type_i, v_type_i_ref, il);
return 0; return 0;
} }
@ -19470,7 +19470,7 @@ size_t llama_state_seq_set_data(struct llama_context * ctx, const uint8_t * src,
inp += sizeof(v_size_row_ref); inp += sizeof(v_size_row_ref);
const size_t v_size_row = ggml_row_size(kv_self.v_l[il]->type, n_embd_v_gqa); const size_t v_size_row = ggml_row_size(kv_self.v_l[il]->type, n_embd_v_gqa);
if (v_size_row != v_size_row_ref) { if (v_size_row != v_size_row_ref) {
llama_cache_seq_rm(cache, dest_seq_id, -1, -1); llama_past_seq_rm(cache, dest_seq_id, -1, -1);
LLAMA_LOG_ERROR("%s: mismatched value row size (%zu != %zu, layer %d)\n", __func__, v_size_row, v_size_row_ref, il); LLAMA_LOG_ERROR("%s: mismatched value row size (%zu != %zu, layer %d)\n", __func__, v_size_row, v_size_row_ref, il);
return 0; return 0;
} }
@ -19490,7 +19490,7 @@ size_t llama_state_seq_set_data(struct llama_context * ctx, const uint8_t * src,
inp += sizeof(v_type_i_ref); inp += sizeof(v_type_i_ref);
const int32_t v_type_i = (int32_t)kv_self.v_l[il]->type; const int32_t v_type_i = (int32_t)kv_self.v_l[il]->type;
if (v_type_i != v_type_i_ref) { if (v_type_i != v_type_i_ref) {
llama_cache_seq_rm(cache, dest_seq_id, -1, -1); llama_past_seq_rm(cache, dest_seq_id, -1, -1);
LLAMA_LOG_ERROR("%s: mismatched value type (%d != %d, layer %d)\n", __func__, v_type_i, v_type_i_ref, il); LLAMA_LOG_ERROR("%s: mismatched value type (%d != %d, layer %d)\n", __func__, v_type_i, v_type_i_ref, il);
return 0; return 0;
} }
@ -19501,7 +19501,7 @@ size_t llama_state_seq_set_data(struct llama_context * ctx, const uint8_t * src,
inp += sizeof(v_size_el_ref); inp += sizeof(v_size_el_ref);
const size_t v_size_el = ggml_type_size(kv_self.v_l[il]->type); const size_t v_size_el = ggml_type_size(kv_self.v_l[il]->type);
if (v_size_el != v_size_el_ref) { if (v_size_el != v_size_el_ref) {
llama_cache_seq_rm(cache, dest_seq_id, -1, -1); llama_past_seq_rm(cache, dest_seq_id, -1, -1);
LLAMA_LOG_ERROR("%s: mismatched value element size (%zu != %zu, layer %d)\n", __func__, v_size_el, v_size_el_ref, il); LLAMA_LOG_ERROR("%s: mismatched value element size (%zu != %zu, layer %d)\n", __func__, v_size_el, v_size_el_ref, il);
return 0; return 0;
} }