From a337ebd7bdd90bab10a68b53b07a748b25014fd3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 11 Mar 2026 16:38:12 +0100 Subject: [PATCH 01/46] model : Initial support for DeepseekV32ForCausalLM (for now with dense attention). Needs manual change of add_bos_token to true in tokenizer_config.json before conversion. --- convert_hf_to_gguf.py | 139 ++++++++++++++++++++++ gguf-py/gguf/constants.py | 47 ++++++++ src/CMakeLists.txt | 1 + src/llama-arch.cpp | 39 +++++++ src/llama-arch.h | 1 + src/llama-model.cpp | 159 ++++++++++++++++++++++++- src/llama-model.h | 1 + src/models/deepseek32.cpp | 240 ++++++++++++++++++++++++++++++++++++++ src/models/models.h | 8 +- 9 files changed, 632 insertions(+), 3 deletions(-) create mode 100644 src/models/deepseek32.cpp diff --git a/convert_hf_to_gguf.py b/convert_hf_to_gguf.py index 30347f7389f..3fdeb277946 100755 --- a/convert_hf_to_gguf.py +++ b/convert_hf_to_gguf.py @@ -8153,6 +8153,145 @@ def prepare_tensors(self): raise ValueError(f"Unprocessed experts: {experts}") +@ModelBase.register( + "DeepseekV32ForCausalLM", +) +class DeepseekV32Model(TextModel): + model_arch = gguf.MODEL_ARCH.DEEPSEEK32 + + # TODO @ngxson : remove this when we support MTP for deepseek models + skip_mtp = True + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.block_count = self.hparams["num_hidden_layers"] + self.hparams.get("num_nextn_predict_layers", 0) + self.tensor_map = gguf.get_tensor_name_map(self.model_arch, self.block_count) + + def set_vocab(self): + self._set_vocab_gpt2() + + def set_gguf_parameters(self): + + # note: deepseek32 using MLA converts into MQA (ie: GQA with 1 group) + self.hparams["num_key_value_heads"] = 1 + + super().set_gguf_parameters() + hparams = self.hparams + + # first_k_dense_replace: number of leading layers using dense FFN instead of MoE + first_k_dense_replace = hparams.get("first_k_dense_replace") + self.gguf_writer.add_leading_dense_block_count(first_k_dense_replace) + self.gguf_writer.add_vocab_size(hparams["vocab_size"]) + self.gguf_writer.add_q_lora_rank(hparams["q_lora_rank"]) + self.gguf_writer.add_kv_lora_rank(hparams["kv_lora_rank"]) + + # note: deepseek32 using MLA converts into MQA with larger heads, then decompresses to MHA + self.gguf_writer.add_key_length(hparams["kv_lora_rank"] + hparams["qk_rope_head_dim"]) + self.gguf_writer.add_value_length(hparams["kv_lora_rank"]) + self.gguf_writer.add_key_length_mla(hparams["qk_nope_head_dim"] + hparams["qk_rope_head_dim"]) + self.gguf_writer.add_value_length_mla(hparams["v_head_dim"]) + + # MoE parameters (required by C++ code for DEEPSEEK32 arch) + self.gguf_writer.add_expert_feed_forward_length(hparams["moe_intermediate_size"]) + self.gguf_writer.add_expert_count(hparams["n_routed_experts"]) + self.gguf_writer.add_expert_shared_count(hparams["n_shared_experts"]) + self.gguf_writer.add_expert_weights_scale(self.hparams["routed_scaling_factor"]) + self.gguf_writer.add_expert_weights_norm(self.hparams["norm_topk_prob"]) + + self.gguf_writer.add_rope_dimension_count(hparams["qk_rope_head_dim"]) + + if (rope_mscale_all := self.rope_parameters.get("mscale_all_dim")) is not None: + # [TAG_DEEPSEEK2_YARN_LOG_MUL_FIX] + # note: for legacy reasons, this is not consistent with the other usages of self.gguf_writer.add_rope_scaling_yarn_log_mul + # ref https://github.com/ggml-org/llama.cpp/pull/17945 + self.gguf_writer.add_rope_scaling_yarn_log_mul(0.1 * rope_mscale_all) + + # NextN/MTP prediction layers + if (num_nextn_predict_layers := self.hparams.get("num_nextn_predict_layers")) is not None: + self.gguf_writer.add_nextn_predict_layers(num_nextn_predict_layers) + + # DSA indexer parameters + self.gguf_writer.add_indexer_head_count(self.hparams["index_n_heads"]) + self.gguf_writer.add_indexer_key_length(self.hparams["index_head_dim"]) + self.gguf_writer.add_indexer_top_k(self.hparams["index_topk"]) + + _experts: list[dict[str, Tensor]] | None = None + + def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None) -> Iterable[tuple[str, Tensor]]: + if name.startswith("language_model."): + name = name.replace("language_model.", "") + + # rename e_score_correction_bias tensors + if name.endswith("e_score_correction_bias"): + name = name.replace("e_score_correction_bias", "e_score_correction.bias") + + # skip Multi-Token Prediction (MTP) layers + if self.skip_mtp: + block_count = self.hparams["num_hidden_layers"] + match = re.match(r"model.layers.(\d+)", name) + if match and int(match.group(1)) >= block_count: + return + + # process the experts separately + if name.find("mlp.experts") != -1: + n_experts = self.hparams["n_routed_experts"] + assert bid is not None + + if self._experts is None: + self._experts = [{} for _ in range(self.block_count)] + + self._experts[bid][name] = data_torch + + if len(self._experts[bid]) >= n_experts * 3: + # merge the experts into a single 3d tensor + for w_name in ["down_proj", "gate_proj", "up_proj"]: + datas: list[Tensor] = [] + + for xid in range(n_experts): + ename = f"model.layers.{bid}.mlp.experts.{xid}.{w_name}.weight" + datas.append(self._experts[bid][ename]) + del self._experts[bid][ename] + + data_torch = torch.stack(datas, dim=0) + + merged_name = f"model.layers.{bid}.mlp.experts.{w_name}.weight" + + yield from super().modify_tensors(data_torch, merged_name, bid) + return + else: + return + + # note: MLA with the absorption optimization, needs these two split and k_b_proj transposed + if name.endswith("kv_b_proj.weight"): + name_kb = name.replace("kv_b_proj", "k_b_proj") + name_vb = name.replace("kv_b_proj", "v_b_proj") + + n_head_kv = self.hparams["num_key_value_heads"] + v_head_dim = self.hparams["v_head_dim"] + qk_nope_head_dim = self.hparams["qk_nope_head_dim"] + + assert data_torch.shape[0] == n_head_kv * (v_head_dim + qk_nope_head_dim) + + kv_b = data_torch.view(n_head_kv, v_head_dim + qk_nope_head_dim, data_torch.shape[-1]) + k_b, v_b = torch.split(kv_b, [qk_nope_head_dim, v_head_dim], dim=1) + k_b = k_b.transpose(1, 2) + + yield from super().modify_tensors(k_b, name_kb, bid) + yield from super().modify_tensors(v_b, name_vb, bid) + return + + yield from super().modify_tensors(data_torch, name, bid) + + def prepare_tensors(self): + super().prepare_tensors() + + if self._experts is not None: + # flatten `list[dict[str, Tensor]]` into `list[str]` + experts = [k for d in self._experts for k in d.keys()] + if len(experts) > 0: + raise ValueError(f"Unprocessed experts: {experts}") + + @ModelBase.register("MiniMaxM2ForCausalLM") class MiniMaxM2Model(TextModel): model_arch = gguf.MODEL_ARCH.MINIMAXM2 diff --git a/gguf-py/gguf/constants.py b/gguf-py/gguf/constants.py index c5f54695067..9f9b44bf17e 100644 --- a/gguf-py/gguf/constants.py +++ b/gguf-py/gguf/constants.py @@ -431,6 +431,7 @@ class MODEL_ARCH(IntEnum): ARCTIC = auto() DEEPSEEK = auto() DEEPSEEK2 = auto() + DEEPSEEK32 = auto() CHATGLM = auto() GLM4 = auto() GLM4_MOE = auto() @@ -874,6 +875,7 @@ class MODEL_TENSOR(IntEnum): MODEL_ARCH.ARCTIC: "arctic", MODEL_ARCH.DEEPSEEK: "deepseek", MODEL_ARCH.DEEPSEEK2: "deepseek2", + MODEL_ARCH.DEEPSEEK32: "deepseek32", MODEL_ARCH.CHATGLM: "chatglm", MODEL_ARCH.GLM4: "glm4", MODEL_ARCH.GLM4_MOE: "glm4moe", @@ -2623,6 +2625,47 @@ class MODEL_TENSOR(IntEnum): MODEL_TENSOR.FFN_UP_SHEXP, MODEL_TENSOR.FFN_EXP_PROBS_B, ], + MODEL_ARCH.DEEPSEEK32: [ + MODEL_TENSOR.TOKEN_EMBD, + MODEL_TENSOR.OUTPUT_NORM, + MODEL_TENSOR.OUTPUT, + MODEL_TENSOR.ROPE_FREQS, + MODEL_TENSOR.ATTN_NORM, + MODEL_TENSOR.ATTN_Q, + MODEL_TENSOR.ATTN_Q_A, + MODEL_TENSOR.ATTN_Q_B, + MODEL_TENSOR.ATTN_KV_A_MQA, + MODEL_TENSOR.ATTN_KV_B, + MODEL_TENSOR.ATTN_K_B, + MODEL_TENSOR.ATTN_V_B, + MODEL_TENSOR.ATTN_Q_A_NORM, + MODEL_TENSOR.ATTN_KV_A_NORM, + MODEL_TENSOR.ATTN_OUT, + MODEL_TENSOR.ATTN_ROT_EMBD, + MODEL_TENSOR.FFN_GATE_INP, + MODEL_TENSOR.FFN_NORM, + MODEL_TENSOR.FFN_GATE, + MODEL_TENSOR.FFN_DOWN, + MODEL_TENSOR.FFN_UP, + MODEL_TENSOR.FFN_GATE_EXP, + MODEL_TENSOR.FFN_DOWN_EXP, + MODEL_TENSOR.FFN_UP_EXP, + MODEL_TENSOR.FFN_GATE_SHEXP, + MODEL_TENSOR.FFN_DOWN_SHEXP, + MODEL_TENSOR.FFN_UP_SHEXP, + MODEL_TENSOR.FFN_EXP_PROBS_B, + MODEL_TENSOR.INDEXER_K_NORM, + MODEL_TENSOR.INDEXER_PROJ, + MODEL_TENSOR.INDEXER_ATTN_K, + MODEL_TENSOR.INDEXER_ATTN_Q_B, + # NextN/MTP tensors - preserved but unused + MODEL_TENSOR.NEXTN_EH_PROJ, + MODEL_TENSOR.NEXTN_EMBED_TOKENS, + MODEL_TENSOR.NEXTN_ENORM, + MODEL_TENSOR.NEXTN_HNORM, + MODEL_TENSOR.NEXTN_SHARED_HEAD_HEAD, + MODEL_TENSOR.NEXTN_SHARED_HEAD_NORM, + ], MODEL_ARCH.ERNIE4_5_MOE: [ MODEL_TENSOR.TOKEN_EMBD, MODEL_TENSOR.OUTPUT_NORM, @@ -3698,6 +3741,10 @@ class MODEL_TENSOR(IntEnum): MODEL_TENSOR.ROPE_FREQS, MODEL_TENSOR.ATTN_ROT_EMBD, ], + MODEL_ARCH.DEEPSEEK32: [ + MODEL_TENSOR.ROPE_FREQS, + MODEL_TENSOR.ATTN_ROT_EMBD, + ], MODEL_ARCH.CHATGLM: [ MODEL_TENSOR.ROPE_FREQS, ], diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 283823fa9c8..e524ebd2f2b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -57,6 +57,7 @@ add_library(llama models/deci.cpp models/deepseek.cpp models/deepseek2.cpp + models/deepseek32.cpp models/delta-net-base.cpp models/dots1.cpp models/dream.cpp diff --git a/src/llama-arch.cpp b/src/llama-arch.cpp index 204105b6dd0..faa7a3a7dae 100644 --- a/src/llama-arch.cpp +++ b/src/llama-arch.cpp @@ -73,6 +73,7 @@ static const std::map LLM_ARCH_NAMES = { { LLM_ARCH_ARCTIC, "arctic" }, { LLM_ARCH_DEEPSEEK, "deepseek" }, { LLM_ARCH_DEEPSEEK2, "deepseek2" }, + { LLM_ARCH_DEEPSEEK32, "deepseek32" }, { LLM_ARCH_CHATGLM, "chatglm" }, { LLM_ARCH_GLM4, "glm4" }, { LLM_ARCH_GLM4_MOE, "glm4moe" }, @@ -1616,6 +1617,44 @@ static std::set llm_get_tensor_names(llm_arch arch) { LLM_TENSOR_FFN_UP_SHEXP, LLM_TENSOR_FFN_EXP_PROBS_B, }; + case LLM_ARCH_DEEPSEEK32: + return { + LLM_TENSOR_TOKEN_EMBD, + LLM_TENSOR_OUTPUT_NORM, + LLM_TENSOR_OUTPUT, + LLM_TENSOR_ATTN_NORM, + LLM_TENSOR_ATTN_Q_A_NORM, + LLM_TENSOR_ATTN_KV_A_NORM, + LLM_TENSOR_ATTN_Q_A, + LLM_TENSOR_ATTN_Q_B, + LLM_TENSOR_ATTN_KV_A_MQA, + LLM_TENSOR_ATTN_KV_B, + LLM_TENSOR_ATTN_K_B, + LLM_TENSOR_ATTN_V_B, + LLM_TENSOR_ATTN_OUT, + LLM_TENSOR_FFN_NORM, + LLM_TENSOR_FFN_GATE, + LLM_TENSOR_FFN_UP, + LLM_TENSOR_FFN_DOWN, + LLM_TENSOR_FFN_GATE_INP, + LLM_TENSOR_FFN_GATE_EXPS, + LLM_TENSOR_FFN_DOWN_EXPS, + LLM_TENSOR_FFN_UP_EXPS, + LLM_TENSOR_FFN_GATE_SHEXP, + LLM_TENSOR_FFN_DOWN_SHEXP, + LLM_TENSOR_FFN_UP_SHEXP, + LLM_TENSOR_FFN_EXP_PROBS_B, + LLM_TENSOR_INDEXER_K_NORM, + LLM_TENSOR_INDEXER_PROJ, + LLM_TENSOR_INDEXER_ATTN_K, + LLM_TENSOR_INDEXER_ATTN_Q_B, + LLM_TENSOR_NEXTN_EH_PROJ, + LLM_TENSOR_NEXTN_EMBED_TOKENS, + LLM_TENSOR_NEXTN_ENORM, + LLM_TENSOR_NEXTN_HNORM, + LLM_TENSOR_NEXTN_SHARED_HEAD_HEAD, + LLM_TENSOR_NEXTN_SHARED_HEAD_NORM, + }; case LLM_ARCH_PLM: return { LLM_TENSOR_TOKEN_EMBD, diff --git a/src/llama-arch.h b/src/llama-arch.h index 28dd1ffac77..6c96da00b31 100644 --- a/src/llama-arch.h +++ b/src/llama-arch.h @@ -77,6 +77,7 @@ enum llm_arch { LLM_ARCH_ARCTIC, LLM_ARCH_DEEPSEEK, LLM_ARCH_DEEPSEEK2, + LLM_ARCH_DEEPSEEK32, LLM_ARCH_CHATGLM, LLM_ARCH_GLM4, LLM_ARCH_GLM4_MOE, diff --git a/src/llama-model.cpp b/src/llama-model.cpp index 0fa47e1b414..b484d82ef14 100644 --- a/src/llama-model.cpp +++ b/src/llama-model.cpp @@ -143,6 +143,7 @@ const char * llm_type_name(llm_type type) { case LLM_TYPE_310B_A15B: return "310B.A15B"; case LLM_TYPE_355B_A32B: return "355B.A32B"; case LLM_TYPE_397B_A17B: return "397B.A17B"; + case LLM_TYPE_685B_A37B: return "685B.A37B"; case LLM_TYPE_744B_A40B: return "744B.A40B"; case LLM_TYPE_E2B: return "E2B"; case LLM_TYPE_E4B: return "E4B"; @@ -1634,6 +1635,55 @@ void llama_model::load_hparams(llama_model_loader & ml) { default: type = LLM_TYPE_UNKNOWN; } } break; + case LLM_ARCH_DEEPSEEK32: + { + ml.get_key(LLM_KV_EXPERT_FEED_FORWARD_LENGTH, hparams.n_ff_exp); + ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS, hparams.f_norm_rms_eps); + hparams.f_norm_eps = 1e-6; // eps for layer norm + ml.get_key_or_arr(LLM_KV_ROPE_DIMENSION_SECTIONS, hparams.rope_sections, 4, false); + + // MoE parameters + ml.get_key(LLM_KV_EXPERT_COUNT, hparams.n_expert); + ml.get_key(LLM_KV_EXPERT_USED_COUNT, hparams.n_expert_used); + ml.get_key(LLM_KV_EXPERT_SHARED_COUNT, hparams.n_expert_shared); + ml.get_key(LLM_KV_LEADING_DENSE_BLOCK_COUNT, hparams.n_layer_dense_lead, false); + ml.get_key(LLM_KV_EXPERT_WEIGHTS_SCALE, hparams.expert_weights_scale, false); + ml.get_key(LLM_KV_EXPERT_WEIGHTS_NORM, hparams.expert_weights_norm, false); + + // deepseek MLA parameters + ml.get_key(LLM_KV_ATTENTION_Q_LORA_RANK, hparams.n_lora_q); + ml.get_key(LLM_KV_ATTENTION_KV_LORA_RANK, hparams.n_lora_kv); + ml.get_key(LLM_KV_ATTENTION_KEY_LENGTH_MLA, hparams.n_embd_head_k_mla_impl, false); + ml.get_key(LLM_KV_ATTENTION_VALUE_LENGTH_MLA, hparams.n_embd_head_v_mla_impl, false); + ml.get_key(LLM_KV_EXPERT_FEED_FORWARD_LENGTH, hparams.n_ff_exp); + ml.get_key(LLM_KV_EXPERT_SHARED_COUNT, hparams.n_expert_shared); + + // DSA parameters + ml.get_key(LLM_KV_ATTENTION_INDEXER_HEAD_COUNT, hparams.indexer_n_head); + ml.get_key(LLM_KV_ATTENTION_INDEXER_KEY_LENGTH, hparams.indexer_head_size); + ml.get_key(LLM_KV_ATTENTION_INDEXER_TOP_K, hparams.indexer_top_k); + + // Expert gating function + ml.get_key(LLM_KV_EXPERT_GATING_FUNC, hparams.expert_gating_func); + + if (ml.get_key(LLM_KV_ROPE_SCALING_YARN_LOG_MUL, hparams.rope_yarn_log_mul, 0.0f)) { + // [TAG_DEEPSEEK2_YARN_LOG_MUL_FIX] + // cancel the factor from the convert script + hparams.rope_yarn_log_mul /= 0.1f; + } + + // NextN/MTP parameters + ml.get_key(LLM_KV_NEXTN_PREDICT_LAYERS, hparams.nextn_predict_layers, false); + + // TODO: when MTP is implemented, this should probably be updated if needed + hparams.n_layer_kv_from_start = hparams.n_layer - hparams.nextn_predict_layers; + + switch (hparams.n_layer) { + case 61: type = LLM_TYPE_685B_A37B; break; + default: type = LLM_TYPE_UNKNOWN; + } + } break; + case LLM_ARCH_PLM: { ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS, hparams.f_norm_rms_eps); @@ -4964,6 +5014,108 @@ bool llama_model::load_tensors(llama_model_loader & ml) { } } } break; + case LLM_ARCH_DEEPSEEK32: + { + const bool is_mla = hparams.is_mla(); + if (!is_mla) { + throw std::runtime_error("DEEPSEEK32 architecture requires MLA"); + } + + // note: these are the actual head sizes you get when treating as MHA or after "decompression" using wv_b for MLA + const int64_t n_embd_head_k_mla = hparams.n_embd_head_k_mla(); + const int64_t n_embd_head_v_mla = hparams.n_embd_head_v_mla(); + + const int64_t n_embd_head_qk_rope = hparams.n_rot(); + const int64_t n_embd_head_qk_nope = n_embd_head_k_mla - n_embd_head_qk_rope; + + const int64_t q_lora_rank = hparams.n_lora_q; + const int64_t kv_lora_rank = hparams.n_lora_kv; + + const int64_t n_ff_exp = hparams.n_ff_exp; + const int64_t n_expert_shared = hparams.n_expert_shared; + + tok_embd = create_tensor(tn(LLM_TENSOR_TOKEN_EMBD, "weight"), {n_embd, n_vocab}, 0); + + // output + output_norm = create_tensor(tn(LLM_TENSOR_OUTPUT_NORM, "weight"), {n_embd}, 0); + // try to load output.weight, if not found, use token_embd (tied embeddings) + output = create_tensor(tn(LLM_TENSOR_OUTPUT, "weight"), {n_embd, n_vocab}, TENSOR_NOT_REQUIRED); + if (!output) { + output = create_tensor(tn(LLM_TENSOR_TOKEN_EMBD, "weight"), {n_embd, n_vocab}, TENSOR_DUPLICATED); + } + + for (int i = 0; i < n_layer; ++i) { + int flags = 0; + if (hparams.nextn_predict_layers > 0 && static_cast(i) >= n_layer - hparams.nextn_predict_layers) { + // skip all tensors in the NextN layers + // TODO @ngxson : TENSOR_NOT_REQUIRED was a hack, need to remove it later + flags |= TENSOR_SKIP | TENSOR_NOT_REQUIRED; + } + + auto & layer = layers[i]; + + layer.attn_norm = create_tensor(tn(LLM_TENSOR_ATTN_NORM, "weight", i), {n_embd}, flags); + layer.attn_q_a_norm = create_tensor(tn(LLM_TENSOR_ATTN_Q_A_NORM, "weight", i), {q_lora_rank}, flags); + layer.attn_kv_a_norm = create_tensor(tn(LLM_TENSOR_ATTN_KV_A_NORM, "weight", i), {kv_lora_rank}, flags); + + layer.wq_a = create_tensor(tn(LLM_TENSOR_ATTN_Q_A, "weight", i), {n_embd, q_lora_rank}, flags); + layer.wq_b = create_tensor(tn(LLM_TENSOR_ATTN_Q_B, "weight", i), {q_lora_rank, n_head * n_embd_head_k_mla}, flags); + + layer.wkv_a_mqa = create_tensor(tn(LLM_TENSOR_ATTN_KV_A_MQA, "weight", i), {n_embd, kv_lora_rank + n_embd_head_qk_rope}, flags); + + // note: only old legacy GGUF files will have the unsplit wkv_b tensor in + layer.wk_b = create_tensor(tn(LLM_TENSOR_ATTN_K_B, "weight", i), {n_embd_head_qk_nope, kv_lora_rank, n_head}, flags); + layer.wv_b = create_tensor(tn(LLM_TENSOR_ATTN_V_B, "weight", i), {kv_lora_rank, n_embd_head_v_mla, n_head}, flags); + + layer.wo = create_tensor(tn(LLM_TENSOR_ATTN_OUT, "weight", i), {n_head * n_embd_head_v_mla, n_embd}, flags); + + layer.ffn_norm = create_tensor(tn(LLM_TENSOR_FFN_NORM, "weight", i), {n_embd}, flags); + + // DSA indexer + layer.indexer_k_norm = create_tensor(tn(LLM_TENSOR_INDEXER_K_NORM, "weight", i), {hparams.indexer_head_size}, flags); + layer.indexer_k_norm_b = create_tensor(tn(LLM_TENSOR_INDEXER_K_NORM, "bias", i), {hparams.indexer_head_size}, flags); + layer.indexer_proj = create_tensor(tn(LLM_TENSOR_INDEXER_PROJ, "weight", i), {n_embd, hparams.indexer_n_head}, flags); + layer.indexer_attn_k = create_tensor(tn(LLM_TENSOR_INDEXER_ATTN_K, "weight", i), {n_embd, hparams.indexer_head_size}, flags); + layer.indexer_attn_q_b = create_tensor(tn(LLM_TENSOR_INDEXER_ATTN_Q_B, "weight", i), {q_lora_rank, hparams.indexer_n_head * hparams.indexer_head_size}, flags); + if (i < (int) hparams.n_layer_dense_lead) { + layer.ffn_gate = create_tensor(tn(LLM_TENSOR_FFN_GATE, "weight", i), {n_embd, n_ff}, flags); + layer.ffn_down = create_tensor(tn(LLM_TENSOR_FFN_DOWN, "weight", i), { n_ff, n_embd}, flags); + layer.ffn_up = create_tensor(tn(LLM_TENSOR_FFN_UP, "weight", i), {n_embd, n_ff}, flags); + } else { + layer.ffn_gate_inp = create_tensor(tn(LLM_TENSOR_FFN_GATE_INP, "weight", i), {n_embd, n_expert}, flags); + layer.ffn_exp_probs_b = create_tensor(tn(LLM_TENSOR_FFN_EXP_PROBS_B, "bias", i), {n_expert}, TENSOR_NOT_REQUIRED); + + if (n_expert == 0) { + throw std::runtime_error("n_expert must be > 0"); + } + if (n_expert_used == 0) { + throw std::runtime_error("n_expert_used must be > 0"); + } + + // MoE branch + layer.ffn_gate_exps = create_tensor(tn(LLM_TENSOR_FFN_GATE_EXPS, "weight", i), { n_embd, n_ff_exp, n_expert}, flags); + layer.ffn_down_exps = create_tensor(tn(LLM_TENSOR_FFN_DOWN_EXPS, "weight", i), {n_ff_exp, n_embd, n_expert}, flags); + layer.ffn_up_exps = create_tensor(tn(LLM_TENSOR_FFN_UP_EXPS, "weight", i), { n_embd, n_ff_exp, n_expert}, flags); + + // Shared expert branch + layer.ffn_gate_shexp = create_tensor(tn(LLM_TENSOR_FFN_GATE_SHEXP, "weight", i), {n_embd, n_ff_exp * n_expert_shared}, flags); + layer.ffn_down_shexp = create_tensor(tn(LLM_TENSOR_FFN_DOWN_SHEXP, "weight", i), { n_ff_exp * n_expert_shared, n_embd}, flags); + layer.ffn_up_shexp = create_tensor(tn(LLM_TENSOR_FFN_UP_SHEXP, "weight", i), {n_embd, n_ff_exp * n_expert_shared}, flags); + } + + // NextN/MTP tensors (preserved but unused) - conditionally load for last nextn_predict_layers + if (hparams.nextn_predict_layers > 0 && static_cast(i) >= n_layer - hparams.nextn_predict_layers) { + layer.nextn.eh_proj = create_tensor(tn(LLM_TENSOR_NEXTN_EH_PROJ, "weight", i), { 2 * n_embd, n_embd }, flags); + layer.nextn.enorm = create_tensor(tn(LLM_TENSOR_NEXTN_ENORM, "weight", i), { n_embd }, flags); + layer.nextn.hnorm = create_tensor(tn(LLM_TENSOR_NEXTN_HNORM, "weight", i), { n_embd }, flags); + + // Optional tensors + layer.nextn.embed_tokens = create_tensor(tn(LLM_TENSOR_NEXTN_EMBED_TOKENS, "weight", i), { n_embd, n_vocab }, flags | TENSOR_NOT_REQUIRED); + layer.nextn.shared_head_head = create_tensor(tn(LLM_TENSOR_NEXTN_SHARED_HEAD_HEAD, "weight", i), { n_embd, n_vocab }, flags | TENSOR_NOT_REQUIRED); + layer.nextn.shared_head_norm = create_tensor(tn(LLM_TENSOR_NEXTN_SHARED_HEAD_NORM, "weight", i), { n_embd }, flags | TENSOR_NOT_REQUIRED); + } + } + } break; case LLM_ARCH_PLM: { const int64_t n_embd_head_qk_rope = hparams.n_rot(); @@ -7772,7 +7924,7 @@ void llama_model::print_info() const { LLAMA_LOG_INFO("%s: expert_weights_scale = %.1f\n", __func__, hparams.expert_weights_scale); } - if (arch == LLM_ARCH_DEEPSEEK2 || arch == LLM_ARCH_GLM_DSA) { + if (arch == LLM_ARCH_DEEPSEEK2 || arch == LLM_ARCH_GLM_DSA || arch == LLM_ARCH_DEEPSEEK32) { LLAMA_LOG_INFO("%s: n_layer_dense_lead = %d\n", __func__, hparams.n_layer_dense_lead); LLAMA_LOG_INFO("%s: n_lora_q = %d\n", __func__, hparams.n_lora_q); LLAMA_LOG_INFO("%s: n_lora_kv = %d\n", __func__, hparams.n_lora_kv); @@ -8353,6 +8505,10 @@ ggml_cgraph * llama_model::build_graph(const llm_graph_params & params) const { { llm = std::make_unique(*this, params); } break; + case LLM_ARCH_DEEPSEEK32: + { + llm = std::make_unique(*this, params); + } break; case LLM_ARCH_CHATGLM: { llm = std::make_unique(*this, params); @@ -8748,6 +8904,7 @@ llama_rope_type llama_model_rope_type(const llama_model * model) { case LLM_ARCH_ARCTIC: case LLM_ARCH_DEEPSEEK: case LLM_ARCH_DEEPSEEK2: + case LLM_ARCH_DEEPSEEK32: case LLM_ARCH_PLM: case LLM_ARCH_CHATGLM: case LLM_ARCH_GRANITE: diff --git a/src/llama-model.h b/src/llama-model.h index 5ecb8344a25..9431d338d7f 100644 --- a/src/llama-model.h +++ b/src/llama-model.h @@ -134,6 +134,7 @@ enum llm_type { LLM_TYPE_310B_A15B, // /MiMo-V2-Flash LLM_TYPE_355B_A32B, // GLM-4.5 LLM_TYPE_397B_A17B, // Qwen3.5 + LLM_TYPE_685B_A37B, // DeepSeek V3.2 LLM_TYPE_744B_A40B, // GLM-5 LLM_TYPE_E2B, LLM_TYPE_E4B, diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp new file mode 100644 index 00000000000..f843dbd41c5 --- /dev/null +++ b/src/models/deepseek32.cpp @@ -0,0 +1,240 @@ +#include "models.h" + +llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_graph_params & params) : + llm_graph_context(params) { + const bool is_mla = hparams.is_mla(); + + // note: these are the actual head sizes you get when treating as MHA or after "decompression" using wv_b for MLA + const int64_t n_embd_head_k = hparams.n_embd_head_k_mla(); + const int64_t n_embd_head_v = hparams.n_embd_head_v_mla(); + + const int64_t n_embd_head_qk_rope = hparams.n_rot(); + const int64_t n_embd_head_qk_nope = n_embd_head_k - n_embd_head_qk_rope; + + const uint32_t kv_lora_rank = hparams.n_lora_kv; + + // We have to pre-scale kq_scale and attn_factor to make the YaRN RoPE work correctly. + // See https://github.com/ggml-org/llama.cpp/discussions/7416 for detailed explanation. + // And also: https://github.com/ggml-org/llama.cpp/pull/17945 [TAG_DEEPSEEK2_YARN_LOG_MUL_FIX] + + // first cancel the adjustment from llama_hparams::yarn_attn_factor_adjust to get the original attn_factor + GGML_ASSERT(ext_factor >= 0.0f); + const float attn_factor_org = attn_factor * (1.0f + 0.1f * logf(1.0f / freq_scale)); + + // use the original attn_factor to pre-scale the kq_scale + const float mscale = attn_factor_org * (1.0f + 0.1f * hparams.rope_yarn_log_mul * logf(1.0f / freq_scale)); + const float kq_scale = 1.0f * mscale * mscale / sqrtf(float(n_embd_head_k)); + + ggml_tensor * cur; + ggml_tensor * inpL; + + // {n_embd, n_tokens} + inpL = build_inp_embd(model.tok_embd); + + // inp_pos - contains the positions + ggml_tensor * inp_pos = build_inp_pos(); + + auto * inp_attn_kv = !is_mla ? build_attn_inp_kv() : nullptr; + auto * inp_attn_k = is_mla ? build_attn_inp_k() : nullptr; + + ggml_tensor * inp_out_ids = build_inp_out_ids(); + + int effective_n_layers = hparams.n_layer - hparams.nextn_predict_layers; + for (int il = 0; il < effective_n_layers; ++il) { + ggml_tensor * inpSA = inpL; + + // norm + cur = build_norm(inpL, model.layers[il].attn_norm, NULL, LLM_NORM_RMS, il); + cb(cur, "attn_norm", il); + + // self_attention + { + ggml_tensor * q = NULL; + + const bool is_lite = model.layers[il].wq; + + q = ggml_mul_mat(ctx0, model.layers[il].wq_a, cur); + cb(q, "q", il); + + q = build_norm(q, model.layers[il].attn_q_a_norm, nullptr, LLM_NORM_RMS, il); + cb(q, "q", il); + + q = ggml_mul_mat(ctx0, model.layers[il].wq_b, q); + cb(q, "q", il); + + // split into {n_embd_head_qk_nope, n_head, n_tokens} + ggml_tensor * q_nope = + ggml_view_3d(ctx0, q, n_embd_head_qk_nope, n_head, n_tokens, ggml_row_size(q->type, n_embd_head_k), + ggml_row_size(q->type, n_embd_head_k) * n_head, 0); + cb(q_nope, "q_nope", il); + + // and {n_embd_head_qk_rope, n_head, n_tokens} + ggml_tensor * q_pe = ggml_view_3d( + ctx0, q, n_embd_head_qk_rope, n_head, n_tokens, ggml_row_size(q->type, n_embd_head_k), + ggml_row_size(q->type, n_embd_head_k) * n_head, ggml_row_size(q->type, n_embd_head_qk_nope)); + cb(q_pe, "q_pe", il); + + ggml_tensor * kv_cmpr_pe = ggml_mul_mat(ctx0, model.layers[il].wkv_a_mqa, cur); + cb(kv_cmpr_pe, "kv_cmpr_pe", il); + + // split into {kv_lora_rank, n_tokens} + ggml_tensor * kv_cmpr = + ggml_view_2d(ctx0, kv_cmpr_pe, kv_lora_rank, n_tokens, + ggml_row_size(kv_cmpr_pe->type, kv_lora_rank + n_embd_head_qk_rope), 0); + cb(kv_cmpr, "kv_cmpr", il); + + // and {n_embd_head_qk_rope, 1, n_tokens} + ggml_tensor * k_pe = ggml_view_3d(ctx0, kv_cmpr_pe, n_embd_head_qk_rope, 1, n_tokens, + ggml_row_size(kv_cmpr_pe->type, kv_lora_rank + n_embd_head_qk_rope), + ggml_row_size(kv_cmpr_pe->type, kv_lora_rank + n_embd_head_qk_rope), + ggml_row_size(kv_cmpr_pe->type, kv_lora_rank)); + cb(k_pe, "k_pe", il); + + q_pe = ggml_rope_ext(ctx0, q_pe, inp_pos, nullptr, n_rot, rope_type, n_ctx_orig, freq_base, freq_scale, + ext_factor, attn_factor, beta_fast, beta_slow); + cb(q_pe, "q_pe", il); + + k_pe = ggml_rope_ext(ctx0, k_pe, inp_pos, nullptr, n_rot, rope_type, n_ctx_orig, freq_base, freq_scale, + ext_factor, attn_factor, beta_fast, beta_slow); + cb(k_pe, "k_pe", il); + + kv_cmpr = build_norm(kv_cmpr, model.layers[il].attn_kv_a_norm, nullptr, LLM_NORM_RMS, il); + cb(kv_cmpr, "kv_cmpr", il); + + if (is_mla) { + // {n_embd_head_qk_nope, n_tokens, n_head} + q_nope = ggml_permute(ctx0, q_nope, 0, 2, 1, 3); + cb(q_nope, "q_nope_perm", il); + + // {n_embd_head_qk_nope, kv_lora_rank, n_head} x {n_embd_head_qk_nope, n_tokens, n_head} + ggml_tensor * q_nope_absorbed = ggml_mul_mat(ctx0, model.layers[il].wk_b, q_nope); + cb(q_nope_absorbed, "q_nope_absorbed", il); + + // {kv_lora_rank, n_head, n_tokens} + q_nope_absorbed = ggml_permute(ctx0, q_nope_absorbed, 0, 2, 1, 3); + cb(q_nope_absorbed, "q_nope_absorbed_perm", il); + + // {n_embd_head_qk_rope + kv_lora_rank, n_head, n_tokens} + // note: rope must go first for in-place context shifting in build_rope_shift() + ggml_tensor * Qcur = ggml_concat(ctx0, q_nope_absorbed, q_pe, 0); + cb(Qcur, "Qcur", il); + + kv_cmpr = ggml_reshape_3d(ctx0, kv_cmpr, kv_lora_rank, 1, n_tokens); + cb(kv_cmpr, "kv_cmpr_reshape", il); + + // {n_embd_head_qk_rope + kv_lora_rank, 1, n_tokens} + ggml_tensor * Kcur = ggml_concat(ctx0, kv_cmpr, k_pe, 0); + cb(Kcur, "Kcur", il); + + // {kv_lora_rank, 1, n_tokens} + ggml_tensor * Vcur = kv_cmpr; + cb(Vcur, "Vcur", il); + + // note: MLA with the absorption optimization converts into MQA (ie: GQA with 1 group) + cur = build_attn(inp_attn_k, + model.layers[il].wo, NULL, + Qcur, Kcur, Vcur, nullptr, nullptr, model.layers[il].wv_b, kq_scale, il); + } else { + ggml_tensor * kv = ggml_mul_mat(ctx0, model.layers[il].wkv_b, kv_cmpr); + cb(kv, "kv", il); + + // split into {n_embd_head_qk_nope, n_head, n_tokens} + ggml_tensor * k_nope = + ggml_view_3d(ctx0, kv, n_embd_head_qk_nope, n_head, n_tokens, + ggml_row_size(kv->type, n_embd_head_qk_nope + n_embd_head_v), + ggml_row_size(kv->type, n_embd_head_qk_nope + n_embd_head_v) * n_head, 0); + cb(k_nope, "k_nope_view", il); + + // and {n_embd_head_v, n_head, n_tokens} + ggml_tensor * Vcur = ggml_view_3d(ctx0, kv, n_embd_head_v, n_head, n_tokens, + ggml_row_size(kv->type, n_embd_head_qk_nope + n_embd_head_v), + ggml_row_size(kv->type, n_embd_head_qk_nope + n_embd_head_v) * n_head, + ggml_row_size(kv->type, n_embd_head_qk_nope)); + cb(Vcur, "Vcur_view", il); + + Vcur = ggml_cont(ctx0, Vcur); + cb(Vcur, "Vcur_cont", il); + + ggml_tensor * Qcur = ggml_concat(ctx0, q_nope, q_pe, 0); + cb(Qcur, "Qcur", il); + + ggml_tensor * Kcur = ggml_concat(ctx0, k_nope, ggml_repeat(ctx0, k_pe, q_pe), 0); + cb(Kcur, "Kcur", il); + + // note: MLA without the absorption optimization converts into MHA (ie: GQA with full n_head groups) + cur = build_attn(inp_attn_kv, + model.layers[il].wo, NULL, + Qcur, Kcur, Vcur, nullptr, nullptr, nullptr, kq_scale, il); + } + } + if (il == effective_n_layers - 1 && inp_out_ids) { + cur = ggml_get_rows(ctx0, cur, inp_out_ids); + inpSA = ggml_get_rows(ctx0, inpSA, inp_out_ids); + } + ggml_tensor * ffn_inp = ggml_add(ctx0, cur, inpSA); + cb(ffn_inp, "ffn_inp", il); + + cur = build_norm(ffn_inp, model.layers[il].ffn_norm, NULL, LLM_NORM_RMS, il); + cb(cur, "ffn_norm", il); + + if ((uint32_t) il < hparams.n_layer_dense_lead) { + cur = build_ffn(cur, + model.layers[il].ffn_up, NULL, NULL, + model.layers[il].ffn_gate, NULL, NULL, + model.layers[il].ffn_down, NULL, NULL, + NULL, LLM_FFN_SILU, LLM_FFN_PAR, il); + cb(cur, "ffn_out", il); + } else { + // MoE branch + ggml_tensor * moe_out = build_moe_ffn(cur, + model.layers[il].ffn_gate_inp, + model.layers[il].ffn_up_exps, + model.layers[il].ffn_gate_exps, + model.layers[il].ffn_down_exps, + model.layers[il].ffn_exp_probs_b, + n_expert, n_expert_used, + LLM_FFN_SILU, hparams.expert_weights_norm, + hparams.expert_weights_scale, + (llama_expert_gating_func_type) hparams.expert_gating_func, + il, + nullptr, + model.layers[il].ffn_gate_up_exps); + cb(moe_out, "ffn_moe_out", il); + + // FFN shared expert + { + ggml_tensor * ffn_shexp = + build_ffn(cur, + model.layers[il].ffn_up_shexp, NULL, NULL, + model.layers[il].ffn_gate_shexp, NULL, NULL, + model.layers[il].ffn_down_shexp, NULL, NULL, + NULL, LLM_FFN_SILU, LLM_FFN_PAR, il); + cb(ffn_shexp, "ffn_shexp", il); + + cur = ggml_add(ctx0, moe_out, ffn_shexp); + cb(cur, "ffn_out", il); + } + } + cur = ggml_add(ctx0, cur, ffn_inp); + + cur = build_cvec(cur, il); + cb(cur, "l_out", il); + + // input for next layer + inpL = cur; + } + cur = inpL; + + cur = build_norm(cur, model.output_norm, NULL, LLM_NORM_RMS, -1); + + cb(cur, "result_norm", -1); + res->t_embd = cur; + + // lm_head + cur = ggml_mul_mat(ctx0, model.output, cur); + + cb(cur, "result_output", -1); + res->t_logits = cur; + + ggml_build_forward_expand(gf, cur); +} diff --git a/src/models/models.h b/src/models/models.h index cf9ba04e7f7..fd8c8d65c78 100644 --- a/src/models/models.h +++ b/src/models/models.h @@ -166,12 +166,16 @@ struct llm_build_deci : public llm_graph_context { llm_build_deci(const llama_model & model, const llm_graph_params & params); }; +struct llm_build_deepseek : public llm_graph_context { + llm_build_deepseek(const llama_model & model, const llm_graph_params & params); +}; + struct llm_build_deepseek2 : public llm_graph_context { llm_build_deepseek2(const llama_model & model, const llm_graph_params & params); }; -struct llm_build_deepseek : public llm_graph_context { - llm_build_deepseek(const llama_model & model, const llm_graph_params & params); +struct llm_build_deepseek32 : public llm_graph_context { + llm_build_deepseek32(const llama_model & model, const llm_graph_params & params); }; struct llm_build_dots1 : public llm_graph_context { From e4676845f66fcfc5ec935345c6f7d560477c2e8b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Thu, 12 Mar 2026 13:16:56 +0100 Subject: [PATCH 02/46] model : added indexer q and k calculation in DeepseekV32ForCausalLM. --- src/models/deepseek32.cpp | 80 +++++++++++++++++++++++++++++++++++---- 1 file changed, 72 insertions(+), 8 deletions(-) diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index f843dbd41c5..836c5828502 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -11,6 +11,11 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ const int64_t n_embd_head_qk_rope = hparams.n_rot(); const int64_t n_embd_head_qk_nope = n_embd_head_k - n_embd_head_qk_rope; + const int64_t n_indexer_head = hparams.indexer_n_head; + const int64_t n_embd_indexer_head = hparams.indexer_head_size; + const int64_t n_embd_indexer_head_rope = hparams.n_rot(); + const int64_t n_embd_indexer_head_nope = n_embd_indexer_head - n_embd_indexer_head_rope; + const uint32_t kv_lora_rank = hparams.n_lora_kv; // We have to pre-scale kq_scale and attn_factor to make the YaRN RoPE work correctly. @@ -49,17 +54,76 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ // self_attention { - ggml_tensor * q = NULL; - - const bool is_lite = model.layers[il].wq; + ggml_tensor * qr = ggml_mul_mat(ctx0, model.layers[il].wq_a, cur); + cb(qr, "qr", il); - q = ggml_mul_mat(ctx0, model.layers[il].wq_a, cur); - cb(q, "q", il); + qr = build_norm(qr, model.layers[il].attn_q_a_norm, nullptr, LLM_NORM_RMS, il); + cb(qr, "qr", il); - q = build_norm(q, model.layers[il].attn_q_a_norm, nullptr, LLM_NORM_RMS, il); - cb(q, "q", il); + // lightning indexer + { + ggml_tensor * indexer_q = ggml_mul_mat(ctx0, model.layers[il].indexer_attn_q_b, qr); + cb(indexer_q, "indexer_q", il); + + // split into {n_embd_indexer_head_rope, n_indexer_head, n_tokens} + ggml_tensor * indexer_q_pe = + ggml_view_3d(ctx0, indexer_q, n_embd_indexer_head_rope, n_indexer_head, n_tokens, + ggml_row_size(indexer_q->type, n_embd_indexer_head), + ggml_row_size(indexer_q->type, n_embd_indexer_head) * n_indexer_head, 0); + cb(indexer_q_pe, "indexer_q_pe", il); + + // and {n_embd_indexer_head_nope, n_indexer_head, n_tokens} + ggml_tensor * indexer_q_nope = + ggml_view_3d(ctx0, indexer_q, n_embd_indexer_head_nope, n_indexer_head, n_tokens, + ggml_row_size(indexer_q->type, n_embd_indexer_head), + ggml_row_size(indexer_q->type, n_embd_indexer_head) * n_indexer_head, + ggml_row_size(indexer_q->type, n_embd_indexer_head_nope)); + cb(indexer_q_nope, "indexer_q_nope", il); + + indexer_q_pe = ggml_rope_ext(ctx0, indexer_q_pe, inp_pos, nullptr, n_rot, + LLAMA_ROPE_TYPE_NEOX, n_ctx_orig, freq_base, freq_scale, + ext_factor, attn_factor, beta_fast, beta_slow); + cb(indexer_q_pe, "indexer_q_pe", il); + + // {n_embd_indexer_head_qk_rope + n_embd_indexer_head_qk_nope, n_head, n_tokens} + indexer_q = ggml_concat(ctx0, indexer_q_pe, indexer_q_nope, 0); + cb(indexer_q, "indexer_q", il); + + ggml_tensor * indexer_k = ggml_mul_mat(ctx0, model.layers[il].indexer_attn_k, cur); + cb(indexer_k, "indexer_k", il); + + indexer_k = build_norm(indexer_k, model.layers[il].indexer_k_norm, model.layers[il].indexer_k_norm_b, LLM_NORM, il); + cb(indexer_k, "indexer_k", il); + + // split into {n_embd_indexer_head_qk_rope, 1, n_tokens} + ggml_tensor * indexer_k_pe = + ggml_view_3d(ctx0, indexer_k, n_embd_indexer_head_rope, 1, n_tokens, + ggml_row_size(indexer_k->type, n_embd_indexer_head), + ggml_row_size(indexer_k->type, n_embd_indexer_head) * 1, 0); + cb(indexer_k_pe, "indexer_k_pe", il); + + // and {n_embd_indexer_head_qk_nope, 1, n_tokens} + ggml_tensor * indexer_k_nope = + ggml_view_3d(ctx0, indexer_k, n_embd_indexer_head_nope, 1, n_tokens, + ggml_row_size(indexer_k->type, n_embd_indexer_head), + ggml_row_size(indexer_k->type, n_embd_indexer_head) * 1, + ggml_row_size(indexer_k->type, n_embd_indexer_head_nope)); + cb(indexer_k_nope, "indexer_k_nope", il); + + indexer_k_pe = ggml_rope_ext(ctx0, indexer_k_pe, inp_pos, nullptr, n_rot, + LLAMA_ROPE_TYPE_NEOX, n_ctx_orig, freq_base, freq_scale, + ext_factor, attn_factor, beta_fast, beta_slow); + cb(indexer_k_pe, "indexer_k_pe", il); + + // {n_embd_indexer_head_qk_rope + n_embd_indexer_head_qk_nope, 1, n_tokens} + indexer_k = ggml_concat(ctx0, indexer_k_pe, indexer_k_nope, 0); + cb(indexer_k, "indexer_k", il); + + ggml_build_forward_expand(gf, indexer_q); + ggml_build_forward_expand(gf, indexer_k); + } - q = ggml_mul_mat(ctx0, model.layers[il].wq_b, q); + ggml_tensor * q = ggml_mul_mat(ctx0, model.layers[il].wq_b, qr); cb(q, "q", il); // split into {n_embd_head_qk_nope, n_head, n_tokens} From 723f0cef0b3d9b8c9ed97284605d1327382d0829 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Thu, 12 Mar 2026 20:51:47 +0100 Subject: [PATCH 03/46] ggml : add Hadamard transform GGML OP and implementation --- ggml/include/ggml.h | 6 +++ ggml/src/ggml-cpu/ggml-cpu.c | 5 ++ ggml/src/ggml-cpu/ops.cpp | 91 ++++++++++++++++++++++++++++++++++++ ggml/src/ggml-cpu/ops.h | 1 + ggml/src/ggml.c | 28 ++++++++++- 5 files changed, 129 insertions(+), 2 deletions(-) diff --git a/ggml/include/ggml.h b/ggml/include/ggml.h index 566e2714790..547ccc42aa5 100644 --- a/ggml/include/ggml.h +++ b/ggml/include/ggml.h @@ -557,6 +557,7 @@ extern "C" { GGML_OP_RWKV_WKV7, GGML_OP_SOLVE_TRI, GGML_OP_GATED_DELTA_NET, + GGML_OP_HADAMARD, GGML_OP_UNARY, @@ -2473,6 +2474,11 @@ extern "C" { struct ggml_tensor * beta, struct ggml_tensor * state); + GGML_API struct ggml_tensor * ggml_hadamard( + struct ggml_context * ctx, + struct ggml_tensor * a, + int n); + // custom operators typedef void (*ggml_custom1_op_t)(struct ggml_tensor * dst , const struct ggml_tensor * a, int ith, int nth, void * userdata); diff --git a/ggml/src/ggml-cpu/ggml-cpu.c b/ggml/src/ggml-cpu/ggml-cpu.c index dc2b5ffaa77..bed01ae65ca 100644 --- a/ggml/src/ggml-cpu/ggml-cpu.c +++ b/ggml/src/ggml-cpu/ggml-cpu.c @@ -2025,6 +2025,10 @@ static void ggml_compute_forward(struct ggml_compute_params * params, struct ggm { ggml_compute_forward_gated_delta_net(params, tensor); } break; + case GGML_OP_HADAMARD: + { + ggml_compute_forward_hadamard(params, tensor); + } break; case GGML_OP_MAP_CUSTOM1: { ggml_compute_forward_map_custom1(params, tensor); @@ -2347,6 +2351,7 @@ static int ggml_get_n_tasks(struct ggml_tensor * node, int n_threads) { case GGML_OP_RWKV_WKV6: case GGML_OP_GATED_LINEAR_ATTN: case GGML_OP_RWKV_WKV7: + case GGML_OP_HADAMARD: { n_tasks = n_threads; } break; diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index 331e071a267..111a474a6f4 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11165,3 +11165,94 @@ void ggml_compute_forward_opt_step_sgd(const ggml_compute_params * params, ggml_ } } } + +// ggml_compute_forward_hadamard + +// Based on a source code from: https://github.com/ikawrakow/ik_llama.cpp +// Copyright (C) 2025 Iwan Kawrakow +// MIT license +// SPDX-License-Identifier: MIT + +#if defined(_MSC_VER) +#pragma warning(disable: 4244 4267) // possible loss of data +#include +#include +#include +#include +#include +inline int popcount(uint32_t x) { return __popcnt(x); } +#else +inline int popcount(uint32_t x) { return __builtin_popcount(x); } +#endif + +template +void fast_ht(int n, T * values) { + constexpr float ksqrt2 = 0.707106781f; + float scale = 1; + for (int h = 1; h < n; h <<= 1) { + for (int i = 0; i < n; i += 2*h) { + for (int j = i; j < i + h; ++j) { + T x = values[j], y = values[j + h]; + values[j+0] = x + y; + values[j+h] = x - y; + } + } + scale *= ksqrt2; + } + for (int i = 0; i < n; ++i) values[i] *= scale; +} + +static void ggml_compute_forward_hadamard_f32( + const ggml_compute_params * params, + ggml_tensor * dst) { + + const ggml_tensor * src0 = dst->src[0]; + + GGML_ASSERT(ggml_is_contiguous(src0)); + GGML_ASSERT(ggml_is_contiguous(dst)); + GGML_ASSERT(ggml_are_same_shape(src0, dst)); + + const int ith = params->ith; + const int nth = params->nth; + + int nh = dst->op_params[0]; + GGML_ASSERT(nh > 1 && popcount(uint32_t(nh)) == 1); + GGML_ASSERT(dst->ne[0] % nh == 0); + + int nc = dst->ne[0]/nh; + int nr = ggml_nrows(dst) * nc; + + int npt = (nr + nth - 1)/nth; + int first = npt*ith; + int last = std::min(first + npt, nr); + + for (int ir = first; ir < last; ++ir) { + int i3 = ir / (dst->ne[1] * dst->ne[2] * nc); + int i2 = (ir - i3*dst->ne[1] * dst->ne[2] * nc)/(dst->ne[1] * nc); + int i1 = (ir - i3*dst->ne[1] * dst->ne[2] * nc - i2*dst->ne[1]*nc)/nc; + int ic = (ir - i3*dst->ne[1] * dst->ne[2] * nc - i2*dst->ne[1]*nc - i1*nc); + + auto x = (const float *)((const char *)src0->data + i3*src0->nb[3] + i2*src0->nb[2] + i1*src0->nb[1]) + ic*nh; + auto y = ( float *)(( char *)dst->data + i3*dst->nb[3] + i2*dst->nb[2] + i1*dst->nb[1]) + ic*nh; + memcpy(y, x, nh*sizeof(float)); + fast_ht(nh, y); + } +} + +void ggml_compute_forward_hadamard( + const ggml_compute_params * params, + ggml_tensor * dst) { + + const ggml_tensor * src0 = dst->src[0]; + + switch (src0->type) { + case GGML_TYPE_F32: + { + ggml_compute_forward_hadamard_f32(params, dst); + } break; + default: + { + GGML_ABORT("fatal error"); + } + } +} diff --git a/ggml/src/ggml-cpu/ops.h b/ggml/src/ggml-cpu/ops.h index 3fa1443abc4..c28d32ea914 100644 --- a/ggml/src/ggml-cpu/ops.h +++ b/ggml/src/ggml-cpu/ops.h @@ -103,6 +103,7 @@ void ggml_compute_forward_rwkv_wkv7(const struct ggml_compute_params * params, s void ggml_compute_forward_solve_tri(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_gla(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_gated_delta_net(const struct ggml_compute_params * params, struct ggml_tensor * dst); +void ggml_compute_forward_hadamard(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom1(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom2(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom3(const struct ggml_compute_params * params, struct ggml_tensor * dst); diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index aeafc395d71..a01ee49ee36 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -1032,6 +1032,7 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "RWKV_WKV7", "SOLVE_TRI", "GATED_DELTA_NET", + "HADAMARD", "UNARY", @@ -1049,7 +1050,7 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "GLU", }; -static_assert(GGML_OP_COUNT == 96, "GGML_OP_COUNT != 96"); +static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "none", @@ -1142,6 +1143,7 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "rwkv_wkv7(r, w, k, v, a, b, s)", "A X = B, A triangular, solve X", "gated_delta_net(q, k, v, g, beta, s)", + "hadamard(x)", "unary(x)", @@ -1159,7 +1161,7 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "glu(x)", }; -static_assert(GGML_OP_COUNT == 96, "GGML_OP_COUNT != 96"); +static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); static_assert(GGML_OP_POOL_COUNT == 2, "GGML_OP_POOL_COUNT != 2"); @@ -6177,6 +6179,28 @@ struct ggml_tensor * ggml_gated_delta_net( return result; } +// ggml_hadamard + +struct ggml_tensor * ggml_hadamard( + struct ggml_context * ctx, + struct ggml_tensor * a, + int n) { + + GGML_ASSERT(a->type == GGML_TYPE_F32); // will not bother implementing for other data types + GGML_ASSERT(n > 1); // no point in Hadamard transforms with less than 2 elements + GGML_ASSERT(a->ne[0] % n == 0); + GGML_ASSERT(n > 0 && ((n & (n - 1)) == 0)); // must be a power of 2 + + struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, GGML_MAX_DIMS, a->ne); + + result->op = GGML_OP_HADAMARD; + result->src[0] = a; + + result->op_params[0] = n; + + return result; +} + //////////////////////////////////////////////////////////////////////////////// struct ggml_hash_set ggml_hash_set_new(size_t size) { From 72b721446726fb029b83bb746566df187079bf60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Fri, 13 Mar 2026 17:02:59 +0100 Subject: [PATCH 04/46] kv-cache : add cache for indexer keys (temporary solution) --- src/llama-kv-cache.cpp | 93 ++++++++++++++++++++++++++++++++++++++++-- src/llama-kv-cache.h | 7 ++++ 2 files changed, 96 insertions(+), 4 deletions(-) diff --git a/src/llama-kv-cache.cpp b/src/llama-kv-cache.cpp index 82fe58fac46..bea96501f9a 100644 --- a/src/llama-kv-cache.cpp +++ b/src/llama-kv-cache.cpp @@ -51,7 +51,7 @@ llama_kv_cache::llama_kv_cache( auto it = ctx_map.find(buft); if (it == ctx_map.end()) { ggml_init_params params = { - /*.mem_size =*/ size_t(2u*(1 + n_stream)*n_layer_kv*ggml_tensor_overhead()), + /*.mem_size =*/ size_t(3u*(1 + n_stream)*n_layer_kv*ggml_tensor_overhead()), /*.mem_buffer =*/ NULL, /*.no_alloc =*/ true, }; @@ -113,6 +113,7 @@ llama_kv_cache::llama_kv_cache( // [TAG_V_CACHE_VARIABLE] const uint32_t n_embd_k_gqa = hparams.n_embd_k_gqa(il); const uint32_t n_embd_v_gqa = !v_trans ? hparams.n_embd_v_gqa(il) : hparams.n_embd_v_gqa_max(); + const uint32_t n_embd_indexer_head = hparams.indexer_head_size; const char * dev_name = "CPU"; @@ -134,24 +135,29 @@ llama_kv_cache::llama_kv_cache( const bool has_k = true; const bool has_v = !is_mla; + const bool has_ik = hparams.indexer_top_k > 0; ggml_tensor * k = has_k ? ggml_new_tensor_3d(ctx, type_k, n_embd_k_gqa, kv_size, n_stream) : nullptr; ggml_tensor * v = has_v ? ggml_new_tensor_3d(ctx, type_v, n_embd_v_gqa, kv_size, n_stream) : nullptr; + ggml_tensor * ik = has_ik ? ggml_new_tensor_3d(ctx, type_k, n_embd_indexer_head, kv_size, n_stream) : nullptr; has_k && ggml_format_name(k, "cache_k_l%d", il); has_v && ggml_format_name(v, "cache_v_l%d", il); + has_ik && ggml_format_name(ik, "cache_ik_l%d", il); std::vector k_stream; std::vector v_stream; + std::vector ik_stream; for (uint32_t s = 0; s < n_stream; ++s) { k_stream.push_back(has_k ? ggml_view_2d(ctx, k, n_embd_k_gqa, kv_size, k->nb[1], s*k->nb[2]) : nullptr); v_stream.push_back(has_v ? ggml_view_2d(ctx, v, n_embd_v_gqa, kv_size, v->nb[1], s*v->nb[2]) : nullptr); + ik_stream.push_back(has_ik ? ggml_view_2d(ctx, ik, n_embd_indexer_head, kv_size, ik->nb[1], s*ik->nb[2]) : nullptr); } map_layer_ids[il] = layers.size(); - layers.push_back({ il, k, v, k_stream, v_stream, }); + layers.push_back({ il, k, v, ik, k_stream, v_stream, ik_stream }); } if (reuse) { @@ -202,11 +208,13 @@ llama_kv_cache::llama_kv_cache( { const size_t memory_size_k = size_k_bytes(); const size_t memory_size_v = size_v_bytes(); + const size_t memory_size_ik = size_ik_bytes(); - LLAMA_LOG_INFO("%s: size = %7.2f MiB (%6u cells, %3d layers, %2u/%u seqs), K (%s): %7.2f MiB, V (%s): %7.2f MiB\n", __func__, + LLAMA_LOG_INFO("%s: size = %7.2f MiB (%6u cells, %3d layers, %2u/%u seqs), K (%s): %7.2f MiB, V (%s): %7.2f MiB, IK (%s): %7.2f MiB\n", __func__, (float)(memory_size_k + memory_size_v) / (1024.0f * 1024.0f), kv_size, (int) layers.size(), n_seq_max, n_stream, ggml_type_name(type_k), (float)memory_size_k / (1024.0f * 1024.0f), - ggml_type_name(type_v), (float)memory_size_v / (1024.0f * 1024.0f)); + ggml_type_name(type_v), (float)memory_size_v / (1024.0f * 1024.0f), + ggml_type_name(type_k), (float)memory_size_ik / (1024.0f * 1024.0f)); } const char * LLAMA_KV_CACHE_DEBUG = getenv("LLAMA_KV_CACHE_DEBUG"); @@ -656,6 +664,10 @@ bool llama_kv_cache::update(llama_context * lctx, bool do_shift, const stream_co if (layer.v_stream[ssrc]) { ggml_backend_tensor_copy(layer.v_stream[ssrc], layer.v_stream[sdst]); } + + if (layer.ik_stream[ssrc]) { + ggml_backend_tensor_copy(layer.ik_stream[ssrc], layer.ik_stream[sdst]); + } } } } @@ -1072,6 +1084,26 @@ ggml_tensor * llama_kv_cache::get_v(ggml_context * ctx, int32_t il, uint32_t n_k ggml_row_size(v->type, kv_size*n_embd_v_gqa)*sinfo.s0); } +ggml_tensor * llama_kv_cache::get_ik(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const { + const int32_t ikv = map_layer_ids.at(il); + + auto * ik = layers[ikv].ik; + + const uint64_t kv_size = get_size(); + const uint64_t n_embd_indexer_head = ik->ne[0]; + + assert(n_embd_indexer_head == hparams.indexer_head_size); + + const uint32_t ns = sinfo.s1 - sinfo.s0 + 1; + + return ggml_view_4d(ctx, ik, + n_embd_indexer_head, 1, n_kv, ns, + ggml_row_size(ik->type, n_embd_indexer_head), + ggml_row_size(ik->type, n_embd_indexer_head), + ggml_row_size(ik->type, n_embd_indexer_head*kv_size), + ggml_row_size(ik->type, n_embd_indexer_head*kv_size)*sinfo.s0); +} + ggml_tensor * llama_kv_cache::cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const { GGML_UNUSED(sinfo); @@ -1163,6 +1195,41 @@ ggml_tensor * llama_kv_cache::cpy_v(ggml_context * ctx, ggml_tensor * v_cur, ggm return ggml_set_rows(ctx, v_view, v_cur, v_idxs); } +ggml_tensor * llama_kv_cache::cpy_ik(ggml_context * ctx, ggml_tensor * ik_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const { + GGML_UNUSED(sinfo); + + const int32_t ikv = map_layer_ids.at(il); + + ggml_tensor * ik = layers[ikv].ik; + + const int64_t n_embd_indexer_head = ik_cur->ne[0]; + const int64_t n_head = ik_cur->ne[1]; + const int64_t n_tokens = ik_cur->ne[2]; + + const int64_t n_embd_gqa = n_embd_indexer_head*n_head; + + // we can merge dims 0 and 1 + // TODO: add ggml helper function for this? + GGML_ASSERT(ggml_row_size(ik_cur->type, n_embd_indexer_head) == ik_cur->nb[1]); + + ik_cur = ggml_view_2d(ctx, ik_cur, n_embd_gqa, n_tokens, ik_cur->nb[2], 0); + + const int64_t n_stream = ik->ne[2]; + + if (n_stream > 1) { + const int64_t kv_size = get_size(); + + assert(n_embd_gqa == ik->ne[0]); + assert(kv_size == ik->ne[1]); + + // merge the buffer across all streams because the idxs are global + ik = ggml_reshape_2d(ctx, ik, n_embd_gqa, kv_size*n_stream); + } + + // store the current K values into the cache + return ggml_set_rows(ctx, ik, ik_cur, k_idxs); +} + ggml_tensor * llama_kv_cache::build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const { const uint32_t n_tokens = ubatch.n_tokens; @@ -1537,6 +1604,16 @@ size_t llama_kv_cache::size_v_bytes() const { return size_v_bytes; } +size_t llama_kv_cache::size_ik_bytes() const { + size_t size_ik_bytes = 0; + + for (const auto & layer : layers) { + size_ik_bytes += ggml_nbytes(layer.ik); + } + + return size_ik_bytes; +} + ggml_tensor * llama_kv_cache::build_rope_shift( const llama_cparams & cparams, ggml_context * ctx, @@ -2242,6 +2319,10 @@ ggml_tensor * llama_kv_cache_context::get_v(ggml_context * ctx, int32_t il) cons return kv->get_v(ctx, il, n_kv, sinfos[i_cur]); } +ggml_tensor * llama_kv_cache_context::get_ik(ggml_context * ctx, int32_t il) const { + return kv->get_ik(ctx, il, n_kv, sinfos[i_cur]); +} + ggml_tensor * llama_kv_cache_context::cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il) const { return kv->cpy_k(ctx, k_cur, k_idxs, il, sinfos[i_cur]); } @@ -2250,6 +2331,10 @@ ggml_tensor * llama_kv_cache_context::cpy_v(ggml_context * ctx, ggml_tensor * v_ return kv->cpy_v(ctx, v_cur, v_idxs, il, sinfos[i_cur]); } +ggml_tensor * llama_kv_cache_context::cpy_ik(ggml_context * ctx, ggml_tensor * ik_cur, ggml_tensor * k_idxs, int32_t il) const { + return kv->cpy_ik(ctx, ik_cur, k_idxs, il, sinfos[i_cur]); +} + ggml_tensor * llama_kv_cache_context::build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const { return kv->build_input_k_idxs(ctx, ubatch); } diff --git a/src/llama-kv-cache.h b/src/llama-kv-cache.h index 33c78c5f210..6e47b40563d 100644 --- a/src/llama-kv-cache.h +++ b/src/llama-kv-cache.h @@ -161,10 +161,12 @@ class llama_kv_cache : public llama_memory_i { // get views of the current state of the cache ggml_tensor * get_k(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const; ggml_tensor * get_v(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const; + ggml_tensor * get_ik(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const; // store k_cur and v_cur in the cache based on the provided head location ggml_tensor * cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const; ggml_tensor * cpy_v(ggml_context * ctx, ggml_tensor * v_cur, ggml_tensor * v_idxs, int32_t il, const slot_info & sinfo) const; + ggml_tensor * cpy_ik(ggml_context * ctx, ggml_tensor * ik_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const; // // preparation API @@ -210,9 +212,11 @@ class llama_kv_cache : public llama_memory_i { ggml_tensor * k; ggml_tensor * v; + ggml_tensor * ik; std::vector k_stream; std::vector v_stream; + std::vector ik_stream; }; bool v_trans = true; // the value tensor is transposed @@ -256,6 +260,7 @@ class llama_kv_cache : public llama_memory_i { size_t size_k_bytes() const; size_t size_v_bytes() const; + size_t size_ik_bytes() const; ggml_tensor * build_rope_shift( const llama_cparams & cparams, @@ -331,6 +336,7 @@ class llama_kv_cache_context : public llama_memory_context_i { // get views of the current state of the cache ggml_tensor * get_k(ggml_context * ctx, int32_t il) const; ggml_tensor * get_v(ggml_context * ctx, int32_t il) const; + ggml_tensor * get_ik(ggml_context * ctx, int32_t il) const; // store k_cur and v_cur in the cache based on the provided head location // note: the heads in k_cur and v_cur should be layed out contiguously in memory @@ -340,6 +346,7 @@ class llama_kv_cache_context : public llama_memory_context_i { // - v_idxs [n_tokens] or [n_tokens*n_embd_v_gqa] depending if V cache is transposed ggml_tensor * cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il) const; ggml_tensor * cpy_v(ggml_context * ctx, ggml_tensor * v_cur, ggml_tensor * v_idxs, int32_t il) const; + ggml_tensor * cpy_ik(ggml_context * ctx, ggml_tensor * ik_cur, ggml_tensor * k_idxs, int32_t il) const; // create destination indices for each head of the current batch for where it would be written in the KV cache // the indices address the global KV cache (not per stream) - this is not relevant for the user of this API, but From 961bc95d96f8dc8268cac42390cbb9a15fd77e68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Sat, 14 Mar 2026 20:17:21 +0100 Subject: [PATCH 05/46] convert : DSA indexer weights are bf16 in the original fp8 model, so I think it's best not to quantize them. --- convert_hf_to_gguf.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/convert_hf_to_gguf.py b/convert_hf_to_gguf.py index 3fdeb277946..212836398b4 100755 --- a/convert_hf_to_gguf.py +++ b/convert_hf_to_gguf.py @@ -618,6 +618,8 @@ def prepare_tensors(self): gguf.MODEL_TENSOR.SSM_CONV1D_Q, gguf.MODEL_TENSOR.SSM_CONV1D_K, gguf.MODEL_TENSOR.SSM_CONV1D_V, + # DSA indexer weights should be F32 + gguf.MODEL_TENSOR.INDEXER_PROJ, ) ) or new_name[-7:] not in (".weight", ".lora_a", ".lora_b") From 9a63e7ab76b435cbb87d9bdebcb023382475066b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Sat, 14 Mar 2026 20:20:39 +0100 Subject: [PATCH 06/46] model : crude proof-of-concept implementation of the DSA indexer for DeepSeek V3.2. --- src/models/deepseek32.cpp | 104 +++++++++++++++++++++++++++++++++++++- 1 file changed, 102 insertions(+), 2 deletions(-) diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index 836c5828502..20d31f73acf 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -1,5 +1,38 @@ #include "models.h" +#include "llama-kv-cache.h" + +void mask_top_k_callback(struct ggml_tensor * dst, const struct ggml_tensor * a, const struct ggml_tensor * b, int ith, int nth, void * userdata) { + // a = kq_mask, b = top_k, dst = output tensor + const int n_seq = a->ne[1]; + const int n_tokens = a->ne[0]; + const int k = b->ne[0]; + + // Get data pointers (assuming F32 for mask, I32 for indices) + const float * mask_data = (const float *) a->data; + const int32_t * topk_data = (const int32_t *) b->data; + float * dst_data = (float *) dst->data; + + // Distribute work across threads if nth > 1 + const int start_row = (n_seq * ith) / nth; + const int end_row = (n_seq * (ith + 1)) / nth; + + for (int i = start_row; i < end_row; ++i) { + // First, set the entire row to -inf + for (int j = 0; j < n_tokens; ++j) { + dst_data[i * n_tokens + j] = -INFINITY; + } + + // Then, restore the values indicated by top_k + for (int j = 0; j < k; ++j) { + int32_t keep_idx = topk_data[i * k + j]; + if (keep_idx >= 0 && keep_idx < n_tokens) { + dst_data[i * n_tokens + keep_idx] = mask_data[i * n_tokens + keep_idx]; + } + } + } +} + llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_graph_params & params) : llm_graph_context(params) { const bool is_mla = hparams.is_mla(); @@ -15,6 +48,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ const int64_t n_embd_indexer_head = hparams.indexer_head_size; const int64_t n_embd_indexer_head_rope = hparams.n_rot(); const int64_t n_embd_indexer_head_nope = n_embd_indexer_head - n_embd_indexer_head_rope; + const uint32_t n_indexer_top_k = hparams.indexer_top_k; const uint32_t kv_lora_rank = hparams.n_lora_kv; @@ -60,6 +94,10 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ qr = build_norm(qr, model.layers[il].attn_q_a_norm, nullptr, LLM_NORM_RMS, il); cb(qr, "qr", il); + ggml_tensor * kq_mask = is_mla ? inp_attn_k->get_kq_mask() : inp_attn_kv->get_kq_mask(); + ggml_tensor * kq_mask_bak = ggml_dup(ctx0, kq_mask); + ggml_build_forward_expand(gf, kq_mask_bak); + // lightning indexer { ggml_tensor * indexer_q = ggml_mul_mat(ctx0, model.layers[il].indexer_attn_q_b, qr); @@ -119,8 +157,68 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ indexer_k = ggml_concat(ctx0, indexer_k_pe, indexer_k_nope, 0); cb(indexer_k, "indexer_k", il); - ggml_build_forward_expand(gf, indexer_q); - ggml_build_forward_expand(gf, indexer_k); + indexer_q = ggml_hadamard(ctx0, indexer_q, n_embd_indexer_head); + cb(indexer_q, "indexer_q", il); + indexer_k = ggml_hadamard(ctx0, indexer_k, n_embd_indexer_head); + cb(indexer_k, "indexer_k", il); + + // store to KV cache + const auto * mctx_cur = is_mla ? inp_attn_k->mctx : inp_attn_kv->mctx; + const auto & k_idxs = is_mla ? inp_attn_k->get_k_idxs() : inp_attn_kv->get_k_idxs(); + ggml_build_forward_expand(gf, mctx_cur->cpy_ik(ctx0, indexer_k, k_idxs, il)); + + ggml_tensor * indexer_weights = ggml_mul_mat(ctx0, model.layers[il].indexer_proj, cur); + cb(indexer_weights, "indexer_weights", il); + + indexer_weights = ggml_scale(ctx0, indexer_weights, 1.0f / sqrtf(float(n_indexer_head))); + cb(indexer_weights, "indexer_weights", il); + + // get cached indexer keys + indexer_k = mctx_cur->get_ik(ctx0, il); + + indexer_q = ggml_permute(ctx0, indexer_q, 0, 2, 1, 3); + cb(indexer_q, "indexer_q", il); + indexer_k = ggml_permute(ctx0, indexer_k, 0, 2, 1, 3); + cb(indexer_k, "indexer_k", il); + + ggml_tensor * indexer_kq = ggml_mul_mat(ctx0, indexer_k, indexer_q); + cb(indexer_kq, "indexer_kq", il); + + indexer_kq = ggml_cont(ctx0, ggml_permute(ctx0, indexer_kq, 2, 1, 0, 3)); + cb(indexer_kq, "indexer_kq", il); + + ggml_tensor * indexer_score = ggml_relu(ctx0, indexer_kq); + cb(indexer_score, "indexer_score", il); + + indexer_score = ggml_mul(ctx0, indexer_score, indexer_weights); + cb(indexer_score, "indexer_score", il); + + indexer_score = ggml_sum_rows(ctx0, indexer_score); + cb(indexer_score, "indexer_score", il); + + indexer_score = ggml_permute(ctx0, indexer_score, 2, 1, 0, 3); + cb(indexer_score, "indexer_score", il); + + indexer_score = ggml_cont(ctx0, indexer_score); + cb(indexer_score, "indexer_score", il); + + indexer_score = ggml_scale(ctx0, indexer_score, 1.0f / sqrtf(float(n_embd_indexer_head))); + cb(indexer_score, "indexer_score", il); + + // mask indexer scores + ggml_tensor * kq_mask_f32 = ggml_cast(ctx0, kq_mask, GGML_TYPE_F32); + indexer_score = ggml_add(ctx0, indexer_score, kq_mask_f32); + cb(indexer_score, "indexer_score", il); + + uint32_t n_top_k = indexer_score->ne[0] < n_indexer_top_k ? indexer_score->ne[0] : n_indexer_top_k; + ggml_tensor * top_k = ggml_cont(ctx0, ggml_argsort_top_k(ctx0, indexer_score, n_top_k)); + cb(top_k, "top_k", il); + + // modify kq mask by masking tokens that are not in top_k indices + ggml_tensor * kq_mask_top_k = ggml_map_custom2(ctx0, kq_mask_f32, top_k, mask_top_k_callback, GGML_DEFAULT_N_THREADS, NULL); + cb(kq_mask_top_k, "kq_mask_top_k", il); + + ggml_build_forward_expand(gf, ggml_cpy(ctx0, ggml_cast(ctx0, kq_mask_top_k, kq_mask->type), kq_mask)); } ggml_tensor * q = ggml_mul_mat(ctx0, model.layers[il].wq_b, qr); @@ -230,6 +328,8 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ model.layers[il].wo, NULL, Qcur, Kcur, Vcur, nullptr, nullptr, nullptr, kq_scale, il); } + + ggml_build_forward_expand(gf, ggml_cpy(ctx0, kq_mask_bak, kq_mask)); } if (il == effective_n_layers - 1 && inp_out_ids) { cur = ggml_get_rows(ctx0, cur, inp_out_ids); From 3eb340ed4b54e9b469a45a01922d5007937eb44f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Sun, 15 Mar 2026 12:53:03 +0100 Subject: [PATCH 07/46] ggml : add CUDA Hadamard transformation implementation (borrowed from ik_llama.cpp) --- ggml/src/ggml-cuda/ggml-cuda.cu | 7 ++- ggml/src/ggml-cuda/hadamard.cu | 86 +++++++++++++++++++++++++++++++++ ggml/src/ggml-cuda/hadamard.cuh | 3 ++ 3 files changed, 95 insertions(+), 1 deletion(-) create mode 100644 ggml/src/ggml-cuda/hadamard.cu create mode 100644 ggml/src/ggml-cuda/hadamard.cuh diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu index cda275b8c58..6a091a6d8a2 100644 --- a/ggml/src/ggml-cuda/ggml-cuda.cu +++ b/ggml/src/ggml-cuda/ggml-cuda.cu @@ -61,6 +61,7 @@ #include "ggml-cuda/tri.cuh" #include "ggml-cuda/cumsum.cuh" #include "ggml-cuda/fill.cuh" +#include "ggml-cuda/hadamard.cuh" #include "ggml.h" #include @@ -2771,6 +2772,9 @@ static bool ggml_cuda_compute_forward(ggml_backend_cuda_context & ctx, struct gg case GGML_OP_FILL: ggml_cuda_op_fill(ctx, dst); break; + case GGML_OP_HADAMARD: + ggml_cuda_op_hadamard(ctx, dst); + break; default: return false; } @@ -5013,7 +5017,8 @@ static bool ggml_backend_cuda_device_supports_op(ggml_backend_dev_t dev, const g case GGML_OP_DIAG: case GGML_OP_SOLVE_TRI: return true; - + case GGML_OP_HADAMARD: + return (op->ne[0] == 64 || op->ne[0] == 128 || op->ne[0] == 256) && op->type == GGML_TYPE_F32 && op->src[0]->type == GGML_TYPE_F32; default: return false; } diff --git a/ggml/src/ggml-cuda/hadamard.cu b/ggml/src/ggml-cuda/hadamard.cu new file mode 100644 index 00000000000..5f34d2579d4 --- /dev/null +++ b/ggml/src/ggml-cuda/hadamard.cu @@ -0,0 +1,86 @@ +// Copyright (C) 2025 Iwan Kawrakow +// MIT license +// SPDX-License-Identifier: MIT + +#include "hadamard.cuh" + +template +static __global__ void hadamard_f32(const char * src, char * dst, int ne0, + size_t nb01, size_t nb02, size_t nb03, size_t nb1, size_t nb2, size_t nb3) { + + constexpr float ksqrt2 = 0.707106781f; + + int nc = ne0/nh; + int ii1 = blockIdx.x; + int i1 = ii1 / nc; + int ic = ii1 % nc; + int i2 = blockIdx.y; + int i3 = blockIdx.z; + + int tid = threadIdx.x; + + const float * x = (const float *)((const char *)src + i1*nb01 + i2*nb02 + i3*nb03) + ic*nh; + float * y = ( float *)((const char *)dst + i1*nb1 + i2*nb2 + i3*nb3) + ic*nh; + + __shared__ float ys[nh]; + + ys[2*tid+0] = x[2*tid+0] + x[2*tid+1]; + ys[2*tid+1] = x[2*tid+0] - x[2*tid+1]; + + float scale = ksqrt2; + +#pragma unroll + for (int h = 2; h < nh; h <<= 2) { + __syncthreads(); + int ii = tid/h, jj = tid%h; + int j = 2*h*ii+jj; + float u = ys[j], v = ys[j+h]; + ys[j+0] = u + v; + ys[j+h] = u - v; + scale *= ksqrt2; + } + + __syncthreads(); + y[2*tid+0] = ys[2*tid+0] * scale; + y[2*tid+1] = ys[2*tid+1] * scale; +} + +static void hadamard_f32_cuda(int nh, const char * x, char * y, int ne0, int ne1, int ne2, int ne3, + size_t nb01, size_t nb02, size_t nb03, size_t nb1, size_t nb2, size_t nb3, cudaStream_t stream) { + int nc = ne0/nh; + int nrows = nc*ne1; + dim3 num_blocks = dim3(nrows, ne2, ne3); + switch (nh) { + case 64: hadamard_f32< 64><<>>(x, y, ne0, nb01, nb02, nb03, nb1, nb2, nb3); break; + case 128: hadamard_f32<128><<>>(x, y, ne0, nb01, nb02, nb03, nb1, nb2, nb3); break; + case 256: hadamard_f32<256><<>>(x, y, ne0, nb01, nb02, nb03, nb1, nb2, nb3); break; + default: GGML_ABORT("Unsupported Hadamard block size"); + } +} + +#if defined(_MSC_VER) +#pragma warning(disable: 4244 4267) // possible loss of data +#include +#include +#include +#include +#include +static inline int popcount(uint32_t x) { return __popcnt(x); } +#else +static inline int popcount(uint32_t x) { return __builtin_popcount(x); } +#endif + + +void ggml_cuda_op_hadamard(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { + const ggml_tensor * src = dst->src[0]; + GGML_ASSERT(src->type == GGML_TYPE_F32); + GGML_ASSERT(dst->type == GGML_TYPE_F32); + GGML_ASSERT(ggml_are_same_shape(src, dst)); + + int nh = dst->op_params[0]; + GGML_ASSERT(dst->ne[0]%nh == 0); + GGML_ASSERT(nh > 1 && popcount(nh) == 1); + + hadamard_f32_cuda(nh, (const char *)src->data, (char *)dst->data, src->ne[0], src->ne[1], src->ne[2], src->ne[3], + src->nb[1], src->nb[2], src->nb[3], dst->nb[1], dst->nb[2], dst->nb[3], ctx.stream()); +} diff --git a/ggml/src/ggml-cuda/hadamard.cuh b/ggml/src/ggml-cuda/hadamard.cuh new file mode 100644 index 00000000000..17b3ac9468f --- /dev/null +++ b/ggml/src/ggml-cuda/hadamard.cuh @@ -0,0 +1,3 @@ +#include "common.cuh" + +void ggml_cuda_op_hadamard(ggml_backend_cuda_context & ctx, ggml_tensor * dst); From 08dc7fd9d9b862976ad9f0bc8749c1c4072f596b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Sun, 15 Mar 2026 21:58:49 +0100 Subject: [PATCH 08/46] ggml : add new GGML_OP_WHERE_ID (akin to torch where but using indices) --- ggml/include/ggml.h | 7 +++ ggml/src/ggml-cpu/ggml-cpu.c | 5 +++ ggml/src/ggml-cpu/ops.cpp | 78 +++++++++++++++++++++++++++++++++ ggml/src/ggml-cpu/ops.h | 1 + ggml/src/ggml-cuda/ggml-cuda.cu | 5 +++ ggml/src/ggml-cuda/where-id.cu | 77 ++++++++++++++++++++++++++++++++ ggml/src/ggml-cuda/where-id.cuh | 3 ++ ggml/src/ggml.c | 29 +++++++++++- 8 files changed, 203 insertions(+), 2 deletions(-) create mode 100644 ggml/src/ggml-cuda/where-id.cu create mode 100644 ggml/src/ggml-cuda/where-id.cuh diff --git a/ggml/include/ggml.h b/ggml/include/ggml.h index 547ccc42aa5..82186fe8f63 100644 --- a/ggml/include/ggml.h +++ b/ggml/include/ggml.h @@ -558,6 +558,7 @@ extern "C" { GGML_OP_SOLVE_TRI, GGML_OP_GATED_DELTA_NET, GGML_OP_HADAMARD, + GGML_OP_WHERE_ID, GGML_OP_UNARY, @@ -2479,6 +2480,12 @@ extern "C" { struct ggml_tensor * a, int n); + GGML_API struct ggml_tensor * ggml_where_id( + struct ggml_context * ctx, + struct ggml_tensor * a, + struct ggml_tensor * b, + struct ggml_tensor * ids); + // custom operators typedef void (*ggml_custom1_op_t)(struct ggml_tensor * dst , const struct ggml_tensor * a, int ith, int nth, void * userdata); diff --git a/ggml/src/ggml-cpu/ggml-cpu.c b/ggml/src/ggml-cpu/ggml-cpu.c index bed01ae65ca..e5e5f0507e1 100644 --- a/ggml/src/ggml-cpu/ggml-cpu.c +++ b/ggml/src/ggml-cpu/ggml-cpu.c @@ -2029,6 +2029,10 @@ static void ggml_compute_forward(struct ggml_compute_params * params, struct ggm { ggml_compute_forward_hadamard(params, tensor); } break; + case GGML_OP_WHERE_ID: + { + ggml_compute_forward_where_id(params, tensor); + } break; case GGML_OP_MAP_CUSTOM1: { ggml_compute_forward_map_custom1(params, tensor); @@ -2352,6 +2356,7 @@ static int ggml_get_n_tasks(struct ggml_tensor * node, int n_threads) { case GGML_OP_GATED_LINEAR_ATTN: case GGML_OP_RWKV_WKV7: case GGML_OP_HADAMARD: + case GGML_OP_WHERE_ID: { n_tasks = n_threads; } break; diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index 111a474a6f4..c4a77b29e92 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11256,3 +11256,81 @@ void ggml_compute_forward_hadamard( } } } + +// ggml_compute_forward_where_id + +static void ggml_compute_forward_where_id_f32( + const ggml_compute_params * params, + ggml_tensor * dst) { + + const ggml_tensor * src0 = dst->src[0]; + const ggml_tensor * src1 = dst->src[1]; + const ggml_tensor * src2 = dst->src[2]; + + GGML_ASSERT(ggml_are_same_shape(src0, src1) && ggml_are_same_shape(src0, dst)); + + GGML_ASSERT(dst->type == GGML_TYPE_F32); + GGML_ASSERT(src0->type == GGML_TYPE_F32); + GGML_ASSERT(src1->type == GGML_TYPE_F32); + GGML_ASSERT(src2->type == GGML_TYPE_I32); + + GGML_ASSERT(src0->nb[0] == sizeof(float)); + GGML_ASSERT(src1->nb[0] == sizeof(float)); + + const int ith = params->ith; + const int nth = params->nth; + + const int nr = ggml_nrows(src0); + + GGML_TENSOR_TERNARY_OP_LOCALS + + GGML_ASSERT( nb0 == sizeof(float)); + GGML_ASSERT(nb00 == sizeof(float)); + + // rows per thread + const int dr = (nr + nth - 1)/nth; + + // row range for this thread + const int ir0 = dr*ith; + const int ir1 = MIN(ir0 + dr, nr); + + for (int ir = ir0; ir < ir1; ++ir) { + // src0 indices + const int i3 = ir/(ne2*ne1); + const int i2 = (ir - i3*ne2*ne1)/ne1; + const int i1 = (ir - i3*ne2*ne1 - i2*ne1); + + const float * src0_ptr = (float *) ((char *) src0->data + i3*nb3 + i2*nb2 + i1*nb1 ); + const float * src1_ptr = (float *) ((char *) src1->data + i3*nb13 + i2*nb12 + i1*nb11 ); + const int32_t * ids_ptr = (int32_t *) ((char *) src2->data + i3*nb23 + i2*nb22 + i1*nb21); + float * dst_ptr = (float *) ((char *) dst->data + i3*nb3 + i2*nb2 + i1*nb1 ); + + // copy whole row from src1 + ggml_vec_cpy_f32(ne00, dst_ptr, src1_ptr); + + // copy only values from src0 indicated by indices in src2 + for (int j = 0; j < ne20; ++j) { + int id = ids_ptr[j]; + GGML_ASSERT(id >= 0 && id < ne00); + dst_ptr[id] = src0_ptr[id]; + } + } +} + +void ggml_compute_forward_where_id( + const ggml_compute_params * params, + ggml_tensor * dst) { + + const ggml_tensor * src0 = dst->src[0]; + + switch (src0->type) { + case GGML_TYPE_F32: + { + ggml_compute_forward_where_id_f32(params, dst); + } break; + default: + { + GGML_ABORT("unsupported type for ggml_compute_forward_where_id: %s", ggml_type_name(src0->type)); + } + } +} diff --git a/ggml/src/ggml-cpu/ops.h b/ggml/src/ggml-cpu/ops.h index c28d32ea914..30b3e6d3118 100644 --- a/ggml/src/ggml-cpu/ops.h +++ b/ggml/src/ggml-cpu/ops.h @@ -104,6 +104,7 @@ void ggml_compute_forward_solve_tri(const struct ggml_compute_params * params, s void ggml_compute_forward_gla(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_gated_delta_net(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_hadamard(const struct ggml_compute_params * params, struct ggml_tensor * dst); +void ggml_compute_forward_where_id(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom1(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom2(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom3(const struct ggml_compute_params * params, struct ggml_tensor * dst); diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu index 6a091a6d8a2..da2b54e137c 100644 --- a/ggml/src/ggml-cuda/ggml-cuda.cu +++ b/ggml/src/ggml-cuda/ggml-cuda.cu @@ -62,6 +62,7 @@ #include "ggml-cuda/cumsum.cuh" #include "ggml-cuda/fill.cuh" #include "ggml-cuda/hadamard.cuh" +#include "ggml-cuda/where-id.cuh" #include "ggml.h" #include @@ -2775,6 +2776,9 @@ static bool ggml_cuda_compute_forward(ggml_backend_cuda_context & ctx, struct gg case GGML_OP_HADAMARD: ggml_cuda_op_hadamard(ctx, dst); break; + case GGML_OP_WHERE_ID: + ggml_cuda_op_where_id(ctx, dst); + break; default: return false; } @@ -5016,6 +5020,7 @@ static bool ggml_backend_cuda_device_supports_op(ggml_backend_dev_t dev, const g case GGML_OP_TRI: case GGML_OP_DIAG: case GGML_OP_SOLVE_TRI: + case GGML_OP_WHERE_ID: return true; case GGML_OP_HADAMARD: return (op->ne[0] == 64 || op->ne[0] == 128 || op->ne[0] == 256) && op->type == GGML_TYPE_F32 && op->src[0]->type == GGML_TYPE_F32; diff --git a/ggml/src/ggml-cuda/where-id.cu b/ggml/src/ggml-cuda/where-id.cu new file mode 100644 index 00000000000..993873462bb --- /dev/null +++ b/ggml/src/ggml-cuda/where-id.cu @@ -0,0 +1,77 @@ +#include "where-id.cuh" + +static __global__ void where_id_kernel( + const float * src0, const int32_t * src1, float * dst, + int64_t ne10, int64_t ne11, int64_t ne12, + size_t nb1, size_t nb2, + size_t nb01, size_t nb02, + size_t nb11, size_t nb12 + ) { + + const int64_t total_blocks = ne11 * ne12; + + for (int64_t block_idx = blockIdx.x; block_idx < total_blocks; block_idx += gridDim.x) { + + const int64_t i1 = block_idx % ne11; + const int64_t i2 = block_idx / ne11; + + float * dst_row = (float *)((char *)dst + i1*nb1 + i2*nb2); + const float * src0_row = (const float *)((const char *)src0 + i1*nb01 + i2*nb02); + const int * src1_row = (const int *)((const char *)src1 + i1*nb11 + i2*nb12); + + for (int64_t i0 = threadIdx.x; i0 < ne10; i0 += blockDim.x) { + const int32_t id = src1_row[i0]; + dst_row[id] = src0_row[id]; + } + } +} + +void ggml_cuda_op_where_id(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { + const ggml_tensor * src0 = dst->src[0]; + const ggml_tensor * src1 = dst->src[1]; + const ggml_tensor * src2 = dst->src[2]; + + GGML_TENSOR_TERNARY_OP_LOCALS + + GGML_ASSERT(ggml_is_contiguous(dst)); + GGML_ASSERT(ggml_is_contiguous(src0)); + GGML_ASSERT(ggml_is_contiguous(src1)); + GGML_ASSERT(ggml_is_contiguous(src2)); + + GGML_ASSERT(dst->type == GGML_TYPE_F32); + GGML_ASSERT(src0->type == GGML_TYPE_F32); + GGML_ASSERT(src1->type == GGML_TYPE_F32); + GGML_ASSERT(src2->type == GGML_TYPE_I32); + + GGML_ASSERT(nb00 == sizeof(float)); + GGML_ASSERT(nb10 == sizeof(float)); + GGML_ASSERT(nb20 == sizeof(int32_t)); + + GGML_ASSERT(ggml_nbytes(src0) == ggml_nbytes(src1)); + GGML_ASSERT(ggml_nbytes(src0) == ggml_nbytes(dst)); + + // step 1 - copy whole src1 to dst + cudaStream_t main_stream = ctx.stream(); + char * dst_ddc = (char *) dst->data; + char * src1_ddc = (char *) src1->data; + + CUDA_CHECK(cudaMemcpyAsync(dst_ddc, src1_ddc, ggml_nbytes(src1), cudaMemcpyDeviceToDevice, main_stream)); + + // step 2 - copy elements from src0 indicated by ids to dst + const float * src0_d = (const float *) src0->data; + const int32_t * src2_d = (const int32_t *) src2->data; + float * dst_d = (float *) dst->data; + + int threads = std::min((int) ne20, 768); // ids + + int64_t total_blocks = ne21 * ne22; + int blocks = (int) std::min((int64_t) 65535, total_blocks); + + where_id_kernel<<>>( + src0_d, src2_d, dst_d, + ne20, ne21, ne22, + nb1, nb2, + nb01, nb02, + nb21, nb22 + ); +} diff --git a/ggml/src/ggml-cuda/where-id.cuh b/ggml/src/ggml-cuda/where-id.cuh new file mode 100644 index 00000000000..bf3ea095a81 --- /dev/null +++ b/ggml/src/ggml-cuda/where-id.cuh @@ -0,0 +1,3 @@ +#include "common.cuh" + +void ggml_cuda_op_where_id(ggml_backend_cuda_context & ctx, ggml_tensor * dst); diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index a01ee49ee36..7132c1f2155 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -1033,6 +1033,7 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "SOLVE_TRI", "GATED_DELTA_NET", "HADAMARD", + "WHERE_ID", "UNARY", @@ -1050,7 +1051,7 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "GLU", }; -static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); +static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT != 98"); static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "none", @@ -1144,6 +1145,7 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "A X = B, A triangular, solve X", "gated_delta_net(q, k, v, g, beta, s)", "hadamard(x)", + "where_id(x,y,ids)", "unary(x)", @@ -1161,7 +1163,7 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "glu(x)", }; -static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); +static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT != 98"); static_assert(GGML_OP_POOL_COUNT == 2, "GGML_OP_POOL_COUNT != 2"); @@ -6201,6 +6203,29 @@ struct ggml_tensor * ggml_hadamard( return result; } +// ggml_where_id + +struct ggml_tensor * ggml_where_id( + struct ggml_context * ctx, + struct ggml_tensor * a, + struct ggml_tensor * b, + struct ggml_tensor * ids) { + + GGML_ASSERT(a->type == GGML_TYPE_F32); + GGML_ASSERT(b->type == GGML_TYPE_F32); + GGML_ASSERT(ids->type == GGML_TYPE_I32); + GGML_ASSERT(a->ne[1] == ids->ne[1]); + + struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, GGML_MAX_DIMS, a->ne); + + result->op = GGML_OP_WHERE_ID; + result->src[0] = a; + result->src[1] = b; + result->src[2] = ids; + + return result; +} + //////////////////////////////////////////////////////////////////////////////// struct ggml_hash_set ggml_hash_set_new(size_t size) { From 998f496475f54e7af2e03fecc744b98ab26ed185 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Sun, 15 Mar 2026 22:09:33 +0100 Subject: [PATCH 09/46] model : used new GGML_OP_WHERE_ID op in DeepSeek V3.2 lightning indexer implementation --- src/models/deepseek32.cpp | 39 ++++++--------------------------------- 1 file changed, 6 insertions(+), 33 deletions(-) diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index 20d31f73acf..aad6ecf5322 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -2,37 +2,6 @@ #include "llama-kv-cache.h" -void mask_top_k_callback(struct ggml_tensor * dst, const struct ggml_tensor * a, const struct ggml_tensor * b, int ith, int nth, void * userdata) { - // a = kq_mask, b = top_k, dst = output tensor - const int n_seq = a->ne[1]; - const int n_tokens = a->ne[0]; - const int k = b->ne[0]; - - // Get data pointers (assuming F32 for mask, I32 for indices) - const float * mask_data = (const float *) a->data; - const int32_t * topk_data = (const int32_t *) b->data; - float * dst_data = (float *) dst->data; - - // Distribute work across threads if nth > 1 - const int start_row = (n_seq * ith) / nth; - const int end_row = (n_seq * (ith + 1)) / nth; - - for (int i = start_row; i < end_row; ++i) { - // First, set the entire row to -inf - for (int j = 0; j < n_tokens; ++j) { - dst_data[i * n_tokens + j] = -INFINITY; - } - - // Then, restore the values indicated by top_k - for (int j = 0; j < k; ++j) { - int32_t keep_idx = topk_data[i * k + j]; - if (keep_idx >= 0 && keep_idx < n_tokens) { - dst_data[i * n_tokens + keep_idx] = mask_data[i * n_tokens + keep_idx]; - } - } - } -} - llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_graph_params & params) : llm_graph_context(params) { const bool is_mla = hparams.is_mla(); @@ -214,8 +183,12 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ ggml_tensor * top_k = ggml_cont(ctx0, ggml_argsort_top_k(ctx0, indexer_score, n_top_k)); cb(top_k, "top_k", il); - // modify kq mask by masking tokens that are not in top_k indices - ggml_tensor * kq_mask_top_k = ggml_map_custom2(ctx0, kq_mask_f32, top_k, mask_top_k_callback, GGML_DEFAULT_N_THREADS, NULL); + // prepare new kq mask - starts filled with -INFINITY + ggml_tensor * kq_mask_all = ggml_fill(ctx0, kq_mask_f32, -INFINITY); + cb(kq_mask_all, "kq_mask_all", il); + + // modify it by unmasking tokens that are in top_k indices + ggml_tensor * kq_mask_top_k = ggml_where_id(ctx0, kq_mask_f32, kq_mask_all, top_k); cb(kq_mask_top_k, "kq_mask_top_k", il); ggml_build_forward_expand(gf, ggml_cpy(ctx0, ggml_cast(ctx0, kq_mask_top_k, kq_mask->type), kq_mask)); From 6c9d773669dfd8898eec8f5f3e20d5b44b619a21 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 16 Mar 2026 16:56:06 +0100 Subject: [PATCH 10/46] model : handle multiple streams in DeepSeek V3.2 lightning indexer --- src/models/deepseek32.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index aad6ecf5322..23bb45c5344 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -145,6 +145,11 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ // get cached indexer keys indexer_k = mctx_cur->get_ik(ctx0, il); + // split the batch into streams if needed + const auto n_stream = indexer_k->ne[3]; + indexer_q = ggml_view_4d(ctx0, indexer_q, indexer_q->ne[0], indexer_q->ne[1], indexer_q->ne[2]/n_stream, n_stream, indexer_q->nb[1], indexer_q->nb[2], indexer_q->nb[3]/n_stream, 0); + indexer_weights = ggml_view_4d(ctx0, indexer_weights, indexer_weights->ne[0], indexer_weights->ne[1]/n_stream, indexer_weights->ne[2], n_stream, indexer_weights->nb[1], indexer_weights->nb[2]/n_stream, indexer_weights->nb[3]/n_stream, 0); + indexer_q = ggml_permute(ctx0, indexer_q, 0, 2, 1, 3); cb(indexer_q, "indexer_q", il); indexer_k = ggml_permute(ctx0, indexer_k, 0, 2, 1, 3); From cb94b565adc7d902f1501ae1718f1161c21875b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 16 Mar 2026 16:56:35 +0100 Subject: [PATCH 11/46] ggml : handle multiple streams in CUDA GGML_OP_WHERE_ID implementation --- ggml/src/ggml-cuda/where-id.cu | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/ggml/src/ggml-cuda/where-id.cu b/ggml/src/ggml-cuda/where-id.cu index 993873462bb..2d9130035ab 100644 --- a/ggml/src/ggml-cuda/where-id.cu +++ b/ggml/src/ggml-cuda/where-id.cu @@ -2,22 +2,23 @@ static __global__ void where_id_kernel( const float * src0, const int32_t * src1, float * dst, - int64_t ne10, int64_t ne11, int64_t ne12, - size_t nb1, size_t nb2, - size_t nb01, size_t nb02, - size_t nb11, size_t nb12 + int64_t ne10, int64_t ne11, int64_t ne12, int64_t ne13, + size_t nb1, size_t nb2, size_t nb3, + size_t nb01, size_t nb02, size_t nb03, + size_t nb11, size_t nb12, size_t nb13 ) { - const int64_t total_blocks = ne11 * ne12; + const int64_t total_blocks = ne11 * ne12 * ne13; for (int64_t block_idx = blockIdx.x; block_idx < total_blocks; block_idx += gridDim.x) { const int64_t i1 = block_idx % ne11; - const int64_t i2 = block_idx / ne11; + const int64_t i2 = (block_idx / ne11) % ne12; + const int64_t i3 = block_idx / (ne11 * ne12); - float * dst_row = (float *)((char *)dst + i1*nb1 + i2*nb2); - const float * src0_row = (const float *)((const char *)src0 + i1*nb01 + i2*nb02); - const int * src1_row = (const int *)((const char *)src1 + i1*nb11 + i2*nb12); + float * dst_row = (float *)((char *)dst + i1*nb1 + i2*nb2 + i3*nb3); + const float * src0_row = (const float *)((const char *)src0 + i1*nb01 + i2*nb02 + i3*nb03); + const int * src1_row = (const int *)((const char *)src1 + i1*nb11 + i2*nb12 + i3*nb13); for (int64_t i0 = threadIdx.x; i0 < ne10; i0 += blockDim.x) { const int32_t id = src1_row[i0]; @@ -64,14 +65,14 @@ void ggml_cuda_op_where_id(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { int threads = std::min((int) ne20, 768); // ids - int64_t total_blocks = ne21 * ne22; + int64_t total_blocks = ne21 * ne22 * ne23; int blocks = (int) std::min((int64_t) 65535, total_blocks); where_id_kernel<<>>( src0_d, src2_d, dst_d, - ne20, ne21, ne22, - nb1, nb2, - nb01, nb02, - nb21, nb22 + ne20, ne21, ne22, ne23, + nb1, nb2, nb3, + nb01, nb02, nb03, + nb21, nb22, nb23 ); } From 02c215991cf28bf96596b6c80df8c36ff257c614 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 16 Mar 2026 17:00:35 +0100 Subject: [PATCH 12/46] kv-cache : fix crashes for models without indexer --- src/llama-kv-cache.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/llama-kv-cache.cpp b/src/llama-kv-cache.cpp index bea96501f9a..2752ac2119f 100644 --- a/src/llama-kv-cache.cpp +++ b/src/llama-kv-cache.cpp @@ -1608,7 +1608,7 @@ size_t llama_kv_cache::size_ik_bytes() const { size_t size_ik_bytes = 0; for (const auto & layer : layers) { - size_ik_bytes += ggml_nbytes(layer.ik); + size_ik_bytes += layer.ik ? ggml_nbytes(layer.ik) : 0; } return size_ik_bytes; From e7aa89a48c9ea815a90699b59baa863b92b6e9e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Sun, 22 Mar 2026 13:42:19 +0100 Subject: [PATCH 13/46] model : replaced ggml_argsort_top_k with ggml_top_k in DeepSeek V3.2 indexer implementation since the former fails for large tensors even when using CCCL. --- src/models/deepseek32.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index 23bb45c5344..372eace7108 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -185,7 +185,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_score, "indexer_score", il); uint32_t n_top_k = indexer_score->ne[0] < n_indexer_top_k ? indexer_score->ne[0] : n_indexer_top_k; - ggml_tensor * top_k = ggml_cont(ctx0, ggml_argsort_top_k(ctx0, indexer_score, n_top_k)); + ggml_tensor * top_k = ggml_cont(ctx0, ggml_top_k(ctx0, indexer_score, n_top_k)); cb(top_k, "top_k", il); // prepare new kq mask - starts filled with -INFINITY From 1874ac9b86ff94c2b6c4fc9c9ac826667db7ba3a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 23 Mar 2026 09:31:27 +0100 Subject: [PATCH 14/46] model : added comments in DeepSeek V3.2 lightning indexer implementation. --- src/models/deepseek32.cpp | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index 372eace7108..4f334462d5d 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -92,7 +92,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ ext_factor, attn_factor, beta_fast, beta_slow); cb(indexer_q_pe, "indexer_q_pe", il); - // {n_embd_indexer_head_qk_rope + n_embd_indexer_head_qk_nope, n_head, n_tokens} + // {n_embd_indexer_head_rope + n_embd_indexer_head_nope, n_head, n_tokens} indexer_q = ggml_concat(ctx0, indexer_q_pe, indexer_q_nope, 0); cb(indexer_q, "indexer_q", il); @@ -102,14 +102,14 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ indexer_k = build_norm(indexer_k, model.layers[il].indexer_k_norm, model.layers[il].indexer_k_norm_b, LLM_NORM, il); cb(indexer_k, "indexer_k", il); - // split into {n_embd_indexer_head_qk_rope, 1, n_tokens} + // split into {n_embd_indexer_head_rope, 1, n_tokens} ggml_tensor * indexer_k_pe = ggml_view_3d(ctx0, indexer_k, n_embd_indexer_head_rope, 1, n_tokens, ggml_row_size(indexer_k->type, n_embd_indexer_head), ggml_row_size(indexer_k->type, n_embd_indexer_head) * 1, 0); cb(indexer_k_pe, "indexer_k_pe", il); - // and {n_embd_indexer_head_qk_nope, 1, n_tokens} + // and {n_embd_indexer_head_nope, 1, n_tokens} ggml_tensor * indexer_k_nope = ggml_view_3d(ctx0, indexer_k, n_embd_indexer_head_nope, 1, n_tokens, ggml_row_size(indexer_k->type, n_embd_indexer_head), @@ -122,20 +122,22 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ ext_factor, attn_factor, beta_fast, beta_slow); cb(indexer_k_pe, "indexer_k_pe", il); - // {n_embd_indexer_head_qk_rope + n_embd_indexer_head_qk_nope, 1, n_tokens} + // {n_embd_indexer_head_rope + n_embd_indexer_head_nope, 1, n_tokens} indexer_k = ggml_concat(ctx0, indexer_k_pe, indexer_k_nope, 0); cb(indexer_k, "indexer_k", il); + // perform Hadamard transform on indexer q and k indexer_q = ggml_hadamard(ctx0, indexer_q, n_embd_indexer_head); cb(indexer_q, "indexer_q", il); indexer_k = ggml_hadamard(ctx0, indexer_k, n_embd_indexer_head); cb(indexer_k, "indexer_k", il); - // store to KV cache + // store indexer keys to KV cache const auto * mctx_cur = is_mla ? inp_attn_k->mctx : inp_attn_kv->mctx; const auto & k_idxs = is_mla ? inp_attn_k->get_k_idxs() : inp_attn_kv->get_k_idxs(); ggml_build_forward_expand(gf, mctx_cur->cpy_ik(ctx0, indexer_k, k_idxs, il)); + // prepare indexer weights ggml_tensor * indexer_weights = ggml_mul_mat(ctx0, model.layers[il].indexer_proj, cur); cb(indexer_weights, "indexer_weights", il); @@ -150,6 +152,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ indexer_q = ggml_view_4d(ctx0, indexer_q, indexer_q->ne[0], indexer_q->ne[1], indexer_q->ne[2]/n_stream, n_stream, indexer_q->nb[1], indexer_q->nb[2], indexer_q->nb[3]/n_stream, 0); indexer_weights = ggml_view_4d(ctx0, indexer_weights, indexer_weights->ne[0], indexer_weights->ne[1]/n_stream, indexer_weights->ne[2], n_stream, indexer_weights->nb[1], indexer_weights->nb[2]/n_stream, indexer_weights->nb[3]/n_stream, 0); + // calculate indexer kq indexer_q = ggml_permute(ctx0, indexer_q, 0, 2, 1, 3); cb(indexer_q, "indexer_q", il); indexer_k = ggml_permute(ctx0, indexer_k, 0, 2, 1, 3); @@ -158,15 +161,19 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ ggml_tensor * indexer_kq = ggml_mul_mat(ctx0, indexer_k, indexer_q); cb(indexer_kq, "indexer_kq", il); + // ReLU requires contiguous tensors indexer_kq = ggml_cont(ctx0, ggml_permute(ctx0, indexer_kq, 2, 1, 0, 3)); cb(indexer_kq, "indexer_kq", il); + // apply ReLU ggml_tensor * indexer_score = ggml_relu(ctx0, indexer_kq); cb(indexer_score, "indexer_score", il); + // multiply scores by indexer weights indexer_score = ggml_mul(ctx0, indexer_score, indexer_weights); cb(indexer_score, "indexer_score", il); + // sum by q n_indexer_head dimension indexer_score = ggml_sum_rows(ctx0, indexer_score); cb(indexer_score, "indexer_score", il); @@ -176,6 +183,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ indexer_score = ggml_cont(ctx0, indexer_score); cb(indexer_score, "indexer_score", il); + // TODO maybe pre-scale indexer weights, so we won't have to do it here indexer_score = ggml_scale(ctx0, indexer_score, 1.0f / sqrtf(float(n_embd_indexer_head))); cb(indexer_score, "indexer_score", il); @@ -184,6 +192,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ indexer_score = ggml_add(ctx0, indexer_score, kq_mask_f32); cb(indexer_score, "indexer_score", il); + // get indices of top k indexer scores uint32_t n_top_k = indexer_score->ne[0] < n_indexer_top_k ? indexer_score->ne[0] : n_indexer_top_k; ggml_tensor * top_k = ggml_cont(ctx0, ggml_top_k(ctx0, indexer_score, n_top_k)); cb(top_k, "top_k", il); From 4309c8486a946a4feea8180ed3bfd51190be7e1d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Tue, 24 Mar 2026 13:51:33 +0100 Subject: [PATCH 15/46] kv-cache : added llama_kv_cache_dsa KV cache specific to DSA composed of llama_kv_cache and new llama_ik_cache (lightning indexer key cache). model : used new llama_kv_cache_dsa instead of modified llama_kv_cache with indexer keys in DeepseekV32ForCausalLM model : removed non-MLA path in DeepseekV32ForCausalLM --- src/CMakeLists.txt | 2 + src/llama-graph.cpp | 149 +++ src/llama-graph.h | 50 + src/llama-ik-cache.cpp | 1885 ++++++++++++++++++++++++++++++++++++ src/llama-ik-cache.h | 306 ++++++ src/llama-kv-cache-dsa.cpp | 251 +++++ src/llama-kv-cache-dsa.h | 137 +++ src/llama-kv-cache.cpp | 93 +- src/llama-kv-cache.h | 7 - src/llama-model.cpp | 18 + src/models/deepseek32.cpp | 74 +- 11 files changed, 2819 insertions(+), 153 deletions(-) create mode 100644 src/llama-ik-cache.cpp create mode 100644 src/llama-ik-cache.h create mode 100644 src/llama-kv-cache-dsa.cpp create mode 100644 src/llama-kv-cache-dsa.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e524ebd2f2b..75e45b9763b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -22,6 +22,8 @@ add_library(llama llama-io.cpp llama-kv-cache.cpp llama-kv-cache-iswa.cpp + llama-ik-cache.cpp + llama-kv-cache-dsa.cpp llama-memory.cpp llama-memory-hybrid.cpp llama-memory-hybrid-iswa.cpp diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index 528f8e54584..8224e4873fd 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -6,6 +6,7 @@ #include "llama-kv-cache.h" #include "llama-kv-cache-iswa.h" +#include "llama-kv-cache-dsa.h" #include "llama-memory-hybrid.h" #include "llama-memory-hybrid-iswa.h" #include "llama-memory-recurrent.h" @@ -31,6 +32,18 @@ static ggml_tensor * build_kq_mask( return ggml_new_tensor_4d(ctx, GGML_TYPE_F32, n_kv, n_tokens/n_stream, 1, n_stream); } +static ggml_tensor * build_kq_mask( + ggml_context * ctx, + const llama_ik_cache_context * mctx, + const llama_ubatch & ubatch, + const llama_cparams & cparams) { + const auto n_kv = mctx->get_n_kv(); + const auto n_tokens = ubatch.n_tokens; + const auto n_stream = cparams.kv_unified ? 1 : ubatch.n_seqs_unq; + + return ggml_new_tensor_4d(ctx, GGML_TYPE_F32, n_kv, n_tokens/n_stream, 1, n_stream); +} + static bool can_reuse_kq_mask( ggml_tensor * kq_mask, const llama_kv_cache_context * mctx, @@ -50,6 +63,25 @@ static bool can_reuse_kq_mask( return res; } +static bool can_reuse_kq_mask( + ggml_tensor * kq_mask, + const llama_ik_cache_context * mctx, + const llama_ubatch & ubatch, + const llama_cparams & cparams) { + const auto n_kv = mctx->get_n_kv(); + const auto n_tokens = ubatch.n_tokens; + const auto n_stream = cparams.kv_unified ? 1 : ubatch.n_seqs_unq; + + bool res = true; + + res &= (kq_mask->ne[0] == n_kv); + res &= (kq_mask->ne[1] == n_tokens/n_stream); + res &= (kq_mask->ne[2] == 1); + res &= (kq_mask->ne[3] == n_stream); + + return res; +} + // impl void llm_graph_input_embd::set_input(const llama_ubatch * ubatch) { @@ -2108,6 +2140,112 @@ ggml_tensor * llm_graph_context::build_attn( return cur; } +ggml_tensor * llm_graph_context::build_attn( + llm_graph_input_attn_k * inp, + ggml_tensor * wo, + ggml_tensor * wo_b, + ggml_tensor * q_cur, + ggml_tensor * k_cur, + ggml_tensor * v_cur, + ggml_tensor * kq_b, + ggml_tensor * sinks, + ggml_tensor * v_mla, + ggml_tensor * top_k, + float kq_scale, + int il) const { + // these nodes are added to the graph together so that they are not reordered + // by doing so, the number of splits in the graph is reduced + // expand k later to enable rope fusion which directly writes into k-v cache + ggml_build_forward_expand(gf, q_cur); + ggml_build_forward_expand(gf, v_cur); + ggml_build_forward_expand(gf, k_cur); + + const auto * mctx_cur = inp->mctx; + + // store to KV cache + { + const auto & k_idxs = inp->get_k_idxs(); + + ggml_build_forward_expand(gf, mctx_cur->cpy_k(ctx0, k_cur, k_idxs, il)); + } + + const auto & kq_mask = inp->get_kq_mask(); + + ggml_tensor * kq_mask_f32 = ggml_cast(ctx0, kq_mask, GGML_TYPE_F32); + + // prepare new kq mask - starts filled with -INFINITY + ggml_tensor * kq_mask_all = ggml_fill(ctx0, kq_mask_f32, -INFINITY); + + // modify it by unmasking tokens that are in top_k indices + ggml_tensor * kq_mask_top_k = ggml_where_id(ctx0, kq_mask_f32, kq_mask_all, top_k); + kq_mask_top_k = ggml_cast(ctx0, kq_mask_top_k, kq_mask->type); + + ggml_tensor * q = q_cur; + ggml_tensor * k = mctx_cur->get_k(ctx0, il); + ggml_tensor * v = ggml_view_4d(ctx0, k, v_cur->ne[0], k->ne[1], k->ne[2], k->ne[3], k->nb[1], k->nb[2], k->nb[3], 0); + + ggml_tensor * cur = build_attn_mha(q, k, v, kq_b, kq_mask_top_k, sinks, v_mla, kq_scale, il); + cb(cur, "kqv_out", il); + + if (wo) { + cur = build_lora_mm(wo, cur); + if (arch == LLM_ARCH_GLM4 || arch == LLM_ARCH_GLM4_MOE) { + // GLM4 and GLM4_MOE seem to have numerical issues with half-precision accumulators + ggml_mul_mat_set_prec(cur, GGML_PREC_F32); + } + } + + if (wo_b) { + cur = ggml_add(ctx0, cur, wo_b); + } + + return cur; +} + + +static std::unique_ptr build_attn_inp_ik_impl( + ggml_context * ctx0, + const llama_ubatch & ubatch, + const llama_hparams & hparams, + const llama_cparams & cparams, + const llama_ik_cache_context * mctx_cur) { + + auto inp = std::make_unique(hparams, cparams, mctx_cur); + + { + GGML_ASSERT(hparams.swa_type == LLAMA_SWA_TYPE_NONE && "Use llama_kv_cache_iswa for SWA"); + + inp->self_k_idxs = mctx_cur->build_input_k_idxs(ctx0, ubatch); + + inp->self_kq_mask = build_kq_mask(ctx0, mctx_cur, ubatch, cparams); + ggml_set_input(inp->self_kq_mask); + + inp->self_kq_mask_cnv = inp->self_kq_mask; + } + + return inp; +} + +void llm_graph_input_attn_ik::set_input(const llama_ubatch * ubatch) { + mctx->set_input_k_idxs(self_k_idxs, ubatch); + + mctx->set_input_kq_mask(self_kq_mask, ubatch, cparams.causal_attn); +} + +bool llm_graph_input_attn_ik::can_reuse(const llm_graph_params & params) { + const auto * mctx = static_cast(params.mctx); + + this->mctx = mctx; + + bool res = true; + + res &= self_k_idxs->ne[0] == params.ubatch.n_tokens; + + res &= can_reuse_kq_mask(self_kq_mask, mctx, params.ubatch, params.cparams); + + return res; +} + ggml_tensor * llm_graph_context::build_attn( llm_graph_input_attn_kv_iswa * inp, ggml_tensor * wo, @@ -2230,6 +2368,17 @@ ggml_tensor * llm_graph_context::build_attn( return cur; } +std::pair llm_graph_context::build_attn_inp_k_dsa() const { + const auto * mctx_cur = static_cast(mctx); + + auto inp_k = build_attn_inp_k_impl(ctx0, ubatch, hparams, cparams, mctx_cur->get_base()); + auto inp_ik = build_attn_inp_ik_impl(ctx0, ubatch, hparams, cparams, mctx_cur->get_ik()); + + return std::make_pair( + (llm_graph_input_attn_k *) res->add_input(std::move(inp_k)), + (llm_graph_input_attn_ik *) res->add_input(std::move(inp_ik))); +} + // TODO: maybe separate the inner implementation into a separate function // like with the non-sliding window equivalent // once sliding-window hybrid caches are a thing. diff --git a/src/llama-graph.h b/src/llama-graph.h index 7f6c9e96356..55cf5031551 100644 --- a/src/llama-graph.h +++ b/src/llama-graph.h @@ -21,6 +21,7 @@ struct llama_cparams; struct llama_memory_context_i; class llama_kv_cache_context; +class llama_ik_cache_context; class llama_kv_cache_iswa_context; class llama_memory_recurrent_context; class llama_memory_hybrid_context; @@ -350,6 +351,39 @@ class llm_graph_input_attn_k : public llm_graph_input_i { const llama_kv_cache_context * mctx; }; +// V-less input for the indexer KV cache +class llm_graph_input_attn_ik : public llm_graph_input_i { +public: + llm_graph_input_attn_ik( + const llama_hparams & hparams, + const llama_cparams & cparams, + const llama_ik_cache_context * mctx) : + hparams(hparams), + cparams(cparams), + mctx(mctx) { + } + ~llm_graph_input_attn_ik() = default; + + void set_input(const llama_ubatch * ubatch) override; + + bool can_reuse(const llm_graph_params & params) override; + + ggml_tensor * get_k_idxs() const { return self_k_idxs; } + + ggml_tensor * get_kq_mask() const { return self_kq_mask_cnv; } + + ggml_tensor * self_k_idxs = nullptr; // I64 [n_batch] + + ggml_tensor * self_kq_mask = nullptr; // F32 [n_kv, n_batch/n_stream, 1, n_stream] + ggml_tensor * self_kq_mask_cnv = nullptr; // [n_kv, n_batch/n_stream, 1, n_stream] + + const llama_hparams hparams; + const llama_cparams cparams; + + const llama_ik_cache_context * mctx; +}; + + class llm_graph_input_attn_kv_iswa : public llm_graph_input_i { public: llm_graph_input_attn_kv_iswa( @@ -914,6 +948,20 @@ struct llm_graph_context { float kq_scale, int il) const; + ggml_tensor * build_attn( + llm_graph_input_attn_k * inp, + ggml_tensor * wo, + ggml_tensor * wo_b, + ggml_tensor * q_cur, // [n_embd_head_q, n_head_q, n_tokens] + ggml_tensor * k_cur, // [n_embd_head_k, n_head_k, n_tokens] + ggml_tensor * v_cur, // [n_embd_head_v, n_head_v, n_tokens] + ggml_tensor * kq_b, + ggml_tensor * sinks, // [n_head_q] + ggml_tensor * v_mla, // [n_embd_head_v_mla, n_embd_head_v, n_head_v] + ggml_tensor * top_k, // [n_indexer_top_k, n_tokens] + float kq_scale, + int il) const; + llm_graph_input_attn_kv_iswa * build_attn_inp_kv_iswa() const; // note: if k_cur or v_cur are not provided, they will not be stored in the memory @@ -945,6 +993,8 @@ struct llm_graph_context { float kq_scale, int il) const; + std::pair build_attn_inp_k_dsa() const; + // // recurrent // diff --git a/src/llama-ik-cache.cpp b/src/llama-ik-cache.cpp new file mode 100644 index 00000000000..f72da29e042 --- /dev/null +++ b/src/llama-ik-cache.cpp @@ -0,0 +1,1885 @@ +#include "llama-ik-cache.h" + +#include "llama-impl.h" +#include "llama-io.h" +#include "llama-model.h" +#include "llama-context.h" + +#include +#include +#include +#include +#include +#include +#include + +// +// llama_ik_cache +// + +llama_ik_cache::llama_ik_cache( + const llama_model & model, + ggml_type type_k, + ggml_type type_v, + bool v_trans, + bool offload, + bool unified, + uint32_t kv_size, + uint32_t n_seq_max, + uint32_t n_pad, + uint32_t n_swa, + llama_swa_type swa_type, + const layer_filter_cb & filter, + const layer_reuse_cb & reuse) : + model(model), hparams(model.hparams), v_trans(v_trans), + n_seq_max(n_seq_max), n_stream(unified ? 1 : n_seq_max), n_pad(n_pad), n_swa(n_swa), swa_type(swa_type) { + + GGML_UNUSED(type_v); + GGML_ASSERT(kv_size % n_pad == 0); + + const uint32_t n_layer_kv = hparams.n_layer_kv(); + + // define a comparator for the buft -> ctx map to ensure that the order is well-defined: + struct ggml_backend_buft_comparator { + bool operator()(const ggml_backend_buffer_type_t & lhs, const ggml_backend_buffer_type_t & rhs) const { + return strcmp(ggml_backend_buft_name(lhs), ggml_backend_buft_name(rhs)) < 0; + } + }; + std::map ctx_map; + + // create a context for each buffer type + auto ctx_for_buft = [&](ggml_backend_buffer_type_t buft) -> ggml_context * { + auto it = ctx_map.find(buft); + if (it == ctx_map.end()) { + ggml_init_params params = { + /*.mem_size =*/ size_t(1u*(1 + n_stream)*n_layer_kv*ggml_tensor_overhead()), + /*.mem_buffer =*/ NULL, + /*.no_alloc =*/ true, + }; + + ggml_context * ctx = ggml_init(params); + if (!ctx) { + return nullptr; + } + + ctx_map.emplace(buft, ctx); + + return ctx; + } + + return it->second.get(); + }; + + GGML_ASSERT(n_stream == 1 || n_stream == n_seq_max); + + v_heads.resize(n_stream); + for (uint32_t s = 0; s < n_stream; ++s) { + v_heads[s] = 0; + } + + v_cells.resize(n_stream); + for (uint32_t s = 0; s < n_stream; ++s) { + v_cells[s].resize(kv_size); + } + + // by default, all sequence ids are mapped to the 0th stream + seq_to_stream.resize(LLAMA_MAX_SEQ, 0); + + if (n_stream > 1) { + seq_to_stream.resize(n_stream, 0); + for (uint32_t s = 0; s < n_stream; ++s) { + seq_to_stream[s] = s; + } + } + + for (uint32_t il = 0; il < hparams.n_layer; il++) { + if (!hparams.has_kv(il)) { + LLAMA_LOG_DEBUG("%s: layer %3d: does not have KV cache\n", __func__, il); + continue; + } + + if (filter && !filter(il)) { + LLAMA_LOG_DEBUG("%s: layer %3d: filtered\n", __func__, il); + continue; + } + + const uint32_t n_embd_k_gqa = hparams.indexer_head_size; + + const char * dev_name = "CPU"; + + ggml_backend_buffer_type_t buft = ggml_backend_cpu_buffer_type(); + + if (offload) { + auto * dev = model.dev_layer(il); + buft = ggml_backend_dev_buffer_type(dev); + + dev_name = ggml_backend_dev_name(dev); + } + + LLAMA_LOG_DEBUG("%s: layer %3d: dev = %s\n", __func__, il, dev_name); + + ggml_context * ctx = ctx_for_buft(buft); + if (!ctx) { + throw std::runtime_error("failed to create ggml context for kv cache"); + } + + ggml_tensor * k = ggml_new_tensor_3d(ctx, type_k, n_embd_k_gqa, kv_size, n_stream); + + ggml_format_name(k, "cache_ik_l%d", il); + + std::vector k_stream; + + for (uint32_t s = 0; s < n_stream; ++s) { + k_stream.push_back(ggml_view_2d(ctx, k, n_embd_k_gqa, kv_size, k->nb[1], s*k->nb[2])); + } + + map_layer_ids[il] = layers.size(); + + layers.push_back({ il, k, k_stream, }); + } + + if (reuse) { + LLAMA_LOG_DEBUG("%s: reusing layers:\n", __func__); + + for (uint32_t il = 0; il < hparams.n_layer; il++) { + const int32_t il_reuse = reuse(il); + + if (il_reuse < 0) { + LLAMA_LOG_DEBUG("%s: - layer %3d: no reuse\n", __func__, il); + continue; + } + + if (filter && !filter(il)) { + LLAMA_LOG_DEBUG("%s: - layer %3d: filtered\n", __func__, il); + continue; + } + + GGML_ASSERT(map_layer_ids.find(il_reuse) != map_layer_ids.end()); + + map_layer_ids[il] = map_layer_ids[il_reuse]; + + LLAMA_LOG_DEBUG("%s: - layer %3d: reuse layer %d, is_swa = %d\n", __func__, il, il_reuse, hparams.is_swa(il)); + } + } + + // allocate tensors and initialize the buffers to avoid NaNs in the padding + for (auto & [buft, ctx] : ctx_map) { + ggml_backend_buffer_t buf; + if (model.hparams.no_alloc) { + buf = ggml_backend_buft_alloc_buffer(buft, /*size =*/ 0); // dummy buffer + for (ggml_tensor * t = ggml_get_first_tensor(ctx.get()); t != nullptr; t = ggml_get_next_tensor(ctx.get(), t)) { + t->buffer = buf; // set dummy buffer for KV cache so that the backend scheduler won't try to allocate it + } + } else { + buf = ggml_backend_alloc_ctx_tensors_from_buft(ctx.get(), buft); // real buffer + } + if (!buf) { + throw std::runtime_error("failed to allocate buffer for kv cache"); + } + + LLAMA_LOG_INFO("%s: %10s KV buffer size = %8.2f MiB\n", __func__, ggml_backend_buffer_name(buf), ggml_backend_buffer_get_size(buf)/1024.0/1024.0); + + ggml_backend_buffer_clear(buf, 0); + ctxs_bufs.emplace_back(std::move(ctx), buf); + } + + { + const size_t memory_size_k = size_k_bytes(); + + LLAMA_LOG_INFO("%s: size = %7.2f MiB (%6u cells, %3d layers, %2u/%u seqs), K (%s): %7.2f MiB\n", __func__, + (float)(memory_size_k) / (1024.0f * 1024.0f), kv_size, (int) layers.size(), n_seq_max, n_stream, + ggml_type_name(type_k), (float)memory_size_k / (1024.0f * 1024.0f)); + } + + const char * LLAMA_KV_CACHE_DEBUG = getenv("LLAMA_KV_CACHE_DEBUG"); + debug = LLAMA_KV_CACHE_DEBUG ? atoi(LLAMA_KV_CACHE_DEBUG) : 0; +} + +void llama_ik_cache::clear(bool data) { + for (uint32_t s = 0; s < n_stream; ++s) { + v_cells[s].reset(); + v_heads[s] = 0; + } + + if (data) { + for (auto & [_, buf] : ctxs_bufs) { + ggml_backend_buffer_clear(buf.get(), 0); + } + } +} + +bool llama_ik_cache::seq_rm(llama_seq_id seq_id, llama_pos p0, llama_pos p1) { + GGML_ASSERT(seq_id == -1 || (seq_id >= 0 && (size_t) seq_id < seq_to_stream.size())); + + if (p0 < 0) { + p0 = 0; + } + + if (p1 < 0) { + p1 = std::numeric_limits::max(); + } + + if (seq_id >= 0) { + auto & cells = v_cells[seq_to_stream[seq_id]]; + auto & head = v_heads[seq_to_stream[seq_id]]; + + uint32_t new_head = cells.size(); + + for (uint32_t i = 0; i < cells.size(); ++i) { + if (!cells.pos_in(i, p0, p1)) { + continue; + } + + if (cells.seq_has(i, seq_id) && cells.seq_rm(i, seq_id)) { + if (new_head == cells.size()) { + new_head = i; + } + } + } + + // If we freed up a slot, set head to it so searching can start there. + if (new_head != cells.size() && new_head < head) { + head = new_head; + } + } else { + // match any sequence + for (uint32_t s = 0; s < n_stream; ++s) { + auto & cells = v_cells[s]; + auto & head = v_heads[s]; + + uint32_t new_head = cells.size(); + + for (uint32_t i = 0; i < cells.size(); ++i) { + if (!cells.pos_in(i, p0, p1)) { + continue; + } + + cells.rm(i); + + if (new_head == cells.size()) { + new_head = i; + } + } + + // If we freed up a slot, set head to it so searching can start there. + if (new_head != cells.size() && new_head < head) { + head = new_head; + } + } + } + + return true; +} + +void llama_ik_cache::seq_cp(llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) { + GGML_ASSERT(seq_id_src >= 0 && (size_t) seq_id_src < seq_to_stream.size()); + GGML_ASSERT(seq_id_dst >= 0 && (size_t) seq_id_dst < seq_to_stream.size()); + + const auto s0 = seq_to_stream[seq_id_src]; + const auto s1 = seq_to_stream[seq_id_dst]; + + if (s0 == s1) { + // since both sequences are in the same stream, no data copy is necessary + // we just have to update the cells meta data + + auto & cells = v_cells[s0]; + + if (seq_id_src == seq_id_dst) { + return; + } + + if (p0 < 0) { + p0 = 0; + } + + if (p1 < 0) { + p1 = std::numeric_limits::max(); + } + + for (uint32_t i = 0; i < cells.size(); ++i) { + if (!cells.pos_in(i, p0, p1)) { + continue; + } + + if (cells.seq_has(i, seq_id_src)) { + cells.seq_add(i, seq_id_dst); + } + } + + return; + } + + // cross-stream sequence copies require to copy the actual buffer data + + bool is_full = true; + + if (p0 > 0 && p0 + 1 < (int) get_size()) { + is_full = false; + } + + if (p1 > 0 && p1 + 1 < (int) get_size()) { + is_full = false; + } + + GGML_ASSERT(is_full && "seq_cp() is only supported for full KV buffers"); + + // enqueue the copy operation - the buffer copy will be performed during the next update + sc_info.ssrc.push_back(s0); + sc_info.sdst.push_back(s1); + + v_cells[s1].reset(); + for (uint32_t i = 0; i < v_cells[s0].size(); ++i) { + if (v_cells[s0].seq_has(i, seq_id_src)) { + llama_pos pos = v_cells[s0].pos_get(i); + llama_pos shift = v_cells[s0].get_shift(i); + + llama_kv_cell_ext ext = v_cells[s0].ext_get(i); + + if (shift != 0) { + pos -= shift; + assert(pos >= 0); + } + + v_cells[s1].pos_set(i, pos); + v_cells[s1].seq_add(i, seq_id_dst); + + if (shift != 0) { + v_cells[s1].pos_add(i, shift); + } + + v_cells[s1].ext_set(i, ext); + } + } + + v_heads[s1] = v_heads[s0]; + + //for (uint32_t s = 0; s < n_stream; ++s) { + // LLAMA_LOG_WARN("%s: seq %d: min = %d, max = %d\n", __func__, s, v_cells[s].seq_pos_min(s), v_cells[s].seq_pos_max(s)); + //} +} + +void llama_ik_cache::seq_keep(llama_seq_id seq_id) { + GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); + + auto & cells = v_cells[seq_to_stream[seq_id]]; + auto & head = v_heads[seq_to_stream[seq_id]]; + + uint32_t new_head = cells.size(); + + for (uint32_t i = 0; i < cells.size(); ++i) { + if (cells.seq_keep(i, seq_id)) { + if (new_head == cells.size()) { + new_head = i; + } + } + } + + // If we freed up a slot, set head to it so searching can start there. + if (new_head != cells.size() && new_head < head) { + head = new_head; + } +} + +void llama_ik_cache::seq_add(llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos shift) { + GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); + GGML_ASSERT(hparams.n_pos_per_embd() == 1 && "seq_add() is only supported for n_pos_per_embd() == 1"); + + auto & cells = v_cells[seq_to_stream[seq_id]]; + auto & head = v_heads[seq_to_stream[seq_id]]; + + if (shift == 0) { + return; + } + + uint32_t new_head = cells.size(); + + if (p0 < 0) { + p0 = 0; + } + + if (p1 < 0) { + p1 = std::numeric_limits::max(); + } + + // If there is no range then return early to avoid looping over all cells. + if (p0 == p1) { + return; + } + + for (uint32_t i = 0; i < cells.size(); ++i) { + if (!cells.pos_in(i, p0, p1)) { + continue; + } + + if (cells.seq_has(i, seq_id)) { + if (cells.pos_add(i, shift)) { + if (new_head == cells.size()) { + new_head = i; + } + } + } + } + + // If we freed up a slot, set head to it so searching can start there. + // Otherwise we just start the next search from the beginning. + head = new_head != cells.size() ? new_head : 0; +} + +void llama_ik_cache::seq_div(llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) { + GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); + GGML_ASSERT(hparams.n_pos_per_embd() == 1 && "seq_div() is only supported for n_pos_per_embd() == 1"); + + auto & cells = v_cells[seq_to_stream[seq_id]]; + + if (d == 1) { + return; + } + + if (p0 < 0) { + p0 = 0; + } + + if (p1 < 0) { + p1 = std::numeric_limits::max(); + } + + // If there is no range then return early to avoid looping over the cache. + if (p0 == p1) { + return; + } + + for (uint32_t i = 0; i < cells.size(); ++i) { + if (!cells.pos_in(i, p0, p1)) { + continue; + } + + if (cells.seq_has(i, seq_id)) { + cells.pos_div(i, d); + } + } +} + +llama_pos llama_ik_cache::seq_pos_min(llama_seq_id seq_id) const { + GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); + + const auto & cells = v_cells[seq_to_stream[seq_id]]; + + return cells.seq_pos_min(seq_id); +} + +llama_pos llama_ik_cache::seq_pos_max(llama_seq_id seq_id) const { + GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); + + const auto & cells = v_cells[seq_to_stream[seq_id]]; + + return cells.seq_pos_max(seq_id); +} + +std::map llama_ik_cache::memory_breakdown() const { + std::map ret; + for (const auto & [ctx, buf] : ctxs_bufs) { + ggml_backend_buffer_type_t buft = ggml_backend_buffer_get_type(buf.get()); + + if (hparams.no_alloc) { + GGML_ASSERT(ggml_backend_buffer_get_base(buf.get()) == nullptr); + ret[buft] += ggml_backend_alloc_ctx_tensors_from_buft_size(ctx.get(), buft); + } else { + // GGML_ASSERT(ggml_backend_buffer_get_base(buf.get()) != nullptr); // multi_buffer does not have a defined base + ret[buft] += ggml_backend_buffer_get_size(buf.get()); + } + } + + return ret; +} + +llama_memory_context_ptr llama_ik_cache::init_batch( + llama_batch_allocr & balloc, + uint32_t n_ubatch, + bool embd_all) { + GGML_UNUSED(embd_all); + + do { + balloc.split_reset(); + + std::vector ubatches; + while (true) { + auto ubatch = n_stream == 1 ? balloc.split_simple(n_ubatch) : balloc.split_equal(n_ubatch, true); + + if (ubatch.n_tokens == 0) { + break; + } + + ubatches.push_back(std::move(ubatch)); // NOLINT + } + + if (balloc.get_n_used() < balloc.get_n_tokens()) { + // failed to find a suitable split + break; + } + + auto sinfos = prepare(ubatches); + if (sinfos.empty()) { + break; + } + + return std::make_unique( + this, std::move(sinfos), std::move(ubatches)); + } while (false); + + return std::make_unique(LLAMA_MEMORY_STATUS_FAILED_PREPARE); +} + +llama_memory_context_ptr llama_ik_cache::init_full() { + return std::make_unique(this); +} + +llama_memory_context_ptr llama_ik_cache::init_update(llama_context * lctx, bool optimize) { + GGML_UNUSED(optimize); + + bool do_shift = get_has_shift(); + + return std::make_unique(this, lctx, do_shift, std::move(sc_info)); +} + +llama_ik_cache::slot_info_vec_t llama_ik_cache::prepare(const std::vector & ubatches) { + llama_ik_cache::slot_info_vec_t res; + + struct state_t { + slot_info sinfo; // slot info for the ubatch + + std::vector v_heads_old; // old positions of the heads, before placing the ubatch + + std::vector v_cells; // copy of the old cells, before placing the ubatch + }; + + // remember the old state of the cells so we can restore it in the end + std::vector states; + + bool success = true; + + for (const auto & ubatch : ubatches) { + // only find a suitable slot for the ubatch. don't modify the cells yet + const auto sinfo_new = find_slot(ubatch, false); + if (sinfo_new.empty()) { + success = false; + break; + } + + // remember the position that we found + res.push_back(sinfo_new); + + // store the old state of the cells in the recovery stack + { + state_t state = { sinfo_new, v_heads, {} }; + + for (uint32_t s = 0; s < sinfo_new.n_stream(); ++s) { + auto & cells = v_cells[sinfo_new.strm[s]]; + + state.v_cells.push_back(cells.cp(sinfo_new.idxs[s])); + } + + states.push_back(std::move(state)); + } + + // now emplace the ubatch + apply_ubatch(sinfo_new, ubatch); + } + + GGML_ASSERT(!states.empty() || !success); + + // iterate backwards and restore the cells to their original state + for (auto it = states.rbegin(); it != states.rend(); ++it) { + const auto & sinfo = it->sinfo; + + for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { + auto & cells = v_cells[sinfo.strm[s]]; + auto & head = v_heads[sinfo.strm[s]]; + + cells.set(sinfo.idxs[s], it->v_cells[s]); + head = it->v_heads_old[s]; + } + } + + if (!success) { + return {}; + } + + return res; +} + +bool llama_ik_cache::update(llama_context * lctx, bool do_shift, const stream_copy_info & sc_info) { + bool updated = false; + + auto * sched = lctx->get_sched(); + + if (!sc_info.empty()) { + assert(n_stream > 1 && "stream copy should never happen with a single stream"); + + llama_synchronize(lctx); + + const size_t n_copy = sc_info.ssrc.size(); + + for (size_t i = 0; i < n_copy; ++i) { + const auto ssrc = sc_info.ssrc[i]; + const auto sdst = sc_info.sdst[i]; + + assert(ssrc < n_stream); + assert(sdst < n_stream); + + LLAMA_LOG_DEBUG("%s: copying KV buffer: stream %d to stream %d\n", __func__, ssrc, sdst); + + assert(ssrc != sdst); + + for (uint32_t il = 0; il < layers.size(); ++il) { + const auto & layer = layers[il]; + + ggml_backend_tensor_copy(layer.k_stream[ssrc], layer.k_stream[sdst]); + } + } + } + + if (do_shift) { + if (!get_can_shift()) { + GGML_ABORT("The current KV cache / model configuration does not support K-shift"); + } + + LLAMA_LOG_DEBUG("%s: applying K-shift\n", __func__); + + // apply K-shift if needed + if (hparams.rope_type != LLAMA_ROPE_TYPE_NONE) { + ggml_backend_sched_reset(sched); + + auto * res = lctx->get_gf_res_reserve(); + + res->reset(); + + auto * gf = build_graph_shift(res, lctx); + if (!ggml_backend_sched_alloc_graph(sched, gf)) { + LLAMA_LOG_ERROR("%s: failed to allocate compute graph for K-shift\n", __func__); + return updated; + } + + res->set_inputs(nullptr); + + if (lctx->graph_compute(gf, false) != GGML_STATUS_SUCCESS) { + LLAMA_LOG_ERROR("%s: failed to compute K-shift\n", __func__); + return updated; + } + + updated = true; + } + + for (uint32_t s = 0; s < n_stream; ++s) { + auto & cells = v_cells[s]; + + cells.reset_shift(); + } + } + + return updated; +} + +llama_ik_cache::slot_info llama_ik_cache::find_slot(const llama_ubatch & ubatch, bool cont) const { + + if (debug > 0) { + for (uint32_t s = 0; s < ubatch.n_seqs_unq; ++s) { + const auto seq_id = ubatch.seq_id_unq[s]; + const auto stream_id = seq_to_stream[seq_id]; + const auto & cells = v_cells[stream_id]; + const uint32_t head_cur = v_heads[stream_id]; + + LLAMA_LOG_DEBUG("%s: stream[%d], n = %5d, used = %5d, head = %5d, size = %5d, n_swa = %5d\n", + __func__, stream_id, cells.used_max_p1(), cells.get_used(), head_cur, get_size(), n_swa); + + if ((debug == 2 && n_swa > 0) || debug > 2) { + std::string ss; + for (uint32_t i = 0; i < cells.size(); ++i) { + if (cells.is_empty(i)) { + ss += '.'; + } else { + assert(cells.seq_count(i) >= 1); + + if (cells.seq_count(i) == 1) { + ss += std::to_string(cells.seq_get(i)); + } else { + ss += 'M'; + } + } + if (i%256 == 255) { + ss += " *"; + ss += '\n'; + } + } + LLAMA_LOG_DEBUG("\n%s\n", ss.c_str()); + } + + if ((debug == 2 && n_swa > 0) || debug > 2) { + std::string ss; + for (uint32_t i = 0; i < cells.size(); ++i) { + std::string cur; + if (cells.is_empty(i)) { + cur = '.'; + } else { + cur = std::to_string(cells.pos_get(i)); + } + const int n = cur.size(); + for (int j = 0; j < 5 - n; ++j) { + cur += ' '; + } + ss += cur; + if (i%256 == 255) { + ss += " *"; + } + if (i%64 == 63) { + ss += '\n'; + } + } + LLAMA_LOG_DEBUG("\n%s\n", ss.c_str()); + } + + for (int s = 0; s < LLAMA_MAX_SEQ; ++s) { + if (cells.seq_pos_min(s) < 0) { + continue; + } + + LLAMA_LOG_DEBUG("%s: stream[%d] min[%d] = %5d, max[%d] = %5d\n", __func__, stream_id, s, cells.seq_pos_min(s), s, cells.seq_pos_max(s)); + } + } + } + + uint32_t n_tokens = ubatch.n_tokens; + uint32_t n_seqs = 1; + + if (n_stream > 1) { + GGML_ASSERT(n_tokens % ubatch.n_seqs_unq == 0); + + n_seqs = ubatch.n_seqs_unq; + n_tokens = n_tokens / n_seqs; + } + + slot_info res = { + /*.s0 =*/ LLAMA_MAX_SEQ, + /*.s1 =*/ 0, + /*.strm =*/ { }, + /*.idxs =*/ { }, + }; + + res.resize(n_seqs); + + for (uint32_t s = 0; s < n_seqs; ++s) { + const auto seq_id = ubatch.seq_id_unq[s]; + + if (n_stream > 1) { + GGML_ASSERT(ubatch.n_seq_id[s*n_tokens] == 1); + GGML_ASSERT(ubatch.seq_id [s*n_tokens][0] == seq_id); + } + + res.s0 = std::min(res.s0, seq_to_stream[seq_id]); + res.s1 = std::max(res.s1, seq_to_stream[seq_id]); + + res.strm[s] = seq_to_stream[seq_id]; + res.idxs[s].reserve(n_tokens); + + const auto & cells = v_cells[seq_to_stream[seq_id]]; + + uint32_t head_cur = v_heads[seq_to_stream[seq_id]]; + + // if we have enough unused cells before the current head -> + // better to start searching from the beginning of the cache, hoping to fill it + if (head_cur > cells.get_used() + 2*n_tokens) { + head_cur = 0; + } + + if (n_tokens > cells.size()) { + LLAMA_LOG_ERROR("%s: n_tokens = %d > size = %u\n", __func__, n_tokens, cells.size()); + return { }; + } + + uint32_t n_tested = 0; + + // for continuous slots, we test that all tokens in the ubatch fit, starting from the current head + // for non-continuous slots, we test the tokens one by one + const uint32_t n_test = cont ? n_tokens : 1; + + while (true) { + if (head_cur + n_test > cells.size()) { + n_tested += cells.size() - head_cur; + head_cur = 0; + continue; + } + + for (uint32_t i = 0; i < n_test; i++) { + const auto idx = head_cur; + + head_cur++; + n_tested++; + + //const llama_pos pos = ubatch.pos[i]; + //const llama_seq_id seq_id = ubatch.seq_id[i][0]; + + // can we use this cell? either: + // - the cell is empty + // - the cell is occupied only by one sequence: + // - (disabled) mask causally, if the sequence is the same as the one we are inserting + // - mask SWA, using current max pos for that sequence in the cache + // always insert in the cell with minimum pos + bool can_use = cells.is_empty(idx); + + if (!can_use && cells.seq_count(idx) == 1) { + const llama_pos pos_cell = cells.pos_get(idx); + + // (disabled) causal mask + // note: it's better to purge any "future" tokens beforehand + //if (cells.seq_has(idx, seq_id)) { + // can_use = pos_cell >= pos; + //} + + if (!can_use) { + const llama_seq_id seq_id_cell = cells.seq_get(idx); + + // SWA mask + if (llama_hparams::is_masked_swa(n_swa, swa_type, pos_cell, cells.seq_pos_max(seq_id_cell) + 1)) { + can_use = true; + } + } + } + + if (can_use) { + res.idxs[s].push_back(idx); + } else { + if (cont) { + break; + } + } + } + + if (res.idxs[s].size() == n_tokens) { + break; + } + + if (cont) { + res.idxs[s].clear(); + } + + if (n_tested >= cells.size()) { + //LLAMA_LOG_ERROR("%s: failed to find a slot for %d tokens\n", __func__, n_tokens); + return { }; + } + } + + // we didn't find a suitable slot - return empty result + if (res.idxs[s].size() < n_tokens) { + return { }; + } + } + + assert(res.s1 >= res.s0); + + return res; +} + +void llama_ik_cache::apply_ubatch(const slot_info & sinfo, const llama_ubatch & ubatch) { + // keep track of the max sequence position that we would overwrite with this ubatch + // for non-SWA cache, this would be always empty + llama_seq_id seq_pos_max_rm[LLAMA_MAX_SEQ]; + for (uint32_t s = 0; s < LLAMA_MAX_SEQ; ++s) { + seq_pos_max_rm[s] = -1; + } + + assert(ubatch.n_tokens == sinfo.n_stream()*sinfo.size()); + + for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { + for (uint32_t ii = 0; ii < sinfo.size(); ++ii) { + const uint32_t i = s*sinfo.size() + ii; + + auto & cells = v_cells[sinfo.strm[s]]; + + const auto idx = sinfo.idxs[s][ii]; + + if (!cells.is_empty(idx)) { + assert(cells.seq_count(idx) == 1); + + const llama_seq_id seq_id = cells.seq_get(idx); + const llama_pos pos = cells.pos_get(idx); + + seq_pos_max_rm[seq_id] = std::max(seq_pos_max_rm[seq_id], pos); + + cells.rm(idx); + } + + cells.pos_set(idx, ubatch.pos[i]); + + if (ubatch.is_pos_2d()) { + llama_kv_cell_ext ext { + /*.x =*/ ubatch.pos[i + ubatch.n_tokens*2], + /*.y =*/ ubatch.pos[i + ubatch.n_tokens], + }; + cells.ext_set(idx, ext); + } + + for (int32_t s = 0; s < ubatch.n_seq_id[i]; s++) { + cells.seq_add(idx, ubatch.seq_id[i][s]); + } + } + } + + // note: we want to preserve the invariant that all positions between [pos_min, pos_max] for each sequence + // will be present in the cache. so we have to purge any position which is less than those we would overwrite + // ref: https://github.com/ggml-org/llama.cpp/pull/13746#issuecomment-2916057092 + for (uint32_t s = 0; s < LLAMA_MAX_SEQ; ++s) { + if (seq_pos_max_rm[s] == -1) { + continue; + } + + GGML_ASSERT(s < seq_to_stream.size()); + + auto & cells = v_cells[seq_to_stream[s]]; + + if (cells.seq_pos_min(s) <= seq_pos_max_rm[s]) { + LLAMA_LOG_DEBUG("%s: purging positions [%d, %d] of sequence %d from KV cache\n", + __func__, cells.seq_pos_min(s), seq_pos_max_rm[s], s); + + seq_rm(s, cells.seq_pos_min(s), seq_pos_max_rm[s] + 1); + } + } + + // move the head at the end of the slot + for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { + auto & head = v_heads[sinfo.strm[s]]; + + head = sinfo.idxs[s].back() + 1; + } +} + +bool llama_ik_cache::get_can_shift() const { + // Step35 uses per-layer RoPE dims; K-shift assumes a single global n_rot. + if (model.arch == LLM_ARCH_STEP35) { + return false; + } + if (hparams.n_pos_per_embd() > 1) { + return false; + } + return true; +} + +uint32_t llama_ik_cache::get_size() const { + const auto & cells = v_cells[seq_to_stream[0]]; + + return cells.size(); +} + +uint32_t llama_ik_cache::get_n_stream() const { + return n_stream; +} + +bool llama_ik_cache::get_has_shift() const { + bool result = false; + + for (uint32_t s = 0; s < n_stream; ++s) { + result |= v_cells[s].get_has_shift(); + } + + return result; +} + +uint32_t llama_ik_cache::get_n_kv(const slot_info & sinfo) const { + uint32_t result = 0; + + // pad the n_kv value so that the graph remains constant across batches and can be reused + // note: this also helps some backends with performance (f.ex https://github.com/ggml-org/llama.cpp/pull/16812#issuecomment-3455112220) + const uint32_t n_pad_cur = std::max(n_pad, 256u); + + for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { + const auto & cells = v_cells[sinfo.strm[s]]; + + result = std::max(std::min(cells.size(), std::max(n_pad_cur, GGML_PAD(cells.used_max_p1(), n_pad_cur))), result); + } + + return result; +} + +ggml_tensor * llama_ik_cache::get_k(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const { + const int32_t ikv = map_layer_ids.at(il); + + auto * k = layers[ikv].k; + + const uint64_t kv_size = get_size(); + const uint64_t n_embd_k_gqa = k->ne[0]; + + assert(n_embd_k_gqa == hparams.indexer_head_size); + + const uint32_t ns = sinfo.s1 - sinfo.s0 + 1; + + return ggml_view_4d(ctx, k, + hparams.indexer_head_size, 1, n_kv, ns, + ggml_row_size(k->type, hparams.indexer_head_size), + ggml_row_size(k->type, n_embd_k_gqa), + ggml_row_size(k->type, n_embd_k_gqa*kv_size), + ggml_row_size(k->type, n_embd_k_gqa*kv_size)*sinfo.s0); +} + +ggml_tensor * llama_ik_cache::cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const { + GGML_UNUSED(sinfo); + + const int32_t ikv = map_layer_ids.at(il); + + ggml_tensor * k = layers[ikv].k; + + const int64_t n_embd_head = k_cur->ne[0]; + const int64_t n_head = k_cur->ne[1]; + const int64_t n_tokens = k_cur->ne[2]; + + const int64_t n_embd_gqa = n_embd_head*n_head; + + // we can merge dims 0 and 1 + // TODO: add ggml helper function for this? + GGML_ASSERT(ggml_row_size(k_cur->type, n_embd_head) == k_cur->nb[1]); + + k_cur = ggml_view_2d(ctx, k_cur, n_embd_gqa, n_tokens, k_cur->nb[2], 0); + + const int64_t n_stream = k->ne[2]; + + if (n_stream > 1) { + const int64_t kv_size = get_size(); + + assert(n_embd_gqa == k->ne[0]); + assert(kv_size == k->ne[1]); + + // merge the buffer across all streams because the idxs are global + k = ggml_reshape_2d(ctx, k, n_embd_gqa, kv_size*n_stream); + } + + // store the current K values into the cache + return ggml_set_rows(ctx, k, k_cur, k_idxs); +} + +ggml_tensor * llama_ik_cache::build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const { + const uint32_t n_tokens = ubatch.n_tokens; + + ggml_tensor * k_idxs = ggml_new_tensor_1d(ctx, GGML_TYPE_I64, n_tokens); + + ggml_set_input(k_idxs); + + return k_idxs; +} + +void llama_ik_cache::set_input_k_idxs(ggml_tensor * dst, const llama_ubatch * ubatch, const slot_info & sinfo) const { + const uint32_t n_tokens = ubatch->n_tokens; + GGML_ASSERT(n_tokens == (int64_t) sinfo.size()*sinfo.n_stream()); + + GGML_ASSERT(ggml_backend_buffer_is_host(dst->buffer)); + int64_t * data = (int64_t *) dst->data; + + for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { + const int64_t offs = sinfo.strm[s]*get_size(); + + for (uint32_t i = 0; i < sinfo.size(); ++i) { + data[s*sinfo.size() + i] = offs + sinfo.idxs[s][i]; + } + } +} + +void llama_ik_cache::set_input_k_shift(ggml_tensor * dst) const { + GGML_ASSERT(ggml_backend_buffer_is_host(dst->buffer)); + + int32_t * data = (int32_t *) dst->data; + + for (uint32_t s = 0; s < n_stream; ++s) { + const auto & cells = v_cells[s]; + + for (uint32_t i = 0; i < cells.size(); ++i) { + data[s*cells.size() + i] = cells.is_empty(i) ? 0 : cells.get_shift(i); + } + } +} + +struct args_set_input_kq_mask { + const llama_hparams & hparams; + const llama_ubatch * ubatch; + + const std::vector & v_cells; + const std::vector & seq_to_stream; + + uint32_t n_swa; + llama_swa_type swa_type; + + int64_t n_kv; + int64_t n_stream; + int64_t n_tps; +}; + +template +static void set_input_kq_mask_impl(const args_set_input_kq_mask & args, float * data) { + //const auto & hparams = args.hparams; + const auto & ubatch = args.ubatch; + + const auto & v_cells = args.v_cells; + const auto & seq_to_stream = args.seq_to_stream; + + const uint32_t n_swa = args.n_swa; + const llama_swa_type swa_type = args.swa_type; + + const int64_t n_kv = args.n_kv; + const int64_t n_stream = args.n_stream; + const int64_t n_tps = args.n_tps; + + // the min position in the batch for each sequence + llama_pos seq_pos_min[LLAMA_MAX_SEQ]; + std::fill(seq_pos_min, seq_pos_min + LLAMA_MAX_SEQ, INT32_MAX); + + for (uint32_t i = 0; i < ubatch->n_tokens; ++i) { + const llama_seq_id seq_id = ubatch->seq_id[i][0]; + + seq_pos_min[seq_id] = std::min(seq_pos_min[seq_id], ubatch->pos[i]); + } + + for (uint32_t s = 0; s < n_stream; ++s) { + // bookkeeping of the KQ mask cells that could change for other tokens of the same sequence + std::unordered_map seq_srct; + std::unordered_map> seq_idxs; + + for (uint32_t ii = 0; ii < n_tps; ++ii) { + const uint32_t i = s*n_tps + ii; + + const llama_seq_id seq_id = ubatch->seq_id[i][0]; + + const auto & cells = v_cells.at(seq_to_stream[seq_id]); + + llama_pos p0 = -1; + const llama_pos p1 = ubatch->pos[i]; + + // for M-RoPE + const llama_pos p1_x = is_2d ? ubatch->pos[i + ubatch->n_tokens*2] : 0; + const llama_pos p1_y = is_2d ? ubatch->pos[i + ubatch->n_tokens] : 0; + + const uint64_t idst = n_kv*i; + + // for tokens of the same sequence, the mask is mostly the same, so we can reuse it + // the only cells that could change are the ones that are with similar positions as the + // ones in the batch (i.e. due to causal masking, SWA, etc.) + // keep track of those cells and shortcut the loop to save time + // note: this optimization is not compatible with Alibi position encoding + // ref: https://github.com/ggml-org/llama.cpp/pull/18842 + bool prev = false; + + auto & idxs = seq_idxs[seq_id]; + + if (!alibi) { + if (seq_srct.find(seq_id) != seq_srct.end()) { + const uint32_t srct = seq_srct[seq_id]; + + const uint64_t idst_prev = n_kv*srct; + + std::copy(data + idst_prev, data + idst_prev + n_kv, data + idst); + + prev = true; + } else { + idxs.clear(); + idxs.reserve(ubatch->n_tokens + n_swa + 32); + + seq_srct[seq_id] = i; + } + } + + for (uint32_t jj = 0; jj < n_kv; ++jj) { + uint32_t j = jj; + + // we have an exiting mask for this sequence -> update just seq_idxs + if (!alibi) { + if (prev) { + if (jj >= idxs.size()) { + break; + } + + j = idxs[jj]; + } + } + + if (cells.is_empty(j)) { + goto skip; + } + + // mask the token if not the same sequence + if (!cells.seq_has(j, seq_id)) { + goto skip; + } + + p0 = cells.pos_get(j); + + if (!alibi) { + if (!prev) { + // record all cells for which: p0 >= seq_pos_min[seq_id] - n_swa - 32 + if (p0 + (int32_t) (n_swa + 32) >= seq_pos_min[seq_id]) { + idxs.push_back(j); + } + } + } + + if (causal) { + // mask future tokens + if (p0 > p1) { + goto skip; + } + + // M-RoPE causal mask + if (is_2d) { + if (p0 == p1) { + const auto & p0_ext = cells.ext_get(j); + + if (p0_ext.is_2d_gt(p1_x, p1_y)) { + goto skip; + } + } + } + } + + // apply SWA if any + if (swa) { + if (llama_hparams::is_masked_swa(n_swa, swa_type, p0, p1)) { + goto skip; + } + } + + if (alibi) { + data[idst + j] = -std::abs(p0 - p1); + } else { + data[idst + j] = 0.0f; + } + + continue; +skip: + data[idst + j] = -INFINITY; + } + } + } +} + +template +static void set_input_kq_mask_impl(const args_set_input_kq_mask & args, float * data) { + const bool alibi = args.hparams.use_alibi; + if (alibi) { + set_input_kq_mask_impl (args, data); + } else { + set_input_kq_mask_impl(args, data); + } +} + +template +static void set_input_kq_mask_impl(const args_set_input_kq_mask & args, float * data) { + const bool is_2d = args.ubatch->is_pos_2d(); + if (is_2d) { + set_input_kq_mask_impl (args, data); + } else { + set_input_kq_mask_impl(args, data); + } +} + +template +static void set_input_kq_mask_impl(const args_set_input_kq_mask & args, float * data) { + const bool swa = args.swa_type != LLAMA_SWA_TYPE_NONE; + if (swa) { + set_input_kq_mask_impl (args, data); + } else { + set_input_kq_mask_impl(args, data); + } +} + +void llama_ik_cache::set_input_kq_mask(ggml_tensor * dst, const llama_ubatch * ubatch, bool causal_attn) const { + const uint32_t n_tokens = ubatch->n_tokens; + + GGML_ASSERT(ggml_backend_buffer_is_host(dst->buffer)); + float * data = (float *) dst->data; + + const int64_t n_kv = dst->ne[0]; + const int64_t n_stream = dst->ne[3]; // num streams in the current ubatch + + GGML_ASSERT(n_tokens%n_stream == 0); + + // n_tps == n_tokens_per_stream + const int64_t n_tps = n_tokens/n_stream; + + //const int64_t t_start = ggml_time_us(); + + const args_set_input_kq_mask args = { + /*.hparams =*/ hparams, + /*.ubatch =*/ ubatch, + /*.v_cells =*/ v_cells, + /*.seq_to_stream =*/ seq_to_stream, + /*.n_swa =*/ n_swa, + /*.swa_type =*/ swa_type, + /*.n_kv =*/ n_kv, + /*.n_stream =*/ n_stream, + /*.n_tps =*/ n_tps, + }; + + if (causal_attn) { + set_input_kq_mask_impl (args, data); + } else { + set_input_kq_mask_impl(args, data); + } + + //const int64_t t_end = ggml_time_us(); + + //LLAMA_LOG_ERROR("%s: kq mask time: %0.3f ms\n", __func__, (t_end - t_start)/1000.0); +} + +size_t llama_ik_cache::total_size() const { + size_t size = 0; + + for (const auto & [_, buf] : ctxs_bufs) { + size += ggml_backend_buffer_get_size(buf.get()); + } + + return size; +} + +size_t llama_ik_cache::size_k_bytes() const { + size_t size_k_bytes = 0; + + for (const auto & layer : layers) { + size_k_bytes += ggml_nbytes(layer.k); + } + + return size_k_bytes; +} + +ggml_tensor * llama_ik_cache::build_rope_shift( + const llama_cparams & cparams, + ggml_context * ctx, + ggml_tensor * cur, + ggml_tensor * shift, + ggml_tensor * factors, + float freq_base, + float freq_scale, + uint32_t il) const { + const auto & n_ctx_orig = cparams.n_ctx_orig_yarn; + + const auto & yarn_ext_factor = cparams.yarn_ext_factor; + const auto & yarn_beta_fast = cparams.yarn_beta_fast; + const auto & yarn_beta_slow = cparams.yarn_beta_slow; + const auto & yarn_attn_factor = cparams.yarn_attn_factor; + + const auto & n_rot = hparams.n_rot(il); + const auto & rope_type = hparams.rope_type == LLAMA_ROPE_TYPE_MROPE || hparams.rope_type == LLAMA_ROPE_TYPE_IMROPE + // @ngxson : this is a workaround + // for M-RoPE, we want to rotate the whole vector when doing KV shift + // a normal RoPE should work, we just need to use the correct ordering + // ref: https://github.com/ggml-org/llama.cpp/pull/13870 + ? LLAMA_ROPE_TYPE_NEOX + : hparams.rope_type; + + ggml_tensor * tmp; + + if (ggml_is_quantized(cur->type)) { + // dequantize to f32 -> RoPE -> quantize back + tmp = ggml_cast(ctx, cur, GGML_TYPE_F32); + + tmp = ggml_rope_ext(ctx, tmp, + shift, factors, n_rot, rope_type, n_ctx_orig, freq_base, freq_scale, + yarn_ext_factor, yarn_attn_factor, yarn_beta_fast, yarn_beta_slow); + + tmp = ggml_cpy(ctx, tmp, cur); + } else { + // we rotate only the first n_rot dimensions + tmp = ggml_rope_ext_inplace(ctx, cur, + shift, factors, n_rot, rope_type, n_ctx_orig, freq_base, freq_scale, + yarn_ext_factor, yarn_attn_factor, yarn_beta_fast, yarn_beta_slow); + } + + return tmp; +} + +class llm_graph_input_ik_shift : public llm_graph_input_i { +public: + llm_graph_input_ik_shift(const llama_ik_cache * kv_self) : kv_self(kv_self) {} + virtual ~llm_graph_input_ik_shift() = default; + + void set_input(const llama_ubatch * ubatch) override; + + ggml_tensor * k_shift; // I32 [kv_size*n_stream] + + const llama_ik_cache * kv_self; +}; + +void llm_graph_input_ik_shift::set_input(const llama_ubatch * ubatch) { + GGML_UNUSED(ubatch); + + if (k_shift) { + kv_self->set_input_k_shift(k_shift); + } +} + +ggml_cgraph * llama_ik_cache::build_graph_shift(llm_graph_result * res, llama_context * lctx) const { + auto * ctx = res->get_ctx(); + auto * gf = res->get_gf(); + + auto inp = std::make_unique(this); + + inp->k_shift = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, (int64_t) get_size()*n_stream); + ggml_set_input(inp->k_shift); + + const auto & cparams = lctx->get_cparams(); + + for (const auto & layer : layers) { + const uint32_t il = layer.il; + + const int64_t n_head_kv = 1; + const int64_t n_embd_k_gqa = hparams.indexer_head_size; + + const auto n_rot = hparams.n_rot(il); + const auto n_embd_head_k = hparams.indexer_head_size; + const auto n_embd_nope = hparams.n_lora_kv > 0 ? n_embd_head_k - n_rot : 0; + + const float freq_base_l = model.get_rope_freq_base (cparams, il); + const float freq_scale_l = model.get_rope_freq_scale(cparams, il); + + ggml_tensor * rope_factors = model.get_rope_factors(cparams, il); + + ggml_tensor * k = + ggml_view_3d(ctx, layer.k, + n_rot, n_head_kv, get_size()*n_stream, + ggml_row_size(layer.k->type, n_embd_head_k), + ggml_row_size(layer.k->type, n_embd_k_gqa), + ggml_row_size(layer.k->type, n_embd_nope)); + + ggml_tensor * cur = build_rope_shift(cparams, ctx, k, inp->k_shift, rope_factors, freq_base_l, freq_scale_l, il); + + ggml_build_forward_expand(gf, cur); + } + + res->add_input(std::move(inp)); + + return gf; +} + +void llama_ik_cache::state_write(llama_io_write_i & io, llama_seq_id seq_id, llama_state_seq_flags flags) const { + GGML_UNUSED(flags); + + io.write(&n_stream, sizeof(n_stream)); + + for (uint32_t s = 0; s < n_stream; ++s) { + cell_ranges_t cr { s, {} }; + + uint32_t cell_count = 0; + + const auto & cells = v_cells[s]; + + // Count the number of cells with the specified seq_id + // Find all the ranges of cells with this seq id (or all, when -1) + uint32_t cell_range_begin = cells.size(); + + for (uint32_t i = 0; i < cells.size(); ++i) { + if (!cells.is_empty(i) && (seq_id == -1 || cells.seq_has(i, seq_id))) { + ++cell_count; + if (cell_range_begin == cells.size()) { + cell_range_begin = i; + } + } else { + if (cell_range_begin != cells.size()) { + cr.data.emplace_back(cell_range_begin, i); + cell_range_begin = cells.size(); + } + } + } + + if (cell_range_begin != cells.size()) { + cr.data.emplace_back(cell_range_begin, cells.size()); + } + + // DEBUG CHECK: Sum of cell counts in ranges should equal the total cell count + uint32_t cell_count_check = 0; + for (const auto & range : cr.data) { + cell_count_check += range.second - range.first; + } + GGML_ASSERT(cell_count == cell_count_check); + + io.write(&cell_count, sizeof(cell_count)); + + // skip empty streams + if (cell_count == 0) { + continue; + } + + state_write_meta(io, cr, seq_id); + state_write_data(io, cr); + } +} + +void llama_ik_cache::state_read(llama_io_read_i & io, llama_seq_id seq_id, llama_state_seq_flags flags) { + GGML_UNUSED(flags); + + GGML_ASSERT(seq_id == -1 || (seq_id >= 0 && (size_t) seq_id < seq_to_stream.size())); + + uint32_t n_stream_cur; + io.read_to(&n_stream_cur, sizeof(n_stream_cur)); + if (n_stream_cur != n_stream) { + throw std::runtime_error("n_stream mismatch"); + } + + for (uint32_t s = 0; s < n_stream; ++s) { + uint32_t cell_count; + io.read_to(&cell_count, sizeof(cell_count)); + + if (cell_count == 0) { + continue; + } + + const uint32_t strm = seq_id == -1 ? s : seq_to_stream[seq_id]; + + slot_info sinfo; + + bool res = true; + res = res && state_read_meta(io, strm, cell_count, sinfo, seq_id); + res = res && state_read_data(io, strm, cell_count, sinfo); + + if (!res) { + if (seq_id == -1) { + clear(true); + } else { + seq_rm(seq_id, -1, -1); + } + throw std::runtime_error("failed to restore kv cache"); + } + } +} + +void llama_ik_cache::state_write_meta(llama_io_write_i & io, const cell_ranges_t & cr, llama_seq_id seq_id) const { + const auto & cells = v_cells[cr.strm]; + + for (const auto & range : cr.data) { + for (uint32_t i = range.first; i < range.second; ++i) { + std::vector seq_ids; + + for (llama_seq_id cur = 0; cur < (int) n_seq_max; ++cur) { + if (cur == seq_id || seq_id == -1) { + if (cells.seq_has(i, cur)) { + seq_ids.push_back(cur); + } + } + } + + const llama_pos pos = cells.pos_get(i); + const uint32_t n_seq_id = seq_ids.size(); + + io.write(&pos, sizeof(pos)); + io.write(&n_seq_id, sizeof(n_seq_id)); + + if (hparams.n_pos_per_embd() > 1) { + const llama_kv_cell_ext ext = cells.ext_get(i); + io.write(&ext, sizeof(ext)); + } + + for (const auto & seq_id : seq_ids) { + io.write(&seq_id, sizeof(seq_id)); + } + } + } +} + +void llama_ik_cache::state_write_data(llama_io_write_i & io, const cell_ranges_t & cr) const { + const uint32_t n_layer = layers.size(); + + io.write(&n_layer, sizeof(n_layer)); + + // Iterate and write all the keys first, each row is a cell + // Get whole range at a time + for (const auto & layer : layers) { + const uint32_t n_embd_k_gqa = hparams.indexer_head_size; + + auto * k = layer.k_stream[cr.strm]; + + // Write key type + const int32_t k_type_i = (int32_t) k->type; + io.write(&k_type_i, sizeof(k_type_i)); + + // Write row size of key + const uint64_t k_size_row = ggml_row_size(k->type, n_embd_k_gqa); + io.write(&k_size_row, sizeof(k_size_row)); + + // Read each range of cells of k_size length and write out + for (const auto & range : cr.data) { + const size_t range_size = range.second - range.first; + const size_t buf_size = range_size * k_size_row; + io.write_tensor(k, range.first * k_size_row, buf_size); + } + } +} + +bool llama_ik_cache::state_read_meta(llama_io_read_i & io, uint32_t strm, uint32_t cell_count, slot_info & sinfo, llama_seq_id dest_seq_id) { + auto & cells = v_cells[strm]; + auto & head = v_heads[strm]; + + if (dest_seq_id != -1) { + // single sequence + seq_rm(dest_seq_id, -1, -1); + + llama_batch_allocr balloc(hparams.n_pos_per_embd()); + + llama_ubatch ubatch = balloc.ubatch_reserve(cell_count, 1); + + ubatch.seq_id_unq[0] = dest_seq_id; + + for (uint32_t i = 0; i < cell_count; ++i) { + llama_pos pos; + uint32_t n_seq_id; + + io.read_to(&pos, sizeof(pos)); + io.read_to(&n_seq_id, sizeof(n_seq_id)); + + if (n_seq_id != 1) { + LLAMA_LOG_ERROR("%s: invalid seq_id-agnostic kv cell\n", __func__); + return false; + } + + if (hparams.n_pos_per_embd() > 1) { + llama_kv_cell_ext ext; + io.read_to(&ext, sizeof(ext)); + + ubatch.pos[i + ubatch.n_tokens] = ext.y; + ubatch.pos[i + ubatch.n_tokens*2] = ext.x; + } + + // read the sequence id, but directly discard it - we will use dest_seq_id instead + { + llama_seq_id seq_id; + io.read_to(&seq_id, sizeof(seq_id)); + } + + ubatch.pos[i] = pos; + ubatch.n_seq_id[i] = n_seq_id; + ubatch.seq_id[i] = &dest_seq_id; + } + + sinfo = find_slot(ubatch, false); + if (sinfo.empty()) { + LLAMA_LOG_ERROR("%s: failed to find available cells in kv cache\n", __func__); + return false; + } + + // TODO: we cannot yet restore llama_kv_cell_ext as the apply_ubatch() does not support it yet + // see: https://github.com/ggml-org/llama.cpp/pull/16825#issuecomment-3460868350 + apply_ubatch(sinfo, ubatch); + + LLAMA_LOG_DEBUG("%s: cell_count = %d, dest_seq_id = %d\n", __func__, cell_count, dest_seq_id); + + // DEBUG CHECK: verify that all cells were allocated and have correct seq_id and pos values + GGML_ASSERT(sinfo.n_stream() == 1); + GGML_ASSERT(sinfo.idxs[0].size() == cell_count); + for (uint32_t i = 0; i < cell_count; ++i) { + const uint32_t idx = sinfo.idxs[0][i]; + GGML_ASSERT(cells.pos_get(idx) == ubatch.pos[i]); + GGML_ASSERT(cells.seq_has(idx, dest_seq_id)); + } + } else { + // whole KV cache restore + + if (cell_count > cells.size()) { + LLAMA_LOG_ERROR("%s: not enough cells in kv cache\n", __func__); + return false; + } + + clear(true); + + for (uint32_t i = 0; i < cell_count; ++i) { + llama_pos pos; + uint32_t n_seq_id; + + io.read_to(&pos, sizeof(pos)); + io.read_to(&n_seq_id, sizeof(n_seq_id)); + + cells.pos_set(i, pos); + + for (uint32_t j = 0; j < n_seq_id; ++j) { + llama_seq_id seq_id; + io.read_to(&seq_id, sizeof(seq_id)); + + if (seq_id < 0 || (uint32_t) seq_id >= n_seq_max) { + LLAMA_LOG_ERROR("%s: invalid seq_id, %d is out of range [0, %u)\n", __func__, seq_id, n_seq_max); + return false; + } + + cells.seq_add(i, seq_id); + } + } + + // Create contiguous slot_info for whole cache restore + sinfo.s0 = strm; + sinfo.s1 = strm; + sinfo.resize(1); + sinfo.strm[0] = strm; + sinfo.idxs[0].resize(cell_count); + for (uint32_t i = 0; i < cell_count; ++i) { + sinfo.idxs[0][i] = i; + } + + head = 0; + } + + return true; +} + +bool llama_ik_cache::state_read_data(llama_io_read_i & io, uint32_t strm, uint32_t cell_count, const slot_info & sinfo) { + auto & cells = v_cells[strm]; + + uint32_t n_layer; + + io.read_to(&n_layer, sizeof(n_layer)); + + if (n_layer != layers.size()) { + LLAMA_LOG_ERROR("%s: mismatched layer count (%u instead of %u)\n", __func__, n_layer, (uint32_t) layers.size()); + return false; + } + + if (cell_count > cells.size()) { + LLAMA_LOG_ERROR("%s: not enough cells in kv cache to restore state (%u > %u)\n", __func__, cell_count, cells.size()); + return false; + } + + // For each layer, read the keys for each cell, one row is one cell, read as one contiguous block + for (const auto & layer : layers) { + const uint32_t il = layer.il; + + const uint32_t n_embd_k_gqa = hparams.indexer_head_size; + + auto * k = layer.k_stream[strm]; + + // Read type of key + int32_t k_type_i_ref; + io.read_to(&k_type_i_ref, sizeof(k_type_i_ref)); + const int32_t k_type_i = (int32_t) k->type; + if (k_type_i != k_type_i_ref) { + LLAMA_LOG_ERROR("%s: mismatched key type (%d != %d, layer %d)\n", __func__, k_type_i, k_type_i_ref, il); + return false; + } + + // Read row size of key + uint64_t k_size_row_ref; + io.read_to(&k_size_row_ref, sizeof(k_size_row_ref)); + const size_t k_size_row = ggml_row_size(k->type, n_embd_k_gqa); + if (k_size_row != k_size_row_ref) { + LLAMA_LOG_ERROR("%s: mismatched key row size (%zu != %zu, layer %d)\n", __func__, k_size_row, (size_t) k_size_row_ref, il); + return false; + } + + if (cell_count) { + if (sinfo.is_contiguous()) { + // Fast path: contiguous cells, single memcpy + ggml_backend_tensor_set(k, io.read(cell_count * k_size_row), sinfo.head() * k_size_row, cell_count * k_size_row); + } else { + // Slow path: scatter to non-contiguous positions + const void * src = io.read(cell_count * k_size_row); + for (uint32_t i = 0; i < cell_count; ++i) { + const size_t dst_offset = sinfo.idxs[0][i] * k_size_row; + ggml_backend_tensor_set(k, (const char*)src + i * k_size_row, dst_offset, k_size_row); + } + } + } + } + + return true; +} + +// +// llama_ik_cache_context +// + +llama_ik_cache_context::llama_ik_cache_context(llama_memory_status status) : status(status) {} + +llama_ik_cache_context::llama_ik_cache_context( + llama_ik_cache * kv) : status(LLAMA_MEMORY_STATUS_SUCCESS), kv(kv) { + n_kv = kv->get_size(); + + const uint32_t n_stream = kv->get_n_stream(); + + // create a dummy slot info - the actual data is irrelevant. we just need to build the graph + sinfos.resize(1); + sinfos[0].s0 = 0; + sinfos[0].s1 = n_stream - 1; + sinfos[0].idxs.resize(n_stream); + for (uint32_t s = 0; s < n_stream; ++s) { + sinfos[0].strm.push_back(s); + sinfos[0].idxs[s].resize(1, 0); + } +} + +llama_ik_cache_context::llama_ik_cache_context( + llama_ik_cache * kv, + llama_context * lctx, + bool do_shift, + stream_copy_info sc_info) : status(LLAMA_MEMORY_STATUS_SUCCESS), kv(kv), lctx(lctx), do_shift(do_shift), sc_info(std::move(sc_info)) { + if (!do_shift && this->sc_info.empty()) { + status = LLAMA_MEMORY_STATUS_NO_UPDATE; + } +} + +llama_ik_cache_context::llama_ik_cache_context( + llama_ik_cache * kv, + llama_ik_cache::slot_info_vec_t sinfos, + std::vector ubatches) : status(LLAMA_MEMORY_STATUS_SUCCESS), kv(kv), sinfos(std::move(sinfos)), ubatches(std::move(ubatches)) { +} + +llama_ik_cache_context::~llama_ik_cache_context() = default; + +bool llama_ik_cache_context::next() { + assert(status == LLAMA_MEMORY_STATUS_SUCCESS); + + if (++i_cur >= ubatches.size()) { + return false; + } + + return true; +} + +bool llama_ik_cache_context::apply() { + assert(!llama_memory_status_is_fail(status)); + + // no ubatches -> this is a KV cache update + if (ubatches.empty()) { + kv->update(lctx, do_shift, sc_info); + + return true; + } + + kv->apply_ubatch(sinfos[i_cur], ubatches[i_cur]); + n_kv = kv->get_n_kv(sinfos[i_cur]); + + return true; +} + +llama_memory_status llama_ik_cache_context::get_status() const { + return status; +} + +const llama_ubatch & llama_ik_cache_context::get_ubatch() const { + assert(status == LLAMA_MEMORY_STATUS_SUCCESS); + + return ubatches[i_cur]; +} + +uint32_t llama_ik_cache_context::get_n_kv() const { + return n_kv; +} + +ggml_tensor * llama_ik_cache_context::get_k(ggml_context * ctx, int32_t il) const { + return kv->get_k(ctx, il, n_kv, sinfos[i_cur]); +} + +ggml_tensor * llama_ik_cache_context::cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il) const { + return kv->cpy_k(ctx, k_cur, k_idxs, il, sinfos[i_cur]); +} + +ggml_tensor * llama_ik_cache_context::build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const { + return kv->build_input_k_idxs(ctx, ubatch); +} + +void llama_ik_cache_context::set_input_k_shift(ggml_tensor * dst) const { + kv->set_input_k_shift(dst); +} + +void llama_ik_cache_context::set_input_k_idxs(ggml_tensor * dst, const llama_ubatch * ubatch) const { + kv->set_input_k_idxs(dst, ubatch, sinfos[i_cur]); +} + +void llama_ik_cache_context::set_input_kq_mask(ggml_tensor * dst, const llama_ubatch * ubatch, bool causal_attn) const { + kv->set_input_kq_mask(dst, ubatch, causal_attn); +} diff --git a/src/llama-ik-cache.h b/src/llama-ik-cache.h new file mode 100644 index 00000000000..b9cde569c06 --- /dev/null +++ b/src/llama-ik-cache.h @@ -0,0 +1,306 @@ +#pragma once + +#include "llama-kv-cache.h" + +#include "llama-batch.h" +#include "llama-graph.h" +#include "llama-kv-cells.h" +#include "llama-memory.h" + +#include +#include + +struct llama_cparams; +struct llama_hparams; +struct llama_model; +struct llama_context; + +// +// llama_ik_cache +// + +class llama_ik_cache : public llama_memory_i { +public: + using stream_copy_info = llama_kv_cache::stream_copy_info; + using slot_info = llama_kv_cache::slot_info; + using slot_info_vec_t = std::vector; + + llama_ik_cache( + const llama_model & model, + ggml_type type_k, + ggml_type type_v, + bool v_trans, + bool offload, + bool unified, + uint32_t kv_size, + uint32_t n_seq_max, + uint32_t n_pad, + uint32_t n_swa, + llama_swa_type swa_type, + const layer_filter_cb & filter, + const layer_reuse_cb & reuse); + + ~llama_ik_cache() = default; + + // + // llama_memory_i + // + + llama_memory_context_ptr init_batch( + llama_batch_allocr & balloc, + uint32_t n_ubatch, + bool embd_all) override; + + llama_memory_context_ptr init_full() override; + + llama_memory_context_ptr init_update(llama_context * lctx, bool optimize) override; + + bool get_can_shift() const override; + + void clear(bool data) override; + + bool seq_rm (llama_seq_id seq_id, llama_pos p0, llama_pos p1) override; + void seq_cp (llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) override; + void seq_keep(llama_seq_id seq_id) override; + void seq_add (llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos shift) override; + void seq_div (llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) override; + + llama_pos seq_pos_min(llama_seq_id seq_id) const override; + llama_pos seq_pos_max(llama_seq_id seq_id) const override; + + std::map memory_breakdown() const override; + + // state write/load + + void state_write(llama_io_write_i & io, llama_seq_id seq_id = -1, llama_state_seq_flags flags = 0) const override; + void state_read (llama_io_read_i & io, llama_seq_id seq_id = -1, llama_state_seq_flags flags = 0) override; + + // + // llama_ik_cache specific API + // + + uint32_t get_size() const; + uint32_t get_n_stream() const; + + bool get_has_shift() const; + + // + // graph_build API + // + + uint32_t get_n_kv(const slot_info & sinfo) const; + + // get views of the current state of the cache + ggml_tensor * get_k(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const; + + // store k_cur and v_cur in the cache based on the provided head location + ggml_tensor * cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const; + + // + // preparation API + // + + // find places for the provided ubatches in the cache, returns the slot infos + // return empty vector on failure + slot_info_vec_t prepare(const std::vector & ubatches); + + bool update(llama_context * lctx, bool do_shift, const stream_copy_info & sc_info); + + // find a slot of kv cells that can hold the ubatch + // if cont == true, then the slot must be continuous + // return empty slot_info on failure + slot_info find_slot(const llama_ubatch & ubatch, bool cont) const; + + // emplace the ubatch context into slot: [sinfo.idxs[0...ubatch.n_tokens - 1]] + void apply_ubatch(const slot_info & sinfo, const llama_ubatch & ubatch); + + // + // input API + // + + ggml_tensor * build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const; + + void set_input_k_idxs(ggml_tensor * dst, const llama_ubatch * ubatch, const slot_info & sinfo) const; + + void set_input_k_shift(ggml_tensor * dst) const; + + void set_input_kq_mask (ggml_tensor * dst, const llama_ubatch * ubatch, bool causal_attn) const; + +private: + const llama_model & model; + const llama_hparams & hparams; + + struct kv_layer { + // layer index in the model + // note: can be different from the layer index in the KV cache + uint32_t il; + + ggml_tensor * k; + + std::vector k_stream; + }; + + bool v_trans = true; // the value tensor is transposed + + const uint32_t n_seq_max = 1; + const uint32_t n_stream = 1; + + // required padding + const uint32_t n_pad = 1; + + // SWA + const uint32_t n_swa = 0; + + // env: LLAMA_KV_CACHE_DEBUG + int debug = 0; + + // this is the SWA type of the cache - not to be confused with the model SWA type + const llama_swa_type swa_type = LLAMA_SWA_TYPE_NONE; + + // ggml contexts for the KV cache along with the allocated backend buffers: + std::vector> ctxs_bufs; + + // the current index from where we start searching for a free slot in the ring buffer of KV cells (see find_slot()) + // note: this is not part of the KV state and it's only used to speed-up the find_slot() method + std::vector v_heads; + + std::vector v_cells; + + // maps from a sequence id to a stream id + std::vector seq_to_stream; + + // pending stream copies that will be applied during the next update + stream_copy_info sc_info; + + std::vector layers; + + // model layer id -> KV cache layer id + std::unordered_map map_layer_ids; + + size_t total_size() const; + + size_t size_k_bytes() const; + + ggml_tensor * build_rope_shift( + const llama_cparams & cparams, + ggml_context * ctx, + ggml_tensor * cur, + ggml_tensor * shift, + ggml_tensor * factors, + float freq_base, + float freq_scale, + uint32_t il) const; + + ggml_cgraph * build_graph_shift( + llm_graph_result * res, + llama_context * lctx) const; + + struct cell_ranges_t { + uint32_t strm; + + std::vector> data; // ranges, from inclusive, to exclusive + }; + + void state_write_meta(llama_io_write_i & io, const cell_ranges_t & cr, llama_seq_id seq_id = -1) const; + void state_write_data(llama_io_write_i & io, const cell_ranges_t & cr) const; + + bool state_read_meta(llama_io_read_i & io, uint32_t strm, uint32_t cell_count, slot_info & sinfo, llama_seq_id dest_seq_id = -1); + bool state_read_data(llama_io_read_i & io, uint32_t strm, uint32_t cell_count, const slot_info & sinfo); +}; + +class llama_ik_cache_context : public llama_memory_context_i { +public: + // some shorthands + using slot_info_vec_t = llama_kv_cache::slot_info_vec_t; + using stream_copy_info = llama_kv_cache::stream_copy_info; + + // used for errors + llama_ik_cache_context(llama_memory_status status); + + // used to create a full-cache context + llama_ik_cache_context( + llama_ik_cache * kv); + + // used to create an update context + llama_ik_cache_context( + llama_ik_cache * kv, + llama_context * lctx, + bool do_shift, + stream_copy_info sc_info); + + // used to create a batch processing context from a batch + llama_ik_cache_context( + llama_ik_cache * kv, + slot_info_vec_t sinfos, + std::vector ubatches); + + virtual ~llama_ik_cache_context(); + + // + // llama_memory_context_i + // + + bool next() override; + bool apply() override; + + llama_memory_status get_status() const override; + const llama_ubatch & get_ubatch() const override; + + // + // llama_ik_cache_context specific API + // + + uint32_t get_n_kv() const; + + // get views of the current state of the cache + ggml_tensor * get_k(ggml_context * ctx, int32_t il) const; + + // store k_cur and v_cur in the cache based on the provided head location + // note: the heads in k_cur and v_cur should be layed out contiguously in memory + // - k_cur [n_embd_head_k, n_head_k, n_tokens] + // - k_idxs [n_tokens] + ggml_tensor * cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il) const; + + // create destination indices for each head of the current batch for where it would be written in the KV cache + // the indices address the global KV cache (not per stream) - this is not relevant for the user of this API, but + // helps understand the implementation logic of cpy_k + ggml_tensor * build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const; + + void set_input_k_idxs(ggml_tensor * dst, const llama_ubatch * ubatch) const; + + void set_input_k_shift (ggml_tensor * dst) const; + void set_input_kq_mask (ggml_tensor * dst, const llama_ubatch * ubatch, bool causal_attn) const; + +private: + llama_memory_status status; + + llama_ik_cache * kv; + llama_context * lctx; + + // + // update context + // + + bool do_shift = false; + + stream_copy_info sc_info; + + // + // batch processing context + // + + // the index of the cur ubatch to process + size_t i_cur = 0; + + slot_info_vec_t sinfos; + + std::vector ubatches; + + // + // data needed for building the compute graph for the current ubatch: + // + + // a heuristic, to avoid attending the full cache if it is not yet utilized + // as the cache gets filled, the benefit from this heuristic disappears + int32_t n_kv; +}; diff --git a/src/llama-kv-cache-dsa.cpp b/src/llama-kv-cache-dsa.cpp new file mode 100644 index 00000000000..82dc15ff265 --- /dev/null +++ b/src/llama-kv-cache-dsa.cpp @@ -0,0 +1,251 @@ +#include "llama-kv-cache-dsa.h" + +#include "llama-impl.h" +#include "llama-batch.h" +#include "llama-model.h" + +#include +#include + +// +// llama_kv_cache_dsa +// + +llama_kv_cache_dsa::llama_kv_cache_dsa( + const llama_model & model, + ggml_type type_k, + ggml_type type_v, + bool v_trans, + bool offload, + bool unified, + uint32_t kv_size, + uint32_t n_seq_max, + uint32_t n_pad, + uint32_t n_swa, + llama_swa_type swa_type, + const layer_filter_cb & filter, + const layer_reuse_cb & reuse) : + n_stream(unified ? 1 : n_seq_max) { + + LLAMA_LOG_INFO("%s: creating main KV cache, size = %u cells\n", __func__, kv_size); + + kv_base = std::make_unique( + model, type_k, type_v, + v_trans, offload, unified, kv_size, n_seq_max, n_pad, + n_swa, swa_type, filter, reuse); + + LLAMA_LOG_INFO("%s: creating indexer KV cache, size = %u cells\n", __func__, kv_size); + + kv_ik = std::make_unique( + model, type_k, type_v, + v_trans, offload, unified, kv_size, n_seq_max, n_pad, + n_swa, swa_type, filter, reuse); +} + +void llama_kv_cache_dsa::clear(bool data) { + kv_base->clear(data); + kv_ik ->clear(data); +} + +bool llama_kv_cache_dsa::seq_rm(llama_seq_id seq_id, llama_pos p0, llama_pos p1) { + bool res = true; + + res = res & kv_base->seq_rm(seq_id, p0, p1); + res = res & kv_ik ->seq_rm(seq_id, p0, p1); + + return res; +} + +void llama_kv_cache_dsa::seq_cp(llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) { + kv_base->seq_cp(seq_id_src, seq_id_dst, p0, p1); + kv_ik ->seq_cp(seq_id_src, seq_id_dst, p0, p1); +} + +void llama_kv_cache_dsa::seq_keep(llama_seq_id seq_id) { + kv_base->seq_keep(seq_id); + kv_ik ->seq_keep(seq_id); +} + +void llama_kv_cache_dsa::seq_add(llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos shift) { + kv_base->seq_add(seq_id, p0, p1, shift); + kv_ik ->seq_add(seq_id, p0, p1, shift); +} + +void llama_kv_cache_dsa::seq_div(llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) { + kv_base->seq_div(seq_id, p0, p1, d); + kv_ik ->seq_div(seq_id, p0, p1, d); +} + +llama_pos llama_kv_cache_dsa::seq_pos_min(llama_seq_id seq_id) const { + return kv_base->seq_pos_min(seq_id); +} + +llama_pos llama_kv_cache_dsa::seq_pos_max(llama_seq_id seq_id) const { + return kv_base->seq_pos_max(seq_id); +} + +std::map llama_kv_cache_dsa::memory_breakdown() const { + std::map mb = kv_base->memory_breakdown(); + for (const auto & buft_size : kv_ik->memory_breakdown()) { + mb[buft_size.first] += buft_size.second; + } + return mb; +} + +llama_memory_context_ptr llama_kv_cache_dsa::init_batch( + llama_batch_allocr & balloc, + uint32_t n_ubatch, + bool embd_all) { + GGML_UNUSED(embd_all); + + do { + balloc.split_reset(); + + std::vector ubatches; + while (true) { + auto ubatch = n_stream == 1 ? balloc.split_simple(n_ubatch) : balloc.split_equal(n_ubatch, true); + + if (ubatch.n_tokens == 0) { + break; + } + + ubatches.push_back(std::move(ubatch)); // NOLINT + } + + if (balloc.get_n_used() < balloc.get_n_tokens()) { + // failed to find a suitable split + break; + } + + auto sinfos_base = kv_base->prepare(ubatches); + if (sinfos_base.empty()) { + break; + } + + auto sinfos_ik = kv_ik->prepare(ubatches); + if (sinfos_ik.empty()) { + break; + } + + assert(sinfos_base.size() == sinfos_ik.size()); + + return std::make_unique( + this, std::move(sinfos_base), std::move(sinfos_ik), std::move(ubatches)); + } while (false); + + return std::make_unique(LLAMA_MEMORY_STATUS_FAILED_PREPARE); +} + +llama_memory_context_ptr llama_kv_cache_dsa::init_full() { + return std::make_unique(this); +} + +llama_memory_context_ptr llama_kv_cache_dsa::init_update(llama_context * lctx, bool optimize) { + return std::make_unique(this, lctx, optimize); +} + +bool llama_kv_cache_dsa::get_can_shift() const { + return kv_base->get_can_shift() && + kv_ik->get_can_shift() && + kv_base->get_size() == kv_ik->get_size(); +} + +void llama_kv_cache_dsa::state_write(llama_io_write_i & io, llama_seq_id seq_id, llama_state_seq_flags flags) const { + kv_base->state_write(io, seq_id, flags); + kv_ik->state_write(io, seq_id, flags); +} + +void llama_kv_cache_dsa::state_read(llama_io_read_i & io, llama_seq_id seq_id, llama_state_seq_flags flags) { + kv_base->state_read(io, seq_id, flags); + kv_ik->state_read(io, seq_id, flags); +} + +llama_kv_cache * llama_kv_cache_dsa::get_base() const { + return kv_base.get(); +} + +llama_ik_cache * llama_kv_cache_dsa::get_ik() const { + return kv_ik.get(); +} + +// +// llama_kv_cache_dsa_context +// + +llama_kv_cache_dsa_context::llama_kv_cache_dsa_context(llama_memory_status status) : status(status) {} + +llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( + llama_kv_cache_dsa * kv) : + ctx_base(kv->get_base()->init_full()), + ctx_ik(kv->get_ik()->init_full()), + status(llama_memory_status_combine(ctx_base->get_status(), ctx_ik->get_status())) { +} + +llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( + llama_kv_cache_dsa * kv, + llama_context * lctx, + bool optimize) : + ctx_base(kv->get_base()->init_update(lctx, optimize)), + ctx_ik(kv->get_ik()->init_update(lctx, optimize)), + status(llama_memory_status_combine(ctx_base->get_status(), ctx_ik->get_status())) { +} + +llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( + llama_kv_cache_dsa * kv, + slot_info_vec_t sinfos_base, + slot_info_vec_t sinfos_ik, + std::vector ubatches) : + ubatches(std::move(ubatches)), + // note: here we copy the ubatches. not sure if this is ideal + ctx_base(new llama_kv_cache_context(kv->get_base(), std::move(sinfos_base), this->ubatches)), + ctx_ik(new llama_ik_cache_context(kv->get_ik(), std::move(sinfos_ik), this->ubatches)), + status(llama_memory_status_combine(ctx_base->get_status(), ctx_ik->get_status())) { +} + +llama_kv_cache_dsa_context:: ~llama_kv_cache_dsa_context() = default; + +bool llama_kv_cache_dsa_context::next() { + assert(status == LLAMA_MEMORY_STATUS_SUCCESS); + + ctx_base->next(); + ctx_ik ->next(); + + if (++i_next >= ubatches.size()) { + return false; + } + + return true; +} + +bool llama_kv_cache_dsa_context::apply() { + assert(!llama_memory_status_is_fail(status)); + + bool res = true; + + res = res & ctx_base->apply(); + res = res & ctx_ik ->apply(); + + return res; +} + +llama_memory_status llama_kv_cache_dsa_context::get_status() const { + return status; +} + +const llama_ubatch & llama_kv_cache_dsa_context::get_ubatch() const { + assert(status == LLAMA_MEMORY_STATUS_SUCCESS); + + return ubatches[i_next]; +} + +const llama_kv_cache_context * llama_kv_cache_dsa_context::get_base() const { + assert(status == LLAMA_MEMORY_STATUS_SUCCESS); + + return static_cast(ctx_base.get()); +} + +const llama_ik_cache_context * llama_kv_cache_dsa_context::get_ik() const { + assert(status == LLAMA_MEMORY_STATUS_SUCCESS); + + return static_cast(ctx_ik.get()); +} diff --git a/src/llama-kv-cache-dsa.h b/src/llama-kv-cache-dsa.h new file mode 100644 index 00000000000..0ea209a5e83 --- /dev/null +++ b/src/llama-kv-cache-dsa.h @@ -0,0 +1,137 @@ +#pragma once + +#include "llama-kv-cache.h" +#include "llama-ik-cache.h" + +#include + +// +// llama_kv_cache_dsa +// + +// utilizes two KV cache instances: llama_kv_cache and llama_ik_cache +// the first instance is for caching key tensors of the model, +// the second instance is for caching lightning indexer key tensors + +class llama_kv_cache_dsa : public llama_memory_i { +public: + llama_kv_cache_dsa( + const llama_model & model, + ggml_type type_k, + ggml_type type_v, + bool v_trans, + bool offload, + bool unified, + uint32_t kv_size, + uint32_t n_seq_max, + uint32_t n_pad, + uint32_t n_swa, + llama_swa_type swa_type, + const layer_filter_cb & filter, + const layer_reuse_cb & reuse); + + ~llama_kv_cache_dsa() = default; + + // + // llama_memory_i + // + + llama_memory_context_ptr init_batch( + llama_batch_allocr & balloc, + uint32_t n_ubatch, + bool embd_all) override; + + llama_memory_context_ptr init_full() override; + + llama_memory_context_ptr init_update(llama_context * lctx, bool optimize) override; + + bool get_can_shift() const override; + + void clear(bool data) override; + + bool seq_rm (llama_seq_id seq_id, llama_pos p0, llama_pos p1) override; + void seq_cp (llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) override; + void seq_keep(llama_seq_id seq_id) override; + void seq_add (llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos shift) override; + void seq_div (llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) override; + + llama_pos seq_pos_min(llama_seq_id seq_id) const override; + llama_pos seq_pos_max(llama_seq_id seq_id) const override; + + std::map memory_breakdown() const override; + + // state write/load + + void state_write(llama_io_write_i & io, llama_seq_id seq_id = -1, llama_state_seq_flags flags = 0) const override; + void state_read (llama_io_read_i & io, llama_seq_id seq_id = -1, llama_state_seq_flags flags = 0) override; + + // + // llama_kv_cache_dsa specific API + // + + llama_kv_cache * get_base() const; + llama_ik_cache * get_ik () const; + +private: + const uint32_t n_stream = 1; + + std::unique_ptr kv_base; + std::unique_ptr kv_ik; +}; + +class llama_kv_cache_dsa_context : public llama_memory_context_i { +public: + using slot_info_vec_t = llama_kv_cache::slot_info_vec_t; + + // used for errors + llama_kv_cache_dsa_context(llama_memory_status status); + + // used to create a full-cache context + llama_kv_cache_dsa_context( + llama_kv_cache_dsa * kv); + + // used to create an update context + llama_kv_cache_dsa_context( + llama_kv_cache_dsa * kv, + llama_context * lctx, + bool optimize); + + // used to create a batch processing context from a batch + llama_kv_cache_dsa_context( + llama_kv_cache_dsa * kv, + slot_info_vec_t sinfos_base, + slot_info_vec_t sinfos_ik, + std::vector ubatches); + + virtual ~llama_kv_cache_dsa_context(); + + // + // llama_memory_context_i + // + + bool next() override; + bool apply() override; + + llama_memory_status get_status() const override; + const llama_ubatch & get_ubatch() const override; + + // + // llama_kv_cache_dsa_context specific API + // + + const llama_kv_cache_context * get_base() const; + const llama_ik_cache_context * get_ik() const; + +private: + //llama_kv_cache_dsa * kv; + + // the index of the next ubatch to process + size_t i_next = 0; + + std::vector ubatches; + + const llama_memory_context_ptr ctx_base; + const llama_memory_context_ptr ctx_ik; + + const llama_memory_status status; +}; diff --git a/src/llama-kv-cache.cpp b/src/llama-kv-cache.cpp index 2752ac2119f..82fe58fac46 100644 --- a/src/llama-kv-cache.cpp +++ b/src/llama-kv-cache.cpp @@ -51,7 +51,7 @@ llama_kv_cache::llama_kv_cache( auto it = ctx_map.find(buft); if (it == ctx_map.end()) { ggml_init_params params = { - /*.mem_size =*/ size_t(3u*(1 + n_stream)*n_layer_kv*ggml_tensor_overhead()), + /*.mem_size =*/ size_t(2u*(1 + n_stream)*n_layer_kv*ggml_tensor_overhead()), /*.mem_buffer =*/ NULL, /*.no_alloc =*/ true, }; @@ -113,7 +113,6 @@ llama_kv_cache::llama_kv_cache( // [TAG_V_CACHE_VARIABLE] const uint32_t n_embd_k_gqa = hparams.n_embd_k_gqa(il); const uint32_t n_embd_v_gqa = !v_trans ? hparams.n_embd_v_gqa(il) : hparams.n_embd_v_gqa_max(); - const uint32_t n_embd_indexer_head = hparams.indexer_head_size; const char * dev_name = "CPU"; @@ -135,29 +134,24 @@ llama_kv_cache::llama_kv_cache( const bool has_k = true; const bool has_v = !is_mla; - const bool has_ik = hparams.indexer_top_k > 0; ggml_tensor * k = has_k ? ggml_new_tensor_3d(ctx, type_k, n_embd_k_gqa, kv_size, n_stream) : nullptr; ggml_tensor * v = has_v ? ggml_new_tensor_3d(ctx, type_v, n_embd_v_gqa, kv_size, n_stream) : nullptr; - ggml_tensor * ik = has_ik ? ggml_new_tensor_3d(ctx, type_k, n_embd_indexer_head, kv_size, n_stream) : nullptr; has_k && ggml_format_name(k, "cache_k_l%d", il); has_v && ggml_format_name(v, "cache_v_l%d", il); - has_ik && ggml_format_name(ik, "cache_ik_l%d", il); std::vector k_stream; std::vector v_stream; - std::vector ik_stream; for (uint32_t s = 0; s < n_stream; ++s) { k_stream.push_back(has_k ? ggml_view_2d(ctx, k, n_embd_k_gqa, kv_size, k->nb[1], s*k->nb[2]) : nullptr); v_stream.push_back(has_v ? ggml_view_2d(ctx, v, n_embd_v_gqa, kv_size, v->nb[1], s*v->nb[2]) : nullptr); - ik_stream.push_back(has_ik ? ggml_view_2d(ctx, ik, n_embd_indexer_head, kv_size, ik->nb[1], s*ik->nb[2]) : nullptr); } map_layer_ids[il] = layers.size(); - layers.push_back({ il, k, v, ik, k_stream, v_stream, ik_stream }); + layers.push_back({ il, k, v, k_stream, v_stream, }); } if (reuse) { @@ -208,13 +202,11 @@ llama_kv_cache::llama_kv_cache( { const size_t memory_size_k = size_k_bytes(); const size_t memory_size_v = size_v_bytes(); - const size_t memory_size_ik = size_ik_bytes(); - LLAMA_LOG_INFO("%s: size = %7.2f MiB (%6u cells, %3d layers, %2u/%u seqs), K (%s): %7.2f MiB, V (%s): %7.2f MiB, IK (%s): %7.2f MiB\n", __func__, + LLAMA_LOG_INFO("%s: size = %7.2f MiB (%6u cells, %3d layers, %2u/%u seqs), K (%s): %7.2f MiB, V (%s): %7.2f MiB\n", __func__, (float)(memory_size_k + memory_size_v) / (1024.0f * 1024.0f), kv_size, (int) layers.size(), n_seq_max, n_stream, ggml_type_name(type_k), (float)memory_size_k / (1024.0f * 1024.0f), - ggml_type_name(type_v), (float)memory_size_v / (1024.0f * 1024.0f), - ggml_type_name(type_k), (float)memory_size_ik / (1024.0f * 1024.0f)); + ggml_type_name(type_v), (float)memory_size_v / (1024.0f * 1024.0f)); } const char * LLAMA_KV_CACHE_DEBUG = getenv("LLAMA_KV_CACHE_DEBUG"); @@ -664,10 +656,6 @@ bool llama_kv_cache::update(llama_context * lctx, bool do_shift, const stream_co if (layer.v_stream[ssrc]) { ggml_backend_tensor_copy(layer.v_stream[ssrc], layer.v_stream[sdst]); } - - if (layer.ik_stream[ssrc]) { - ggml_backend_tensor_copy(layer.ik_stream[ssrc], layer.ik_stream[sdst]); - } } } } @@ -1084,26 +1072,6 @@ ggml_tensor * llama_kv_cache::get_v(ggml_context * ctx, int32_t il, uint32_t n_k ggml_row_size(v->type, kv_size*n_embd_v_gqa)*sinfo.s0); } -ggml_tensor * llama_kv_cache::get_ik(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const { - const int32_t ikv = map_layer_ids.at(il); - - auto * ik = layers[ikv].ik; - - const uint64_t kv_size = get_size(); - const uint64_t n_embd_indexer_head = ik->ne[0]; - - assert(n_embd_indexer_head == hparams.indexer_head_size); - - const uint32_t ns = sinfo.s1 - sinfo.s0 + 1; - - return ggml_view_4d(ctx, ik, - n_embd_indexer_head, 1, n_kv, ns, - ggml_row_size(ik->type, n_embd_indexer_head), - ggml_row_size(ik->type, n_embd_indexer_head), - ggml_row_size(ik->type, n_embd_indexer_head*kv_size), - ggml_row_size(ik->type, n_embd_indexer_head*kv_size)*sinfo.s0); -} - ggml_tensor * llama_kv_cache::cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const { GGML_UNUSED(sinfo); @@ -1195,41 +1163,6 @@ ggml_tensor * llama_kv_cache::cpy_v(ggml_context * ctx, ggml_tensor * v_cur, ggm return ggml_set_rows(ctx, v_view, v_cur, v_idxs); } -ggml_tensor * llama_kv_cache::cpy_ik(ggml_context * ctx, ggml_tensor * ik_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const { - GGML_UNUSED(sinfo); - - const int32_t ikv = map_layer_ids.at(il); - - ggml_tensor * ik = layers[ikv].ik; - - const int64_t n_embd_indexer_head = ik_cur->ne[0]; - const int64_t n_head = ik_cur->ne[1]; - const int64_t n_tokens = ik_cur->ne[2]; - - const int64_t n_embd_gqa = n_embd_indexer_head*n_head; - - // we can merge dims 0 and 1 - // TODO: add ggml helper function for this? - GGML_ASSERT(ggml_row_size(ik_cur->type, n_embd_indexer_head) == ik_cur->nb[1]); - - ik_cur = ggml_view_2d(ctx, ik_cur, n_embd_gqa, n_tokens, ik_cur->nb[2], 0); - - const int64_t n_stream = ik->ne[2]; - - if (n_stream > 1) { - const int64_t kv_size = get_size(); - - assert(n_embd_gqa == ik->ne[0]); - assert(kv_size == ik->ne[1]); - - // merge the buffer across all streams because the idxs are global - ik = ggml_reshape_2d(ctx, ik, n_embd_gqa, kv_size*n_stream); - } - - // store the current K values into the cache - return ggml_set_rows(ctx, ik, ik_cur, k_idxs); -} - ggml_tensor * llama_kv_cache::build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const { const uint32_t n_tokens = ubatch.n_tokens; @@ -1604,16 +1537,6 @@ size_t llama_kv_cache::size_v_bytes() const { return size_v_bytes; } -size_t llama_kv_cache::size_ik_bytes() const { - size_t size_ik_bytes = 0; - - for (const auto & layer : layers) { - size_ik_bytes += layer.ik ? ggml_nbytes(layer.ik) : 0; - } - - return size_ik_bytes; -} - ggml_tensor * llama_kv_cache::build_rope_shift( const llama_cparams & cparams, ggml_context * ctx, @@ -2319,10 +2242,6 @@ ggml_tensor * llama_kv_cache_context::get_v(ggml_context * ctx, int32_t il) cons return kv->get_v(ctx, il, n_kv, sinfos[i_cur]); } -ggml_tensor * llama_kv_cache_context::get_ik(ggml_context * ctx, int32_t il) const { - return kv->get_ik(ctx, il, n_kv, sinfos[i_cur]); -} - ggml_tensor * llama_kv_cache_context::cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il) const { return kv->cpy_k(ctx, k_cur, k_idxs, il, sinfos[i_cur]); } @@ -2331,10 +2250,6 @@ ggml_tensor * llama_kv_cache_context::cpy_v(ggml_context * ctx, ggml_tensor * v_ return kv->cpy_v(ctx, v_cur, v_idxs, il, sinfos[i_cur]); } -ggml_tensor * llama_kv_cache_context::cpy_ik(ggml_context * ctx, ggml_tensor * ik_cur, ggml_tensor * k_idxs, int32_t il) const { - return kv->cpy_ik(ctx, ik_cur, k_idxs, il, sinfos[i_cur]); -} - ggml_tensor * llama_kv_cache_context::build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const { return kv->build_input_k_idxs(ctx, ubatch); } diff --git a/src/llama-kv-cache.h b/src/llama-kv-cache.h index 6e47b40563d..33c78c5f210 100644 --- a/src/llama-kv-cache.h +++ b/src/llama-kv-cache.h @@ -161,12 +161,10 @@ class llama_kv_cache : public llama_memory_i { // get views of the current state of the cache ggml_tensor * get_k(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const; ggml_tensor * get_v(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const; - ggml_tensor * get_ik(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const; // store k_cur and v_cur in the cache based on the provided head location ggml_tensor * cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const; ggml_tensor * cpy_v(ggml_context * ctx, ggml_tensor * v_cur, ggml_tensor * v_idxs, int32_t il, const slot_info & sinfo) const; - ggml_tensor * cpy_ik(ggml_context * ctx, ggml_tensor * ik_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const; // // preparation API @@ -212,11 +210,9 @@ class llama_kv_cache : public llama_memory_i { ggml_tensor * k; ggml_tensor * v; - ggml_tensor * ik; std::vector k_stream; std::vector v_stream; - std::vector ik_stream; }; bool v_trans = true; // the value tensor is transposed @@ -260,7 +256,6 @@ class llama_kv_cache : public llama_memory_i { size_t size_k_bytes() const; size_t size_v_bytes() const; - size_t size_ik_bytes() const; ggml_tensor * build_rope_shift( const llama_cparams & cparams, @@ -336,7 +331,6 @@ class llama_kv_cache_context : public llama_memory_context_i { // get views of the current state of the cache ggml_tensor * get_k(ggml_context * ctx, int32_t il) const; ggml_tensor * get_v(ggml_context * ctx, int32_t il) const; - ggml_tensor * get_ik(ggml_context * ctx, int32_t il) const; // store k_cur and v_cur in the cache based on the provided head location // note: the heads in k_cur and v_cur should be layed out contiguously in memory @@ -346,7 +340,6 @@ class llama_kv_cache_context : public llama_memory_context_i { // - v_idxs [n_tokens] or [n_tokens*n_embd_v_gqa] depending if V cache is transposed ggml_tensor * cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il) const; ggml_tensor * cpy_v(ggml_context * ctx, ggml_tensor * v_cur, ggml_tensor * v_idxs, int32_t il) const; - ggml_tensor * cpy_ik(ggml_context * ctx, ggml_tensor * ik_cur, ggml_tensor * k_idxs, int32_t il) const; // create destination indices for each head of the current batch for where it would be written in the KV cache // the indices address the global KV cache (not per stream) - this is not relevant for the user of this API, but diff --git a/src/llama-model.cpp b/src/llama-model.cpp index b484d82ef14..58969cc1b56 100644 --- a/src/llama-model.cpp +++ b/src/llama-model.cpp @@ -8,6 +8,7 @@ #include "llama-kv-cache.h" #include "llama-kv-cache-iswa.h" +#include "llama-kv-cache-dsa.h" #include "llama-memory-hybrid.h" #include "llama-memory-hybrid-iswa.h" #include "llama-memory-recurrent.h" @@ -8111,6 +8112,23 @@ llama_memory_i * llama_model::create_memory(const llama_memory_params & params, { res = nullptr; } break; + case LLM_ARCH_DEEPSEEK32: + { + res = new llama_kv_cache_dsa( + *this, + params.type_k, + params.type_v, + !cparams.flash_attn, + cparams.offload_kqv, + cparams.kv_unified, + cparams.n_ctx_seq, + cparams.n_seq_max, + 1, + hparams.n_swa, + hparams.swa_type, + nullptr, + nullptr); + } break; // Models that need standard caching should rely on recurrent/hybrid // checks default: diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index 4f334462d5d..3f05264d703 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -1,14 +1,17 @@ #include "models.h" #include "llama-kv-cache.h" +#include "llama-ik-cache.h" llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_graph_params & params) : llm_graph_context(params) { const bool is_mla = hparams.is_mla(); + GGML_ASSERT(is_mla); // note: these are the actual head sizes you get when treating as MHA or after "decompression" using wv_b for MLA const int64_t n_embd_head_k = hparams.n_embd_head_k_mla(); const int64_t n_embd_head_v = hparams.n_embd_head_v_mla(); + GGML_UNUSED(n_embd_head_v); const int64_t n_embd_head_qk_rope = hparams.n_rot(); const int64_t n_embd_head_qk_nope = n_embd_head_k - n_embd_head_qk_rope; @@ -42,8 +45,9 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ // inp_pos - contains the positions ggml_tensor * inp_pos = build_inp_pos(); - auto * inp_attn_kv = !is_mla ? build_attn_inp_kv() : nullptr; - auto * inp_attn_k = is_mla ? build_attn_inp_k() : nullptr; + std::pair inp_attn_dsa = build_attn_inp_k_dsa(); + auto * inp_attn_k = inp_attn_dsa.first; + auto * inp_attn_ik = inp_attn_dsa.second; ggml_tensor * inp_out_ids = build_inp_out_ids(); @@ -63,9 +67,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ qr = build_norm(qr, model.layers[il].attn_q_a_norm, nullptr, LLM_NORM_RMS, il); cb(qr, "qr", il); - ggml_tensor * kq_mask = is_mla ? inp_attn_k->get_kq_mask() : inp_attn_kv->get_kq_mask(); - ggml_tensor * kq_mask_bak = ggml_dup(ctx0, kq_mask); - ggml_build_forward_expand(gf, kq_mask_bak); + ggml_tensor * top_k = nullptr; // lightning indexer { @@ -133,9 +135,9 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_k, "indexer_k", il); // store indexer keys to KV cache - const auto * mctx_cur = is_mla ? inp_attn_k->mctx : inp_attn_kv->mctx; - const auto & k_idxs = is_mla ? inp_attn_k->get_k_idxs() : inp_attn_kv->get_k_idxs(); - ggml_build_forward_expand(gf, mctx_cur->cpy_ik(ctx0, indexer_k, k_idxs, il)); + const auto * mctx_cur = inp_attn_ik->mctx; + const auto & k_idxs = inp_attn_ik->get_k_idxs(); + ggml_build_forward_expand(gf, mctx_cur->cpy_k(ctx0, indexer_k, k_idxs, il)); // prepare indexer weights ggml_tensor * indexer_weights = ggml_mul_mat(ctx0, model.layers[il].indexer_proj, cur); @@ -145,7 +147,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_weights, "indexer_weights", il); // get cached indexer keys - indexer_k = mctx_cur->get_ik(ctx0, il); + indexer_k = mctx_cur->get_k(ctx0, il); // split the batch into streams if needed const auto n_stream = indexer_k->ne[3]; @@ -188,24 +190,14 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_score, "indexer_score", il); // mask indexer scores - ggml_tensor * kq_mask_f32 = ggml_cast(ctx0, kq_mask, GGML_TYPE_F32); - indexer_score = ggml_add(ctx0, indexer_score, kq_mask_f32); + ggml_tensor * indexer_kq_mask = inp_attn_ik->get_kq_mask(); + indexer_score = ggml_add(ctx0, indexer_score, indexer_kq_mask); cb(indexer_score, "indexer_score", il); // get indices of top k indexer scores uint32_t n_top_k = indexer_score->ne[0] < n_indexer_top_k ? indexer_score->ne[0] : n_indexer_top_k; - ggml_tensor * top_k = ggml_cont(ctx0, ggml_top_k(ctx0, indexer_score, n_top_k)); + top_k = ggml_cont(ctx0, ggml_top_k(ctx0, indexer_score, n_top_k)); cb(top_k, "top_k", il); - - // prepare new kq mask - starts filled with -INFINITY - ggml_tensor * kq_mask_all = ggml_fill(ctx0, kq_mask_f32, -INFINITY); - cb(kq_mask_all, "kq_mask_all", il); - - // modify it by unmasking tokens that are in top_k indices - ggml_tensor * kq_mask_top_k = ggml_where_id(ctx0, kq_mask_f32, kq_mask_all, top_k); - cb(kq_mask_top_k, "kq_mask_top_k", il); - - ggml_build_forward_expand(gf, ggml_cpy(ctx0, ggml_cast(ctx0, kq_mask_top_k, kq_mask->type), kq_mask)); } ggml_tensor * q = ggml_mul_mat(ctx0, model.layers[il].wq_b, qr); @@ -250,7 +242,8 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ kv_cmpr = build_norm(kv_cmpr, model.layers[il].attn_kv_a_norm, nullptr, LLM_NORM_RMS, il); cb(kv_cmpr, "kv_cmpr", il); - if (is_mla) { + // MLA attention + { // {n_embd_head_qk_nope, n_tokens, n_head} q_nope = ggml_permute(ctx0, q_nope, 0, 2, 1, 3); cb(q_nope, "q_nope_perm", il); @@ -282,41 +275,8 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ // note: MLA with the absorption optimization converts into MQA (ie: GQA with 1 group) cur = build_attn(inp_attn_k, model.layers[il].wo, NULL, - Qcur, Kcur, Vcur, nullptr, nullptr, model.layers[il].wv_b, kq_scale, il); - } else { - ggml_tensor * kv = ggml_mul_mat(ctx0, model.layers[il].wkv_b, kv_cmpr); - cb(kv, "kv", il); - - // split into {n_embd_head_qk_nope, n_head, n_tokens} - ggml_tensor * k_nope = - ggml_view_3d(ctx0, kv, n_embd_head_qk_nope, n_head, n_tokens, - ggml_row_size(kv->type, n_embd_head_qk_nope + n_embd_head_v), - ggml_row_size(kv->type, n_embd_head_qk_nope + n_embd_head_v) * n_head, 0); - cb(k_nope, "k_nope_view", il); - - // and {n_embd_head_v, n_head, n_tokens} - ggml_tensor * Vcur = ggml_view_3d(ctx0, kv, n_embd_head_v, n_head, n_tokens, - ggml_row_size(kv->type, n_embd_head_qk_nope + n_embd_head_v), - ggml_row_size(kv->type, n_embd_head_qk_nope + n_embd_head_v) * n_head, - ggml_row_size(kv->type, n_embd_head_qk_nope)); - cb(Vcur, "Vcur_view", il); - - Vcur = ggml_cont(ctx0, Vcur); - cb(Vcur, "Vcur_cont", il); - - ggml_tensor * Qcur = ggml_concat(ctx0, q_nope, q_pe, 0); - cb(Qcur, "Qcur", il); - - ggml_tensor * Kcur = ggml_concat(ctx0, k_nope, ggml_repeat(ctx0, k_pe, q_pe), 0); - cb(Kcur, "Kcur", il); - - // note: MLA without the absorption optimization converts into MHA (ie: GQA with full n_head groups) - cur = build_attn(inp_attn_kv, - model.layers[il].wo, NULL, - Qcur, Kcur, Vcur, nullptr, nullptr, nullptr, kq_scale, il); + Qcur, Kcur, Vcur, nullptr, nullptr, model.layers[il].wv_b, top_k, kq_scale, il); } - - ggml_build_forward_expand(gf, ggml_cpy(ctx0, kq_mask_bak, kq_mask)); } if (il == effective_n_layers - 1 && inp_out_ids) { cur = ggml_get_rows(ctx0, cur, inp_out_ids); From 9b0a4eea57b2a25268f26971954a2994ca82f0b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Tue, 24 Mar 2026 17:25:42 +0100 Subject: [PATCH 16/46] ggml : replaced GGML_OP_WHERE_ID with GGML_OP_SCATTER that works similar to torch scatter_ operation. --- ggml/include/ggml.h | 8 ++-- ggml/src/ggml-cpu/ggml-cpu.c | 6 +-- ggml/src/ggml-cpu/ops.cpp | 33 +++++++------- ggml/src/ggml-cpu/ops.h | 2 +- ggml/src/ggml-cuda/ggml-cuda.cu | 8 ++-- ggml/src/ggml-cuda/scatter.cu | 72 ++++++++++++++++++++++++++++++ ggml/src/ggml-cuda/scatter.cuh | 3 ++ ggml/src/ggml-cuda/where-id.cu | 78 --------------------------------- ggml/src/ggml-cuda/where-id.cuh | 3 -- ggml/src/ggml.c | 21 ++++----- src/llama-graph.cpp | 5 ++- 11 files changed, 117 insertions(+), 122 deletions(-) create mode 100644 ggml/src/ggml-cuda/scatter.cu create mode 100644 ggml/src/ggml-cuda/scatter.cuh delete mode 100644 ggml/src/ggml-cuda/where-id.cu delete mode 100644 ggml/src/ggml-cuda/where-id.cuh diff --git a/ggml/include/ggml.h b/ggml/include/ggml.h index 82186fe8f63..48a5e6ee831 100644 --- a/ggml/include/ggml.h +++ b/ggml/include/ggml.h @@ -558,7 +558,7 @@ extern "C" { GGML_OP_SOLVE_TRI, GGML_OP_GATED_DELTA_NET, GGML_OP_HADAMARD, - GGML_OP_WHERE_ID, + GGML_OP_SCATTER, GGML_OP_UNARY, @@ -2480,11 +2480,11 @@ extern "C" { struct ggml_tensor * a, int n); - GGML_API struct ggml_tensor * ggml_where_id( + GGML_API struct ggml_tensor * ggml_scatter( struct ggml_context * ctx, struct ggml_tensor * a, - struct ggml_tensor * b, - struct ggml_tensor * ids); + struct ggml_tensor * ids, + float c); // custom operators diff --git a/ggml/src/ggml-cpu/ggml-cpu.c b/ggml/src/ggml-cpu/ggml-cpu.c index e5e5f0507e1..7118439b831 100644 --- a/ggml/src/ggml-cpu/ggml-cpu.c +++ b/ggml/src/ggml-cpu/ggml-cpu.c @@ -2029,9 +2029,9 @@ static void ggml_compute_forward(struct ggml_compute_params * params, struct ggm { ggml_compute_forward_hadamard(params, tensor); } break; - case GGML_OP_WHERE_ID: + case GGML_OP_SCATTER: { - ggml_compute_forward_where_id(params, tensor); + ggml_compute_forward_scatter(params, tensor); } break; case GGML_OP_MAP_CUSTOM1: { @@ -2356,7 +2356,7 @@ static int ggml_get_n_tasks(struct ggml_tensor * node, int n_threads) { case GGML_OP_GATED_LINEAR_ATTN: case GGML_OP_RWKV_WKV7: case GGML_OP_HADAMARD: - case GGML_OP_WHERE_ID: + case GGML_OP_SCATTER: { n_tasks = n_threads; } break; diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index c4a77b29e92..d720a6253aa 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11257,32 +11257,30 @@ void ggml_compute_forward_hadamard( } } -// ggml_compute_forward_where_id +// ggml_compute_forward_scatter -static void ggml_compute_forward_where_id_f32( +static void ggml_compute_forward_scatter_f32( const ggml_compute_params * params, ggml_tensor * dst) { const ggml_tensor * src0 = dst->src[0]; const ggml_tensor * src1 = dst->src[1]; - const ggml_tensor * src2 = dst->src[2]; + const float c = ggml_get_op_params_f32(dst, 0); - GGML_ASSERT(ggml_are_same_shape(src0, src1) && ggml_are_same_shape(src0, dst)); + GGML_ASSERT(ggml_are_same_shape(src0, dst)); GGML_ASSERT(dst->type == GGML_TYPE_F32); GGML_ASSERT(src0->type == GGML_TYPE_F32); - GGML_ASSERT(src1->type == GGML_TYPE_F32); - GGML_ASSERT(src2->type == GGML_TYPE_I32); + GGML_ASSERT(src1->type == GGML_TYPE_I32); GGML_ASSERT(src0->nb[0] == sizeof(float)); - GGML_ASSERT(src1->nb[0] == sizeof(float)); const int ith = params->ith; const int nth = params->nth; const int nr = ggml_nrows(src0); - GGML_TENSOR_TERNARY_OP_LOCALS + GGML_TENSOR_BINARY_OP_LOCALS GGML_ASSERT( nb0 == sizeof(float)); GGML_ASSERT(nb00 == sizeof(float)); @@ -11301,23 +11299,22 @@ static void ggml_compute_forward_where_id_f32( const int i1 = (ir - i3*ne2*ne1 - i2*ne1); const float * src0_ptr = (float *) ((char *) src0->data + i3*nb3 + i2*nb2 + i1*nb1 ); - const float * src1_ptr = (float *) ((char *) src1->data + i3*nb13 + i2*nb12 + i1*nb11 ); - const int32_t * ids_ptr = (int32_t *) ((char *) src2->data + i3*nb23 + i2*nb22 + i1*nb21); + const int32_t * ids_ptr = (int32_t *) ((char *) src1->data + i3*nb13 + i2*nb12 + i1*nb11); float * dst_ptr = (float *) ((char *) dst->data + i3*nb3 + i2*nb2 + i1*nb1 ); - // copy whole row from src1 - ggml_vec_cpy_f32(ne00, dst_ptr, src1_ptr); + // copy whole row from src0 + ggml_vec_cpy_f32(ne00, dst_ptr, src0_ptr); - // copy only values from src0 indicated by indices in src2 - for (int j = 0; j < ne20; ++j) { + // set dst elements indicated by indices in src1 to c + for (int j = 0; j < ne10; ++j) { int id = ids_ptr[j]; GGML_ASSERT(id >= 0 && id < ne00); - dst_ptr[id] = src0_ptr[id]; + dst_ptr[id] = c; } } } -void ggml_compute_forward_where_id( +void ggml_compute_forward_scatter( const ggml_compute_params * params, ggml_tensor * dst) { @@ -11326,11 +11323,11 @@ void ggml_compute_forward_where_id( switch (src0->type) { case GGML_TYPE_F32: { - ggml_compute_forward_where_id_f32(params, dst); + ggml_compute_forward_scatter_f32(params, dst); } break; default: { - GGML_ABORT("unsupported type for ggml_compute_forward_where_id: %s", ggml_type_name(src0->type)); + GGML_ABORT("unsupported type for ggml_compute_forward_scatter: %s", ggml_type_name(src0->type)); } } } diff --git a/ggml/src/ggml-cpu/ops.h b/ggml/src/ggml-cpu/ops.h index 30b3e6d3118..4fecd4651e8 100644 --- a/ggml/src/ggml-cpu/ops.h +++ b/ggml/src/ggml-cpu/ops.h @@ -104,7 +104,7 @@ void ggml_compute_forward_solve_tri(const struct ggml_compute_params * params, s void ggml_compute_forward_gla(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_gated_delta_net(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_hadamard(const struct ggml_compute_params * params, struct ggml_tensor * dst); -void ggml_compute_forward_where_id(const struct ggml_compute_params * params, struct ggml_tensor * dst); +void ggml_compute_forward_scatter(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom1(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom2(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom3(const struct ggml_compute_params * params, struct ggml_tensor * dst); diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu index da2b54e137c..4af7f2ba1d9 100644 --- a/ggml/src/ggml-cuda/ggml-cuda.cu +++ b/ggml/src/ggml-cuda/ggml-cuda.cu @@ -62,7 +62,7 @@ #include "ggml-cuda/cumsum.cuh" #include "ggml-cuda/fill.cuh" #include "ggml-cuda/hadamard.cuh" -#include "ggml-cuda/where-id.cuh" +#include "ggml-cuda/scatter.cuh" #include "ggml.h" #include @@ -2776,8 +2776,8 @@ static bool ggml_cuda_compute_forward(ggml_backend_cuda_context & ctx, struct gg case GGML_OP_HADAMARD: ggml_cuda_op_hadamard(ctx, dst); break; - case GGML_OP_WHERE_ID: - ggml_cuda_op_where_id(ctx, dst); + case GGML_OP_SCATTER: + ggml_cuda_op_scatter(ctx, dst); break; default: return false; @@ -5020,7 +5020,7 @@ static bool ggml_backend_cuda_device_supports_op(ggml_backend_dev_t dev, const g case GGML_OP_TRI: case GGML_OP_DIAG: case GGML_OP_SOLVE_TRI: - case GGML_OP_WHERE_ID: + case GGML_OP_SCATTER: return true; case GGML_OP_HADAMARD: return (op->ne[0] == 64 || op->ne[0] == 128 || op->ne[0] == 256) && op->type == GGML_TYPE_F32 && op->src[0]->type == GGML_TYPE_F32; diff --git a/ggml/src/ggml-cuda/scatter.cu b/ggml/src/ggml-cuda/scatter.cu new file mode 100644 index 00000000000..990b5cddb7a --- /dev/null +++ b/ggml/src/ggml-cuda/scatter.cu @@ -0,0 +1,72 @@ +#include "scatter.cuh" + +static __global__ void scatter_kernel( + const int32_t * src0, float * dst, const float c, + int64_t ne00, int64_t ne01, int64_t ne02, int64_t ne03, + size_t nb1, size_t nb2, size_t nb3, + size_t nb01, size_t nb02, size_t nb03 + ) { + + const int64_t total_blocks = ne01 * ne02 * ne03; + + for (int64_t block_idx = blockIdx.x; block_idx < total_blocks; block_idx += gridDim.x) { + + const int64_t i1 = block_idx % ne01; + const int64_t i2 = (block_idx / ne01) % ne02; + const int64_t i3 = block_idx / (ne01 * ne02); + + float * dst_row = (float *)((char *)dst + i1*nb1 + i2*nb2 + i3*nb3); + const int * src0_row = (const int *)((const char *)src0 + i1*nb01 + i2*nb02 + i3*nb03); + + for (int64_t i0 = threadIdx.x; i0 < ne00; i0 += blockDim.x) { + const int32_t id = src0_row[i0]; + dst_row[id] = c; + } + } +} + +void ggml_cuda_op_scatter(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { + const ggml_tensor * src0 = dst->src[0]; + const ggml_tensor * src1 = dst->src[1]; + + GGML_TENSOR_BINARY_OP_LOCALS + + GGML_ASSERT(ggml_is_contiguous(dst)); + GGML_ASSERT(ggml_is_contiguous(src0)); + GGML_ASSERT(ggml_is_contiguous(src1)); + + GGML_ASSERT(dst->type == GGML_TYPE_F32); + GGML_ASSERT(src0->type == GGML_TYPE_F32); + GGML_ASSERT(src1->type == GGML_TYPE_I32); + + GGML_ASSERT(nb00 == sizeof(float)); + GGML_ASSERT(nb10 == sizeof(int32_t)); + + GGML_ASSERT(ggml_nbytes(src0) == ggml_nbytes(dst)); + + float c; + memcpy(&c, (float *) dst->op_params + 0, sizeof(float)); + + // step 1 - copy whole src0 to dst + cudaStream_t main_stream = ctx.stream(); + char * dst_ddc = (char *) dst->data; + char * src0_ddc = (char *) src0->data; + + CUDA_CHECK(cudaMemcpyAsync(dst_ddc, src0_ddc, ggml_nbytes(src0), cudaMemcpyDeviceToDevice, main_stream)); + + // step 2 - set elements in dst indicated by ids to c + const int32_t * src1_d = (const int32_t *) src1->data; + float * dst_d = (float *) dst->data; + + int threads = std::min((int) ne10, 768); // ids + + int64_t total_blocks = ne11 * ne12 * ne13; + int blocks = (int) std::min((int64_t) 65535, total_blocks); + + scatter_kernel<<>>( + src1_d, dst_d, c, + ne10, ne11, ne12, ne13, + nb1, nb2, nb3, + nb11, nb12, nb13 + ); +} diff --git a/ggml/src/ggml-cuda/scatter.cuh b/ggml/src/ggml-cuda/scatter.cuh new file mode 100644 index 00000000000..b435c992a64 --- /dev/null +++ b/ggml/src/ggml-cuda/scatter.cuh @@ -0,0 +1,3 @@ +#include "common.cuh" + +void ggml_cuda_op_scatter(ggml_backend_cuda_context & ctx, ggml_tensor * dst); diff --git a/ggml/src/ggml-cuda/where-id.cu b/ggml/src/ggml-cuda/where-id.cu deleted file mode 100644 index 2d9130035ab..00000000000 --- a/ggml/src/ggml-cuda/where-id.cu +++ /dev/null @@ -1,78 +0,0 @@ -#include "where-id.cuh" - -static __global__ void where_id_kernel( - const float * src0, const int32_t * src1, float * dst, - int64_t ne10, int64_t ne11, int64_t ne12, int64_t ne13, - size_t nb1, size_t nb2, size_t nb3, - size_t nb01, size_t nb02, size_t nb03, - size_t nb11, size_t nb12, size_t nb13 - ) { - - const int64_t total_blocks = ne11 * ne12 * ne13; - - for (int64_t block_idx = blockIdx.x; block_idx < total_blocks; block_idx += gridDim.x) { - - const int64_t i1 = block_idx % ne11; - const int64_t i2 = (block_idx / ne11) % ne12; - const int64_t i3 = block_idx / (ne11 * ne12); - - float * dst_row = (float *)((char *)dst + i1*nb1 + i2*nb2 + i3*nb3); - const float * src0_row = (const float *)((const char *)src0 + i1*nb01 + i2*nb02 + i3*nb03); - const int * src1_row = (const int *)((const char *)src1 + i1*nb11 + i2*nb12 + i3*nb13); - - for (int64_t i0 = threadIdx.x; i0 < ne10; i0 += blockDim.x) { - const int32_t id = src1_row[i0]; - dst_row[id] = src0_row[id]; - } - } -} - -void ggml_cuda_op_where_id(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { - const ggml_tensor * src0 = dst->src[0]; - const ggml_tensor * src1 = dst->src[1]; - const ggml_tensor * src2 = dst->src[2]; - - GGML_TENSOR_TERNARY_OP_LOCALS - - GGML_ASSERT(ggml_is_contiguous(dst)); - GGML_ASSERT(ggml_is_contiguous(src0)); - GGML_ASSERT(ggml_is_contiguous(src1)); - GGML_ASSERT(ggml_is_contiguous(src2)); - - GGML_ASSERT(dst->type == GGML_TYPE_F32); - GGML_ASSERT(src0->type == GGML_TYPE_F32); - GGML_ASSERT(src1->type == GGML_TYPE_F32); - GGML_ASSERT(src2->type == GGML_TYPE_I32); - - GGML_ASSERT(nb00 == sizeof(float)); - GGML_ASSERT(nb10 == sizeof(float)); - GGML_ASSERT(nb20 == sizeof(int32_t)); - - GGML_ASSERT(ggml_nbytes(src0) == ggml_nbytes(src1)); - GGML_ASSERT(ggml_nbytes(src0) == ggml_nbytes(dst)); - - // step 1 - copy whole src1 to dst - cudaStream_t main_stream = ctx.stream(); - char * dst_ddc = (char *) dst->data; - char * src1_ddc = (char *) src1->data; - - CUDA_CHECK(cudaMemcpyAsync(dst_ddc, src1_ddc, ggml_nbytes(src1), cudaMemcpyDeviceToDevice, main_stream)); - - // step 2 - copy elements from src0 indicated by ids to dst - const float * src0_d = (const float *) src0->data; - const int32_t * src2_d = (const int32_t *) src2->data; - float * dst_d = (float *) dst->data; - - int threads = std::min((int) ne20, 768); // ids - - int64_t total_blocks = ne21 * ne22 * ne23; - int blocks = (int) std::min((int64_t) 65535, total_blocks); - - where_id_kernel<<>>( - src0_d, src2_d, dst_d, - ne20, ne21, ne22, ne23, - nb1, nb2, nb3, - nb01, nb02, nb03, - nb21, nb22, nb23 - ); -} diff --git a/ggml/src/ggml-cuda/where-id.cuh b/ggml/src/ggml-cuda/where-id.cuh deleted file mode 100644 index bf3ea095a81..00000000000 --- a/ggml/src/ggml-cuda/where-id.cuh +++ /dev/null @@ -1,3 +0,0 @@ -#include "common.cuh" - -void ggml_cuda_op_where_id(ggml_backend_cuda_context & ctx, ggml_tensor * dst); diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index 7132c1f2155..809e71d2133 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -1033,7 +1033,7 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "SOLVE_TRI", "GATED_DELTA_NET", "HADAMARD", - "WHERE_ID", + "SCATTER", "UNARY", @@ -1145,7 +1145,7 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "A X = B, A triangular, solve X", "gated_delta_net(q, k, v, g, beta, s)", "hadamard(x)", - "where_id(x,y,ids)", + "scatter(x,ids,c)", "unary(x)", @@ -6203,25 +6203,26 @@ struct ggml_tensor * ggml_hadamard( return result; } -// ggml_where_id +// ggml_scatter -struct ggml_tensor * ggml_where_id( +struct ggml_tensor * ggml_scatter( struct ggml_context * ctx, struct ggml_tensor * a, - struct ggml_tensor * b, - struct ggml_tensor * ids) { + struct ggml_tensor * ids, + float c) { GGML_ASSERT(a->type == GGML_TYPE_F32); - GGML_ASSERT(b->type == GGML_TYPE_F32); GGML_ASSERT(ids->type == GGML_TYPE_I32); GGML_ASSERT(a->ne[1] == ids->ne[1]); struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, GGML_MAX_DIMS, a->ne); - result->op = GGML_OP_WHERE_ID; + float params[1] = { c }; + ggml_set_op_params(result, ¶ms, sizeof(params)); + + result->op = GGML_OP_SCATTER; result->src[0] = a; - result->src[1] = b; - result->src[2] = ids; + result->src[1] = ids; return result; } diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index 8224e4873fd..29d804638cc 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -2177,7 +2177,10 @@ ggml_tensor * llm_graph_context::build_attn( ggml_tensor * kq_mask_all = ggml_fill(ctx0, kq_mask_f32, -INFINITY); // modify it by unmasking tokens that are in top_k indices - ggml_tensor * kq_mask_top_k = ggml_where_id(ctx0, kq_mask_f32, kq_mask_all, top_k); + ggml_tensor * kq_mask_top_k = ggml_scatter(ctx0, kq_mask_all, top_k, 0); + + // combine with the original kq mask + kq_mask_top_k = ggml_add(ctx0, kq_mask_top_k, kq_mask_f32); kq_mask_top_k = ggml_cast(ctx0, kq_mask_top_k, kq_mask->type); ggml_tensor * q = q_cur; From 0ee5d80ed39b4701aebd8d099996be7c39b7dec6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Tue, 24 Mar 2026 20:32:45 +0100 Subject: [PATCH 17/46] ggml : added inplace version of GGML_OP_SCATTER and tests for this OP --- ggml/include/ggml.h | 6 +++ ggml/src/ggml-cpu/ops.cpp | 6 ++- ggml/src/ggml-cuda/scatter.cu | 16 ++++---- ggml/src/ggml.c | 27 +++++++++++--- tests/test-backend-ops.cpp | 69 +++++++++++++++++++++++++++++++++++ 5 files changed, 111 insertions(+), 13 deletions(-) diff --git a/ggml/include/ggml.h b/ggml/include/ggml.h index 48a5e6ee831..1c8f347476d 100644 --- a/ggml/include/ggml.h +++ b/ggml/include/ggml.h @@ -2486,6 +2486,12 @@ extern "C" { struct ggml_tensor * ids, float c); + GGML_API struct ggml_tensor * ggml_scatter_inplace( + struct ggml_context * ctx, + struct ggml_tensor * a, + struct ggml_tensor * ids, + float c); + // custom operators typedef void (*ggml_custom1_op_t)(struct ggml_tensor * dst , const struct ggml_tensor * a, int ith, int nth, void * userdata); diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index d720a6253aa..86eeaa479ac 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11265,7 +11265,9 @@ static void ggml_compute_forward_scatter_f32( const ggml_tensor * src0 = dst->src[0]; const ggml_tensor * src1 = dst->src[1]; + const float c = ggml_get_op_params_f32(dst, 0); + const bool inplace = ggml_get_op_params_i32(dst, 1); GGML_ASSERT(ggml_are_same_shape(src0, dst)); @@ -11303,7 +11305,9 @@ static void ggml_compute_forward_scatter_f32( float * dst_ptr = (float *) ((char *) dst->data + i3*nb3 + i2*nb2 + i1*nb1 ); // copy whole row from src0 - ggml_vec_cpy_f32(ne00, dst_ptr, src0_ptr); + if (!inplace) { + ggml_vec_cpy_f32(ne00, dst_ptr, src0_ptr); + } // set dst elements indicated by indices in src1 to c for (int j = 0; j < ne10; ++j) { diff --git a/ggml/src/ggml-cuda/scatter.cu b/ggml/src/ggml-cuda/scatter.cu index 990b5cddb7a..0c252dad65e 100644 --- a/ggml/src/ggml-cuda/scatter.cu +++ b/ggml/src/ggml-cuda/scatter.cu @@ -44,21 +44,23 @@ void ggml_cuda_op_scatter(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { GGML_ASSERT(ggml_nbytes(src0) == ggml_nbytes(dst)); - float c; - memcpy(&c, (float *) dst->op_params + 0, sizeof(float)); + float c = ggml_get_op_params_f32(dst, 0); + bool inplace = ggml_get_op_params_i32(dst, 1); // step 1 - copy whole src0 to dst - cudaStream_t main_stream = ctx.stream(); - char * dst_ddc = (char *) dst->data; - char * src0_ddc = (char *) src0->data; + if (!inplace) { + cudaStream_t main_stream = ctx.stream(); + char * dst_ddc = (char *) dst->data; + char * src0_ddc = (char *) src0->data; - CUDA_CHECK(cudaMemcpyAsync(dst_ddc, src0_ddc, ggml_nbytes(src0), cudaMemcpyDeviceToDevice, main_stream)); + CUDA_CHECK(cudaMemcpyAsync(dst_ddc, src0_ddc, ggml_nbytes(src0), cudaMemcpyDeviceToDevice, main_stream)); + } // step 2 - set elements in dst indicated by ids to c const int32_t * src1_d = (const int32_t *) src1->data; float * dst_d = (float *) dst->data; - int threads = std::min((int) ne10, 768); // ids + int threads = std::min((int) ne10, 512); // ids int64_t total_blocks = ne11 * ne12 * ne13; int blocks = (int) std::min((int64_t) 65535, total_blocks); diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index 809e71d2133..82a889cbfad 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -6205,20 +6205,21 @@ struct ggml_tensor * ggml_hadamard( // ggml_scatter -struct ggml_tensor * ggml_scatter( +static struct ggml_tensor * ggml_scatter_impl( struct ggml_context * ctx, struct ggml_tensor * a, struct ggml_tensor * ids, - float c) { + float c, + bool inplace) { GGML_ASSERT(a->type == GGML_TYPE_F32); GGML_ASSERT(ids->type == GGML_TYPE_I32); GGML_ASSERT(a->ne[1] == ids->ne[1]); - struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, GGML_MAX_DIMS, a->ne); + struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a); - float params[1] = { c }; - ggml_set_op_params(result, ¶ms, sizeof(params)); + ggml_set_op_params_f32(result, 0, c); + ggml_set_op_params_i32(result, 1, inplace ? 1 : 0); result->op = GGML_OP_SCATTER; result->src[0] = a; @@ -6227,6 +6228,22 @@ struct ggml_tensor * ggml_scatter( return result; } +struct ggml_tensor * ggml_scatter( + struct ggml_context * ctx, + struct ggml_tensor * a, + struct ggml_tensor * ids, + float c) { + return ggml_scatter_impl(ctx, a, ids, c, false); +} + +struct ggml_tensor * ggml_scatter_inplace( + struct ggml_context * ctx, + struct ggml_tensor * a, + struct ggml_tensor * ids, + float c) { + return ggml_scatter_impl(ctx, a, ids, c, true); +} + //////////////////////////////////////////////////////////////////////////////// struct ggml_hash_set ggml_hash_set_new(size_t size) { diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index 32a83b001d8..b615702a298 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -6648,6 +6648,65 @@ struct test_diag : public test_case { } }; +// GGML_OP_SCATTER +struct test_scatter : public test_case { + const ggml_type type_a; + const ggml_type type_ids; + const std::array ne_a; + const std::array ne_ids; + float c; + bool inplace; + + std::string vars() override { + return VARS_TO_STR6(type_a, type_ids, ne_a, ne_ids, c, inplace); + } + + test_scatter(ggml_type type_a = GGML_TYPE_F32, + ggml_type type_ids = GGML_TYPE_I32, + std::array ne_a = {10, 10, 10, 10}, + std::array ne_ids = {3, 10, 10, 10}, + float c = 2.0f, + bool inplace = false) + : type_a(type_a), type_ids(type_ids), ne_a(ne_a), ne_ids(ne_ids), c(c), inplace(inplace) {} + + ggml_tensor * build_graph(ggml_context * ctx) override { + ggml_tensor * a = ggml_new_tensor(ctx, type_a, 4, ne_a.data()); + ggml_set_param(a); + ggml_set_name(a, "a"); + + ggml_tensor * ids = ggml_new_tensor(ctx, type_ids, 4, ne_ids.data()); + ggml_set_param(ids); + ggml_set_name(ids, "ids"); + + ggml_tensor * out; + if (inplace) { + out = ggml_scatter_inplace(ctx, a, ids, c); + } else { + out = ggml_scatter(ctx, a, ids, c); + } + ggml_set_name(out, "out"); + + return out; + } + + void initialize_tensors(ggml_context * ctx) override { + for (ggml_tensor * t = ggml_get_first_tensor(ctx); t != NULL; t = ggml_get_next_tensor(ctx, t)) { + if (t->type == GGML_TYPE_I32) { + // ids + const int num_pos_ids = ggml_nelements(t); + std::vector data(num_pos_ids); + for (int i = 0; i < num_pos_ids; i++) { + data[i] = rand() % ne_a[0]; + } + ggml_backend_tensor_set(t, data.data(), 0, num_pos_ids * sizeof(int)); + } else { + init_tensor_uniform(t); + } + } + } +}; + + enum llm_norm_type { LLM_NORM, @@ -8474,6 +8533,12 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_falcon(2)); #endif + // scatter + test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, true)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, false)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, true)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, false)); + return test_cases; } #ifdef _MSC_VER @@ -8730,6 +8795,10 @@ static std::vector> make_test_cases_perf() { test_cases.emplace_back(new test_acc(GGML_TYPE_F32, {256, 17, 2, 3}, {128, 16, 2, 3}, 2)); test_cases.emplace_back(new test_acc(GGML_TYPE_F32, {256, 17, 2, 3}, {64, 16, 2, 3}, 3)); + // scatter + test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); + return test_cases; } From 7f5578fe083300c8315cc591143f1af9eee0dc88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Tue, 24 Mar 2026 21:28:28 +0100 Subject: [PATCH 18/46] gguf-py : removed obsolete KV_B tensor from DEEPSEEK32 arch --- gguf-py/gguf/constants.py | 1 - 1 file changed, 1 deletion(-) diff --git a/gguf-py/gguf/constants.py b/gguf-py/gguf/constants.py index 9f9b44bf17e..e76339d5c3b 100644 --- a/gguf-py/gguf/constants.py +++ b/gguf-py/gguf/constants.py @@ -2635,7 +2635,6 @@ class MODEL_TENSOR(IntEnum): MODEL_TENSOR.ATTN_Q_A, MODEL_TENSOR.ATTN_Q_B, MODEL_TENSOR.ATTN_KV_A_MQA, - MODEL_TENSOR.ATTN_KV_B, MODEL_TENSOR.ATTN_K_B, MODEL_TENSOR.ATTN_V_B, MODEL_TENSOR.ATTN_Q_A_NORM, From 54945c7ec1592b0a064b331d025be6b6c0387d23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Tue, 24 Mar 2026 21:51:19 +0100 Subject: [PATCH 19/46] convert : make pyright happy --- convert_hf_to_gguf.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/convert_hf_to_gguf.py b/convert_hf_to_gguf.py index 212836398b4..944d3d82750 100755 --- a/convert_hf_to_gguf.py +++ b/convert_hf_to_gguf.py @@ -8181,8 +8181,7 @@ def set_gguf_parameters(self): hparams = self.hparams # first_k_dense_replace: number of leading layers using dense FFN instead of MoE - first_k_dense_replace = hparams.get("first_k_dense_replace") - self.gguf_writer.add_leading_dense_block_count(first_k_dense_replace) + self.gguf_writer.add_leading_dense_block_count(hparams["first_k_dense_replace"]) self.gguf_writer.add_vocab_size(hparams["vocab_size"]) self.gguf_writer.add_q_lora_rank(hparams["q_lora_rank"]) self.gguf_writer.add_kv_lora_rank(hparams["kv_lora_rank"]) From 5677f082b0d37ec6bc9eaf6d755e22197c51948a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 25 Mar 2026 11:08:29 +0100 Subject: [PATCH 20/46] ggml : added f16 version of GGML_OP_SCATTER --- ggml/src/ggml-cpu/ops.cpp | 66 +++++++++++++++++++++++++++++++++++ ggml/src/ggml-cuda/scatter.cu | 38 +++++++++++++------- ggml/src/ggml.c | 2 +- tests/test-backend-ops.cpp | 6 ++++ 4 files changed, 99 insertions(+), 13 deletions(-) diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index 86eeaa479ac..31040e278be 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11318,6 +11318,68 @@ static void ggml_compute_forward_scatter_f32( } } +static void ggml_compute_forward_scatter_f16( + const ggml_compute_params * params, + ggml_tensor * dst) { + + const ggml_tensor * src0 = dst->src[0]; + const ggml_tensor * src1 = dst->src[1]; + + const ggml_fp16_t c = GGML_CPU_FP32_TO_FP16(ggml_get_op_params_f32(dst, 0)); + const bool inplace = ggml_get_op_params_i32(dst, 1); + + GGML_ASSERT(ggml_are_same_shape(src0, dst)); + + GGML_ASSERT(dst->type == GGML_TYPE_F16); + GGML_ASSERT(src0->type == GGML_TYPE_F16); + GGML_ASSERT(src1->type == GGML_TYPE_I32); + + GGML_ASSERT(src0->nb[0] == sizeof(ggml_fp16_t)); + + const int ith = params->ith; + const int nth = params->nth; + + const int nr = ggml_nrows(src0); + + GGML_TENSOR_BINARY_OP_LOCALS + + GGML_ASSERT( nb0 == sizeof(ggml_fp16_t)); + GGML_ASSERT(nb00 == sizeof(ggml_fp16_t)); + + // rows per thread + const int dr = (nr + nth - 1)/nth; + + // row range for this thread + const int ir0 = dr*ith; + const int ir1 = MIN(ir0 + dr, nr); + + for (int ir = ir0; ir < ir1; ++ir) { + // src0 indices + const int i3 = ir/(ne2*ne1); + const int i2 = (ir - i3*ne2*ne1)/ne1; + const int i1 = (ir - i3*ne2*ne1 - i2*ne1); + + const ggml_fp16_t * src0_ptr = (ggml_fp16_t *) ((char *) src0->data + i3*nb3 + i2*nb2 + i1*nb1 ); + const int32_t * ids_ptr = (int32_t *) ((char *) src1->data + i3*nb13 + i2*nb12 + i1*nb11); + ggml_fp16_t * dst_ptr = (ggml_fp16_t *) ((char *) dst->data + i3*nb3 + i2*nb2 + i1*nb1 ); + + // copy whole row from src0 + if (!inplace) { + // ggml_vec_cpy_f16(ne00, dst_ptr, src0_ptr) + for (int i = 0; i < ne00; ++i) { + dst_ptr[i] = src0_ptr[i]; + } + } + + // set dst elements indicated by indices in src1 to c + for (int j = 0; j < ne10; ++j) { + int id = ids_ptr[j]; + GGML_ASSERT(id >= 0 && id < ne00); + dst_ptr[id] = c; + } + } +} + void ggml_compute_forward_scatter( const ggml_compute_params * params, ggml_tensor * dst) { @@ -11329,6 +11391,10 @@ void ggml_compute_forward_scatter( { ggml_compute_forward_scatter_f32(params, dst); } break; + case GGML_TYPE_F16: + { + ggml_compute_forward_scatter_f16(params, dst); + } break; default: { GGML_ABORT("unsupported type for ggml_compute_forward_scatter: %s", ggml_type_name(src0->type)); diff --git a/ggml/src/ggml-cuda/scatter.cu b/ggml/src/ggml-cuda/scatter.cu index 0c252dad65e..6dacb28b521 100644 --- a/ggml/src/ggml-cuda/scatter.cu +++ b/ggml/src/ggml-cuda/scatter.cu @@ -1,7 +1,9 @@ #include "scatter.cuh" +#include "convert.cuh" +template static __global__ void scatter_kernel( - const int32_t * src0, float * dst, const float c, + const int32_t * src0, T * dst, const T c, int64_t ne00, int64_t ne01, int64_t ne02, int64_t ne03, size_t nb1, size_t nb2, size_t nb3, size_t nb01, size_t nb02, size_t nb03 @@ -15,7 +17,7 @@ static __global__ void scatter_kernel( const int64_t i2 = (block_idx / ne01) % ne02; const int64_t i3 = block_idx / (ne01 * ne02); - float * dst_row = (float *)((char *)dst + i1*nb1 + i2*nb2 + i3*nb3); + T * dst_row = (T *)((char *)dst + i1*nb1 + i2*nb2 + i3*nb3); const int * src0_row = (const int *)((const char *)src0 + i1*nb01 + i2*nb02 + i3*nb03); for (int64_t i0 = threadIdx.x; i0 < ne00; i0 += blockDim.x) { @@ -35,11 +37,9 @@ void ggml_cuda_op_scatter(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { GGML_ASSERT(ggml_is_contiguous(src0)); GGML_ASSERT(ggml_is_contiguous(src1)); - GGML_ASSERT(dst->type == GGML_TYPE_F32); - GGML_ASSERT(src0->type == GGML_TYPE_F32); + GGML_ASSERT(dst->type == src0->type); GGML_ASSERT(src1->type == GGML_TYPE_I32); - GGML_ASSERT(nb00 == sizeof(float)); GGML_ASSERT(nb10 == sizeof(int32_t)); GGML_ASSERT(ggml_nbytes(src0) == ggml_nbytes(dst)); @@ -58,17 +58,31 @@ void ggml_cuda_op_scatter(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { // step 2 - set elements in dst indicated by ids to c const int32_t * src1_d = (const int32_t *) src1->data; - float * dst_d = (float *) dst->data; + void * dst_d = dst->data; int threads = std::min((int) ne10, 512); // ids int64_t total_blocks = ne11 * ne12 * ne13; int blocks = (int) std::min((int64_t) 65535, total_blocks); - scatter_kernel<<>>( - src1_d, dst_d, c, - ne10, ne11, ne12, ne13, - nb1, nb2, nb3, - nb11, nb12, nb13 - ); + switch (dst->type) { + case GGML_TYPE_F32: + scatter_kernel<<>>( + src1_d, (float *) dst_d, c, + ne10, ne11, ne12, ne13, + nb1, nb2, nb3, + nb11, nb12, nb13 + ); + break; + case GGML_TYPE_F16: + scatter_kernel<<>>( + src1_d, (half *) dst_d, ggml_cuda_cast(c), + ne10, ne11, ne12, ne13, + nb1, nb2, nb3, + nb11, nb12, nb13 + ); + break; + default: + GGML_ABORT("unsupported type"); + } } diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index 82a889cbfad..9744813f453 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -6212,7 +6212,7 @@ static struct ggml_tensor * ggml_scatter_impl( float c, bool inplace) { - GGML_ASSERT(a->type == GGML_TYPE_F32); + GGML_ASSERT(a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16); GGML_ASSERT(ids->type == GGML_TYPE_I32); GGML_ASSERT(a->ne[1] == ids->ne[1]); diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index b615702a298..f8318a14ef3 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -8538,6 +8538,10 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, false)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, false)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, true)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, false)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, true)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, false)); return test_cases; } @@ -8798,6 +8802,8 @@ static std::vector> make_test_cases_perf() { // scatter test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); + test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); return test_cases; } From 1c830a178b3485ea63a7422035a81ec7b9286868 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 25 Mar 2026 11:35:13 +0100 Subject: [PATCH 21/46] ggml : added f16 version of GGML_OP_FILL --- ggml/src/ggml-cpu/ops.cpp | 36 +++++++++++++++++++++++++++++++++++- ggml/src/ggml.c | 2 +- tests/test-backend-ops.cpp | 3 +++ 3 files changed, 39 insertions(+), 2 deletions(-) diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index 31040e278be..8f9f082c434 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -2229,8 +2229,42 @@ static void ggml_compute_forward_fill_f32(const ggml_compute_params * params, gg } } +static void ggml_compute_forward_fill_f16(const ggml_compute_params * params, ggml_tensor * dst) { + const ggml_fp16_t c = GGML_CPU_FP32_TO_FP16(ggml_get_op_params_f32(dst, 0)); + + GGML_TENSOR_LOCALS(int64_t, ne, dst, ne); + GGML_TENSOR_LOCALS(size_t, nb, dst, nb); + + const auto [ir0, ir1] = get_thread_range(params, dst); + + for (int64_t ir = ir0; ir < ir1; ++ir) { + const int64_t i03 = ir/(ne2*ne1); + const int64_t i02 = (ir - i03*ne2*ne1)/ne1; + const int64_t i01 = (ir - i03*ne2*ne1 - i02*ne1); + + ggml_fp16_t * dst_ptr = (ggml_fp16_t *) ((char *) dst->data + i03*nb3 + i02*nb2 + i01*nb1); + + ggml_vec_set_f16(ne0, dst_ptr, c); + } +} + void ggml_compute_forward_fill(const ggml_compute_params * params, ggml_tensor * dst) { - ggml_compute_forward_fill_f32(params, dst); + const ggml_tensor * src0 = dst->src[0]; + + switch (src0->type) { + case GGML_TYPE_F32: + { + ggml_compute_forward_fill_f32(params, dst); + } break; + case GGML_TYPE_F16: + { + ggml_compute_forward_fill_f16(params, dst); + } break; + default: + { + GGML_ABORT("unsupported type for ggml_compute_forward_fill: %s", ggml_type_name(src0->type)); + } + } } // ggml_compute_tri diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index 9744813f453..bc5bae4096b 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -5177,7 +5177,7 @@ static struct ggml_tensor * ggml_fill_impl( struct ggml_tensor * a, float c, bool inplace) { - GGML_ASSERT(a->type == GGML_TYPE_F32); + GGML_ASSERT(a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16); GGML_ASSERT(ggml_is_contiguous(a)); struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a); diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index f8318a14ef3..9abb98cdbd5 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -8370,6 +8370,9 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_fill(2.0f, GGML_TYPE_F32, { 303, 207, 11, 3 })); test_cases.emplace_back(new test_fill(-152.0f, GGML_TYPE_F32, { 800, 600, 4, 4 })); test_cases.emplace_back(new test_fill(3.5f, GGML_TYPE_F32, { 2048, 512, 2, 2 })); + test_cases.emplace_back(new test_fill(2.0f, GGML_TYPE_F16, { 303, 207, 11, 3 })); + test_cases.emplace_back(new test_fill(-152.0f, GGML_TYPE_F16, { 800, 600, 4, 4 })); + test_cases.emplace_back(new test_fill(3.5f, GGML_TYPE_F16, { 2048, 512, 2, 2 })); test_cases.emplace_back(new test_diag()); test_cases.emplace_back(new test_diag(GGML_TYPE_F32, { 79, 1, 19, 13 })); From 83a0313a146926e54da330446c4feeab6b3d9ec1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 25 Mar 2026 11:35:57 +0100 Subject: [PATCH 22/46] model : GGML_OP_SCATTER AND GGML_OP_FILL now work with f16 data, so we can get rid of ggml_cast() calls in sparse attention implementation --- src/llama-graph.cpp | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index 29d804638cc..21a4158c79e 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -2171,17 +2171,14 @@ ggml_tensor * llm_graph_context::build_attn( const auto & kq_mask = inp->get_kq_mask(); - ggml_tensor * kq_mask_f32 = ggml_cast(ctx0, kq_mask, GGML_TYPE_F32); - // prepare new kq mask - starts filled with -INFINITY - ggml_tensor * kq_mask_all = ggml_fill(ctx0, kq_mask_f32, -INFINITY); + ggml_tensor * kq_mask_all = ggml_fill(ctx0, kq_mask, -INFINITY); // modify it by unmasking tokens that are in top_k indices ggml_tensor * kq_mask_top_k = ggml_scatter(ctx0, kq_mask_all, top_k, 0); // combine with the original kq mask - kq_mask_top_k = ggml_add(ctx0, kq_mask_top_k, kq_mask_f32); - kq_mask_top_k = ggml_cast(ctx0, kq_mask_top_k, kq_mask->type); + kq_mask_top_k = ggml_add(ctx0, kq_mask_top_k, kq_mask); ggml_tensor * q = q_cur; ggml_tensor * k = mctx_cur->get_k(ctx0, il); From 6011bdd92baccc46b18d60d5e15f735e5d5b7e6d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Fri, 27 Mar 2026 20:07:50 +0100 Subject: [PATCH 23/46] ggml : fix bug in CUDA Hadamard transform implementation --- ggml/src/ggml-cuda/ggml-cuda.cu | 6 ++++-- ggml/src/ggml-cuda/hadamard.cu | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu index 4af7f2ba1d9..ca10582d230 100644 --- a/ggml/src/ggml-cuda/ggml-cuda.cu +++ b/ggml/src/ggml-cuda/ggml-cuda.cu @@ -5022,8 +5022,10 @@ static bool ggml_backend_cuda_device_supports_op(ggml_backend_dev_t dev, const g case GGML_OP_SOLVE_TRI: case GGML_OP_SCATTER: return true; - case GGML_OP_HADAMARD: - return (op->ne[0] == 64 || op->ne[0] == 128 || op->ne[0] == 256) && op->type == GGML_TYPE_F32 && op->src[0]->type == GGML_TYPE_F32; + case GGML_OP_HADAMARD: { + int nh = op->op_params[0]; + return (nh == 64 || nh == 128 || nh == 256) && op->ne[0] % nh == 0 && op->type == GGML_TYPE_F32 && op->src[0]->type == GGML_TYPE_F32; + } default: return false; } diff --git a/ggml/src/ggml-cuda/hadamard.cu b/ggml/src/ggml-cuda/hadamard.cu index 5f34d2579d4..f03866cb5a0 100644 --- a/ggml/src/ggml-cuda/hadamard.cu +++ b/ggml/src/ggml-cuda/hadamard.cu @@ -30,7 +30,7 @@ static __global__ void hadamard_f32(const char * src, char * dst, int ne0, float scale = ksqrt2; #pragma unroll - for (int h = 2; h < nh; h <<= 2) { + for (int h = 2; h < nh; h <<= 1) { __syncthreads(); int ii = tid/h, jj = tid%h; int j = 2*h*ii+jj; From 4aec6a86bdb2fd2ceca6663d5c2c4210d9f8ede0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Fri, 27 Mar 2026 20:23:38 +0100 Subject: [PATCH 24/46] ggml : simplified testing for nh being power of 2 in Hadamard transform implementations --- ggml/src/ggml-cpu/ops.cpp | 14 +------------- ggml/src/ggml-cuda/hadamard.cu | 17 ++--------------- 2 files changed, 3 insertions(+), 28 deletions(-) diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index 8f9f082c434..48a3644332a 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11207,18 +11207,6 @@ void ggml_compute_forward_opt_step_sgd(const ggml_compute_params * params, ggml_ // MIT license // SPDX-License-Identifier: MIT -#if defined(_MSC_VER) -#pragma warning(disable: 4244 4267) // possible loss of data -#include -#include -#include -#include -#include -inline int popcount(uint32_t x) { return __popcnt(x); } -#else -inline int popcount(uint32_t x) { return __builtin_popcount(x); } -#endif - template void fast_ht(int n, T * values) { constexpr float ksqrt2 = 0.707106781f; @@ -11250,7 +11238,7 @@ static void ggml_compute_forward_hadamard_f32( const int nth = params->nth; int nh = dst->op_params[0]; - GGML_ASSERT(nh > 1 && popcount(uint32_t(nh)) == 1); + GGML_ASSERT(nh > 1 && ((nh & (nh - 1)) == 0)); // power of 2 GGML_ASSERT(dst->ne[0] % nh == 0); int nc = dst->ne[0]/nh; diff --git a/ggml/src/ggml-cuda/hadamard.cu b/ggml/src/ggml-cuda/hadamard.cu index f03866cb5a0..45091d2d204 100644 --- a/ggml/src/ggml-cuda/hadamard.cu +++ b/ggml/src/ggml-cuda/hadamard.cu @@ -58,19 +58,6 @@ static void hadamard_f32_cuda(int nh, const char * x, char * y, int ne0, int ne1 } } -#if defined(_MSC_VER) -#pragma warning(disable: 4244 4267) // possible loss of data -#include -#include -#include -#include -#include -static inline int popcount(uint32_t x) { return __popcnt(x); } -#else -static inline int popcount(uint32_t x) { return __builtin_popcount(x); } -#endif - - void ggml_cuda_op_hadamard(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { const ggml_tensor * src = dst->src[0]; GGML_ASSERT(src->type == GGML_TYPE_F32); @@ -78,8 +65,8 @@ void ggml_cuda_op_hadamard(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { GGML_ASSERT(ggml_are_same_shape(src, dst)); int nh = dst->op_params[0]; - GGML_ASSERT(dst->ne[0]%nh == 0); - GGML_ASSERT(nh > 1 && popcount(nh) == 1); + GGML_ASSERT(dst->ne[0] % nh == 0); + GGML_ASSERT(nh > 1 && ((nh & (nh - 1)) == 0)); // power of 2 hadamard_f32_cuda(nh, (const char *)src->data, (char *)dst->data, src->ne[0], src->ne[1], src->ne[2], src->ne[3], src->nb[1], src->nb[2], src->nb[3], dst->nb[1], dst->nb[2], dst->nb[3], ctx.stream()); From a74d83a1b135b12a17a3aed27284c913955924f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Fri, 27 Mar 2026 20:32:59 +0100 Subject: [PATCH 25/46] ggml : added test for GGML_OP_HADAMARD --- tests/test-backend-ops.cpp | 39 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index 9abb98cdbd5..e631fed8a2d 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -6648,6 +6648,39 @@ struct test_diag : public test_case { } }; +// GGML_OP_HADAMARD +struct test_hadamard : public test_case { + const ggml_type type_a; + const std::array ne_a; + int nh; + + std::string vars() override { + return VARS_TO_STR3(type_a, ne_a, nh); + } + + test_hadamard(ggml_type type_a = GGML_TYPE_F32, + std::array ne_a = {128, 10, 10, 10}, + int nh = 128) + : type_a(type_a), ne_a(ne_a), nh(nh) {} + + ggml_tensor * build_graph(ggml_context * ctx) override { + ggml_tensor * a = ggml_new_tensor(ctx, type_a, 4, ne_a.data()); + ggml_set_param(a); + ggml_set_name(a, "a"); + + ggml_tensor * out = ggml_hadamard(ctx, a, nh); + ggml_set_name(out, "out"); + + return out; + } + + void initialize_tensors(ggml_context * ctx) override { + for (ggml_tensor * t = ggml_get_first_tensor(ctx); t != NULL; t = ggml_get_next_tensor(ctx, t)) { + init_tensor_uniform(t, -1.0f, 1.0f); + } + } +}; + // GGML_OP_SCATTER struct test_scatter : public test_case { const ggml_type type_a; @@ -8536,6 +8569,9 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_falcon(2)); #endif + // hadamard + test_cases.emplace_back(new test_hadamard()); + // scatter test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, false)); @@ -8802,6 +8838,9 @@ static std::vector> make_test_cases_perf() { test_cases.emplace_back(new test_acc(GGML_TYPE_F32, {256, 17, 2, 3}, {128, 16, 2, 3}, 2)); test_cases.emplace_back(new test_acc(GGML_TYPE_F32, {256, 17, 2, 3}, {64, 16, 2, 3}, 3)); + // hadamard + test_cases.emplace_back(new test_hadamard()); + // scatter test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); From 5b9ce6cc4e378a66ced2580aa15759c75da26ffa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Fri, 27 Mar 2026 21:10:58 +0100 Subject: [PATCH 26/46] convert : check if add_bos_token is true when converting DeepseekV32ForCausalLM-based models. --- convert_hf_to_gguf.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/convert_hf_to_gguf.py b/convert_hf_to_gguf.py index 944d3d82750..c146a99778a 100755 --- a/convert_hf_to_gguf.py +++ b/convert_hf_to_gguf.py @@ -8170,6 +8170,9 @@ def __init__(self, *args, **kwargs): self.tensor_map = gguf.get_tensor_name_map(self.model_arch, self.block_count) def set_vocab(self): + from transformers import AutoTokenizer + tokenizer = AutoTokenizer.from_pretrained(self.dir_model) + assert tokenizer.add_bos_token, "Change value of add_bos_token to true in tokenizer_config.json file." self._set_vocab_gpt2() def set_gguf_parameters(self): From 6959bcfb82da97a07d3824eb8f2da5d7bfc43247 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 1 Apr 2026 17:13:49 +0200 Subject: [PATCH 27/46] graph : replaced llama_ik_cache with llama_kv_cache instance created based on tweaked hparams. --- src/CMakeLists.txt | 1 - src/llama-graph.cpp | 80 +- src/llama-graph.h | 36 +- src/llama-ik-cache.cpp | 1891 ----------------------------------- src/llama-ik-cache.h | 306 ------ src/llama-kv-cache-dsa.cpp | 25 +- src/llama-kv-cache-dsa.h | 11 +- src/llama-kv-cache-iswa.cpp | 4 +- src/llama-kv-cache.cpp | 5 +- src/llama-kv-cache.h | 1 + src/llama-memory-hybrid.cpp | 1 + src/llama-model.cpp | 1 + src/models/deepseek32.cpp | 5 +- 13 files changed, 37 insertions(+), 2330 deletions(-) delete mode 100644 src/llama-ik-cache.cpp delete mode 100644 src/llama-ik-cache.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 75e45b9763b..95465265f77 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -22,7 +22,6 @@ add_library(llama llama-io.cpp llama-kv-cache.cpp llama-kv-cache-iswa.cpp - llama-ik-cache.cpp llama-kv-cache-dsa.cpp llama-memory.cpp llama-memory-hybrid.cpp diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index 49ac3111313..9e87140c742 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -32,18 +32,6 @@ static ggml_tensor * build_kq_mask( return ggml_new_tensor_4d(ctx, GGML_TYPE_F32, n_kv, n_tokens/n_stream, 1, n_stream); } -static ggml_tensor * build_kq_mask( - ggml_context * ctx, - const llama_ik_cache_context * mctx, - const llama_ubatch & ubatch, - const llama_cparams & cparams) { - const auto n_kv = mctx->get_n_kv(); - const auto n_tokens = ubatch.n_tokens; - const auto n_stream = cparams.kv_unified ? 1 : ubatch.n_seqs_unq; - - return ggml_new_tensor_4d(ctx, GGML_TYPE_F32, n_kv, n_tokens/n_stream, 1, n_stream); -} - static bool can_reuse_kq_mask( ggml_tensor * kq_mask, const llama_kv_cache_context * mctx, @@ -63,25 +51,6 @@ static bool can_reuse_kq_mask( return res; } -static bool can_reuse_kq_mask( - ggml_tensor * kq_mask, - const llama_ik_cache_context * mctx, - const llama_ubatch & ubatch, - const llama_cparams & cparams) { - const auto n_kv = mctx->get_n_kv(); - const auto n_tokens = ubatch.n_tokens; - const auto n_stream = cparams.kv_unified ? 1 : ubatch.n_seqs_unq; - - bool res = true; - - res &= (kq_mask->ne[0] == n_kv); - res &= (kq_mask->ne[1] == n_tokens/n_stream); - res &= (kq_mask->ne[2] == 1); - res &= (kq_mask->ne[3] == n_stream); - - return res; -} - // impl void llm_graph_input_embd::set_input(const llama_ubatch * ubatch) { @@ -2254,49 +2223,6 @@ ggml_tensor * llm_graph_context::build_attn( } -static std::unique_ptr build_attn_inp_ik_impl( - ggml_context * ctx0, - const llama_ubatch & ubatch, - const llama_hparams & hparams, - const llama_cparams & cparams, - const llama_ik_cache_context * mctx_cur) { - - auto inp = std::make_unique(hparams, cparams, mctx_cur); - - { - GGML_ASSERT(hparams.swa_type == LLAMA_SWA_TYPE_NONE && "Use llama_kv_cache_iswa for SWA"); - - inp->self_k_idxs = mctx_cur->build_input_k_idxs(ctx0, ubatch); - - inp->self_kq_mask = build_kq_mask(ctx0, mctx_cur, ubatch, cparams); - ggml_set_input(inp->self_kq_mask); - - inp->self_kq_mask_cnv = inp->self_kq_mask; - } - - return inp; -} - -void llm_graph_input_attn_ik::set_input(const llama_ubatch * ubatch) { - mctx->set_input_k_idxs(self_k_idxs, ubatch); - - mctx->set_input_kq_mask(self_kq_mask, ubatch, cparams.causal_attn); -} - -bool llm_graph_input_attn_ik::can_reuse(const llm_graph_params & params) { - const auto * mctx = static_cast(params.mctx); - - this->mctx = mctx; - - bool res = true; - - res &= self_k_idxs->ne[0] == params.ubatch.n_tokens; - - res &= can_reuse_kq_mask(self_kq_mask, mctx, params.ubatch, params.cparams); - - return res; -} - ggml_tensor * llm_graph_context::build_attn( llm_graph_input_attn_kv_iswa * inp, ggml_tensor * wo, @@ -2419,15 +2345,15 @@ ggml_tensor * llm_graph_context::build_attn( return cur; } -std::pair llm_graph_context::build_attn_inp_k_dsa() const { +std::pair llm_graph_context::build_attn_inp_k_dsa() const { const auto * mctx_cur = static_cast(mctx); auto inp_k = build_attn_inp_k_impl(ctx0, ubatch, hparams, cparams, mctx_cur->get_base()); - auto inp_ik = build_attn_inp_ik_impl(ctx0, ubatch, hparams, cparams, mctx_cur->get_ik()); + auto inp_ik = build_attn_inp_k_impl(ctx0, ubatch, hparams, cparams, mctx_cur->get_ik()); return std::make_pair( (llm_graph_input_attn_k *) res->add_input(std::move(inp_k)), - (llm_graph_input_attn_ik *) res->add_input(std::move(inp_ik))); + (llm_graph_input_attn_k *) res->add_input(std::move(inp_ik))); } // TODO: maybe separate the inner implementation into a separate function diff --git a/src/llama-graph.h b/src/llama-graph.h index a5aadbeef78..249749a4f2a 100644 --- a/src/llama-graph.h +++ b/src/llama-graph.h @@ -21,7 +21,6 @@ struct llama_cparams; struct llama_memory_context_i; class llama_kv_cache_context; -class llama_ik_cache_context; class llama_kv_cache_iswa_context; class llama_memory_recurrent_context; class llama_memory_hybrid_context; @@ -351,39 +350,6 @@ class llm_graph_input_attn_k : public llm_graph_input_i { const llama_kv_cache_context * mctx; }; -// V-less input for the indexer KV cache -class llm_graph_input_attn_ik : public llm_graph_input_i { -public: - llm_graph_input_attn_ik( - const llama_hparams & hparams, - const llama_cparams & cparams, - const llama_ik_cache_context * mctx) : - hparams(hparams), - cparams(cparams), - mctx(mctx) { - } - ~llm_graph_input_attn_ik() = default; - - void set_input(const llama_ubatch * ubatch) override; - - bool can_reuse(const llm_graph_params & params) override; - - ggml_tensor * get_k_idxs() const { return self_k_idxs; } - - ggml_tensor * get_kq_mask() const { return self_kq_mask_cnv; } - - ggml_tensor * self_k_idxs = nullptr; // I64 [n_batch] - - ggml_tensor * self_kq_mask = nullptr; // F32 [n_kv, n_batch/n_stream, 1, n_stream] - ggml_tensor * self_kq_mask_cnv = nullptr; // [n_kv, n_batch/n_stream, 1, n_stream] - - const llama_hparams hparams; - const llama_cparams cparams; - - const llama_ik_cache_context * mctx; -}; - - class llm_graph_input_attn_kv_iswa : public llm_graph_input_i { public: llm_graph_input_attn_kv_iswa( @@ -1000,7 +966,7 @@ struct llm_graph_context { float kq_scale, int il) const; - std::pair build_attn_inp_k_dsa() const; + std::pair build_attn_inp_k_dsa() const; // // recurrent diff --git a/src/llama-ik-cache.cpp b/src/llama-ik-cache.cpp deleted file mode 100644 index 9d3056e389e..00000000000 --- a/src/llama-ik-cache.cpp +++ /dev/null @@ -1,1891 +0,0 @@ -#include "llama-ik-cache.h" - -#include "llama-impl.h" -#include "llama-io.h" -#include "llama-model.h" -#include "llama-context.h" - -#include -#include -#include -#include -#include -#include -#include - -// -// llama_ik_cache -// - -llama_ik_cache::llama_ik_cache( - const llama_model & model, - ggml_type type_k, - ggml_type type_v, - bool v_trans, - bool offload, - bool unified, - uint32_t kv_size, - uint32_t n_seq_max, - uint32_t n_pad, - uint32_t n_swa, - llama_swa_type swa_type, - const layer_filter_cb & filter, - const layer_reuse_cb & reuse) : - model(model), hparams(model.hparams), v_trans(v_trans), - n_seq_max(n_seq_max), n_stream(unified ? 1 : n_seq_max), n_pad(n_pad), n_swa(n_swa), swa_type(swa_type) { - - GGML_UNUSED(type_v); - GGML_ASSERT(kv_size % n_pad == 0); - - const uint32_t n_layer_kv = hparams.n_layer_kv(); - - // define a comparator for the buft -> ctx map to ensure that the order is well-defined: - struct ggml_backend_buft_comparator { - bool operator()(const ggml_backend_buffer_type_t & lhs, const ggml_backend_buffer_type_t & rhs) const { - return strcmp(ggml_backend_buft_name(lhs), ggml_backend_buft_name(rhs)) < 0; - } - }; - std::map ctx_map; - - // create a context for each buffer type - auto ctx_for_buft = [&](ggml_backend_buffer_type_t buft) -> ggml_context * { - auto it = ctx_map.find(buft); - if (it == ctx_map.end()) { - ggml_init_params params = { - /*.mem_size =*/ size_t(1u*(1 + n_stream)*n_layer_kv*ggml_tensor_overhead()), - /*.mem_buffer =*/ NULL, - /*.no_alloc =*/ true, - }; - - ggml_context * ctx = ggml_init(params); - if (!ctx) { - return nullptr; - } - - ctx_map.emplace(buft, ctx); - - return ctx; - } - - return it->second.get(); - }; - - GGML_ASSERT(n_stream == 1 || n_stream == n_seq_max); - - v_heads.resize(n_stream); - for (uint32_t s = 0; s < n_stream; ++s) { - v_heads[s] = 0; - } - - v_cells.resize(n_stream); - for (uint32_t s = 0; s < n_stream; ++s) { - v_cells[s].resize(kv_size); - } - - // by default, all sequence ids are mapped to the 0th stream - seq_to_stream.resize(LLAMA_MAX_SEQ, 0); - - if (n_stream > 1) { - seq_to_stream.resize(n_stream, 0); - for (uint32_t s = 0; s < n_stream; ++s) { - seq_to_stream[s] = s; - } - } - - for (uint32_t il = 0; il < hparams.n_layer; il++) { - if (!hparams.has_kv(il)) { - LLAMA_LOG_DEBUG("%s: layer %3d: does not have KV cache\n", __func__, il); - continue; - } - - if (filter && !filter(il)) { - LLAMA_LOG_DEBUG("%s: layer %3d: filtered\n", __func__, il); - continue; - } - - const uint32_t n_embd_k_gqa = hparams.indexer_head_size; - - const char * dev_name = "CPU"; - - ggml_backend_buffer_type_t buft = ggml_backend_cpu_buffer_type(); - - if (offload) { - auto * dev = model.dev_layer(il); - buft = ggml_backend_dev_buffer_type(dev); - - dev_name = ggml_backend_dev_name(dev); - } - - LLAMA_LOG_DEBUG("%s: layer %3d: dev = %s\n", __func__, il, dev_name); - - ggml_context * ctx = ctx_for_buft(buft); - if (!ctx) { - throw std::runtime_error("failed to create ggml context for kv cache"); - } - - ggml_tensor * k = ggml_new_tensor_3d(ctx, type_k, n_embd_k_gqa, kv_size, n_stream); - - ggml_format_name(k, "cache_ik_l%d", il); - - std::vector k_stream; - - for (uint32_t s = 0; s < n_stream; ++s) { - k_stream.push_back(ggml_view_2d(ctx, k, n_embd_k_gqa, kv_size, k->nb[1], s*k->nb[2])); - } - - map_layer_ids[il] = layers.size(); - - layers.push_back({ il, k, k_stream, }); - } - - if (reuse) { - LLAMA_LOG_DEBUG("%s: reusing layers:\n", __func__); - - for (uint32_t il = 0; il < hparams.n_layer; il++) { - const int32_t il_reuse = reuse(il); - - if (il_reuse < 0) { - LLAMA_LOG_DEBUG("%s: - layer %3d: no reuse\n", __func__, il); - continue; - } - - if (filter && !filter(il)) { - LLAMA_LOG_DEBUG("%s: - layer %3d: filtered\n", __func__, il); - continue; - } - - GGML_ASSERT(map_layer_ids.find(il_reuse) != map_layer_ids.end()); - - map_layer_ids[il] = map_layer_ids[il_reuse]; - - LLAMA_LOG_DEBUG("%s: - layer %3d: reuse layer %d, is_swa = %d\n", __func__, il, il_reuse, hparams.is_swa(il)); - } - } - - // allocate tensors and initialize the buffers to avoid NaNs in the padding - for (auto & [buft, ctx] : ctx_map) { - ggml_backend_buffer_t buf; - if (model.hparams.no_alloc) { - buf = ggml_backend_buft_alloc_buffer(buft, /*size =*/ 0); // dummy buffer - for (ggml_tensor * t = ggml_get_first_tensor(ctx.get()); t != nullptr; t = ggml_get_next_tensor(ctx.get(), t)) { - t->buffer = buf; // set dummy buffer for KV cache so that the backend scheduler won't try to allocate it - } - } else { - buf = ggml_backend_alloc_ctx_tensors_from_buft(ctx.get(), buft); // real buffer - } - if (!buf) { - throw std::runtime_error("failed to allocate buffer for kv cache"); - } - - LLAMA_LOG_INFO("%s: %10s KV buffer size = %8.2f MiB\n", __func__, ggml_backend_buffer_name(buf), ggml_backend_buffer_get_size(buf)/1024.0/1024.0); - - ggml_backend_buffer_clear(buf, 0); - ctxs_bufs.emplace_back(std::move(ctx), buf); - } - - { - const size_t memory_size_k = size_k_bytes(); - - LLAMA_LOG_INFO("%s: size = %7.2f MiB (%6u cells, %3d layers, %2u/%u seqs), K (%s): %7.2f MiB\n", __func__, - (float)(memory_size_k) / (1024.0f * 1024.0f), kv_size, (int) layers.size(), n_seq_max, n_stream, - ggml_type_name(type_k), (float)memory_size_k / (1024.0f * 1024.0f)); - } - - const char * LLAMA_KV_CACHE_DEBUG = getenv("LLAMA_KV_CACHE_DEBUG"); - debug = LLAMA_KV_CACHE_DEBUG ? atoi(LLAMA_KV_CACHE_DEBUG) : 0; -} - -void llama_ik_cache::clear(bool data) { - for (uint32_t s = 0; s < n_stream; ++s) { - v_cells[s].reset(); - v_heads[s] = 0; - } - - if (data) { - for (auto & [_, buf] : ctxs_bufs) { - ggml_backend_buffer_clear(buf.get(), 0); - } - } -} - -bool llama_ik_cache::seq_rm(llama_seq_id seq_id, llama_pos p0, llama_pos p1) { - GGML_ASSERT(seq_id == -1 || (seq_id >= 0 && (size_t) seq_id < seq_to_stream.size())); - - if (p0 < 0) { - p0 = 0; - } - - if (p1 < 0) { - p1 = std::numeric_limits::max(); - } - - if (seq_id >= 0) { - auto & cells = v_cells[seq_to_stream[seq_id]]; - auto & head = v_heads[seq_to_stream[seq_id]]; - - uint32_t new_head = cells.size(); - - for (uint32_t i = 0; i < cells.size(); ++i) { - if (!cells.pos_in(i, p0, p1)) { - continue; - } - - if (cells.seq_has(i, seq_id) && cells.seq_rm(i, seq_id)) { - if (new_head == cells.size()) { - new_head = i; - } - } - } - - // If we freed up a slot, set head to it so searching can start there. - if (new_head != cells.size() && new_head < head) { - head = new_head; - } - } else { - // match any sequence - for (uint32_t s = 0; s < n_stream; ++s) { - auto & cells = v_cells[s]; - auto & head = v_heads[s]; - - uint32_t new_head = cells.size(); - - for (uint32_t i = 0; i < cells.size(); ++i) { - if (!cells.pos_in(i, p0, p1)) { - continue; - } - - cells.rm(i); - - if (new_head == cells.size()) { - new_head = i; - } - } - - // If we freed up a slot, set head to it so searching can start there. - if (new_head != cells.size() && new_head < head) { - head = new_head; - } - } - } - - return true; -} - -void llama_ik_cache::seq_cp(llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) { - GGML_ASSERT(seq_id_src >= 0 && (size_t) seq_id_src < seq_to_stream.size()); - GGML_ASSERT(seq_id_dst >= 0 && (size_t) seq_id_dst < seq_to_stream.size()); - - const auto s0 = seq_to_stream[seq_id_src]; - const auto s1 = seq_to_stream[seq_id_dst]; - - if (s0 == s1) { - // since both sequences are in the same stream, no data copy is necessary - // we just have to update the cells meta data - - auto & cells = v_cells[s0]; - - if (seq_id_src == seq_id_dst) { - return; - } - - if (p0 < 0) { - p0 = 0; - } - - if (p1 < 0) { - p1 = std::numeric_limits::max(); - } - - for (uint32_t i = 0; i < cells.size(); ++i) { - if (!cells.pos_in(i, p0, p1)) { - continue; - } - - if (cells.seq_has(i, seq_id_src)) { - cells.seq_add(i, seq_id_dst); - } - } - - return; - } - - // cross-stream sequence copies require to copy the actual buffer data - - bool is_full = true; - - if (p0 > 0 && p0 + 1 < (int) get_size()) { - is_full = false; - } - - if (p1 > 0 && p1 + 1 < (int) get_size()) { - is_full = false; - } - - GGML_ASSERT(is_full && "seq_cp() is only supported for full KV buffers"); - - // enqueue the copy operation - the buffer copy will be performed during the next update - sc_info.ssrc.push_back(s0); - sc_info.sdst.push_back(s1); - - v_cells[s1].reset(); - for (uint32_t i = 0; i < v_cells[s0].size(); ++i) { - if (v_cells[s0].seq_has(i, seq_id_src)) { - llama_pos pos = v_cells[s0].pos_get(i); - llama_pos shift = v_cells[s0].get_shift(i); - - llama_kv_cell_ext ext = v_cells[s0].ext_get(i); - - if (shift != 0) { - pos -= shift; - assert(pos >= 0); - } - - v_cells[s1].pos_set(i, pos); - v_cells[s1].seq_add(i, seq_id_dst); - - if (shift != 0) { - v_cells[s1].pos_add(i, shift); - } - - v_cells[s1].ext_set(i, ext); - } - } - - v_heads[s1] = v_heads[s0]; - - //for (uint32_t s = 0; s < n_stream; ++s) { - // LLAMA_LOG_WARN("%s: seq %d: min = %d, max = %d\n", __func__, s, v_cells[s].seq_pos_min(s), v_cells[s].seq_pos_max(s)); - //} -} - -void llama_ik_cache::seq_keep(llama_seq_id seq_id) { - GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); - - auto & cells = v_cells[seq_to_stream[seq_id]]; - auto & head = v_heads[seq_to_stream[seq_id]]; - - uint32_t new_head = cells.size(); - - for (uint32_t i = 0; i < cells.size(); ++i) { - if (cells.seq_keep(i, seq_id)) { - if (new_head == cells.size()) { - new_head = i; - } - } - } - - // If we freed up a slot, set head to it so searching can start there. - if (new_head != cells.size() && new_head < head) { - head = new_head; - } -} - -void llama_ik_cache::seq_add(llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos shift) { - GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); - GGML_ASSERT(hparams.n_pos_per_embd() == 1 && "seq_add() is only supported for n_pos_per_embd() == 1"); - - auto & cells = v_cells[seq_to_stream[seq_id]]; - auto & head = v_heads[seq_to_stream[seq_id]]; - - if (shift == 0) { - return; - } - - uint32_t new_head = cells.size(); - - if (p0 < 0) { - p0 = 0; - } - - if (p1 < 0) { - p1 = std::numeric_limits::max(); - } - - // If there is no range then return early to avoid looping over all cells. - if (p0 == p1) { - return; - } - - for (uint32_t i = 0; i < cells.size(); ++i) { - if (!cells.pos_in(i, p0, p1)) { - continue; - } - - if (cells.seq_has(i, seq_id)) { - if (cells.pos_add(i, shift)) { - if (new_head == cells.size()) { - new_head = i; - } - } - } - } - - // If we freed up a slot, set head to it so searching can start there. - // Otherwise we just start the next search from the beginning. - head = new_head != cells.size() ? new_head : 0; -} - -void llama_ik_cache::seq_div(llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) { - GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); - GGML_ASSERT(hparams.n_pos_per_embd() == 1 && "seq_div() is only supported for n_pos_per_embd() == 1"); - - auto & cells = v_cells[seq_to_stream[seq_id]]; - - if (d == 1) { - return; - } - - if (p0 < 0) { - p0 = 0; - } - - if (p1 < 0) { - p1 = std::numeric_limits::max(); - } - - // If there is no range then return early to avoid looping over the cache. - if (p0 == p1) { - return; - } - - for (uint32_t i = 0; i < cells.size(); ++i) { - if (!cells.pos_in(i, p0, p1)) { - continue; - } - - if (cells.seq_has(i, seq_id)) { - cells.pos_div(i, d); - } - } -} - -llama_pos llama_ik_cache::seq_pos_min(llama_seq_id seq_id) const { - GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); - - const auto & cells = v_cells[seq_to_stream[seq_id]]; - - return cells.seq_pos_min(seq_id); -} - -llama_pos llama_ik_cache::seq_pos_max(llama_seq_id seq_id) const { - GGML_ASSERT(seq_id >= 0 && (size_t) seq_id < seq_to_stream.size()); - - const auto & cells = v_cells[seq_to_stream[seq_id]]; - - return cells.seq_pos_max(seq_id); -} - -std::map llama_ik_cache::memory_breakdown() const { - std::map ret; - for (const auto & [ctx, buf] : ctxs_bufs) { - ggml_backend_buffer_type_t buft = ggml_backend_buffer_get_type(buf.get()); - - if (hparams.no_alloc) { - GGML_ASSERT(ggml_backend_buffer_get_base(buf.get()) == nullptr); - ret[buft] += ggml_backend_alloc_ctx_tensors_from_buft_size(ctx.get(), buft); - } else { - // GGML_ASSERT(ggml_backend_buffer_get_base(buf.get()) != nullptr); // multi_buffer does not have a defined base - ret[buft] += ggml_backend_buffer_get_size(buf.get()); - } - } - - return ret; -} - -llama_memory_context_ptr llama_ik_cache::init_batch( - llama_batch_allocr & balloc, - uint32_t n_ubatch, - bool embd_all) { - GGML_UNUSED(embd_all); - - do { - balloc.split_reset(); - - std::vector ubatches; - while (true) { - auto ubatch = n_stream == 1 ? balloc.split_simple(n_ubatch) : balloc.split_equal(n_ubatch, true); - - if (ubatch.n_tokens == 0) { - break; - } - - ubatches.push_back(std::move(ubatch)); // NOLINT - } - - if (balloc.get_n_used() < balloc.get_n_tokens()) { - // failed to find a suitable split - break; - } - - auto sinfos = prepare(ubatches); - if (sinfos.empty()) { - break; - } - - return std::make_unique( - this, std::move(sinfos), std::move(ubatches)); - } while (false); - - return std::make_unique(LLAMA_MEMORY_STATUS_FAILED_PREPARE); -} - -llama_memory_context_ptr llama_ik_cache::init_full() { - return std::make_unique(this); -} - -llama_memory_context_ptr llama_ik_cache::init_update(llama_context * lctx, bool optimize) { - GGML_UNUSED(optimize); - - bool do_shift = get_has_shift(); - - return std::make_unique(this, lctx, do_shift, std::move(sc_info)); -} - -llama_ik_cache::slot_info_vec_t llama_ik_cache::prepare(const std::vector & ubatches) { - llama_ik_cache::slot_info_vec_t res; - - struct state_t { - slot_info sinfo; // slot info for the ubatch - - std::vector v_heads_old; // old positions of the heads, before placing the ubatch - - std::vector v_cells; // copy of the old cells, before placing the ubatch - }; - - // remember the old state of the cells so we can restore it in the end - std::vector states; - - bool success = true; - - for (const auto & ubatch : ubatches) { - // only find a suitable slot for the ubatch. don't modify the cells yet - const auto sinfo_new = find_slot(ubatch, false); - if (sinfo_new.empty()) { - success = false; - break; - } - - // remember the position that we found - res.push_back(sinfo_new); - - // store the old state of the cells in the recovery stack - { - state_t state = { sinfo_new, v_heads, {} }; - - for (uint32_t s = 0; s < sinfo_new.n_stream(); ++s) { - auto & cells = v_cells[sinfo_new.strm[s]]; - - state.v_cells.push_back(cells.cp(sinfo_new.idxs[s])); - } - - states.push_back(std::move(state)); - } - - // now emplace the ubatch - apply_ubatch(sinfo_new, ubatch); - } - - GGML_ASSERT(!states.empty() || !success); - - // iterate backwards and restore the cells to their original state - for (auto it = states.rbegin(); it != states.rend(); ++it) { - const auto & sinfo = it->sinfo; - - for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { - auto & cells = v_cells[sinfo.strm[s]]; - auto & head = v_heads[sinfo.strm[s]]; - - cells.set(sinfo.idxs[s], it->v_cells[s]); - head = it->v_heads_old[s]; - } - } - - if (!success) { - return {}; - } - - return res; -} - -bool llama_ik_cache::update(llama_context * lctx, bool do_shift, const stream_copy_info & sc_info) { - bool updated = false; - - auto * sched = lctx->get_sched(); - - if (!sc_info.empty()) { - assert(n_stream > 1 && "stream copy should never happen with a single stream"); - - llama_synchronize(lctx); - - const size_t n_copy = sc_info.ssrc.size(); - - for (size_t i = 0; i < n_copy; ++i) { - const auto ssrc = sc_info.ssrc[i]; - const auto sdst = sc_info.sdst[i]; - - assert(ssrc < n_stream); - assert(sdst < n_stream); - - LLAMA_LOG_DEBUG("%s: copying KV buffer: stream %d to stream %d\n", __func__, ssrc, sdst); - - assert(ssrc != sdst); - - for (uint32_t il = 0; il < layers.size(); ++il) { - const auto & layer = layers[il]; - - ggml_backend_tensor_copy(layer.k_stream[ssrc], layer.k_stream[sdst]); - } - } - } - - if (do_shift) { - if (!get_can_shift()) { - GGML_ABORT("The current KV cache / model configuration does not support K-shift"); - } - - LLAMA_LOG_DEBUG("%s: applying K-shift\n", __func__); - - // apply K-shift if needed - if (hparams.rope_type != LLAMA_ROPE_TYPE_NONE) { - ggml_backend_sched_reset(sched); - - auto * res = lctx->get_gf_res_reserve(); - - res->reset(); - - auto * gf = build_graph_shift(res, lctx); - if (!ggml_backend_sched_alloc_graph(sched, gf)) { - LLAMA_LOG_ERROR("%s: failed to allocate compute graph for K-shift\n", __func__); - return updated; - } - - res->set_inputs(nullptr); - - if (lctx->graph_compute(gf, false) != GGML_STATUS_SUCCESS) { - LLAMA_LOG_ERROR("%s: failed to compute K-shift\n", __func__); - return updated; - } - - updated = true; - } - - for (uint32_t s = 0; s < n_stream; ++s) { - auto & cells = v_cells[s]; - - cells.reset_shift(); - } - } - - return updated; -} - -llama_ik_cache::slot_info llama_ik_cache::find_slot(const llama_ubatch & ubatch, bool cont) const { - - if (debug > 0) { - for (uint32_t s = 0; s < ubatch.n_seqs_unq; ++s) { - const auto seq_id = ubatch.seq_id_unq[s]; - const auto stream_id = seq_to_stream[seq_id]; - const auto & cells = v_cells[stream_id]; - const uint32_t head_cur = v_heads[stream_id]; - - LLAMA_LOG_DEBUG("%s: stream[%d], n = %5d, used = %5d, head = %5d, size = %5d, n_swa = %5d\n", - __func__, stream_id, cells.used_max_p1(), cells.get_used(), head_cur, get_size(), n_swa); - - if ((debug == 2 && n_swa > 0) || debug > 2) { - std::string ss; - for (uint32_t i = 0; i < cells.size(); ++i) { - if (cells.is_empty(i)) { - ss += '.'; - } else { - assert(cells.seq_count(i) >= 1); - - if (cells.seq_count(i) == 1) { - ss += std::to_string(cells.seq_get(i)); - } else { - ss += 'M'; - } - } - if (i%256 == 255) { - ss += " *"; - ss += '\n'; - } - } - LLAMA_LOG_DEBUG("\n%s\n", ss.c_str()); - } - - if ((debug == 2 && n_swa > 0) || debug > 2) { - std::string ss; - for (uint32_t i = 0; i < cells.size(); ++i) { - std::string cur; - if (cells.is_empty(i)) { - cur = '.'; - } else { - cur = std::to_string(cells.pos_get(i)); - } - const int n = cur.size(); - for (int j = 0; j < 5 - n; ++j) { - cur += ' '; - } - ss += cur; - if (i%256 == 255) { - ss += " *"; - } - if (i%64 == 63) { - ss += '\n'; - } - } - LLAMA_LOG_DEBUG("\n%s\n", ss.c_str()); - } - - for (int s = 0; s < LLAMA_MAX_SEQ; ++s) { - if (cells.seq_pos_min(s) < 0) { - continue; - } - - LLAMA_LOG_DEBUG("%s: stream[%d] min[%d] = %5d, max[%d] = %5d\n", __func__, stream_id, s, cells.seq_pos_min(s), s, cells.seq_pos_max(s)); - } - } - } - - uint32_t n_tokens = ubatch.n_tokens; - uint32_t n_seqs = 1; - - if (n_stream > 1) { - GGML_ASSERT(n_tokens % ubatch.n_seqs_unq == 0); - - n_seqs = ubatch.n_seqs_unq; - n_tokens = n_tokens / n_seqs; - } - - slot_info res = { - /*.s0 =*/ LLAMA_MAX_SEQ, - /*.s1 =*/ 0, - /*.strm =*/ { }, - /*.idxs =*/ { }, - }; - - res.resize(n_seqs); - - for (uint32_t s = 0; s < n_seqs; ++s) { - const auto seq_id = ubatch.seq_id_unq[s]; - - if (n_stream > 1) { - GGML_ASSERT(ubatch.n_seq_id[s*n_tokens] == 1); - GGML_ASSERT(ubatch.seq_id [s*n_tokens][0] == seq_id); - } - - res.s0 = std::min(res.s0, seq_to_stream[seq_id]); - res.s1 = std::max(res.s1, seq_to_stream[seq_id]); - - res.strm[s] = seq_to_stream[seq_id]; - res.idxs[s].reserve(n_tokens); - - const auto & cells = v_cells[seq_to_stream[seq_id]]; - - uint32_t head_cur = v_heads[seq_to_stream[seq_id]]; - - // if we have enough unused cells before the current head -> - // better to start searching from the beginning of the cache, hoping to fill it - if (head_cur > cells.get_used() + 2*n_tokens) { - head_cur = 0; - } - - if (n_tokens > cells.size()) { - LLAMA_LOG_ERROR("%s: n_tokens = %d > size = %u\n", __func__, n_tokens, cells.size()); - return { }; - } - - uint32_t n_tested = 0; - - // for continuous slots, we test that all tokens in the ubatch fit, starting from the current head - // for non-continuous slots, we test the tokens one by one - const uint32_t n_test = cont ? n_tokens : 1; - - while (true) { - if (head_cur + n_test > cells.size()) { - n_tested += cells.size() - head_cur; - head_cur = 0; - continue; - } - - for (uint32_t i = 0; i < n_test; i++) { - const auto idx = head_cur; - - head_cur++; - n_tested++; - - //const llama_pos pos = ubatch.pos[i]; - //const llama_seq_id seq_id = ubatch.seq_id[i][0]; - - // can we use this cell? either: - // - the cell is empty - // - the cell is occupied only by one sequence: - // - (disabled) mask causally, if the sequence is the same as the one we are inserting - // - mask SWA, using current max pos for that sequence in the cache - // always insert in the cell with minimum pos - bool can_use = cells.is_empty(idx); - - if (!can_use && cells.seq_count(idx) == 1) { - const llama_pos pos_cell = cells.pos_get(idx); - - // (disabled) causal mask - // note: it's better to purge any "future" tokens beforehand - //if (cells.seq_has(idx, seq_id)) { - // can_use = pos_cell >= pos; - //} - - if (!can_use) { - const llama_seq_id seq_id_cell = cells.seq_get(idx); - - // SWA mask - if (llama_hparams::is_masked_swa(n_swa, swa_type, pos_cell, cells.seq_pos_max(seq_id_cell) + 1)) { - can_use = true; - } - } - } - - if (can_use) { - res.idxs[s].push_back(idx); - } else { - if (cont) { - break; - } - } - } - - if (res.idxs[s].size() == n_tokens) { - break; - } - - if (cont) { - res.idxs[s].clear(); - } - - if (n_tested >= cells.size()) { - //LLAMA_LOG_ERROR("%s: failed to find a slot for %d tokens\n", __func__, n_tokens); - return { }; - } - } - - // we didn't find a suitable slot - return empty result - if (res.idxs[s].size() < n_tokens) { - return { }; - } - } - - assert(res.s1 >= res.s0); - - return res; -} - -void llama_ik_cache::apply_ubatch(const slot_info & sinfo, const llama_ubatch & ubatch) { - // keep track of the max sequence position that we would overwrite with this ubatch - // for non-SWA cache, this would be always empty - llama_seq_id seq_pos_max_rm[LLAMA_MAX_SEQ]; - for (uint32_t s = 0; s < LLAMA_MAX_SEQ; ++s) { - seq_pos_max_rm[s] = -1; - } - - assert(ubatch.n_tokens == sinfo.n_stream()*sinfo.size()); - - for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { - for (uint32_t ii = 0; ii < sinfo.size(); ++ii) { - const uint32_t i = s*sinfo.size() + ii; - - auto & cells = v_cells[sinfo.strm[s]]; - - const auto idx = sinfo.idxs[s][ii]; - - if (!cells.is_empty(idx)) { - assert(cells.seq_count(idx) == 1); - - const llama_seq_id seq_id = cells.seq_get(idx); - const llama_pos pos = cells.pos_get(idx); - - seq_pos_max_rm[seq_id] = std::max(seq_pos_max_rm[seq_id], pos); - - cells.rm(idx); - } - - cells.pos_set(idx, ubatch.pos[i]); - - if (ubatch.is_pos_2d()) { - llama_kv_cell_ext ext { - /*.x =*/ ubatch.pos[i + ubatch.n_tokens*2], - /*.y =*/ ubatch.pos[i + ubatch.n_tokens], - }; - cells.ext_set(idx, ext); - } - - for (int32_t s = 0; s < ubatch.n_seq_id[i]; s++) { - cells.seq_add(idx, ubatch.seq_id[i][s]); - } - } - } - - // note: we want to preserve the invariant that all positions between [pos_min, pos_max] for each sequence - // will be present in the cache. so we have to purge any position which is less than those we would overwrite - // ref: https://github.com/ggml-org/llama.cpp/pull/13746#issuecomment-2916057092 - for (uint32_t s = 0; s < LLAMA_MAX_SEQ; ++s) { - if (seq_pos_max_rm[s] == -1) { - continue; - } - - GGML_ASSERT(s < seq_to_stream.size()); - - auto & cells = v_cells[seq_to_stream[s]]; - - if (cells.seq_pos_min(s) <= seq_pos_max_rm[s]) { - LLAMA_LOG_DEBUG("%s: purging positions [%d, %d] of sequence %d from KV cache\n", - __func__, cells.seq_pos_min(s), seq_pos_max_rm[s], s); - - seq_rm(s, cells.seq_pos_min(s), seq_pos_max_rm[s] + 1); - } - } - - // move the head at the end of the slot - for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { - auto & head = v_heads[sinfo.strm[s]]; - - head = sinfo.idxs[s].back() + 1; - } -} - -bool llama_ik_cache::get_can_shift() const { - // Step35 uses per-layer RoPE dims; K-shift assumes a single global n_rot. - if (model.arch == LLM_ARCH_STEP35) { - return false; - } - if (hparams.n_pos_per_embd() > 1) { - return false; - } - return true; -} - -uint32_t llama_ik_cache::get_size() const { - const auto & cells = v_cells[seq_to_stream[0]]; - - return cells.size(); -} - -uint32_t llama_ik_cache::get_n_stream() const { - return n_stream; -} - -bool llama_ik_cache::get_has_shift() const { - bool result = false; - - for (uint32_t s = 0; s < n_stream; ++s) { - result |= v_cells[s].get_has_shift(); - } - - return result; -} - -uint32_t llama_ik_cache::get_n_kv(const slot_info & sinfo) const { - uint32_t result = 0; - - // pad the n_kv value so that the graph remains constant across batches and can be reused - // note: this also helps some backends with performance (f.ex https://github.com/ggml-org/llama.cpp/pull/16812#issuecomment-3455112220) - const uint32_t n_pad_cur = std::max(n_pad, 256u); - - for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { - const auto & cells = v_cells[sinfo.strm[s]]; - - result = std::max(std::min(cells.size(), std::max(n_pad_cur, GGML_PAD(cells.used_max_p1(), n_pad_cur))), result); - } - - return result; -} - -ggml_tensor * llama_ik_cache::get_k(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const { - const int32_t ikv = map_layer_ids.at(il); - - auto * k = layers[ikv].k; - - const uint64_t kv_size = get_size(); - const uint64_t n_embd_k_gqa = k->ne[0]; - - assert(n_embd_k_gqa == hparams.indexer_head_size); - - const uint32_t ns = sinfo.s1 - sinfo.s0 + 1; - - return ggml_view_4d(ctx, k, - hparams.indexer_head_size, 1, n_kv, ns, - ggml_row_size(k->type, hparams.indexer_head_size), - ggml_row_size(k->type, n_embd_k_gqa), - ggml_row_size(k->type, n_embd_k_gqa*kv_size), - ggml_row_size(k->type, n_embd_k_gqa*kv_size)*sinfo.s0); -} - -ggml_tensor * llama_ik_cache::cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const { - GGML_UNUSED(sinfo); - - const int32_t ikv = map_layer_ids.at(il); - - ggml_tensor * k = layers[ikv].k; - - const int64_t n_embd_head = k_cur->ne[0]; - const int64_t n_head = k_cur->ne[1]; - const int64_t n_tokens = k_cur->ne[2]; - - const int64_t n_embd_gqa = n_embd_head*n_head; - - // we can merge dims 0 and 1 - // TODO: add ggml helper function for this? - GGML_ASSERT(ggml_row_size(k_cur->type, n_embd_head) == k_cur->nb[1]); - - k_cur = ggml_view_2d(ctx, k_cur, n_embd_gqa, n_tokens, k_cur->nb[2], 0); - - const int64_t n_stream = k->ne[2]; - - if (n_stream > 1) { - const int64_t kv_size = get_size(); - - assert(n_embd_gqa == k->ne[0]); - assert(kv_size == k->ne[1]); - - // merge the buffer across all streams because the idxs are global - k = ggml_reshape_2d(ctx, k, n_embd_gqa, kv_size*n_stream); - } - - // store the current K values into the cache - return ggml_set_rows(ctx, k, k_cur, k_idxs); -} - -ggml_tensor * llama_ik_cache::build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const { - const uint32_t n_tokens = ubatch.n_tokens; - - ggml_tensor * k_idxs = ggml_new_tensor_1d(ctx, GGML_TYPE_I64, n_tokens); - - ggml_set_input(k_idxs); - - return k_idxs; -} - -void llama_ik_cache::set_input_k_idxs(ggml_tensor * dst, const llama_ubatch * ubatch, const slot_info & sinfo) const { - const uint32_t n_tokens = ubatch->n_tokens; - GGML_ASSERT(n_tokens == (int64_t) sinfo.size()*sinfo.n_stream()); - - GGML_ASSERT(ggml_backend_buffer_is_host(dst->buffer)); - int64_t * data = (int64_t *) dst->data; - - for (uint32_t s = 0; s < sinfo.n_stream(); ++s) { - const int64_t offs = sinfo.strm[s]*get_size(); - - for (uint32_t i = 0; i < sinfo.size(); ++i) { - data[s*sinfo.size() + i] = offs + sinfo.idxs[s][i]; - } - } -} - -void llama_ik_cache::set_input_k_shift(ggml_tensor * dst) const { - GGML_ASSERT(ggml_backend_buffer_is_host(dst->buffer)); - - int32_t * data = (int32_t *) dst->data; - - for (uint32_t s = 0; s < n_stream; ++s) { - const auto & cells = v_cells[s]; - - for (uint32_t i = 0; i < cells.size(); ++i) { - data[s*cells.size() + i] = cells.is_empty(i) ? 0 : cells.get_shift(i); - } - } -} - -struct args_set_input_kq_mask { - const llama_hparams & hparams; - const llama_ubatch * ubatch; - - const std::vector & v_cells; - const std::vector & seq_to_stream; - - uint32_t n_swa; - llama_swa_type swa_type; - - int64_t n_kv; - int64_t n_stream; - int64_t n_tps; -}; - -template -static void set_input_kq_mask_impl(const args_set_input_kq_mask & args, float * data) { - //const auto & hparams = args.hparams; - const auto & ubatch = args.ubatch; - - const auto & v_cells = args.v_cells; - const auto & seq_to_stream = args.seq_to_stream; - - const uint32_t n_swa = args.n_swa; - const llama_swa_type swa_type = args.swa_type; - - const int64_t n_kv = args.n_kv; - const int64_t n_stream = args.n_stream; - const int64_t n_tps = args.n_tps; - - // the min position in the batch for each sequence - llama_pos seq_pos_min[LLAMA_MAX_SEQ]; - std::fill(seq_pos_min, seq_pos_min + LLAMA_MAX_SEQ, INT32_MAX); - - for (uint32_t i = 0; i < ubatch->n_tokens; ++i) { - const llama_seq_id seq_id = ubatch->seq_id[i][0]; - - seq_pos_min[seq_id] = std::min(seq_pos_min[seq_id], ubatch->pos[i]); - } - - for (uint32_t s = 0; s < n_stream; ++s) { - // bookkeeping of the KQ mask cells that could change for other tokens of the same sequence - std::unordered_map seq_srct; - std::unordered_map> seq_idxs; - - for (uint32_t ii = 0; ii < n_tps; ++ii) { - const uint32_t i = s*n_tps + ii; - - const llama_seq_id seq_id = ubatch->seq_id[i][0]; - - const auto & cells = v_cells.at(seq_to_stream[seq_id]); - - llama_pos p0 = -1; - const llama_pos p1 = ubatch->pos[i]; - - // for M-RoPE - const llama_pos p1_x = is_2d ? ubatch->pos[i + ubatch->n_tokens*2] : 0; - const llama_pos p1_y = is_2d ? ubatch->pos[i + ubatch->n_tokens] : 0; - - const uint64_t idst = n_kv*i; - - // for tokens of the same sequence, the mask is mostly the same, so we can reuse it - // the only cells that could change are the ones that are with similar positions as the - // ones in the batch (i.e. due to causal masking, SWA, etc.) - // keep track of those cells and shortcut the loop to save time - // note: this optimization is not compatible with Alibi position encoding - // ref: https://github.com/ggml-org/llama.cpp/pull/18842 - bool prev = false; - - auto & idxs = seq_idxs[seq_id]; - - if (!alibi) { - if (seq_srct.find(seq_id) != seq_srct.end()) { - const uint32_t srct = seq_srct[seq_id]; - - const uint64_t idst_prev = n_kv*srct; - - std::copy(data + idst_prev, data + idst_prev + n_kv, data + idst); - - prev = true; - } else { - idxs.clear(); - idxs.reserve(ubatch->n_tokens + n_swa + 32); - - seq_srct[seq_id] = i; - } - } - - for (uint32_t jj = 0; jj < n_kv; ++jj) { - uint32_t j = jj; - - // we have an exiting mask for this sequence -> update just seq_idxs - if (!alibi) { - if (prev) { - if (jj >= idxs.size()) { - break; - } - - j = idxs[jj]; - } - } - - if (cells.is_empty(j)) { - goto skip; - } - - // mask the token if not the same sequence - if (!cells.seq_has(j, seq_id)) { - goto skip; - } - - p0 = cells.pos_get(j); - - if (!alibi) { - if (!prev) { - // record all cells for which: p0 >= seq_pos_min[seq_id] - n_swa - 32 - if (p0 + (int32_t) (n_swa + 32) >= seq_pos_min[seq_id]) { - idxs.push_back(j); - } - } - } - - if (causal) { - // mask future tokens - if (p0 > p1) { - goto skip; - } - - // M-RoPE causal mask - if (is_2d) { - if (p0 == p1) { - const auto & p0_ext = cells.ext_get(j); - - if (p0_ext.is_2d_gt(p1_x, p1_y)) { - goto skip; - } - } - } - } - - // apply SWA if any - if (swa) { - if (llama_hparams::is_masked_swa(n_swa, swa_type, p0, p1)) { - goto skip; - } - } - - if (alibi) { - data[idst + j] = -std::abs(p0 - p1); - } else { - data[idst + j] = 0.0f; - } - - continue; -skip: - data[idst + j] = -INFINITY; - } - } - } -} - -template -static void set_input_kq_mask_impl(const args_set_input_kq_mask & args, float * data) { - const bool alibi = args.hparams.use_alibi; - if (alibi) { - set_input_kq_mask_impl (args, data); - } else { - set_input_kq_mask_impl(args, data); - } -} - -template -static void set_input_kq_mask_impl(const args_set_input_kq_mask & args, float * data) { - const bool is_2d = args.ubatch->is_pos_2d(); - if (is_2d) { - set_input_kq_mask_impl (args, data); - } else { - set_input_kq_mask_impl(args, data); - } -} - -template -static void set_input_kq_mask_impl(const args_set_input_kq_mask & args, float * data) { - const bool swa = args.swa_type != LLAMA_SWA_TYPE_NONE; - if (swa) { - set_input_kq_mask_impl (args, data); - } else { - set_input_kq_mask_impl(args, data); - } -} - -void llama_ik_cache::set_input_kq_mask(ggml_tensor * dst, const llama_ubatch * ubatch, bool causal_attn) const { - const uint32_t n_tokens = ubatch->n_tokens; - - GGML_ASSERT(ggml_backend_buffer_is_host(dst->buffer)); - float * data = (float *) dst->data; - - const int64_t n_kv = dst->ne[0]; - const int64_t n_stream = dst->ne[3]; // num streams in the current ubatch - - GGML_ASSERT(n_tokens%n_stream == 0); - - // n_tps == n_tokens_per_stream - const int64_t n_tps = n_tokens/n_stream; - - //const int64_t t_start = ggml_time_us(); - - const args_set_input_kq_mask args = { - /*.hparams =*/ hparams, - /*.ubatch =*/ ubatch, - /*.v_cells =*/ v_cells, - /*.seq_to_stream =*/ seq_to_stream, - /*.n_swa =*/ n_swa, - /*.swa_type =*/ swa_type, - /*.n_kv =*/ n_kv, - /*.n_stream =*/ n_stream, - /*.n_tps =*/ n_tps, - }; - - if (causal_attn) { - set_input_kq_mask_impl (args, data); - } else { - set_input_kq_mask_impl(args, data); - } - - //const int64_t t_end = ggml_time_us(); - - //LLAMA_LOG_ERROR("%s: kq mask time: %0.3f ms\n", __func__, (t_end - t_start)/1000.0); -} - -size_t llama_ik_cache::total_size() const { - size_t size = 0; - - for (const auto & [_, buf] : ctxs_bufs) { - size += ggml_backend_buffer_get_size(buf.get()); - } - - return size; -} - -size_t llama_ik_cache::size_k_bytes() const { - size_t size_k_bytes = 0; - - for (const auto & layer : layers) { - size_k_bytes += ggml_nbytes(layer.k); - } - - return size_k_bytes; -} - -ggml_tensor * llama_ik_cache::build_rope_shift( - const llama_cparams & cparams, - ggml_context * ctx, - ggml_tensor * cur, - ggml_tensor * shift, - ggml_tensor * factors, - float freq_base, - float freq_scale, - uint32_t il) const { - const auto & n_ctx_orig = cparams.n_ctx_orig_yarn; - - const auto & yarn_ext_factor = cparams.yarn_ext_factor; - const auto & yarn_beta_fast = cparams.yarn_beta_fast; - const auto & yarn_beta_slow = cparams.yarn_beta_slow; - const auto & yarn_attn_factor = cparams.yarn_attn_factor; - - const auto & n_rot = hparams.n_rot(il); - const auto & rope_type = hparams.rope_type == LLAMA_ROPE_TYPE_MROPE || hparams.rope_type == LLAMA_ROPE_TYPE_IMROPE - // @ngxson : this is a workaround - // for M-RoPE, we want to rotate the whole vector when doing KV shift - // a normal RoPE should work, we just need to use the correct ordering - // ref: https://github.com/ggml-org/llama.cpp/pull/13870 - ? LLAMA_ROPE_TYPE_NEOX - : hparams.rope_type; - - ggml_tensor * tmp; - - if (ggml_is_quantized(cur->type)) { - // dequantize to f32 -> RoPE -> quantize back - tmp = ggml_cast(ctx, cur, GGML_TYPE_F32); - - tmp = ggml_rope_ext(ctx, tmp, - shift, factors, n_rot, rope_type, n_ctx_orig, freq_base, freq_scale, - yarn_ext_factor, yarn_attn_factor, yarn_beta_fast, yarn_beta_slow); - - tmp = ggml_cpy(ctx, tmp, cur); - } else { - // we rotate only the first n_rot dimensions - tmp = ggml_rope_ext_inplace(ctx, cur, - shift, factors, n_rot, rope_type, n_ctx_orig, freq_base, freq_scale, - yarn_ext_factor, yarn_attn_factor, yarn_beta_fast, yarn_beta_slow); - } - - return tmp; -} - -class llm_graph_input_ik_shift : public llm_graph_input_i { -public: - llm_graph_input_ik_shift(const llama_ik_cache * kv_self) : kv_self(kv_self) {} - virtual ~llm_graph_input_ik_shift() = default; - - void set_input(const llama_ubatch * ubatch) override; - - ggml_tensor * k_shift; // I32 [kv_size*n_stream] - - const llama_ik_cache * kv_self; -}; - -void llm_graph_input_ik_shift::set_input(const llama_ubatch * ubatch) { - GGML_UNUSED(ubatch); - - if (k_shift) { - kv_self->set_input_k_shift(k_shift); - } -} - -ggml_cgraph * llama_ik_cache::build_graph_shift(llm_graph_result * res, llama_context * lctx) const { - auto * ctx = res->get_ctx(); - auto * gf = res->get_gf(); - - auto inp = std::make_unique(this); - - inp->k_shift = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, (int64_t) get_size()*n_stream); - ggml_set_input(inp->k_shift); - - const auto & cparams = lctx->get_cparams(); - - for (const auto & layer : layers) { - const uint32_t il = layer.il; - - const int64_t n_head_kv = 1; - const int64_t n_embd_k_gqa = hparams.indexer_head_size; - - const auto n_rot = hparams.n_rot(il); - const auto n_embd_head_k = hparams.indexer_head_size; - const auto n_embd_nope = hparams.n_lora_kv > 0 ? n_embd_head_k - n_rot : 0; - - const float freq_base_l = model.get_rope_freq_base (cparams, il); - const float freq_scale_l = model.get_rope_freq_scale(cparams, il); - - ggml_tensor * rope_factors = model.get_rope_factors(cparams, il); - - ggml_tensor * k = - ggml_view_3d(ctx, layer.k, - n_rot, n_head_kv, get_size()*n_stream, - ggml_row_size(layer.k->type, n_embd_head_k), - ggml_row_size(layer.k->type, n_embd_k_gqa), - ggml_row_size(layer.k->type, n_embd_nope)); - - ggml_tensor * cur = build_rope_shift(cparams, ctx, k, inp->k_shift, rope_factors, freq_base_l, freq_scale_l, il); - - ggml_build_forward_expand(gf, cur); - } - - res->add_input(std::move(inp)); - - return gf; -} - -void llama_ik_cache::state_write(llama_io_write_i & io, llama_seq_id seq_id, llama_state_seq_flags flags) const { - GGML_UNUSED(flags); - - io.write(&n_stream, sizeof(n_stream)); - - for (uint32_t s = 0; s < n_stream; ++s) { - cell_ranges_t cr { s, {} }; - - uint32_t cell_count = 0; - - const auto & cells = v_cells[s]; - - // Count the number of cells with the specified seq_id - // Find all the ranges of cells with this seq id (or all, when -1) - uint32_t cell_range_begin = cells.size(); - - for (uint32_t i = 0; i < cells.size(); ++i) { - if (!cells.is_empty(i) && (seq_id == -1 || cells.seq_has(i, seq_id))) { - ++cell_count; - if (cell_range_begin == cells.size()) { - cell_range_begin = i; - } - } else { - if (cell_range_begin != cells.size()) { - cr.data.emplace_back(cell_range_begin, i); - cell_range_begin = cells.size(); - } - } - } - - if (cell_range_begin != cells.size()) { - cr.data.emplace_back(cell_range_begin, cells.size()); - } - - // DEBUG CHECK: Sum of cell counts in ranges should equal the total cell count - uint32_t cell_count_check = 0; - for (const auto & range : cr.data) { - cell_count_check += range.second - range.first; - } - GGML_ASSERT(cell_count == cell_count_check); - - io.write(&cell_count, sizeof(cell_count)); - - // skip empty streams - if (cell_count == 0) { - continue; - } - - state_write_meta(io, cr, seq_id); - state_write_data(io, cr); - } -} - -void llama_ik_cache::state_read(llama_io_read_i & io, llama_seq_id seq_id, llama_state_seq_flags flags) { - GGML_UNUSED(flags); - - GGML_ASSERT(seq_id == -1 || (seq_id >= 0 && (size_t) seq_id < seq_to_stream.size())); - - uint32_t n_stream_cur; - io.read_to(&n_stream_cur, sizeof(n_stream_cur)); - if (n_stream_cur != n_stream) { - throw std::runtime_error("n_stream mismatch"); - } - - for (uint32_t s = 0; s < n_stream; ++s) { - uint32_t cell_count; - io.read_to(&cell_count, sizeof(cell_count)); - - if (cell_count == 0) { - continue; - } - - const uint32_t strm = seq_id == -1 ? s : seq_to_stream[seq_id]; - - slot_info sinfo; - - bool res = true; - res = res && state_read_meta(io, strm, cell_count, sinfo, seq_id); - res = res && state_read_data(io, strm, cell_count, sinfo); - - if (!res) { - if (seq_id == -1) { - clear(true); - } else { - seq_rm(seq_id, -1, -1); - } - throw std::runtime_error("failed to restore kv cache"); - } - } -} - -void llama_ik_cache::state_write_meta(llama_io_write_i & io, const cell_ranges_t & cr, llama_seq_id seq_id) const { - const auto & cells = v_cells[cr.strm]; - - for (const auto & range : cr.data) { - for (uint32_t i = range.first; i < range.second; ++i) { - std::vector seq_ids; - - for (llama_seq_id cur = 0; cur < (int) n_seq_max; ++cur) { - if (cur == seq_id || seq_id == -1) { - if (cells.seq_has(i, cur)) { - seq_ids.push_back(cur); - } - } - } - - const llama_pos pos = cells.pos_get(i); - const uint32_t n_seq_id = seq_ids.size(); - - io.write(&pos, sizeof(pos)); - io.write(&n_seq_id, sizeof(n_seq_id)); - - if (hparams.n_pos_per_embd() > 1) { - const llama_kv_cell_ext ext = cells.ext_get(i); - io.write(&ext, sizeof(ext)); - } - - for (const auto & seq_id : seq_ids) { - io.write(&seq_id, sizeof(seq_id)); - } - } - } -} - -void llama_ik_cache::state_write_data(llama_io_write_i & io, const cell_ranges_t & cr) const { - const uint32_t n_layer = layers.size(); - - io.write(&n_layer, sizeof(n_layer)); - - // Iterate and write all the keys first, each row is a cell - // Get whole range at a time - for (const auto & layer : layers) { - const uint32_t n_embd_k_gqa = hparams.indexer_head_size; - - auto * k = layer.k_stream[cr.strm]; - - // Write key type - const int32_t k_type_i = (int32_t) k->type; - io.write(&k_type_i, sizeof(k_type_i)); - - // Write row size of key - const uint64_t k_size_row = ggml_row_size(k->type, n_embd_k_gqa); - io.write(&k_size_row, sizeof(k_size_row)); - - // Read each range of cells of k_size length and write out - for (const auto & range : cr.data) { - const size_t range_size = range.second - range.first; - const size_t buf_size = range_size * k_size_row; - io.write_tensor(k, range.first * k_size_row, buf_size); - } - } -} - -bool llama_ik_cache::state_read_meta(llama_io_read_i & io, uint32_t strm, uint32_t cell_count, slot_info & sinfo, llama_seq_id dest_seq_id) { - auto & cells = v_cells[strm]; - auto & head = v_heads[strm]; - - if (dest_seq_id != -1) { - // single sequence - seq_rm(dest_seq_id, -1, -1); - - llama_batch_allocr balloc(hparams.n_pos_per_embd()); - - llama_ubatch ubatch = balloc.ubatch_reserve(cell_count, 1); - - ubatch.seq_id_unq[0] = dest_seq_id; - - for (uint32_t i = 0; i < cell_count; ++i) { - llama_pos pos; - uint32_t n_seq_id; - - io.read_to(&pos, sizeof(pos)); - io.read_to(&n_seq_id, sizeof(n_seq_id)); - - if (n_seq_id != 1) { - LLAMA_LOG_ERROR("%s: invalid seq_id-agnostic kv cell\n", __func__); - return false; - } - - if (hparams.n_pos_per_embd() > 1) { - llama_kv_cell_ext ext; - io.read_to(&ext, sizeof(ext)); - - ubatch.pos[i + ubatch.n_tokens] = ext.y; - ubatch.pos[i + ubatch.n_tokens*2] = ext.x; - } - - // read the sequence id, but directly discard it - we will use dest_seq_id instead - { - llama_seq_id seq_id; - io.read_to(&seq_id, sizeof(seq_id)); - } - - ubatch.pos[i] = pos; - ubatch.n_seq_id[i] = n_seq_id; - ubatch.seq_id[i] = &dest_seq_id; - } - - sinfo = find_slot(ubatch, false); - if (sinfo.empty()) { - LLAMA_LOG_ERROR("%s: failed to find available cells in kv cache\n", __func__); - return false; - } - - // TODO: we cannot yet restore llama_kv_cell_ext as the apply_ubatch() does not support it yet - // see: https://github.com/ggml-org/llama.cpp/pull/16825#issuecomment-3460868350 - apply_ubatch(sinfo, ubatch); - - LLAMA_LOG_DEBUG("%s: cell_count = %d, dest_seq_id = %d\n", __func__, cell_count, dest_seq_id); - - // DEBUG CHECK: verify that all cells were allocated and have correct seq_id and pos values - GGML_ASSERT(sinfo.n_stream() == 1); - GGML_ASSERT(sinfo.idxs[0].size() == cell_count); - for (uint32_t i = 0; i < cell_count; ++i) { - const uint32_t idx = sinfo.idxs[0][i]; - GGML_ASSERT(cells.pos_get(idx) == ubatch.pos[i]); - GGML_ASSERT(cells.seq_has(idx, dest_seq_id)); - } - } else { - // whole KV cache restore - - if (cell_count > cells.size()) { - LLAMA_LOG_ERROR("%s: not enough cells in kv cache\n", __func__); - return false; - } - - clear(true); - - for (uint32_t i = 0; i < cell_count; ++i) { - llama_pos pos; - uint32_t n_seq_id; - - io.read_to(&pos, sizeof(pos)); - io.read_to(&n_seq_id, sizeof(n_seq_id)); - - cells.pos_set(i, pos); - - if (hparams.n_pos_per_embd() > 1) { - llama_kv_cell_ext ext; - io.read_to(&ext, sizeof(ext)); - cells.ext_set(i, ext); - } - - for (uint32_t j = 0; j < n_seq_id; ++j) { - llama_seq_id seq_id; - io.read_to(&seq_id, sizeof(seq_id)); - - if (seq_id < 0 || (uint32_t) seq_id >= n_seq_max) { - LLAMA_LOG_ERROR("%s: invalid seq_id, %d is out of range [0, %u)\n", __func__, seq_id, n_seq_max); - return false; - } - - cells.seq_add(i, seq_id); - } - } - - // Create contiguous slot_info for whole cache restore - sinfo.s0 = strm; - sinfo.s1 = strm; - sinfo.resize(1); - sinfo.strm[0] = strm; - sinfo.idxs[0].resize(cell_count); - for (uint32_t i = 0; i < cell_count; ++i) { - sinfo.idxs[0][i] = i; - } - - head = 0; - } - - return true; -} - -bool llama_ik_cache::state_read_data(llama_io_read_i & io, uint32_t strm, uint32_t cell_count, const slot_info & sinfo) { - auto & cells = v_cells[strm]; - - uint32_t n_layer; - - io.read_to(&n_layer, sizeof(n_layer)); - - if (n_layer != layers.size()) { - LLAMA_LOG_ERROR("%s: mismatched layer count (%u instead of %u)\n", __func__, n_layer, (uint32_t) layers.size()); - return false; - } - - if (cell_count > cells.size()) { - LLAMA_LOG_ERROR("%s: not enough cells in kv cache to restore state (%u > %u)\n", __func__, cell_count, cells.size()); - return false; - } - - // For each layer, read the keys for each cell, one row is one cell, read as one contiguous block - for (const auto & layer : layers) { - const uint32_t il = layer.il; - - const uint32_t n_embd_k_gqa = hparams.indexer_head_size; - - auto * k = layer.k_stream[strm]; - - // Read type of key - int32_t k_type_i_ref; - io.read_to(&k_type_i_ref, sizeof(k_type_i_ref)); - const int32_t k_type_i = (int32_t) k->type; - if (k_type_i != k_type_i_ref) { - LLAMA_LOG_ERROR("%s: mismatched key type (%d != %d, layer %d)\n", __func__, k_type_i, k_type_i_ref, il); - return false; - } - - // Read row size of key - uint64_t k_size_row_ref; - io.read_to(&k_size_row_ref, sizeof(k_size_row_ref)); - const size_t k_size_row = ggml_row_size(k->type, n_embd_k_gqa); - if (k_size_row != k_size_row_ref) { - LLAMA_LOG_ERROR("%s: mismatched key row size (%zu != %zu, layer %d)\n", __func__, k_size_row, (size_t) k_size_row_ref, il); - return false; - } - - if (cell_count) { - if (sinfo.is_contiguous()) { - // Fast path: contiguous cells, single memcpy - ggml_backend_tensor_set(k, io.read(cell_count * k_size_row), sinfo.head() * k_size_row, cell_count * k_size_row); - } else { - // Slow path: scatter to non-contiguous positions - const void * src = io.read(cell_count * k_size_row); - for (uint32_t i = 0; i < cell_count; ++i) { - const size_t dst_offset = sinfo.idxs[0][i] * k_size_row; - ggml_backend_tensor_set(k, (const char*)src + i * k_size_row, dst_offset, k_size_row); - } - } - } - } - - return true; -} - -// -// llama_ik_cache_context -// - -llama_ik_cache_context::llama_ik_cache_context(llama_memory_status status) : status(status) {} - -llama_ik_cache_context::llama_ik_cache_context( - llama_ik_cache * kv) : status(LLAMA_MEMORY_STATUS_SUCCESS), kv(kv) { - n_kv = kv->get_size(); - - const uint32_t n_stream = kv->get_n_stream(); - - // create a dummy slot info - the actual data is irrelevant. we just need to build the graph - sinfos.resize(1); - sinfos[0].s0 = 0; - sinfos[0].s1 = n_stream - 1; - sinfos[0].idxs.resize(n_stream); - for (uint32_t s = 0; s < n_stream; ++s) { - sinfos[0].strm.push_back(s); - sinfos[0].idxs[s].resize(1, 0); - } -} - -llama_ik_cache_context::llama_ik_cache_context( - llama_ik_cache * kv, - llama_context * lctx, - bool do_shift, - stream_copy_info sc_info) : status(LLAMA_MEMORY_STATUS_SUCCESS), kv(kv), lctx(lctx), do_shift(do_shift), sc_info(std::move(sc_info)) { - if (!do_shift && this->sc_info.empty()) { - status = LLAMA_MEMORY_STATUS_NO_UPDATE; - } -} - -llama_ik_cache_context::llama_ik_cache_context( - llama_ik_cache * kv, - llama_ik_cache::slot_info_vec_t sinfos, - std::vector ubatches) : status(LLAMA_MEMORY_STATUS_SUCCESS), kv(kv), sinfos(std::move(sinfos)), ubatches(std::move(ubatches)) { -} - -llama_ik_cache_context::~llama_ik_cache_context() = default; - -bool llama_ik_cache_context::next() { - assert(status == LLAMA_MEMORY_STATUS_SUCCESS); - - if (++i_cur >= ubatches.size()) { - return false; - } - - return true; -} - -bool llama_ik_cache_context::apply() { - assert(!llama_memory_status_is_fail(status)); - - // no ubatches -> this is a KV cache update - if (ubatches.empty()) { - kv->update(lctx, do_shift, sc_info); - - return true; - } - - kv->apply_ubatch(sinfos[i_cur], ubatches[i_cur]); - n_kv = kv->get_n_kv(sinfos[i_cur]); - - return true; -} - -llama_memory_status llama_ik_cache_context::get_status() const { - return status; -} - -const llama_ubatch & llama_ik_cache_context::get_ubatch() const { - assert(status == LLAMA_MEMORY_STATUS_SUCCESS); - - return ubatches[i_cur]; -} - -uint32_t llama_ik_cache_context::get_n_kv() const { - return n_kv; -} - -ggml_tensor * llama_ik_cache_context::get_k(ggml_context * ctx, int32_t il) const { - return kv->get_k(ctx, il, n_kv, sinfos[i_cur]); -} - -ggml_tensor * llama_ik_cache_context::cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il) const { - return kv->cpy_k(ctx, k_cur, k_idxs, il, sinfos[i_cur]); -} - -ggml_tensor * llama_ik_cache_context::build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const { - return kv->build_input_k_idxs(ctx, ubatch); -} - -void llama_ik_cache_context::set_input_k_shift(ggml_tensor * dst) const { - kv->set_input_k_shift(dst); -} - -void llama_ik_cache_context::set_input_k_idxs(ggml_tensor * dst, const llama_ubatch * ubatch) const { - kv->set_input_k_idxs(dst, ubatch, sinfos[i_cur]); -} - -void llama_ik_cache_context::set_input_kq_mask(ggml_tensor * dst, const llama_ubatch * ubatch, bool causal_attn) const { - kv->set_input_kq_mask(dst, ubatch, causal_attn); -} diff --git a/src/llama-ik-cache.h b/src/llama-ik-cache.h deleted file mode 100644 index b9cde569c06..00000000000 --- a/src/llama-ik-cache.h +++ /dev/null @@ -1,306 +0,0 @@ -#pragma once - -#include "llama-kv-cache.h" - -#include "llama-batch.h" -#include "llama-graph.h" -#include "llama-kv-cells.h" -#include "llama-memory.h" - -#include -#include - -struct llama_cparams; -struct llama_hparams; -struct llama_model; -struct llama_context; - -// -// llama_ik_cache -// - -class llama_ik_cache : public llama_memory_i { -public: - using stream_copy_info = llama_kv_cache::stream_copy_info; - using slot_info = llama_kv_cache::slot_info; - using slot_info_vec_t = std::vector; - - llama_ik_cache( - const llama_model & model, - ggml_type type_k, - ggml_type type_v, - bool v_trans, - bool offload, - bool unified, - uint32_t kv_size, - uint32_t n_seq_max, - uint32_t n_pad, - uint32_t n_swa, - llama_swa_type swa_type, - const layer_filter_cb & filter, - const layer_reuse_cb & reuse); - - ~llama_ik_cache() = default; - - // - // llama_memory_i - // - - llama_memory_context_ptr init_batch( - llama_batch_allocr & balloc, - uint32_t n_ubatch, - bool embd_all) override; - - llama_memory_context_ptr init_full() override; - - llama_memory_context_ptr init_update(llama_context * lctx, bool optimize) override; - - bool get_can_shift() const override; - - void clear(bool data) override; - - bool seq_rm (llama_seq_id seq_id, llama_pos p0, llama_pos p1) override; - void seq_cp (llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) override; - void seq_keep(llama_seq_id seq_id) override; - void seq_add (llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos shift) override; - void seq_div (llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) override; - - llama_pos seq_pos_min(llama_seq_id seq_id) const override; - llama_pos seq_pos_max(llama_seq_id seq_id) const override; - - std::map memory_breakdown() const override; - - // state write/load - - void state_write(llama_io_write_i & io, llama_seq_id seq_id = -1, llama_state_seq_flags flags = 0) const override; - void state_read (llama_io_read_i & io, llama_seq_id seq_id = -1, llama_state_seq_flags flags = 0) override; - - // - // llama_ik_cache specific API - // - - uint32_t get_size() const; - uint32_t get_n_stream() const; - - bool get_has_shift() const; - - // - // graph_build API - // - - uint32_t get_n_kv(const slot_info & sinfo) const; - - // get views of the current state of the cache - ggml_tensor * get_k(ggml_context * ctx, int32_t il, uint32_t n_kv, const slot_info & sinfo) const; - - // store k_cur and v_cur in the cache based on the provided head location - ggml_tensor * cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il, const slot_info & sinfo) const; - - // - // preparation API - // - - // find places for the provided ubatches in the cache, returns the slot infos - // return empty vector on failure - slot_info_vec_t prepare(const std::vector & ubatches); - - bool update(llama_context * lctx, bool do_shift, const stream_copy_info & sc_info); - - // find a slot of kv cells that can hold the ubatch - // if cont == true, then the slot must be continuous - // return empty slot_info on failure - slot_info find_slot(const llama_ubatch & ubatch, bool cont) const; - - // emplace the ubatch context into slot: [sinfo.idxs[0...ubatch.n_tokens - 1]] - void apply_ubatch(const slot_info & sinfo, const llama_ubatch & ubatch); - - // - // input API - // - - ggml_tensor * build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const; - - void set_input_k_idxs(ggml_tensor * dst, const llama_ubatch * ubatch, const slot_info & sinfo) const; - - void set_input_k_shift(ggml_tensor * dst) const; - - void set_input_kq_mask (ggml_tensor * dst, const llama_ubatch * ubatch, bool causal_attn) const; - -private: - const llama_model & model; - const llama_hparams & hparams; - - struct kv_layer { - // layer index in the model - // note: can be different from the layer index in the KV cache - uint32_t il; - - ggml_tensor * k; - - std::vector k_stream; - }; - - bool v_trans = true; // the value tensor is transposed - - const uint32_t n_seq_max = 1; - const uint32_t n_stream = 1; - - // required padding - const uint32_t n_pad = 1; - - // SWA - const uint32_t n_swa = 0; - - // env: LLAMA_KV_CACHE_DEBUG - int debug = 0; - - // this is the SWA type of the cache - not to be confused with the model SWA type - const llama_swa_type swa_type = LLAMA_SWA_TYPE_NONE; - - // ggml contexts for the KV cache along with the allocated backend buffers: - std::vector> ctxs_bufs; - - // the current index from where we start searching for a free slot in the ring buffer of KV cells (see find_slot()) - // note: this is not part of the KV state and it's only used to speed-up the find_slot() method - std::vector v_heads; - - std::vector v_cells; - - // maps from a sequence id to a stream id - std::vector seq_to_stream; - - // pending stream copies that will be applied during the next update - stream_copy_info sc_info; - - std::vector layers; - - // model layer id -> KV cache layer id - std::unordered_map map_layer_ids; - - size_t total_size() const; - - size_t size_k_bytes() const; - - ggml_tensor * build_rope_shift( - const llama_cparams & cparams, - ggml_context * ctx, - ggml_tensor * cur, - ggml_tensor * shift, - ggml_tensor * factors, - float freq_base, - float freq_scale, - uint32_t il) const; - - ggml_cgraph * build_graph_shift( - llm_graph_result * res, - llama_context * lctx) const; - - struct cell_ranges_t { - uint32_t strm; - - std::vector> data; // ranges, from inclusive, to exclusive - }; - - void state_write_meta(llama_io_write_i & io, const cell_ranges_t & cr, llama_seq_id seq_id = -1) const; - void state_write_data(llama_io_write_i & io, const cell_ranges_t & cr) const; - - bool state_read_meta(llama_io_read_i & io, uint32_t strm, uint32_t cell_count, slot_info & sinfo, llama_seq_id dest_seq_id = -1); - bool state_read_data(llama_io_read_i & io, uint32_t strm, uint32_t cell_count, const slot_info & sinfo); -}; - -class llama_ik_cache_context : public llama_memory_context_i { -public: - // some shorthands - using slot_info_vec_t = llama_kv_cache::slot_info_vec_t; - using stream_copy_info = llama_kv_cache::stream_copy_info; - - // used for errors - llama_ik_cache_context(llama_memory_status status); - - // used to create a full-cache context - llama_ik_cache_context( - llama_ik_cache * kv); - - // used to create an update context - llama_ik_cache_context( - llama_ik_cache * kv, - llama_context * lctx, - bool do_shift, - stream_copy_info sc_info); - - // used to create a batch processing context from a batch - llama_ik_cache_context( - llama_ik_cache * kv, - slot_info_vec_t sinfos, - std::vector ubatches); - - virtual ~llama_ik_cache_context(); - - // - // llama_memory_context_i - // - - bool next() override; - bool apply() override; - - llama_memory_status get_status() const override; - const llama_ubatch & get_ubatch() const override; - - // - // llama_ik_cache_context specific API - // - - uint32_t get_n_kv() const; - - // get views of the current state of the cache - ggml_tensor * get_k(ggml_context * ctx, int32_t il) const; - - // store k_cur and v_cur in the cache based on the provided head location - // note: the heads in k_cur and v_cur should be layed out contiguously in memory - // - k_cur [n_embd_head_k, n_head_k, n_tokens] - // - k_idxs [n_tokens] - ggml_tensor * cpy_k(ggml_context * ctx, ggml_tensor * k_cur, ggml_tensor * k_idxs, int32_t il) const; - - // create destination indices for each head of the current batch for where it would be written in the KV cache - // the indices address the global KV cache (not per stream) - this is not relevant for the user of this API, but - // helps understand the implementation logic of cpy_k - ggml_tensor * build_input_k_idxs(ggml_context * ctx, const llama_ubatch & ubatch) const; - - void set_input_k_idxs(ggml_tensor * dst, const llama_ubatch * ubatch) const; - - void set_input_k_shift (ggml_tensor * dst) const; - void set_input_kq_mask (ggml_tensor * dst, const llama_ubatch * ubatch, bool causal_attn) const; - -private: - llama_memory_status status; - - llama_ik_cache * kv; - llama_context * lctx; - - // - // update context - // - - bool do_shift = false; - - stream_copy_info sc_info; - - // - // batch processing context - // - - // the index of the cur ubatch to process - size_t i_cur = 0; - - slot_info_vec_t sinfos; - - std::vector ubatches; - - // - // data needed for building the compute graph for the current ubatch: - // - - // a heuristic, to avoid attending the full cache if it is not yet utilized - // as the cache gets filled, the benefit from this heuristic disappears - int32_t n_kv; -}; diff --git a/src/llama-kv-cache-dsa.cpp b/src/llama-kv-cache-dsa.cpp index 82dc15ff265..d1632dec879 100644 --- a/src/llama-kv-cache-dsa.cpp +++ b/src/llama-kv-cache-dsa.cpp @@ -25,19 +25,28 @@ llama_kv_cache_dsa::llama_kv_cache_dsa( llama_swa_type swa_type, const layer_filter_cb & filter, const layer_reuse_cb & reuse) : - n_stream(unified ? 1 : n_seq_max) { + hparams_ik(model.hparams), n_stream(unified ? 1 : n_seq_max) { LLAMA_LOG_INFO("%s: creating main KV cache, size = %u cells\n", __func__, kv_size); kv_base = std::make_unique( - model, type_k, type_v, + model, model.hparams, type_k, type_v, v_trans, offload, unified, kv_size, n_seq_max, n_pad, n_swa, swa_type, filter, reuse); + // we use llama_kv_cache for caching indexer keys + // by hand-tweaking some hparams we fool it to create + // indexer key cache tensors with correct dimensions + // https://github.com/ggml-org/llama.cpp/pull/21149#discussion_r3015940823 + + // DSA lightning indexer uses MQA with single key head + std::fill(hparams_ik.n_head_kv_arr.begin(), hparams_ik.n_head_kv_arr.end(), 1); + hparams_ik.n_embd_head_k_full = model.hparams.indexer_head_size; + LLAMA_LOG_INFO("%s: creating indexer KV cache, size = %u cells\n", __func__, kv_size); - kv_ik = std::make_unique( - model, type_k, type_v, + kv_ik = std::make_unique( + model, hparams_ik, type_k, type_v, v_trans, offload, unified, kv_size, n_seq_max, n_pad, n_swa, swa_type, filter, reuse); } @@ -164,7 +173,7 @@ llama_kv_cache * llama_kv_cache_dsa::get_base() const { return kv_base.get(); } -llama_ik_cache * llama_kv_cache_dsa::get_ik() const { +llama_kv_cache * llama_kv_cache_dsa::get_ik() const { return kv_ik.get(); } @@ -198,7 +207,7 @@ llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( ubatches(std::move(ubatches)), // note: here we copy the ubatches. not sure if this is ideal ctx_base(new llama_kv_cache_context(kv->get_base(), std::move(sinfos_base), this->ubatches)), - ctx_ik(new llama_ik_cache_context(kv->get_ik(), std::move(sinfos_ik), this->ubatches)), + ctx_ik(new llama_kv_cache_context(kv->get_ik(), std::move(sinfos_ik), this->ubatches)), status(llama_memory_status_combine(ctx_base->get_status(), ctx_ik->get_status())) { } @@ -244,8 +253,8 @@ const llama_kv_cache_context * llama_kv_cache_dsa_context::get_base() const { return static_cast(ctx_base.get()); } -const llama_ik_cache_context * llama_kv_cache_dsa_context::get_ik() const { +const llama_kv_cache_context * llama_kv_cache_dsa_context::get_ik() const { assert(status == LLAMA_MEMORY_STATUS_SUCCESS); - return static_cast(ctx_ik.get()); + return static_cast(ctx_ik.get()); } diff --git a/src/llama-kv-cache-dsa.h b/src/llama-kv-cache-dsa.h index 0ea209a5e83..d213e3ea4ef 100644 --- a/src/llama-kv-cache-dsa.h +++ b/src/llama-kv-cache-dsa.h @@ -1,7 +1,6 @@ #pragma once #include "llama-kv-cache.h" -#include "llama-ik-cache.h" #include @@ -9,7 +8,7 @@ // llama_kv_cache_dsa // -// utilizes two KV cache instances: llama_kv_cache and llama_ik_cache +// utilizes two KV cache instances: llama_kv_cache and llama_kv_cache // the first instance is for caching key tensors of the model, // the second instance is for caching lightning indexer key tensors @@ -70,13 +69,15 @@ class llama_kv_cache_dsa : public llama_memory_i { // llama_kv_cache * get_base() const; - llama_ik_cache * get_ik () const; + llama_kv_cache * get_ik () const; private: + // we keep indexer KV cache hparams instance here as llama_kv_cache stores only reference to it + llama_hparams hparams_ik; const uint32_t n_stream = 1; std::unique_ptr kv_base; - std::unique_ptr kv_ik; + std::unique_ptr kv_ik; }; class llama_kv_cache_dsa_context : public llama_memory_context_i { @@ -120,7 +121,7 @@ class llama_kv_cache_dsa_context : public llama_memory_context_i { // const llama_kv_cache_context * get_base() const; - const llama_ik_cache_context * get_ik() const; + const llama_kv_cache_context * get_ik() const; private: //llama_kv_cache_dsa * kv; diff --git a/src/llama-kv-cache-iswa.cpp b/src/llama-kv-cache-iswa.cpp index 26e2cb4270b..9b9f1790363 100644 --- a/src/llama-kv-cache-iswa.cpp +++ b/src/llama-kv-cache-iswa.cpp @@ -60,14 +60,14 @@ llama_kv_cache_iswa::llama_kv_cache_iswa( LLAMA_LOG_INFO("%s: creating non-SWA KV cache, size = %u cells\n", __func__, size_base); kv_base = std::make_unique( - model, type_k, type_v, + model, hparams, type_k, type_v, v_trans, offload, unified, size_base, n_seq_max, n_pad, 0, LLAMA_SWA_TYPE_NONE, filter_base, reuse); LLAMA_LOG_INFO("%s: creating SWA KV cache, size = %u cells\n", __func__, size_swa); kv_swa = std::make_unique( - model, type_k, type_v, + model, hparams, type_k, type_v, v_trans, offload, unified, size_swa, n_seq_max, n_pad, hparams.n_swa, hparams.swa_type, filter_swa, reuse); } diff --git a/src/llama-kv-cache.cpp b/src/llama-kv-cache.cpp index 5f57ba9e1d8..6b4a0254969 100644 --- a/src/llama-kv-cache.cpp +++ b/src/llama-kv-cache.cpp @@ -19,6 +19,7 @@ llama_kv_cache::llama_kv_cache( const llama_model & model, + const llama_hparams & hparams, ggml_type type_k, ggml_type type_v, bool v_trans, @@ -31,7 +32,7 @@ llama_kv_cache::llama_kv_cache( llama_swa_type swa_type, const layer_filter_cb & filter, const layer_reuse_cb & reuse) : - model(model), hparams(model.hparams), v_trans(v_trans), + model(model), hparams(hparams), v_trans(v_trans), n_seq_max(n_seq_max), n_stream(unified ? 1 : n_seq_max), n_pad(n_pad), n_swa(n_swa), swa_type(swa_type) { GGML_ASSERT(kv_size % n_pad == 0); @@ -181,7 +182,7 @@ llama_kv_cache::llama_kv_cache( // allocate tensors and initialize the buffers to avoid NaNs in the padding for (auto & [buft, ctx] : ctx_map) { ggml_backend_buffer_t buf; - if (model.hparams.no_alloc) { + if (hparams.no_alloc) { buf = ggml_backend_buft_alloc_buffer(buft, /*size =*/ 0); // dummy buffer for (ggml_tensor * t = ggml_get_first_tensor(ctx.get()); t != nullptr; t = ggml_get_next_tensor(ctx.get(), t)) { t->buffer = buf; // set dummy buffer for KV cache so that the backend scheduler won't try to allocate it diff --git a/src/llama-kv-cache.h b/src/llama-kv-cache.h index 33c78c5f210..aea78240dbb 100644 --- a/src/llama-kv-cache.h +++ b/src/llama-kv-cache.h @@ -95,6 +95,7 @@ class llama_kv_cache : public llama_memory_i { llama_kv_cache( const llama_model & model, + const llama_hparams & hparams, ggml_type type_k, ggml_type type_v, bool v_trans, diff --git a/src/llama-memory-hybrid.cpp b/src/llama-memory-hybrid.cpp index a1b45e4a3cc..cb739825f9b 100644 --- a/src/llama-memory-hybrid.cpp +++ b/src/llama-memory-hybrid.cpp @@ -32,6 +32,7 @@ llama_memory_hybrid::llama_memory_hybrid( hparams(model.hparams), mem_attn(new llama_kv_cache( model, + model.hparams, type_k, type_v, v_trans, diff --git a/src/llama-model.cpp b/src/llama-model.cpp index 65c5aa29baa..20e4e2ba08e 100644 --- a/src/llama-model.cpp +++ b/src/llama-model.cpp @@ -8436,6 +8436,7 @@ llama_memory_i * llama_model::create_memory(const llama_memory_params & params, res = new llama_kv_cache( *this, + hparams, params.type_k, params.type_v, !cparams.flash_attn, diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index 3f05264d703..d1c48816676 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -1,7 +1,6 @@ #include "models.h" #include "llama-kv-cache.h" -#include "llama-ik-cache.h" llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_graph_params & params) : llm_graph_context(params) { @@ -45,7 +44,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ // inp_pos - contains the positions ggml_tensor * inp_pos = build_inp_pos(); - std::pair inp_attn_dsa = build_attn_inp_k_dsa(); + std::pair inp_attn_dsa = build_attn_inp_k_dsa(); auto * inp_attn_k = inp_attn_dsa.first; auto * inp_attn_ik = inp_attn_dsa.second; @@ -190,7 +189,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_score, "indexer_score", il); // mask indexer scores - ggml_tensor * indexer_kq_mask = inp_attn_ik->get_kq_mask(); + ggml_tensor * indexer_kq_mask = inp_attn_ik->self_kq_mask; indexer_score = ggml_add(ctx0, indexer_score, indexer_kq_mask); cb(indexer_score, "indexer_score", il); From f443d0c7e34a070501b462e4a2fec37cc8d9cf7f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 1 Apr 2026 19:01:48 +0200 Subject: [PATCH 28/46] graph : implemented llm_graph_input_attn_k_dsa --- src/llama-graph.cpp | 61 +++++++++++++++++++++++++++++++++----- src/llama-graph.h | 42 ++++++++++++++++++++++++-- src/llama-kv-cache-dsa.cpp | 22 +++++++------- src/llama-kv-cache-dsa.h | 6 ++-- src/models/deepseek32.cpp | 17 +++++------ 5 files changed, 115 insertions(+), 33 deletions(-) diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index 9e87140c742..4dccf67a974 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -467,6 +467,32 @@ bool llm_graph_input_attn_k::can_reuse(const llm_graph_params & params) { return res; } +void llm_graph_input_attn_k_dsa::set_input(const llama_ubatch * ubatch) { + mctx->get_base()->set_input_k_idxs(self_k_idxs, ubatch); + + mctx->get_base()->set_input_kq_mask(self_kq_mask, ubatch, cparams.causal_attn); + + mctx->get_dsa()->set_input_k_idxs(self_k_idxs_dsa, ubatch); + + mctx->get_dsa()->set_input_kq_mask(self_kq_mask_dsa, ubatch, cparams.causal_attn); +} + +bool llm_graph_input_attn_k_dsa::can_reuse(const llm_graph_params & params) { + const auto * mctx = static_cast(params.mctx); + + this->mctx = mctx; + + bool res = true; + + res &= self_k_idxs->ne[0] == params.ubatch.n_tokens; + res &= self_k_idxs_dsa->ne[0] == params.ubatch.n_tokens; + + res &= can_reuse_kq_mask(self_kq_mask, mctx->get_base(), params.ubatch, params.cparams); + res &= can_reuse_kq_mask(self_kq_mask_dsa, mctx->get_dsa(), params.ubatch, params.cparams); + + return res; +} + void llm_graph_input_attn_kv_iswa::set_input(const llama_ubatch * ubatch) { mctx->get_base()->set_input_k_idxs(self_k_idxs, ubatch); mctx->get_base()->set_input_v_idxs(self_v_idxs, ubatch); @@ -2161,7 +2187,7 @@ ggml_tensor * llm_graph_context::build_attn( } ggml_tensor * llm_graph_context::build_attn( - llm_graph_input_attn_k * inp, + llm_graph_input_attn_k_dsa * inp, ggml_tensor * wo, ggml_tensor * wo_b, ggml_tensor * q_cur, @@ -2180,7 +2206,7 @@ ggml_tensor * llm_graph_context::build_attn( ggml_build_forward_expand(gf, v_cur); ggml_build_forward_expand(gf, k_cur); - const auto * mctx_cur = inp->mctx; + const auto * mctx_cur = inp->mctx->get_base(); // store to KV cache { @@ -2345,15 +2371,34 @@ ggml_tensor * llm_graph_context::build_attn( return cur; } -std::pair llm_graph_context::build_attn_inp_k_dsa() const { +llm_graph_input_attn_k_dsa * llm_graph_context::build_attn_inp_k_dsa() const { const auto * mctx_cur = static_cast(mctx); - auto inp_k = build_attn_inp_k_impl(ctx0, ubatch, hparams, cparams, mctx_cur->get_base()); - auto inp_ik = build_attn_inp_k_impl(ctx0, ubatch, hparams, cparams, mctx_cur->get_ik()); + auto inp = std::make_unique(hparams, cparams, mctx_cur); + + { + inp->self_k_idxs = mctx_cur->get_base()->build_input_k_idxs(ctx0, ubatch); + + inp->self_kq_mask = build_kq_mask(ctx0, mctx_cur->get_base(), ubatch, cparams); + ggml_set_input(inp->self_kq_mask); + ggml_set_name(inp->self_kq_mask, "self_kq_mask"); + + inp->self_kq_mask_cnv = cparams.flash_attn ? ggml_cast(ctx0, inp->self_kq_mask, GGML_TYPE_F16) : inp->self_kq_mask; + ggml_set_name(inp->self_kq_mask_cnv, "self_kq_mask_cnv"); + } + + { + inp->self_k_idxs_dsa = mctx_cur->get_dsa()->build_input_k_idxs(ctx0, ubatch); + + inp->self_kq_mask_dsa = build_kq_mask(ctx0, mctx_cur->get_dsa(), ubatch, cparams); + ggml_set_input(inp->self_kq_mask_dsa); + ggml_set_name(inp->self_kq_mask_dsa, "self_kq_mask_dsa"); + + inp->self_kq_mask_dsa_cnv = cparams.flash_attn ? ggml_cast(ctx0, inp->self_kq_mask_dsa, GGML_TYPE_F16) : inp->self_kq_mask_dsa; + ggml_set_name(inp->self_kq_mask_dsa_cnv, "self_kq_mask_dsa_cnv"); + } - return std::make_pair( - (llm_graph_input_attn_k *) res->add_input(std::move(inp_k)), - (llm_graph_input_attn_k *) res->add_input(std::move(inp_ik))); + return (llm_graph_input_attn_k_dsa *) res->add_input(std::move(inp)); } // TODO: maybe separate the inner implementation into a separate function diff --git a/src/llama-graph.h b/src/llama-graph.h index 249749a4f2a..0542ef5b51d 100644 --- a/src/llama-graph.h +++ b/src/llama-graph.h @@ -21,6 +21,7 @@ struct llama_cparams; struct llama_memory_context_i; class llama_kv_cache_context; +class llama_kv_cache_dsa_context; class llama_kv_cache_iswa_context; class llama_memory_recurrent_context; class llama_memory_hybrid_context; @@ -350,6 +351,43 @@ class llm_graph_input_attn_k : public llm_graph_input_i { const llama_kv_cache_context * mctx; }; +class llm_graph_input_attn_k_dsa : public llm_graph_input_i { +public: + llm_graph_input_attn_k_dsa( + const llama_hparams & hparams, + const llama_cparams & cparams, + const llama_kv_cache_dsa_context * mctx) : + hparams(hparams), + cparams(cparams), + mctx(mctx) { + } + ~llm_graph_input_attn_k_dsa() = default; + + void set_input(const llama_ubatch * ubatch) override; + + bool can_reuse(const llm_graph_params & params) override; + + ggml_tensor * get_k_idxs() const { return self_k_idxs; } + ggml_tensor * get_k_idxs_dsa() const { return self_k_idxs_dsa; } + + ggml_tensor * get_kq_mask() const { return self_kq_mask_cnv; } + ggml_tensor * get_kq_mask_dsa() const { return self_kq_mask_dsa; } + + ggml_tensor * self_k_idxs = nullptr; // I64 [n_batch] + ggml_tensor * self_k_idxs_dsa = nullptr; // I64 [n_batch] + + ggml_tensor * self_kq_mask = nullptr; // F32 [n_kv, n_batch/n_stream, 1, n_stream] + ggml_tensor * self_kq_mask_cnv = nullptr; // [n_kv, n_batch/n_stream, 1, n_stream] + ggml_tensor * self_kq_mask_dsa = nullptr; // F32 [n_kv, n_batch/n_stream, 1, n_stream] + ggml_tensor * self_kq_mask_dsa_cnv = nullptr; // [n_kv, n_batch/n_stream, 1, n_stream] + + const llama_hparams hparams; + const llama_cparams cparams; + + const llama_kv_cache_dsa_context * mctx; +}; + + class llm_graph_input_attn_kv_iswa : public llm_graph_input_i { public: llm_graph_input_attn_kv_iswa( @@ -922,7 +960,7 @@ struct llm_graph_context { int il) const; ggml_tensor * build_attn( - llm_graph_input_attn_k * inp, + llm_graph_input_attn_k_dsa * inp, ggml_tensor * wo, ggml_tensor * wo_b, ggml_tensor * q_cur, // [n_embd_head_q, n_head_q, n_tokens] @@ -966,7 +1004,7 @@ struct llm_graph_context { float kq_scale, int il) const; - std::pair build_attn_inp_k_dsa() const; + llm_graph_input_attn_k_dsa * build_attn_inp_k_dsa() const; // // recurrent diff --git a/src/llama-kv-cache-dsa.cpp b/src/llama-kv-cache-dsa.cpp index d1632dec879..c78306cad1c 100644 --- a/src/llama-kv-cache-dsa.cpp +++ b/src/llama-kv-cache-dsa.cpp @@ -173,7 +173,7 @@ llama_kv_cache * llama_kv_cache_dsa::get_base() const { return kv_base.get(); } -llama_kv_cache * llama_kv_cache_dsa::get_ik() const { +llama_kv_cache * llama_kv_cache_dsa::get_dsa() const { return kv_ik.get(); } @@ -186,8 +186,8 @@ llama_kv_cache_dsa_context::llama_kv_cache_dsa_context(llama_memory_status statu llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( llama_kv_cache_dsa * kv) : ctx_base(kv->get_base()->init_full()), - ctx_ik(kv->get_ik()->init_full()), - status(llama_memory_status_combine(ctx_base->get_status(), ctx_ik->get_status())) { + ctx_dsa(kv->get_dsa()->init_full()), + status(llama_memory_status_combine(ctx_base->get_status(), ctx_dsa->get_status())) { } llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( @@ -195,8 +195,8 @@ llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( llama_context * lctx, bool optimize) : ctx_base(kv->get_base()->init_update(lctx, optimize)), - ctx_ik(kv->get_ik()->init_update(lctx, optimize)), - status(llama_memory_status_combine(ctx_base->get_status(), ctx_ik->get_status())) { + ctx_dsa(kv->get_dsa()->init_update(lctx, optimize)), + status(llama_memory_status_combine(ctx_base->get_status(), ctx_dsa->get_status())) { } llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( @@ -207,8 +207,8 @@ llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( ubatches(std::move(ubatches)), // note: here we copy the ubatches. not sure if this is ideal ctx_base(new llama_kv_cache_context(kv->get_base(), std::move(sinfos_base), this->ubatches)), - ctx_ik(new llama_kv_cache_context(kv->get_ik(), std::move(sinfos_ik), this->ubatches)), - status(llama_memory_status_combine(ctx_base->get_status(), ctx_ik->get_status())) { + ctx_dsa(new llama_kv_cache_context(kv->get_dsa(), std::move(sinfos_ik), this->ubatches)), + status(llama_memory_status_combine(ctx_base->get_status(), ctx_dsa->get_status())) { } llama_kv_cache_dsa_context:: ~llama_kv_cache_dsa_context() = default; @@ -217,7 +217,7 @@ bool llama_kv_cache_dsa_context::next() { assert(status == LLAMA_MEMORY_STATUS_SUCCESS); ctx_base->next(); - ctx_ik ->next(); + ctx_dsa ->next(); if (++i_next >= ubatches.size()) { return false; @@ -232,7 +232,7 @@ bool llama_kv_cache_dsa_context::apply() { bool res = true; res = res & ctx_base->apply(); - res = res & ctx_ik ->apply(); + res = res & ctx_dsa ->apply(); return res; } @@ -253,8 +253,8 @@ const llama_kv_cache_context * llama_kv_cache_dsa_context::get_base() const { return static_cast(ctx_base.get()); } -const llama_kv_cache_context * llama_kv_cache_dsa_context::get_ik() const { +const llama_kv_cache_context * llama_kv_cache_dsa_context::get_dsa() const { assert(status == LLAMA_MEMORY_STATUS_SUCCESS); - return static_cast(ctx_ik.get()); + return static_cast(ctx_dsa.get()); } diff --git a/src/llama-kv-cache-dsa.h b/src/llama-kv-cache-dsa.h index d213e3ea4ef..404784a7836 100644 --- a/src/llama-kv-cache-dsa.h +++ b/src/llama-kv-cache-dsa.h @@ -69,7 +69,7 @@ class llama_kv_cache_dsa : public llama_memory_i { // llama_kv_cache * get_base() const; - llama_kv_cache * get_ik () const; + llama_kv_cache * get_dsa () const; private: // we keep indexer KV cache hparams instance here as llama_kv_cache stores only reference to it @@ -121,7 +121,7 @@ class llama_kv_cache_dsa_context : public llama_memory_context_i { // const llama_kv_cache_context * get_base() const; - const llama_kv_cache_context * get_ik() const; + const llama_kv_cache_context * get_dsa() const; private: //llama_kv_cache_dsa * kv; @@ -132,7 +132,7 @@ class llama_kv_cache_dsa_context : public llama_memory_context_i { std::vector ubatches; const llama_memory_context_ptr ctx_base; - const llama_memory_context_ptr ctx_ik; + const llama_memory_context_ptr ctx_dsa; const llama_memory_status status; }; diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index d1c48816676..aea6b9b5a7e 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -1,6 +1,7 @@ #include "models.h" #include "llama-kv-cache.h" +#include "llama-kv-cache-dsa.h" llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_graph_params & params) : llm_graph_context(params) { @@ -44,9 +45,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ // inp_pos - contains the positions ggml_tensor * inp_pos = build_inp_pos(); - std::pair inp_attn_dsa = build_attn_inp_k_dsa(); - auto * inp_attn_k = inp_attn_dsa.first; - auto * inp_attn_ik = inp_attn_dsa.second; + llm_graph_input_attn_k_dsa * inp_attn_dsa = build_attn_inp_k_dsa(); ggml_tensor * inp_out_ids = build_inp_out_ids(); @@ -134,9 +133,9 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_k, "indexer_k", il); // store indexer keys to KV cache - const auto * mctx_cur = inp_attn_ik->mctx; - const auto & k_idxs = inp_attn_ik->get_k_idxs(); - ggml_build_forward_expand(gf, mctx_cur->cpy_k(ctx0, indexer_k, k_idxs, il)); + const auto * mctx_dsa = inp_attn_dsa->mctx->get_dsa(); + const auto & k_idxs = inp_attn_dsa->get_k_idxs_dsa(); + ggml_build_forward_expand(gf, mctx_dsa->cpy_k(ctx0, indexer_k, k_idxs, il)); // prepare indexer weights ggml_tensor * indexer_weights = ggml_mul_mat(ctx0, model.layers[il].indexer_proj, cur); @@ -146,7 +145,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_weights, "indexer_weights", il); // get cached indexer keys - indexer_k = mctx_cur->get_k(ctx0, il); + indexer_k = mctx_dsa->get_k(ctx0, il); // split the batch into streams if needed const auto n_stream = indexer_k->ne[3]; @@ -189,7 +188,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_score, "indexer_score", il); // mask indexer scores - ggml_tensor * indexer_kq_mask = inp_attn_ik->self_kq_mask; + ggml_tensor * indexer_kq_mask = inp_attn_dsa->get_kq_mask_dsa(); indexer_score = ggml_add(ctx0, indexer_score, indexer_kq_mask); cb(indexer_score, "indexer_score", il); @@ -272,7 +271,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(Vcur, "Vcur", il); // note: MLA with the absorption optimization converts into MQA (ie: GQA with 1 group) - cur = build_attn(inp_attn_k, + cur = build_attn(inp_attn_dsa, model.layers[il].wo, NULL, Qcur, Kcur, Vcur, nullptr, nullptr, model.layers[il].wv_b, top_k, kq_scale, il); } From d3236d8986640efa35105239ef267fd828fe560d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 1 Apr 2026 21:31:49 +0200 Subject: [PATCH 29/46] graph : renamed DSA-related suffixes, since in DSA-related classes _base/no suffix was used for MLA part and _dsa/_ik were used for lightning indexer part, to make names more obvious I renamed _base/no suffix to _mla and _dsa/_ik to _lid. --- src/llama-graph.cpp | 46 +++++++-------- src/llama-graph.h | 24 ++++---- src/llama-kv-cache-dsa.cpp | 116 ++++++++++++++++++------------------- src/llama-kv-cache-dsa.h | 18 +++--- src/models/deepseek32.cpp | 10 ++-- 5 files changed, 107 insertions(+), 107 deletions(-) diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index 4dccf67a974..66771fd803f 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -468,13 +468,13 @@ bool llm_graph_input_attn_k::can_reuse(const llm_graph_params & params) { } void llm_graph_input_attn_k_dsa::set_input(const llama_ubatch * ubatch) { - mctx->get_base()->set_input_k_idxs(self_k_idxs, ubatch); + mctx->get_mla()->set_input_k_idxs(self_k_idxs_mla, ubatch); - mctx->get_base()->set_input_kq_mask(self_kq_mask, ubatch, cparams.causal_attn); + mctx->get_mla()->set_input_kq_mask(self_kq_mask_mla, ubatch, cparams.causal_attn); - mctx->get_dsa()->set_input_k_idxs(self_k_idxs_dsa, ubatch); + mctx->get_lid()->set_input_k_idxs(self_k_idxs_lid, ubatch); - mctx->get_dsa()->set_input_kq_mask(self_kq_mask_dsa, ubatch, cparams.causal_attn); + mctx->get_lid()->set_input_kq_mask(self_kq_mask_lid, ubatch, cparams.causal_attn); } bool llm_graph_input_attn_k_dsa::can_reuse(const llm_graph_params & params) { @@ -484,11 +484,11 @@ bool llm_graph_input_attn_k_dsa::can_reuse(const llm_graph_params & params) { bool res = true; - res &= self_k_idxs->ne[0] == params.ubatch.n_tokens; - res &= self_k_idxs_dsa->ne[0] == params.ubatch.n_tokens; + res &= self_k_idxs_mla->ne[0] == params.ubatch.n_tokens; + res &= self_k_idxs_lid->ne[0] == params.ubatch.n_tokens; - res &= can_reuse_kq_mask(self_kq_mask, mctx->get_base(), params.ubatch, params.cparams); - res &= can_reuse_kq_mask(self_kq_mask_dsa, mctx->get_dsa(), params.ubatch, params.cparams); + res &= can_reuse_kq_mask(self_kq_mask_mla, mctx->get_mla(), params.ubatch, params.cparams); + res &= can_reuse_kq_mask(self_kq_mask_lid, mctx->get_lid(), params.ubatch, params.cparams); return res; } @@ -2206,16 +2206,16 @@ ggml_tensor * llm_graph_context::build_attn( ggml_build_forward_expand(gf, v_cur); ggml_build_forward_expand(gf, k_cur); - const auto * mctx_cur = inp->mctx->get_base(); + const auto * mctx_cur = inp->mctx->get_mla(); // store to KV cache { - const auto & k_idxs = inp->get_k_idxs(); + const auto & k_idxs = inp->get_k_idxs_mla(); ggml_build_forward_expand(gf, mctx_cur->cpy_k(ctx0, k_cur, k_idxs, il)); } - const auto & kq_mask = inp->get_kq_mask(); + const auto & kq_mask = inp->get_kq_mask_mla(); // prepare new kq mask - starts filled with -INFINITY ggml_tensor * kq_mask_all = ggml_fill(ctx0, kq_mask, -INFINITY); @@ -2377,25 +2377,25 @@ llm_graph_input_attn_k_dsa * llm_graph_context::build_attn_inp_k_dsa() const { auto inp = std::make_unique(hparams, cparams, mctx_cur); { - inp->self_k_idxs = mctx_cur->get_base()->build_input_k_idxs(ctx0, ubatch); + inp->self_k_idxs_mla = mctx_cur->get_mla()->build_input_k_idxs(ctx0, ubatch); - inp->self_kq_mask = build_kq_mask(ctx0, mctx_cur->get_base(), ubatch, cparams); - ggml_set_input(inp->self_kq_mask); - ggml_set_name(inp->self_kq_mask, "self_kq_mask"); + inp->self_kq_mask_mla = build_kq_mask(ctx0, mctx_cur->get_mla(), ubatch, cparams); + ggml_set_input(inp->self_kq_mask_mla); + ggml_set_name(inp->self_kq_mask_mla, "self_kq_mask_mla"); - inp->self_kq_mask_cnv = cparams.flash_attn ? ggml_cast(ctx0, inp->self_kq_mask, GGML_TYPE_F16) : inp->self_kq_mask; - ggml_set_name(inp->self_kq_mask_cnv, "self_kq_mask_cnv"); + inp->self_kq_mask_mla_cnv = cparams.flash_attn ? ggml_cast(ctx0, inp->self_kq_mask_mla, GGML_TYPE_F16) : inp->self_kq_mask_mla; + ggml_set_name(inp->self_kq_mask_mla_cnv, "self_kq_mask_mla_cnv"); } { - inp->self_k_idxs_dsa = mctx_cur->get_dsa()->build_input_k_idxs(ctx0, ubatch); + inp->self_k_idxs_lid = mctx_cur->get_lid()->build_input_k_idxs(ctx0, ubatch); - inp->self_kq_mask_dsa = build_kq_mask(ctx0, mctx_cur->get_dsa(), ubatch, cparams); - ggml_set_input(inp->self_kq_mask_dsa); - ggml_set_name(inp->self_kq_mask_dsa, "self_kq_mask_dsa"); + inp->self_kq_mask_lid = build_kq_mask(ctx0, mctx_cur->get_lid(), ubatch, cparams); + ggml_set_input(inp->self_kq_mask_lid); + ggml_set_name(inp->self_kq_mask_lid, "self_kq_mask_lid"); - inp->self_kq_mask_dsa_cnv = cparams.flash_attn ? ggml_cast(ctx0, inp->self_kq_mask_dsa, GGML_TYPE_F16) : inp->self_kq_mask_dsa; - ggml_set_name(inp->self_kq_mask_dsa_cnv, "self_kq_mask_dsa_cnv"); + inp->self_kq_mask_lid_cnv = cparams.flash_attn ? ggml_cast(ctx0, inp->self_kq_mask_lid, GGML_TYPE_F16) : inp->self_kq_mask_lid; + ggml_set_name(inp->self_kq_mask_lid_cnv, "self_kq_mask_lid_cnv"); } return (llm_graph_input_attn_k_dsa *) res->add_input(std::move(inp)); diff --git a/src/llama-graph.h b/src/llama-graph.h index 0542ef5b51d..928c1d6e1d9 100644 --- a/src/llama-graph.h +++ b/src/llama-graph.h @@ -367,19 +367,19 @@ class llm_graph_input_attn_k_dsa : public llm_graph_input_i { bool can_reuse(const llm_graph_params & params) override; - ggml_tensor * get_k_idxs() const { return self_k_idxs; } - ggml_tensor * get_k_idxs_dsa() const { return self_k_idxs_dsa; } + ggml_tensor * get_k_idxs_mla() const { return self_k_idxs_mla; } + ggml_tensor * get_k_idxs_lid() const { return self_k_idxs_lid; } - ggml_tensor * get_kq_mask() const { return self_kq_mask_cnv; } - ggml_tensor * get_kq_mask_dsa() const { return self_kq_mask_dsa; } + ggml_tensor * get_kq_mask_mla() const { return self_kq_mask_mla_cnv; } + ggml_tensor * get_kq_mask_lid() const { return self_kq_mask_lid; } - ggml_tensor * self_k_idxs = nullptr; // I64 [n_batch] - ggml_tensor * self_k_idxs_dsa = nullptr; // I64 [n_batch] + ggml_tensor * self_k_idxs_mla = nullptr; // I64 [n_batch] + ggml_tensor * self_k_idxs_lid = nullptr; // I64 [n_batch] - ggml_tensor * self_kq_mask = nullptr; // F32 [n_kv, n_batch/n_stream, 1, n_stream] - ggml_tensor * self_kq_mask_cnv = nullptr; // [n_kv, n_batch/n_stream, 1, n_stream] - ggml_tensor * self_kq_mask_dsa = nullptr; // F32 [n_kv, n_batch/n_stream, 1, n_stream] - ggml_tensor * self_kq_mask_dsa_cnv = nullptr; // [n_kv, n_batch/n_stream, 1, n_stream] + ggml_tensor * self_kq_mask_mla = nullptr; // F32 [n_kv, n_batch/n_stream, 1, n_stream] + ggml_tensor * self_kq_mask_mla_cnv = nullptr; // [n_kv, n_batch/n_stream, 1, n_stream] + ggml_tensor * self_kq_mask_lid = nullptr; // F32 [n_kv, n_batch/n_stream, 1, n_stream] + ggml_tensor * self_kq_mask_lid_cnv = nullptr; // [n_kv, n_batch/n_stream, 1, n_stream] const llama_hparams hparams; const llama_cparams cparams; @@ -959,6 +959,8 @@ struct llm_graph_context { float kq_scale, int il) const; + llm_graph_input_attn_k_dsa * build_attn_inp_k_dsa() const; + ggml_tensor * build_attn( llm_graph_input_attn_k_dsa * inp, ggml_tensor * wo, @@ -1004,8 +1006,6 @@ struct llm_graph_context { float kq_scale, int il) const; - llm_graph_input_attn_k_dsa * build_attn_inp_k_dsa() const; - // // recurrent // diff --git a/src/llama-kv-cache-dsa.cpp b/src/llama-kv-cache-dsa.cpp index c78306cad1c..a7d9513917d 100644 --- a/src/llama-kv-cache-dsa.cpp +++ b/src/llama-kv-cache-dsa.cpp @@ -25,11 +25,11 @@ llama_kv_cache_dsa::llama_kv_cache_dsa( llama_swa_type swa_type, const layer_filter_cb & filter, const layer_reuse_cb & reuse) : - hparams_ik(model.hparams), n_stream(unified ? 1 : n_seq_max) { + hparams_lid(model.hparams), n_stream(unified ? 1 : n_seq_max) { LLAMA_LOG_INFO("%s: creating main KV cache, size = %u cells\n", __func__, kv_size); - kv_base = std::make_unique( + kv_mla = std::make_unique( model, model.hparams, type_k, type_v, v_trans, offload, unified, kv_size, n_seq_max, n_pad, n_swa, swa_type, filter, reuse); @@ -40,62 +40,62 @@ llama_kv_cache_dsa::llama_kv_cache_dsa( // https://github.com/ggml-org/llama.cpp/pull/21149#discussion_r3015940823 // DSA lightning indexer uses MQA with single key head - std::fill(hparams_ik.n_head_kv_arr.begin(), hparams_ik.n_head_kv_arr.end(), 1); - hparams_ik.n_embd_head_k_full = model.hparams.indexer_head_size; + std::fill(hparams_lid.n_head_kv_arr.begin(), hparams_lid.n_head_kv_arr.end(), 1); + hparams_lid.n_embd_head_k_full = model.hparams.indexer_head_size; LLAMA_LOG_INFO("%s: creating indexer KV cache, size = %u cells\n", __func__, kv_size); - kv_ik = std::make_unique( - model, hparams_ik, type_k, type_v, + kv_lid = std::make_unique( + model, hparams_lid, type_k, type_v, v_trans, offload, unified, kv_size, n_seq_max, n_pad, n_swa, swa_type, filter, reuse); } void llama_kv_cache_dsa::clear(bool data) { - kv_base->clear(data); - kv_ik ->clear(data); + kv_mla->clear(data); + kv_lid->clear(data); } bool llama_kv_cache_dsa::seq_rm(llama_seq_id seq_id, llama_pos p0, llama_pos p1) { bool res = true; - res = res & kv_base->seq_rm(seq_id, p0, p1); - res = res & kv_ik ->seq_rm(seq_id, p0, p1); + res = res & kv_mla->seq_rm(seq_id, p0, p1); + res = res & kv_lid->seq_rm(seq_id, p0, p1); return res; } void llama_kv_cache_dsa::seq_cp(llama_seq_id seq_id_src, llama_seq_id seq_id_dst, llama_pos p0, llama_pos p1) { - kv_base->seq_cp(seq_id_src, seq_id_dst, p0, p1); - kv_ik ->seq_cp(seq_id_src, seq_id_dst, p0, p1); + kv_mla->seq_cp(seq_id_src, seq_id_dst, p0, p1); + kv_lid->seq_cp(seq_id_src, seq_id_dst, p0, p1); } void llama_kv_cache_dsa::seq_keep(llama_seq_id seq_id) { - kv_base->seq_keep(seq_id); - kv_ik ->seq_keep(seq_id); + kv_mla->seq_keep(seq_id); + kv_lid->seq_keep(seq_id); } void llama_kv_cache_dsa::seq_add(llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos shift) { - kv_base->seq_add(seq_id, p0, p1, shift); - kv_ik ->seq_add(seq_id, p0, p1, shift); + kv_mla->seq_add(seq_id, p0, p1, shift); + kv_lid->seq_add(seq_id, p0, p1, shift); } void llama_kv_cache_dsa::seq_div(llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d) { - kv_base->seq_div(seq_id, p0, p1, d); - kv_ik ->seq_div(seq_id, p0, p1, d); + kv_mla->seq_div(seq_id, p0, p1, d); + kv_lid->seq_div(seq_id, p0, p1, d); } llama_pos llama_kv_cache_dsa::seq_pos_min(llama_seq_id seq_id) const { - return kv_base->seq_pos_min(seq_id); + return kv_mla->seq_pos_min(seq_id); } llama_pos llama_kv_cache_dsa::seq_pos_max(llama_seq_id seq_id) const { - return kv_base->seq_pos_max(seq_id); + return kv_mla->seq_pos_max(seq_id); } std::map llama_kv_cache_dsa::memory_breakdown() const { - std::map mb = kv_base->memory_breakdown(); - for (const auto & buft_size : kv_ik->memory_breakdown()) { + std::map mb = kv_mla->memory_breakdown(); + for (const auto & buft_size : kv_lid->memory_breakdown()) { mb[buft_size.first] += buft_size.second; } return mb; @@ -126,20 +126,20 @@ llama_memory_context_ptr llama_kv_cache_dsa::init_batch( break; } - auto sinfos_base = kv_base->prepare(ubatches); - if (sinfos_base.empty()) { + auto sinfos_mla = kv_mla->prepare(ubatches); + if (sinfos_mla.empty()) { break; } - auto sinfos_ik = kv_ik->prepare(ubatches); - if (sinfos_ik.empty()) { + auto sinfos_lid = kv_lid->prepare(ubatches); + if (sinfos_lid.empty()) { break; } - assert(sinfos_base.size() == sinfos_ik.size()); + assert(sinfos_mla.size() == sinfos_lid.size()); return std::make_unique( - this, std::move(sinfos_base), std::move(sinfos_ik), std::move(ubatches)); + this, std::move(sinfos_mla), std::move(sinfos_lid), std::move(ubatches)); } while (false); return std::make_unique(LLAMA_MEMORY_STATUS_FAILED_PREPARE); @@ -154,27 +154,27 @@ llama_memory_context_ptr llama_kv_cache_dsa::init_update(llama_context * lctx, b } bool llama_kv_cache_dsa::get_can_shift() const { - return kv_base->get_can_shift() && - kv_ik->get_can_shift() && - kv_base->get_size() == kv_ik->get_size(); + return kv_mla->get_can_shift() && + kv_lid->get_can_shift() && + kv_mla->get_size() == kv_lid->get_size(); } void llama_kv_cache_dsa::state_write(llama_io_write_i & io, llama_seq_id seq_id, llama_state_seq_flags flags) const { - kv_base->state_write(io, seq_id, flags); - kv_ik->state_write(io, seq_id, flags); + kv_mla->state_write(io, seq_id, flags); + kv_lid->state_write(io, seq_id, flags); } void llama_kv_cache_dsa::state_read(llama_io_read_i & io, llama_seq_id seq_id, llama_state_seq_flags flags) { - kv_base->state_read(io, seq_id, flags); - kv_ik->state_read(io, seq_id, flags); + kv_mla->state_read(io, seq_id, flags); + kv_lid->state_read(io, seq_id, flags); } -llama_kv_cache * llama_kv_cache_dsa::get_base() const { - return kv_base.get(); +llama_kv_cache * llama_kv_cache_dsa::get_mla() const { + return kv_mla.get(); } -llama_kv_cache * llama_kv_cache_dsa::get_dsa() const { - return kv_ik.get(); +llama_kv_cache * llama_kv_cache_dsa::get_lid() const { + return kv_lid.get(); } // @@ -185,30 +185,30 @@ llama_kv_cache_dsa_context::llama_kv_cache_dsa_context(llama_memory_status statu llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( llama_kv_cache_dsa * kv) : - ctx_base(kv->get_base()->init_full()), - ctx_dsa(kv->get_dsa()->init_full()), - status(llama_memory_status_combine(ctx_base->get_status(), ctx_dsa->get_status())) { + ctx_mla(kv->get_mla()->init_full()), + ctx_lid(kv->get_lid()->init_full()), + status(llama_memory_status_combine(ctx_mla->get_status(), ctx_lid->get_status())) { } llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( llama_kv_cache_dsa * kv, llama_context * lctx, bool optimize) : - ctx_base(kv->get_base()->init_update(lctx, optimize)), - ctx_dsa(kv->get_dsa()->init_update(lctx, optimize)), - status(llama_memory_status_combine(ctx_base->get_status(), ctx_dsa->get_status())) { + ctx_mla(kv->get_mla()->init_update(lctx, optimize)), + ctx_lid(kv->get_lid()->init_update(lctx, optimize)), + status(llama_memory_status_combine(ctx_mla->get_status(), ctx_lid->get_status())) { } llama_kv_cache_dsa_context::llama_kv_cache_dsa_context( llama_kv_cache_dsa * kv, - slot_info_vec_t sinfos_base, - slot_info_vec_t sinfos_ik, + slot_info_vec_t sinfos_mla, + slot_info_vec_t sinfos_lid, std::vector ubatches) : ubatches(std::move(ubatches)), // note: here we copy the ubatches. not sure if this is ideal - ctx_base(new llama_kv_cache_context(kv->get_base(), std::move(sinfos_base), this->ubatches)), - ctx_dsa(new llama_kv_cache_context(kv->get_dsa(), std::move(sinfos_ik), this->ubatches)), - status(llama_memory_status_combine(ctx_base->get_status(), ctx_dsa->get_status())) { + ctx_mla(new llama_kv_cache_context(kv->get_mla(), std::move(sinfos_mla), this->ubatches)), + ctx_lid(new llama_kv_cache_context(kv->get_lid(), std::move(sinfos_lid), this->ubatches)), + status(llama_memory_status_combine(ctx_mla->get_status(), ctx_lid->get_status())) { } llama_kv_cache_dsa_context:: ~llama_kv_cache_dsa_context() = default; @@ -216,8 +216,8 @@ llama_kv_cache_dsa_context:: ~llama_kv_cache_dsa_context() = default; bool llama_kv_cache_dsa_context::next() { assert(status == LLAMA_MEMORY_STATUS_SUCCESS); - ctx_base->next(); - ctx_dsa ->next(); + ctx_mla->next(); + ctx_lid->next(); if (++i_next >= ubatches.size()) { return false; @@ -231,8 +231,8 @@ bool llama_kv_cache_dsa_context::apply() { bool res = true; - res = res & ctx_base->apply(); - res = res & ctx_dsa ->apply(); + res = res & ctx_mla->apply(); + res = res & ctx_lid->apply(); return res; } @@ -247,14 +247,14 @@ const llama_ubatch & llama_kv_cache_dsa_context::get_ubatch() const { return ubatches[i_next]; } -const llama_kv_cache_context * llama_kv_cache_dsa_context::get_base() const { +const llama_kv_cache_context * llama_kv_cache_dsa_context::get_mla() const { assert(status == LLAMA_MEMORY_STATUS_SUCCESS); - return static_cast(ctx_base.get()); + return static_cast(ctx_mla.get()); } -const llama_kv_cache_context * llama_kv_cache_dsa_context::get_dsa() const { +const llama_kv_cache_context * llama_kv_cache_dsa_context::get_lid() const { assert(status == LLAMA_MEMORY_STATUS_SUCCESS); - return static_cast(ctx_dsa.get()); + return static_cast(ctx_lid.get()); } diff --git a/src/llama-kv-cache-dsa.h b/src/llama-kv-cache-dsa.h index 404784a7836..6d57c741967 100644 --- a/src/llama-kv-cache-dsa.h +++ b/src/llama-kv-cache-dsa.h @@ -68,16 +68,16 @@ class llama_kv_cache_dsa : public llama_memory_i { // llama_kv_cache_dsa specific API // - llama_kv_cache * get_base() const; - llama_kv_cache * get_dsa () const; + llama_kv_cache * get_mla() const; + llama_kv_cache * get_lid() const; private: // we keep indexer KV cache hparams instance here as llama_kv_cache stores only reference to it - llama_hparams hparams_ik; + llama_hparams hparams_lid; const uint32_t n_stream = 1; - std::unique_ptr kv_base; - std::unique_ptr kv_ik; + std::unique_ptr kv_mla; + std::unique_ptr kv_lid; }; class llama_kv_cache_dsa_context : public llama_memory_context_i { @@ -120,8 +120,8 @@ class llama_kv_cache_dsa_context : public llama_memory_context_i { // llama_kv_cache_dsa_context specific API // - const llama_kv_cache_context * get_base() const; - const llama_kv_cache_context * get_dsa() const; + const llama_kv_cache_context * get_mla() const; + const llama_kv_cache_context * get_lid() const; private: //llama_kv_cache_dsa * kv; @@ -131,8 +131,8 @@ class llama_kv_cache_dsa_context : public llama_memory_context_i { std::vector ubatches; - const llama_memory_context_ptr ctx_base; - const llama_memory_context_ptr ctx_dsa; + const llama_memory_context_ptr ctx_mla; + const llama_memory_context_ptr ctx_lid; const llama_memory_status status; }; diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index aea6b9b5a7e..16822fca4ba 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -133,9 +133,9 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_k, "indexer_k", il); // store indexer keys to KV cache - const auto * mctx_dsa = inp_attn_dsa->mctx->get_dsa(); - const auto & k_idxs = inp_attn_dsa->get_k_idxs_dsa(); - ggml_build_forward_expand(gf, mctx_dsa->cpy_k(ctx0, indexer_k, k_idxs, il)); + const auto * mctx_lid = inp_attn_dsa->mctx->get_lid(); + const auto & k_idxs_lid = inp_attn_dsa->get_k_idxs_lid(); + ggml_build_forward_expand(gf, mctx_lid->cpy_k(ctx0, indexer_k, k_idxs_lid, il)); // prepare indexer weights ggml_tensor * indexer_weights = ggml_mul_mat(ctx0, model.layers[il].indexer_proj, cur); @@ -145,7 +145,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_weights, "indexer_weights", il); // get cached indexer keys - indexer_k = mctx_dsa->get_k(ctx0, il); + indexer_k = mctx_lid->get_k(ctx0, il); // split the batch into streams if needed const auto n_stream = indexer_k->ne[3]; @@ -188,7 +188,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_score, "indexer_score", il); // mask indexer scores - ggml_tensor * indexer_kq_mask = inp_attn_dsa->get_kq_mask_dsa(); + ggml_tensor * indexer_kq_mask = inp_attn_dsa->get_kq_mask_lid(); indexer_score = ggml_add(ctx0, indexer_score, indexer_kq_mask); cb(indexer_score, "indexer_score", il); From 5086217234311a750d14807b5c970c558f9dd895 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Thu, 2 Apr 2026 09:56:33 +0200 Subject: [PATCH 30/46] llama : handle LLM_ARCH_DEEPSEEK32 in test-llama-archs --- tests/test-llama-archs.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/test-llama-archs.cpp b/tests/test-llama-archs.cpp index df21ced74be..598a562215f 100644 --- a/tests/test-llama-archs.cpp +++ b/tests/test-llama-archs.cpp @@ -92,6 +92,7 @@ static gguf_context_ptr get_gguf_ctx(const llm_arch arch, const bool moe) { n_ff = 96; n_layer = 22; // hparams.n_layer_kv_from_start = 20 is hardcoded } else if (arch == LLM_ARCH_DEEPSEEK2 + || arch == LLM_ARCH_DEEPSEEK32 || arch == LLM_ARCH_GLM_DSA || arch == LLM_ARCH_KIMI_LINEAR || arch == LLM_ARCH_MISTRAL4) { @@ -148,6 +149,7 @@ static gguf_context_ptr get_gguf_ctx(const llm_arch arch, const bool moe) { ms.add_kv(LLM_KV_ATTENTION_MAX_ALIBI_BIAS, 8.0f); if (arch == LLM_ARCH_DEEPSEEK2 + || arch == LLM_ARCH_DEEPSEEK32 || arch == LLM_ARCH_GLM_DSA || arch == LLM_ARCH_KIMI_LINEAR || arch == LLM_ARCH_MISTRAL4) { @@ -311,6 +313,7 @@ static bool moe_mandatory(const llm_arch arch) { case LLM_ARCH_ARCTIC: case LLM_ARCH_DEEPSEEK: case LLM_ARCH_DEEPSEEK2: + case LLM_ARCH_DEEPSEEK32: case LLM_ARCH_GLM4_MOE: case LLM_ARCH_GLM_DSA: case LLM_ARCH_EXAONE_MOE: From a7820f6db7d3ee6ab2e9532f4d3f1fe33f4d6d78 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Thu, 2 Apr 2026 09:59:21 +0200 Subject: [PATCH 31/46] model : replace ggml_hadamard() in DEEPSEEK32 with Hadamard rotation matrix multiplication. ggml : remove unused GGML_OP_HADAMARD --- ggml/include/ggml.h | 6 --- ggml/src/ggml-cpu/ggml-cpu.c | 5 --- ggml/src/ggml-cpu/ops.cpp | 79 --------------------------------- ggml/src/ggml-cpu/ops.h | 1 - ggml/src/ggml-cuda/ggml-cuda.cu | 8 ---- ggml/src/ggml-cuda/hadamard.cu | 73 ------------------------------ ggml/src/ggml-cuda/hadamard.cuh | 3 -- ggml/src/ggml.c | 28 +----------- src/llama-graph.cpp | 12 ++--- src/llama-graph.h | 2 + src/llama-kv-cache.cpp | 5 +++ src/models/deepseek32.cpp | 4 +- tests/test-backend-ops.cpp | 39 ---------------- 13 files changed, 15 insertions(+), 250 deletions(-) delete mode 100644 ggml/src/ggml-cuda/hadamard.cu delete mode 100644 ggml/src/ggml-cuda/hadamard.cuh diff --git a/ggml/include/ggml.h b/ggml/include/ggml.h index 9f1604875a2..2a484a5c466 100644 --- a/ggml/include/ggml.h +++ b/ggml/include/ggml.h @@ -559,7 +559,6 @@ extern "C" { GGML_OP_RWKV_WKV7, GGML_OP_SOLVE_TRI, GGML_OP_GATED_DELTA_NET, - GGML_OP_HADAMARD, GGML_OP_SCATTER, GGML_OP_UNARY, @@ -2483,11 +2482,6 @@ extern "C" { struct ggml_tensor * beta, struct ggml_tensor * state); - GGML_API struct ggml_tensor * ggml_hadamard( - struct ggml_context * ctx, - struct ggml_tensor * a, - int n); - GGML_API struct ggml_tensor * ggml_scatter( struct ggml_context * ctx, struct ggml_tensor * a, diff --git a/ggml/src/ggml-cpu/ggml-cpu.c b/ggml/src/ggml-cpu/ggml-cpu.c index 26ae243ec60..8f659dfda50 100644 --- a/ggml/src/ggml-cpu/ggml-cpu.c +++ b/ggml/src/ggml-cpu/ggml-cpu.c @@ -2031,10 +2031,6 @@ static void ggml_compute_forward(struct ggml_compute_params * params, struct ggm { ggml_compute_forward_gated_delta_net(params, tensor); } break; - case GGML_OP_HADAMARD: - { - ggml_compute_forward_hadamard(params, tensor); - } break; case GGML_OP_SCATTER: { ggml_compute_forward_scatter(params, tensor); @@ -2358,7 +2354,6 @@ static int ggml_get_n_tasks(struct ggml_tensor * node, int n_threads) { case GGML_OP_FLASH_ATTN_BACK: case GGML_OP_SSM_CONV: case GGML_OP_SSM_SCAN: - case GGML_OP_HADAMARD: case GGML_OP_SCATTER: { n_tasks = n_threads; diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index 58a1cc1e4e7..0e278a354aa 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11240,85 +11240,6 @@ void ggml_compute_forward_opt_step_sgd(const ggml_compute_params * params, ggml_ } } -// ggml_compute_forward_hadamard - -// Based on a source code from: https://github.com/ikawrakow/ik_llama.cpp -// Copyright (C) 2025 Iwan Kawrakow -// MIT license -// SPDX-License-Identifier: MIT - -template -void fast_ht(int n, T * values) { - constexpr float ksqrt2 = 0.707106781f; - float scale = 1; - for (int h = 1; h < n; h <<= 1) { - for (int i = 0; i < n; i += 2*h) { - for (int j = i; j < i + h; ++j) { - T x = values[j], y = values[j + h]; - values[j+0] = x + y; - values[j+h] = x - y; - } - } - scale *= ksqrt2; - } - for (int i = 0; i < n; ++i) values[i] *= scale; -} - -static void ggml_compute_forward_hadamard_f32( - const ggml_compute_params * params, - ggml_tensor * dst) { - - const ggml_tensor * src0 = dst->src[0]; - - GGML_ASSERT(ggml_is_contiguous(src0)); - GGML_ASSERT(ggml_is_contiguous(dst)); - GGML_ASSERT(ggml_are_same_shape(src0, dst)); - - const int ith = params->ith; - const int nth = params->nth; - - int nh = dst->op_params[0]; - GGML_ASSERT(nh > 1 && ((nh & (nh - 1)) == 0)); // power of 2 - GGML_ASSERT(dst->ne[0] % nh == 0); - - int nc = dst->ne[0]/nh; - int nr = ggml_nrows(dst) * nc; - - int npt = (nr + nth - 1)/nth; - int first = npt*ith; - int last = std::min(first + npt, nr); - - for (int ir = first; ir < last; ++ir) { - int i3 = ir / (dst->ne[1] * dst->ne[2] * nc); - int i2 = (ir - i3*dst->ne[1] * dst->ne[2] * nc)/(dst->ne[1] * nc); - int i1 = (ir - i3*dst->ne[1] * dst->ne[2] * nc - i2*dst->ne[1]*nc)/nc; - int ic = (ir - i3*dst->ne[1] * dst->ne[2] * nc - i2*dst->ne[1]*nc - i1*nc); - - auto x = (const float *)((const char *)src0->data + i3*src0->nb[3] + i2*src0->nb[2] + i1*src0->nb[1]) + ic*nh; - auto y = ( float *)(( char *)dst->data + i3*dst->nb[3] + i2*dst->nb[2] + i1*dst->nb[1]) + ic*nh; - memcpy(y, x, nh*sizeof(float)); - fast_ht(nh, y); - } -} - -void ggml_compute_forward_hadamard( - const ggml_compute_params * params, - ggml_tensor * dst) { - - const ggml_tensor * src0 = dst->src[0]; - - switch (src0->type) { - case GGML_TYPE_F32: - { - ggml_compute_forward_hadamard_f32(params, dst); - } break; - default: - { - GGML_ABORT("fatal error"); - } - } -} - // ggml_compute_forward_scatter static void ggml_compute_forward_scatter_f32( diff --git a/ggml/src/ggml-cpu/ops.h b/ggml/src/ggml-cpu/ops.h index 4fecd4651e8..8f6f64aa624 100644 --- a/ggml/src/ggml-cpu/ops.h +++ b/ggml/src/ggml-cpu/ops.h @@ -103,7 +103,6 @@ void ggml_compute_forward_rwkv_wkv7(const struct ggml_compute_params * params, s void ggml_compute_forward_solve_tri(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_gla(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_gated_delta_net(const struct ggml_compute_params * params, struct ggml_tensor * dst); -void ggml_compute_forward_hadamard(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_scatter(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom1(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom2(const struct ggml_compute_params * params, struct ggml_tensor * dst); diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu index ec4c22961db..9462153fc68 100644 --- a/ggml/src/ggml-cuda/ggml-cuda.cu +++ b/ggml/src/ggml-cuda/ggml-cuda.cu @@ -61,7 +61,6 @@ #include "ggml-cuda/tri.cuh" #include "ggml-cuda/cumsum.cuh" #include "ggml-cuda/fill.cuh" -#include "ggml-cuda/hadamard.cuh" #include "ggml-cuda/scatter.cuh" #include "ggml.h" @@ -2817,9 +2816,6 @@ static bool ggml_cuda_compute_forward(ggml_backend_cuda_context & ctx, struct gg case GGML_OP_FILL: ggml_cuda_op_fill(ctx, dst); break; - case GGML_OP_HADAMARD: - ggml_cuda_op_hadamard(ctx, dst); - break; case GGML_OP_SCATTER: ggml_cuda_op_scatter(ctx, dst); break; @@ -5065,10 +5061,6 @@ static bool ggml_backend_cuda_device_supports_op(ggml_backend_dev_t dev, const g case GGML_OP_SOLVE_TRI: case GGML_OP_SCATTER: return true; - case GGML_OP_HADAMARD: { - int nh = op->op_params[0]; - return (nh == 64 || nh == 128 || nh == 256) && op->ne[0] % nh == 0 && op->type == GGML_TYPE_F32 && op->src[0]->type == GGML_TYPE_F32; - } default: return false; } diff --git a/ggml/src/ggml-cuda/hadamard.cu b/ggml/src/ggml-cuda/hadamard.cu deleted file mode 100644 index 45091d2d204..00000000000 --- a/ggml/src/ggml-cuda/hadamard.cu +++ /dev/null @@ -1,73 +0,0 @@ -// Copyright (C) 2025 Iwan Kawrakow -// MIT license -// SPDX-License-Identifier: MIT - -#include "hadamard.cuh" - -template -static __global__ void hadamard_f32(const char * src, char * dst, int ne0, - size_t nb01, size_t nb02, size_t nb03, size_t nb1, size_t nb2, size_t nb3) { - - constexpr float ksqrt2 = 0.707106781f; - - int nc = ne0/nh; - int ii1 = blockIdx.x; - int i1 = ii1 / nc; - int ic = ii1 % nc; - int i2 = blockIdx.y; - int i3 = blockIdx.z; - - int tid = threadIdx.x; - - const float * x = (const float *)((const char *)src + i1*nb01 + i2*nb02 + i3*nb03) + ic*nh; - float * y = ( float *)((const char *)dst + i1*nb1 + i2*nb2 + i3*nb3) + ic*nh; - - __shared__ float ys[nh]; - - ys[2*tid+0] = x[2*tid+0] + x[2*tid+1]; - ys[2*tid+1] = x[2*tid+0] - x[2*tid+1]; - - float scale = ksqrt2; - -#pragma unroll - for (int h = 2; h < nh; h <<= 1) { - __syncthreads(); - int ii = tid/h, jj = tid%h; - int j = 2*h*ii+jj; - float u = ys[j], v = ys[j+h]; - ys[j+0] = u + v; - ys[j+h] = u - v; - scale *= ksqrt2; - } - - __syncthreads(); - y[2*tid+0] = ys[2*tid+0] * scale; - y[2*tid+1] = ys[2*tid+1] * scale; -} - -static void hadamard_f32_cuda(int nh, const char * x, char * y, int ne0, int ne1, int ne2, int ne3, - size_t nb01, size_t nb02, size_t nb03, size_t nb1, size_t nb2, size_t nb3, cudaStream_t stream) { - int nc = ne0/nh; - int nrows = nc*ne1; - dim3 num_blocks = dim3(nrows, ne2, ne3); - switch (nh) { - case 64: hadamard_f32< 64><<>>(x, y, ne0, nb01, nb02, nb03, nb1, nb2, nb3); break; - case 128: hadamard_f32<128><<>>(x, y, ne0, nb01, nb02, nb03, nb1, nb2, nb3); break; - case 256: hadamard_f32<256><<>>(x, y, ne0, nb01, nb02, nb03, nb1, nb2, nb3); break; - default: GGML_ABORT("Unsupported Hadamard block size"); - } -} - -void ggml_cuda_op_hadamard(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { - const ggml_tensor * src = dst->src[0]; - GGML_ASSERT(src->type == GGML_TYPE_F32); - GGML_ASSERT(dst->type == GGML_TYPE_F32); - GGML_ASSERT(ggml_are_same_shape(src, dst)); - - int nh = dst->op_params[0]; - GGML_ASSERT(dst->ne[0] % nh == 0); - GGML_ASSERT(nh > 1 && ((nh & (nh - 1)) == 0)); // power of 2 - - hadamard_f32_cuda(nh, (const char *)src->data, (char *)dst->data, src->ne[0], src->ne[1], src->ne[2], src->ne[3], - src->nb[1], src->nb[2], src->nb[3], dst->nb[1], dst->nb[2], dst->nb[3], ctx.stream()); -} diff --git a/ggml/src/ggml-cuda/hadamard.cuh b/ggml/src/ggml-cuda/hadamard.cuh deleted file mode 100644 index 17b3ac9468f..00000000000 --- a/ggml/src/ggml-cuda/hadamard.cuh +++ /dev/null @@ -1,3 +0,0 @@ -#include "common.cuh" - -void ggml_cuda_op_hadamard(ggml_backend_cuda_context & ctx, ggml_tensor * dst); diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index d06d3a156c6..442b8b06a8d 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -1040,7 +1040,6 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "RWKV_WKV7", "SOLVE_TRI", "GATED_DELTA_NET", - "HADAMARD", "SCATTER", "UNARY", @@ -1059,7 +1058,7 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "GLU", }; -static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT != 98"); +static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "none", @@ -1152,7 +1151,6 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "rwkv_wkv7(r, w, k, v, a, b, s)", "A X = B, A triangular, solve X", "gated_delta_net(q, k, v, g, beta, s)", - "hadamard(x)", "scatter(x,ids,c)", "unary(x)", @@ -1171,7 +1169,7 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "glu(x)", }; -static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT != 98"); +static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); static_assert(GGML_OP_POOL_COUNT == 2, "GGML_OP_POOL_COUNT != 2"); @@ -6198,28 +6196,6 @@ struct ggml_tensor * ggml_gated_delta_net( return result; } -// ggml_hadamard - -struct ggml_tensor * ggml_hadamard( - struct ggml_context * ctx, - struct ggml_tensor * a, - int n) { - - GGML_ASSERT(a->type == GGML_TYPE_F32); // will not bother implementing for other data types - GGML_ASSERT(n > 1); // no point in Hadamard transforms with less than 2 elements - GGML_ASSERT(a->ne[0] % n == 0); - GGML_ASSERT(n > 0 && ((n & (n - 1)) == 0)); // must be a power of 2 - - struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, GGML_MAX_DIMS, a->ne); - - result->op = GGML_OP_HADAMARD; - result->src[0] = a; - - result->op_params[0] = n; - - return result; -} - // ggml_scatter static struct ggml_tensor * ggml_scatter_impl( diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index f920e1cfbbc..7ece07b594e 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -502,6 +502,8 @@ void llm_graph_input_attn_k_dsa::set_input(const llama_ubatch * ubatch) { mctx->get_lid()->set_input_k_idxs(self_k_idxs_lid, ubatch); mctx->get_lid()->set_input_kq_mask(self_kq_mask_lid, ubatch, cparams.causal_attn); + + mctx->get_lid()->set_input_k_rot(self_k_rot_lid); } bool llm_graph_input_attn_k_dsa::can_reuse(const llm_graph_params & params) { @@ -2458,22 +2460,16 @@ llm_graph_input_attn_k_dsa * llm_graph_context::build_attn_inp_k_dsa() const { inp->self_k_idxs_mla = mctx_cur->get_mla()->build_input_k_idxs(ctx0, ubatch); inp->self_kq_mask_mla = build_attn_inp_kq_mask(ctx0, mctx_cur->get_mla(), ubatch, cparams); - ggml_set_input(inp->self_kq_mask_mla); - ggml_set_name(inp->self_kq_mask_mla, "self_kq_mask_mla"); - inp->self_kq_mask_mla_cnv = cparams.flash_attn ? ggml_cast(ctx0, inp->self_kq_mask_mla, GGML_TYPE_F16) : inp->self_kq_mask_mla; - ggml_set_name(inp->self_kq_mask_mla_cnv, "self_kq_mask_mla_cnv"); } { inp->self_k_idxs_lid = mctx_cur->get_lid()->build_input_k_idxs(ctx0, ubatch); inp->self_kq_mask_lid = build_attn_inp_kq_mask(ctx0, mctx_cur->get_lid(), ubatch, cparams); - ggml_set_input(inp->self_kq_mask_lid); - ggml_set_name(inp->self_kq_mask_lid, "self_kq_mask_lid"); - inp->self_kq_mask_lid_cnv = cparams.flash_attn ? ggml_cast(ctx0, inp->self_kq_mask_lid, GGML_TYPE_F16) : inp->self_kq_mask_lid; - ggml_set_name(inp->self_kq_mask_lid_cnv, "self_kq_mask_lid_cnv"); + + inp->self_k_rot_lid = mctx_cur->get_lid()->build_input_k_rot(ctx0); } return (llm_graph_input_attn_k_dsa *) res->add_input(std::move(inp)); diff --git a/src/llama-graph.h b/src/llama-graph.h index b3296cb5cd3..ab42243097c 100644 --- a/src/llama-graph.h +++ b/src/llama-graph.h @@ -385,6 +385,8 @@ class llm_graph_input_attn_k_dsa : public llm_graph_input_i { ggml_tensor * self_kq_mask_lid = nullptr; // F32 [n_kv, n_batch/n_stream, 1, n_stream] ggml_tensor * self_kq_mask_lid_cnv = nullptr; // [n_kv, n_batch/n_stream, 1, n_stream] + ggml_tensor * self_k_rot_lid = nullptr; + const llama_hparams hparams; const llama_cparams cparams; diff --git a/src/llama-kv-cache.cpp b/src/llama-kv-cache.cpp index b499c99a60e..0d82d52343d 100644 --- a/src/llama-kv-cache.cpp +++ b/src/llama-kv-cache.cpp @@ -281,6 +281,11 @@ llama_kv_cache::llama_kv_cache( !hparams.is_n_embd_k_gqa_variable() && hparams.n_embd_head_k() % 64 == 0; + // always create Hadamard rotation tensors for DeepSeek V3.2 DSA lightning indexer + if (model.arch == LLM_ARCH_DEEPSEEK32 && hparams.n_embd_head_k_full == hparams.indexer_head_size) { + attn_rot_k = true; + } + attn_rot_v = !attn_rot_disable && ggml_is_quantized(type_v) && diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index 16822fca4ba..128c5bd0506 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -127,9 +127,9 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ cb(indexer_k, "indexer_k", il); // perform Hadamard transform on indexer q and k - indexer_q = ggml_hadamard(ctx0, indexer_q, n_embd_indexer_head); + indexer_q = ggml_mul_mat(ctx0, inp_attn_dsa->self_k_rot_lid, indexer_q); cb(indexer_q, "indexer_q", il); - indexer_k = ggml_hadamard(ctx0, indexer_k, n_embd_indexer_head); + indexer_k = ggml_mul_mat(ctx0, inp_attn_dsa->self_k_rot_lid, indexer_k); cb(indexer_k, "indexer_k", il); // store indexer keys to KV cache diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index 784aaf5de47..97d6cb3aabd 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -6655,39 +6655,6 @@ struct test_diag : public test_case { } }; -// GGML_OP_HADAMARD -struct test_hadamard : public test_case { - const ggml_type type_a; - const std::array ne_a; - int nh; - - std::string vars() override { - return VARS_TO_STR3(type_a, ne_a, nh); - } - - test_hadamard(ggml_type type_a = GGML_TYPE_F32, - std::array ne_a = {128, 10, 10, 10}, - int nh = 128) - : type_a(type_a), ne_a(ne_a), nh(nh) {} - - ggml_tensor * build_graph(ggml_context * ctx) override { - ggml_tensor * a = ggml_new_tensor(ctx, type_a, 4, ne_a.data()); - ggml_set_param(a); - ggml_set_name(a, "a"); - - ggml_tensor * out = ggml_hadamard(ctx, a, nh); - ggml_set_name(out, "out"); - - return out; - } - - void initialize_tensors(ggml_context * ctx) override { - for (ggml_tensor * t = ggml_get_first_tensor(ctx); t != NULL; t = ggml_get_next_tensor(ctx, t)) { - init_tensor_uniform(t, -1.0f, 1.0f); - } - } -}; - // GGML_OP_SCATTER struct test_scatter : public test_case { const ggml_type type_a; @@ -8808,9 +8775,6 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_falcon(2)); #endif - // hadamard - test_cases.emplace_back(new test_hadamard()); - // scatter test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, false)); @@ -9096,9 +9060,6 @@ static std::vector> make_test_cases_perf() { test_cases.emplace_back(new test_gated_delta_net(GGML_TYPE_F32, 4, 128, 1024, 1)); // 4h PP-1024 test_cases.emplace_back(new test_gated_delta_net(GGML_TYPE_F32, 32, 128, 64, 1, 1, false, true)); // KDA PP-64 - // hadamard - test_cases.emplace_back(new test_hadamard()); - // scatter test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); From 014e63cd92dad80143dd124cdb245ff82e56e44b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 8 Apr 2026 13:44:17 +0200 Subject: [PATCH 32/46] ggml : added new GGML_OP_LIGHTNING_INDEXER that merges ggml_mul_mat(), ggml_relu() and ggml_sum_rows() to save compute buffer memory. model : used new ggml_lightning_indexer() in DeepseekV32ForCausalLM model implementation. tests : added test for GGML_OP_LIGHTNING_INDEXER. --- ggml/include/ggml.h | 9 ++ ggml/src/ggml-cpu/ggml-cpu.c | 10 ++ ggml/src/ggml-cpu/ops.cpp | 69 +++++++++++ ggml/src/ggml-cpu/ops.h | 1 + ggml/src/ggml-cuda/ggml-cuda.cu | 5 + ggml/src/ggml-cuda/lightning_indexer.cu | 143 +++++++++++++++++++++++ ggml/src/ggml-cuda/lightning_indexer.cuh | 3 + ggml/src/ggml.c | 41 ++++++- src/models/deepseek32.cpp | 13 ++- tests/test-backend-ops.cpp | 55 +++++++++ 10 files changed, 343 insertions(+), 6 deletions(-) create mode 100644 ggml/src/ggml-cuda/lightning_indexer.cu create mode 100644 ggml/src/ggml-cuda/lightning_indexer.cuh diff --git a/ggml/include/ggml.h b/ggml/include/ggml.h index 2a484a5c466..d3ab1ac9312 100644 --- a/ggml/include/ggml.h +++ b/ggml/include/ggml.h @@ -560,6 +560,7 @@ extern "C" { GGML_OP_SOLVE_TRI, GGML_OP_GATED_DELTA_NET, GGML_OP_SCATTER, + GGML_OP_LIGHTNING_INDEXER, GGML_OP_UNARY, @@ -2494,6 +2495,14 @@ extern "C" { struct ggml_tensor * ids, float c); + GGML_API struct ggml_tensor * ggml_lightning_indexer( + struct ggml_context * ctx, + struct ggml_tensor * q, + struct ggml_tensor * k, + struct ggml_tensor * weights, + float scale_embd, + float scale_heads); + // custom operators typedef void (*ggml_custom1_op_t)(struct ggml_tensor * dst , const struct ggml_tensor * a, int ith, int nth, void * userdata); diff --git a/ggml/src/ggml-cpu/ggml-cpu.c b/ggml/src/ggml-cpu/ggml-cpu.c index 8f659dfda50..17f5da6ccbe 100644 --- a/ggml/src/ggml-cpu/ggml-cpu.c +++ b/ggml/src/ggml-cpu/ggml-cpu.c @@ -2035,6 +2035,10 @@ static void ggml_compute_forward(struct ggml_compute_params * params, struct ggm { ggml_compute_forward_scatter(params, tensor); } break; + case GGML_OP_LIGHTNING_INDEXER: + { + ggml_compute_forward_lightning_indexer(params, tensor); + } break; case GGML_OP_MAP_CUSTOM1: { ggml_compute_forward_map_custom1(params, tensor); @@ -2355,6 +2359,7 @@ static int ggml_get_n_tasks(struct ggml_tensor * node, int n_threads) { case GGML_OP_SSM_CONV: case GGML_OP_SSM_SCAN: case GGML_OP_SCATTER: + case GGML_OP_LIGHTNING_INDEXER: { n_tasks = n_threads; } break; @@ -2938,6 +2943,11 @@ struct ggml_cplan ggml_graph_plan( { GGML_ABORT("fatal error"); } + case GGML_OP_LIGHTNING_INDEXER: + { + const int64_t ne00 = node->src[0]->ne[0]; + cur += sizeof(float)*ne00*n_tasks; + } break; default: break; } diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index 0e278a354aa..f0ba8012c83 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11384,3 +11384,72 @@ void ggml_compute_forward_scatter( } } } + +// ggml_compute_forward_lightning_indexer + +void ggml_compute_forward_lightning_indexer( + const ggml_compute_params * params, + ggml_tensor * dst) { + + const ggml_tensor * src0 = dst->src[0]; // q + const ggml_tensor * src1 = dst->src[1]; // k + const ggml_tensor * src2 = dst->src[2]; // weights + + const float scale_embd = ggml_get_op_params_f32(dst, 0); + const float scale_heads = ggml_get_op_params_f32(dst, 1); + + GGML_ASSERT(dst->type == GGML_TYPE_F32); + GGML_ASSERT(src0->type == GGML_TYPE_F32); + GGML_ASSERT(src1->type == GGML_TYPE_F16); + GGML_ASSERT(src2->type == GGML_TYPE_F32); + + GGML_TENSOR_TERNARY_OP_LOCALS + + GGML_ASSERT( nb0 == sizeof(float)); + GGML_ASSERT(nb00 == sizeof(float)); + + int n_embd = src0->ne[0]; + int n_head = src0->ne[1]; + int n_batch = src0->ne[2]; + int n_stream = src0->ne[3]; + int n_kv = src1->ne[2]; + + const int nr = n_kv; + const int ith = params->ith; + const int nth = params->nth; + + // rows per thread + const int dr = (nr + nth - 1)/nth; + + // row range for this thread + const int ir0 = dr*ith; + const int ir1 = MIN(ir0 + dr, nr); + + // TODO handle quantized KV cache + + for (int i_stream = 0; i_stream < n_stream; ++i_stream) { + for (int i_batch = 0; i_batch < n_batch; ++i_batch) { + for (int i_kv = ir0; i_kv < ir1; ++i_kv) { + ggml_fp16_t * src1_row = (ggml_fp16_t *) ((char *) src1->data + i_kv*nb12 + i_stream*nb13); + float * src2_row = (float *) ((char *) src2->data + i_batch*nb21 + i_stream*nb23); + float * dst_row = (float *) ((char *) dst->data + i_batch*nb1 + i_stream*nb3); + float score = 0.0f; + for (int i_head = 0; i_head < n_head; ++i_head) { + // dot product of q and k for head i_head + float qk = 0.0f; + float * src0_row = (float *) ((char *) src0->data + i_head*nb01 + i_batch*nb02 + i_stream*nb03); + for(int i_embd = 0; i_embd < n_embd; ++i_embd) { + const float q = src0_row[i_embd]; + const float k = GGML_CPU_FP16_TO_FP32(src1_row[i_embd]); + qk += q*k; + } + qk *= scale_embd; + // ReLU and weights + score += MAX(qk, 0.0f) * src2_row[i_head]; + } + score *= scale_heads; + dst_row[i_kv] = score; + } + } + } +} diff --git a/ggml/src/ggml-cpu/ops.h b/ggml/src/ggml-cpu/ops.h index 8f6f64aa624..e38f48e349a 100644 --- a/ggml/src/ggml-cpu/ops.h +++ b/ggml/src/ggml-cpu/ops.h @@ -104,6 +104,7 @@ void ggml_compute_forward_solve_tri(const struct ggml_compute_params * params, s void ggml_compute_forward_gla(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_gated_delta_net(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_scatter(const struct ggml_compute_params * params, struct ggml_tensor * dst); +void ggml_compute_forward_lightning_indexer(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom1(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom2(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom3(const struct ggml_compute_params * params, struct ggml_tensor * dst); diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu index 9462153fc68..71fc2af845c 100644 --- a/ggml/src/ggml-cuda/ggml-cuda.cu +++ b/ggml/src/ggml-cuda/ggml-cuda.cu @@ -62,6 +62,7 @@ #include "ggml-cuda/cumsum.cuh" #include "ggml-cuda/fill.cuh" #include "ggml-cuda/scatter.cuh" +#include "ggml-cuda/lightning_indexer.cuh" #include "ggml.h" #include @@ -2819,6 +2820,9 @@ static bool ggml_cuda_compute_forward(ggml_backend_cuda_context & ctx, struct gg case GGML_OP_SCATTER: ggml_cuda_op_scatter(ctx, dst); break; + case GGML_OP_LIGHTNING_INDEXER: + ggml_cuda_op_lightning_indexer(ctx, dst); + break; default: return false; } @@ -5060,6 +5064,7 @@ static bool ggml_backend_cuda_device_supports_op(ggml_backend_dev_t dev, const g case GGML_OP_DIAG: case GGML_OP_SOLVE_TRI: case GGML_OP_SCATTER: + case GGML_OP_LIGHTNING_INDEXER: return true; default: return false; diff --git a/ggml/src/ggml-cuda/lightning_indexer.cu b/ggml/src/ggml-cuda/lightning_indexer.cu new file mode 100644 index 00000000000..1953a48b7da --- /dev/null +++ b/ggml/src/ggml-cuda/lightning_indexer.cu @@ -0,0 +1,143 @@ +#include "lightning_indexer.cuh" +#include "convert.cuh" + +constexpr int KVS_PER_WARP = 8; +constexpr int WARPS_PER_BLOCK = 8; + +template +static __global__ void lightning_indexer_kernel( + const float * src0, const half * src1, const float * src2, float * dst, + const float scale_embd, const float scale_heads, + int64_t n_stream, int64_t n_batch, int64_t n_kv, + size_t nb1, size_t nb2, size_t nb3, + size_t nb01, size_t nb02, size_t nb03, + size_t nb11, size_t nb12, size_t nb13, + size_t nb21, size_t nb22, size_t nb23 + ) { + + int i_batch = blockIdx.y; + int i_stream = blockIdx.z; + int i_warp = threadIdx.y; + int i_lane = threadIdx.x; + + // each warp processes KVS_PER_WARP KV elements + // each block processes WARPS_PER_BLOCK * KVS_PER_WARP KV elements + int start_kv_block = blockIdx.x * (WARPS_PER_BLOCK * KVS_PER_WARP); + int start_kv = start_kv_block + i_warp * KVS_PER_WARP; + + const char * q_base = (const char *) src0 + i_batch*nb02 + i_stream*nb03; + const float * w_base = (const float *) ((const char *) src2 + i_batch*nb21 + i_stream*nb23); + + int2 k_vecs[KVS_PER_WARP]; + float score_k[KVS_PER_WARP] = {0.0f}; + + // preload k values (they are reused in a loop below) + #pragma unroll + for (int k = 0; k < KVS_PER_WARP; ++k) { + int i_kv = start_kv + k; + if (i_kv < n_kv) { + const char* k_base = (const char *) src1 + i_kv*nb12 + i_stream*nb13; + k_vecs[k] = *(const int2 *) (k_base + i_lane * sizeof(int2)); + } else { + k_vecs[k] = make_int2(0, 0); + } + } + + for (int h = 0; h < n_head; ++h) { + const float4 q_vec = *(const float4 *) (q_base + h*nb01 + i_lane*4*sizeof(float)); + const float w_val = w_base[h]; + + float qk[KVS_PER_WARP] = {0.0f}; + + #pragma unroll + for (int k = 0; k < KVS_PER_WARP; ++k) { + const float2 f01 = __half22float2(*(half2 *) &k_vecs[k].x); + const float2 f23 = __half22float2(*(half2 *) &k_vecs[k].y); + + qk[k] += q_vec.x * f01.x; + qk[k] += q_vec.y * f01.y; + qk[k] += q_vec.z * f23.x; + qk[k] += q_vec.w * f23.y; + } + + #pragma unroll + for (int k = 0; k < KVS_PER_WARP; ++k) { + float sum = warp_reduce_sum(qk[k]); + + // scale_embd, ReLU, weight + if (i_lane == 0) { + sum *= scale_embd; + sum = (sum > 0.0f) ? sum : 0.0f; + score_k[k] += sum * w_val; + } + } + } + + // scale_heads, store output + if (i_lane == 0) { + float * dst_base = (float *) ((char *) dst + i_batch*nb1 + i_stream*nb3); + #pragma unroll + for (int k = 0; k < KVS_PER_WARP; ++k) { + int i_kv = start_kv + k; + if (i_kv < n_kv) { + dst_base[i_kv] = score_k[k] * scale_heads; + } + } + } +} + +void ggml_cuda_op_lightning_indexer(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { + const ggml_tensor * src0 = dst->src[0]; + const ggml_tensor * src1 = dst->src[1]; + const ggml_tensor * src2 = dst->src[2]; + + const float scale_embd = ggml_get_op_params_f32(dst, 0); + const float scale_heads = ggml_get_op_params_f32(dst, 1); + + // TODO handle quantized KV cache + GGML_ASSERT(dst->type == GGML_TYPE_F32); + GGML_ASSERT(src0->type == GGML_TYPE_F32); + GGML_ASSERT(src1->type == GGML_TYPE_F16); + GGML_ASSERT(src2->type == GGML_TYPE_F32); + + GGML_TENSOR_TERNARY_OP_LOCALS + + // input tensor rows must be contiguous + GGML_ASSERT(nb00 == ggml_type_size(src0->type)); + GGML_ASSERT(nb10 == ggml_type_size(src1->type)); + GGML_ASSERT(nb20 == ggml_type_size(src2->type)); + + // dst cannot be transposed or permuted + GGML_ASSERT(nb0 == sizeof(float)); + GGML_ASSERT(nb0 <= nb1); + GGML_ASSERT(nb1 <= nb2); + GGML_ASSERT(nb2 <= nb3); + + const int n_embd = src0->ne[0]; + const int n_head = src0->ne[1]; + const int n_batch = src0->ne[2]; + const int n_stream = src0->ne[3]; + const int n_kv = src1->ne[2]; + + const float * src0_d = (const float *) src0->data; + const half * src1_d = (const half *) src1->data; + const float * src2_d = (const float *) src2->data; + float * dst_d = (float *) dst->data; + + dim3 block(32, WARPS_PER_BLOCK); + int num_kv_blocks = (n_kv + (KVS_PER_WARP * WARPS_PER_BLOCK) - 1) / (KVS_PER_WARP * WARPS_PER_BLOCK); + dim3 grid(num_kv_blocks, n_batch, n_stream); + + if (n_embd == 128 && n_head == 64) { + lightning_indexer_kernel<128, 64><<>>( + src0_d, src1_d, src2_d, dst_d, scale_embd, scale_heads, + n_stream, n_batch, n_kv, + nb1, nb2, nb3, + nb01, nb02, nb03, + nb11, nb12, nb13, + nb21, nb22, nb23 + ); + } else { + GGML_ABORT("fatal error"); + } +} diff --git a/ggml/src/ggml-cuda/lightning_indexer.cuh b/ggml/src/ggml-cuda/lightning_indexer.cuh new file mode 100644 index 00000000000..31fcc7d5ae0 --- /dev/null +++ b/ggml/src/ggml-cuda/lightning_indexer.cuh @@ -0,0 +1,3 @@ +#include "common.cuh" + +void ggml_cuda_op_lightning_indexer(ggml_backend_cuda_context & ctx, ggml_tensor * dst); diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index 442b8b06a8d..7540a2700e0 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -1041,6 +1041,7 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "SOLVE_TRI", "GATED_DELTA_NET", "SCATTER", + "LIGHTNING_INDEXER", "UNARY", @@ -1058,7 +1059,7 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "GLU", }; -static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); +static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT != 98"); static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "none", @@ -1152,6 +1153,7 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "A X = B, A triangular, solve X", "gated_delta_net(q, k, v, g, beta, s)", "scatter(x,ids,c)", + "lightning_indexer(q, k, weights, scale_embd, scale_heads)", "unary(x)", @@ -1169,7 +1171,7 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "glu(x)", }; -static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); +static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT != 98"); static_assert(GGML_OP_POOL_COUNT == 2, "GGML_OP_POOL_COUNT != 2"); @@ -6237,6 +6239,41 @@ struct ggml_tensor * ggml_scatter_inplace( return ggml_scatter_impl(ctx, a, ids, c, true); } +// ggml_lightning_indexer + +struct ggml_tensor * ggml_lightning_indexer( + struct ggml_context * ctx, + struct ggml_tensor * q, + struct ggml_tensor * k, + struct ggml_tensor * weights, + float scale_embd, + float scale_heads) { + + GGML_ASSERT(q->type == GGML_TYPE_F32); + GGML_ASSERT(k->type == GGML_TYPE_F16); + GGML_ASSERT(weights->type == GGML_TYPE_F32); + GGML_ASSERT(q->ne[0] == k->ne[0]); + GGML_ASSERT(q->ne[1] == weights->ne[0]); + GGML_ASSERT(k->ne[1] == 1); + GGML_ASSERT(q->ne[2] == weights->ne[1]); + GGML_ASSERT(weights->ne[2] == 1); + GGML_ASSERT(q->ne[3] == k->ne[3]); + GGML_ASSERT(k->ne[3] == weights->ne[3]); + + int64_t ne[4] = { k->ne[2], q->ne[2], 1, q->ne[3] }; + struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne); + + ggml_set_op_params_f32(result, 0, scale_embd); + ggml_set_op_params_f32(result, 1, scale_heads); + + result->op = GGML_OP_LIGHTNING_INDEXER; + result->src[0] = q; + result->src[1] = k; + result->src[2] = weights; + + return result; +} + //////////////////////////////////////////////////////////////////////////////// struct ggml_hash_set ggml_hash_set_new(size_t size) { diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index 128c5bd0506..685a6947baf 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -141,9 +141,6 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ ggml_tensor * indexer_weights = ggml_mul_mat(ctx0, model.layers[il].indexer_proj, cur); cb(indexer_weights, "indexer_weights", il); - indexer_weights = ggml_scale(ctx0, indexer_weights, 1.0f / sqrtf(float(n_indexer_head))); - cb(indexer_weights, "indexer_weights", il); - // get cached indexer keys indexer_k = mctx_lid->get_k(ctx0, il); @@ -152,6 +149,10 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ indexer_q = ggml_view_4d(ctx0, indexer_q, indexer_q->ne[0], indexer_q->ne[1], indexer_q->ne[2]/n_stream, n_stream, indexer_q->nb[1], indexer_q->nb[2], indexer_q->nb[3]/n_stream, 0); indexer_weights = ggml_view_4d(ctx0, indexer_weights, indexer_weights->ne[0], indexer_weights->ne[1]/n_stream, indexer_weights->ne[2], n_stream, indexer_weights->nb[1], indexer_weights->nb[2]/n_stream, indexer_weights->nb[3]/n_stream, 0); +#if 1 + ggml_tensor * indexer_score = ggml_lightning_indexer(ctx0, indexer_q, indexer_k, indexer_weights, 1.0f / sqrtf(float(n_embd_indexer_head)), 1.0f / sqrtf(float(n_indexer_head))); + cb(indexer_score, "indexer_score", il); +#else // calculate indexer kq indexer_q = ggml_permute(ctx0, indexer_q, 0, 2, 1, 3); cb(indexer_q, "indexer_q", il); @@ -169,6 +170,10 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ ggml_tensor * indexer_score = ggml_relu(ctx0, indexer_kq); cb(indexer_score, "indexer_score", il); + // scale weights + indexer_weights = ggml_scale(ctx0, indexer_weights, 1.0f / sqrtf(float(n_indexer_head))); + cb(indexer_weights, "indexer_weights", il); + // multiply scores by indexer weights indexer_score = ggml_mul(ctx0, indexer_score, indexer_weights); cb(indexer_score, "indexer_score", il); @@ -186,7 +191,7 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ // TODO maybe pre-scale indexer weights, so we won't have to do it here indexer_score = ggml_scale(ctx0, indexer_score, 1.0f / sqrtf(float(n_embd_indexer_head))); cb(indexer_score, "indexer_score", il); - +#endif // mask indexer scores ggml_tensor * indexer_kq_mask = inp_attn_dsa->get_kq_mask_lid(); indexer_score = ggml_add(ctx0, indexer_score, indexer_kq_mask); diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index 97d6cb3aabd..557b1285cba 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -6713,6 +6713,57 @@ struct test_scatter : public test_case { } }; +// GGML_OP_LIGHTNING_INDEXER +struct test_lightning_indexer : public test_case { + const ggml_type type_a; + const ggml_type type_b; + const ggml_type type_c; + const std::array ne_a; + const std::array ne_b; + const std::array ne_c; + float scale_embd; + float scale_heads; + + std::string vars() override { + return VARS_TO_STR8(type_a, type_b, type_c, ne_a, ne_b, ne_c, scale_embd, scale_heads); + } + + test_lightning_indexer(ggml_type type_a = GGML_TYPE_F32, + ggml_type type_b = GGML_TYPE_F16, + ggml_type type_c = GGML_TYPE_F32, + std::array ne_a = {128, 64, 128, 1}, + std::array ne_b = {128, 1, 256, 1}, + std::array ne_c = {64, 128, 1, 1}, + float scale_embd = 1.0f / sqrtf(float(128)), + float scale_heads = 1.0f / sqrtf(float(64))) + : type_a(type_a), type_b(type_b), type_c(type_c), ne_a(ne_a), ne_b(ne_b), ne_c(ne_c), scale_embd(scale_embd), scale_heads(scale_heads) {} + + ggml_tensor * build_graph(ggml_context * ctx) override { + ggml_tensor * a = ggml_new_tensor(ctx, type_a, 4, ne_a.data()); + ggml_set_param(a); + ggml_set_name(a, "a"); + + ggml_tensor * b = ggml_new_tensor(ctx, type_b, 4, ne_b.data()); + ggml_set_param(b); + ggml_set_name(b, "b"); + + ggml_tensor * c = ggml_new_tensor(ctx, type_c, 4, ne_c.data()); + ggml_set_param(c); + ggml_set_name(c, "c"); + + ggml_tensor * out = ggml_lightning_indexer(ctx, a, b, c, scale_embd, scale_heads); + ggml_set_name(out, "out"); + + return out; + } + + void initialize_tensors(ggml_context * ctx) override { + for (ggml_tensor * t = ggml_get_first_tensor(ctx); t != NULL; t = ggml_get_next_tensor(ctx, t)) { + init_tensor_uniform(t); + } + } +}; + // Deserializable generic test case struct input_tensor { ggml_type type; @@ -8785,6 +8836,8 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, false)); + test_cases.emplace_back(new test_lightning_indexer()); + return test_cases; } #ifdef _MSC_VER @@ -9066,6 +9119,8 @@ static std::vector> make_test_cases_perf() { test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); + test_cases.emplace_back(new test_lightning_indexer()); + return test_cases; } From 3d61d0bafe83d7923aef3972bea5e8e76f2c2a43 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Sun, 12 Apr 2026 13:10:42 +0200 Subject: [PATCH 33/46] ggml : support lightning indexer key quantization --- ggml/src/ggml-cpu/ggml-cpu.c | 5 +- ggml/src/ggml-cpu/ops.cpp | 20 ++++--- ggml/src/ggml-cuda/lightning_indexer.cu | 76 +++++++++++++++++-------- ggml/src/ggml.c | 1 - tests/test-backend-ops.cpp | 16 +++++- 5 files changed, 83 insertions(+), 35 deletions(-) diff --git a/ggml/src/ggml-cpu/ggml-cpu.c b/ggml/src/ggml-cpu/ggml-cpu.c index 17f5da6ccbe..b36e730c8be 100644 --- a/ggml/src/ggml-cpu/ggml-cpu.c +++ b/ggml/src/ggml-cpu/ggml-cpu.c @@ -2945,8 +2945,9 @@ struct ggml_cplan ggml_graph_plan( } case GGML_OP_LIGHTNING_INDEXER: { - const int64_t ne00 = node->src[0]->ne[0]; - cur += sizeof(float)*ne00*n_tasks; + // temp buffer for dequantizing lightning indexer keys + const int64_t ne10 = node->src[1]->ne[0]; + cur += sizeof(float)*ne10*n_tasks; } break; default: break; diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index f0ba8012c83..92a34bae360 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11400,7 +11400,6 @@ void ggml_compute_forward_lightning_indexer( GGML_ASSERT(dst->type == GGML_TYPE_F32); GGML_ASSERT(src0->type == GGML_TYPE_F32); - GGML_ASSERT(src1->type == GGML_TYPE_F16); GGML_ASSERT(src2->type == GGML_TYPE_F32); GGML_TENSOR_TERNARY_OP_LOCALS @@ -11414,10 +11413,16 @@ void ggml_compute_forward_lightning_indexer( int n_stream = src0->ne[3]; int n_kv = src1->ne[2]; + ggml_to_float_t const k_to_float = ggml_get_type_traits(src1->type)->to_float; + GGML_ASSERT((src1->type == GGML_TYPE_F32 || k_to_float) && "lightning indexer: unsupported K-type"); + const int nr = n_kv; const int ith = params->ith; const int nth = params->nth; + // (temporary) buffer for K converted to float + float * src1_row_f32 = (float *) params->wdata + ith*(1*n_embd + CACHE_LINE_SIZE_F32); + // rows per thread const int dr = (nr + nth - 1)/nth; @@ -11430,7 +11435,12 @@ void ggml_compute_forward_lightning_indexer( for (int i_stream = 0; i_stream < n_stream; ++i_stream) { for (int i_batch = 0; i_batch < n_batch; ++i_batch) { for (int i_kv = ir0; i_kv < ir1; ++i_kv) { - ggml_fp16_t * src1_row = (ggml_fp16_t *) ((char *) src1->data + i_kv*nb12 + i_stream*nb13); + char * src1_row = (char *) src1->data + i_kv*nb12 + i_stream*nb13; + if (k_to_float) { + k_to_float(src1_row, src1_row_f32, n_embd); + } else { + src1_row_f32 = (float *) src1_row; + } float * src2_row = (float *) ((char *) src2->data + i_batch*nb21 + i_stream*nb23); float * dst_row = (float *) ((char *) dst->data + i_batch*nb1 + i_stream*nb3); float score = 0.0f; @@ -11438,11 +11448,7 @@ void ggml_compute_forward_lightning_indexer( // dot product of q and k for head i_head float qk = 0.0f; float * src0_row = (float *) ((char *) src0->data + i_head*nb01 + i_batch*nb02 + i_stream*nb03); - for(int i_embd = 0; i_embd < n_embd; ++i_embd) { - const float q = src0_row[i_embd]; - const float k = GGML_CPU_FP16_TO_FP32(src1_row[i_embd]); - qk += q*k; - } + ggml_vec_dot_f32(n_embd, &qk, 0, src0_row, 0, src1_row_f32, 0, 1); qk *= scale_embd; // ReLU and weights score += MAX(qk, 0.0f) * src2_row[i_head]; diff --git a/ggml/src/ggml-cuda/lightning_indexer.cu b/ggml/src/ggml-cuda/lightning_indexer.cu index 1953a48b7da..db7d466becb 100644 --- a/ggml/src/ggml-cuda/lightning_indexer.cu +++ b/ggml/src/ggml-cuda/lightning_indexer.cu @@ -1,12 +1,13 @@ #include "lightning_indexer.cuh" +#include "fattn-common.cuh" #include "convert.cuh" constexpr int KVS_PER_WARP = 8; constexpr int WARPS_PER_BLOCK = 8; -template +template static __global__ void lightning_indexer_kernel( - const float * src0, const half * src1, const float * src2, float * dst, + const float * src0, const char * src1, const float * src2, float * dst, const float scale_embd, const float scale_heads, int64_t n_stream, int64_t n_batch, int64_t n_kv, size_t nb1, size_t nb2, size_t nb3, @@ -28,18 +29,20 @@ static __global__ void lightning_indexer_kernel( const char * q_base = (const char *) src0 + i_batch*nb02 + i_stream*nb03; const float * w_base = (const float *) ((const char *) src2 + i_batch*nb21 + i_stream*nb23); - int2 k_vecs[KVS_PER_WARP]; + float4 k_vecs[KVS_PER_WARP]; float score_k[KVS_PER_WARP] = {0.0f}; + constexpr dequantize_V_t dequantize_k = get_dequantize_V(); + // preload k values (they are reused in a loop below) #pragma unroll for (int k = 0; k < KVS_PER_WARP; ++k) { int i_kv = start_kv + k; if (i_kv < n_kv) { - const char* k_base = (const char *) src1 + i_kv*nb12 + i_stream*nb13; - k_vecs[k] = *(const int2 *) (k_base + i_lane * sizeof(int2)); + const void * k_base = (const void *) ((const char *) src1 + i_kv*nb12 + i_stream*nb13); + dequantize_k(k_base, &k_vecs[k], i_lane * 4); } else { - k_vecs[k] = make_int2(0, 0); + k_vecs[k] = make_float4(0, 0, 0, 0); } } @@ -51,13 +54,11 @@ static __global__ void lightning_indexer_kernel( #pragma unroll for (int k = 0; k < KVS_PER_WARP; ++k) { - const float2 f01 = __half22float2(*(half2 *) &k_vecs[k].x); - const float2 f23 = __half22float2(*(half2 *) &k_vecs[k].y); - - qk[k] += q_vec.x * f01.x; - qk[k] += q_vec.y * f01.y; - qk[k] += q_vec.z * f23.x; - qk[k] += q_vec.w * f23.y; + const float4 k_vec = k_vecs[k]; + qk[k] += q_vec.x * k_vec.x; + qk[k] += q_vec.y * k_vec.y; + qk[k] += q_vec.z * k_vec.z; + qk[k] += q_vec.w * k_vec.w; } #pragma unroll @@ -86,6 +87,36 @@ static __global__ void lightning_indexer_kernel( } } +#define DECL_LIGHTNING_INDEXER_CASE(n_embd, n_head, type_K) \ + template __global__ void lightning_indexer_kernel ( \ + const float * src0, const char * src1, const float * src2, float * dst, \ + const float scale_embd, const float scale_heads, \ + int64_t n_stream, int64_t n_batch, int64_t n_kv, \ + size_t nb1, size_t nb2, size_t nb3, \ + size_t nb01, size_t nb02, size_t nb03, \ + size_t nb11, size_t nb12, size_t nb13, \ + size_t nb21, size_t nb22, size_t nb23); + +DECL_LIGHTNING_INDEXER_CASE(128, 64, GGML_TYPE_F16) +DECL_LIGHTNING_INDEXER_CASE(128, 64, GGML_TYPE_Q4_0) +DECL_LIGHTNING_INDEXER_CASE(128, 64, GGML_TYPE_Q4_1) +DECL_LIGHTNING_INDEXER_CASE(128, 64, GGML_TYPE_Q5_0) +DECL_LIGHTNING_INDEXER_CASE(128, 64, GGML_TYPE_Q5_1) +DECL_LIGHTNING_INDEXER_CASE(128, 64, GGML_TYPE_Q8_0) +DECL_LIGHTNING_INDEXER_CASE(128, 64, GGML_TYPE_BF16) + +#define LIGHTNING_INDEXER_CASE(n_embd, n_head, K, type_K) \ + if (K->type == (type_K)) { \ + lightning_indexer_kernel<<>>( \ + src0_d, src1_d, src2_d, dst_d, scale_embd, scale_heads, \ + n_stream, n_batch, n_kv, \ + nb1, nb2, nb3, \ + nb01, nb02, nb03, \ + nb11, nb12, nb13, \ + nb21, nb22, nb23 \ + ); \ + } else + void ggml_cuda_op_lightning_indexer(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { const ggml_tensor * src0 = dst->src[0]; const ggml_tensor * src1 = dst->src[1]; @@ -97,7 +128,6 @@ void ggml_cuda_op_lightning_indexer(ggml_backend_cuda_context & ctx, ggml_tensor // TODO handle quantized KV cache GGML_ASSERT(dst->type == GGML_TYPE_F32); GGML_ASSERT(src0->type == GGML_TYPE_F32); - GGML_ASSERT(src1->type == GGML_TYPE_F16); GGML_ASSERT(src2->type == GGML_TYPE_F32); GGML_TENSOR_TERNARY_OP_LOCALS @@ -120,7 +150,7 @@ void ggml_cuda_op_lightning_indexer(ggml_backend_cuda_context & ctx, ggml_tensor const int n_kv = src1->ne[2]; const float * src0_d = (const float *) src0->data; - const half * src1_d = (const half *) src1->data; + const char * src1_d = (const char *) src1->data; const float * src2_d = (const float *) src2->data; float * dst_d = (float *) dst->data; @@ -129,14 +159,14 @@ void ggml_cuda_op_lightning_indexer(ggml_backend_cuda_context & ctx, ggml_tensor dim3 grid(num_kv_blocks, n_batch, n_stream); if (n_embd == 128 && n_head == 64) { - lightning_indexer_kernel<128, 64><<>>( - src0_d, src1_d, src2_d, dst_d, scale_embd, scale_heads, - n_stream, n_batch, n_kv, - nb1, nb2, nb3, - nb01, nb02, nb03, - nb11, nb12, nb13, - nb21, nb22, nb23 - ); + LIGHTNING_INDEXER_CASE(128, 64, src1, GGML_TYPE_F16) + LIGHTNING_INDEXER_CASE(128, 64, src1, GGML_TYPE_Q4_0) + LIGHTNING_INDEXER_CASE(128, 64, src1, GGML_TYPE_Q4_1) + LIGHTNING_INDEXER_CASE(128, 64, src1, GGML_TYPE_Q5_0) + LIGHTNING_INDEXER_CASE(128, 64, src1, GGML_TYPE_Q5_1) + LIGHTNING_INDEXER_CASE(128, 64, src1, GGML_TYPE_Q8_0) + LIGHTNING_INDEXER_CASE(128, 64, src1, GGML_TYPE_BF16) + GGML_ABORT("fatal error"); } else { GGML_ABORT("fatal error"); } diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index 7540a2700e0..258f359da3c 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -6250,7 +6250,6 @@ struct ggml_tensor * ggml_lightning_indexer( float scale_heads) { GGML_ASSERT(q->type == GGML_TYPE_F32); - GGML_ASSERT(k->type == GGML_TYPE_F16); GGML_ASSERT(weights->type == GGML_TYPE_F32); GGML_ASSERT(q->ne[0] == k->ne[0]); GGML_ASSERT(q->ne[1] == weights->ne[0]); diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index 557b1285cba..6b9e1cba376 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -8836,7 +8836,13 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, false)); - test_cases.emplace_back(new test_lightning_indexer()); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_1, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q5_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q5_1, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q8_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_BF16, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); return test_cases; } @@ -9119,7 +9125,13 @@ static std::vector> make_test_cases_perf() { test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); - test_cases.emplace_back(new test_lightning_indexer()); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_1, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q5_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q5_1, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q8_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); + test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_BF16, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); return test_cases; } From 65c355719d9ba7e1ce91d8b205f69abfd2039980 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 13 Apr 2026 14:26:00 +0200 Subject: [PATCH 34/46] chore : fix trailing whitespaces --- ggml/src/ggml-cuda/lightning_indexer.cu | 8 ++++---- src/models/deepseek32.cpp | 16 ++++++++-------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/ggml/src/ggml-cuda/lightning_indexer.cu b/ggml/src/ggml-cuda/lightning_indexer.cu index db7d466becb..784a7c777b5 100644 --- a/ggml/src/ggml-cuda/lightning_indexer.cu +++ b/ggml/src/ggml-cuda/lightning_indexer.cu @@ -25,7 +25,7 @@ static __global__ void lightning_indexer_kernel( // each block processes WARPS_PER_BLOCK * KVS_PER_WARP KV elements int start_kv_block = blockIdx.x * (WARPS_PER_BLOCK * KVS_PER_WARP); int start_kv = start_kv_block + i_warp * KVS_PER_WARP; - + const char * q_base = (const char *) src0 + i_batch*nb02 + i_stream*nb03; const float * w_base = (const float *) ((const char *) src2 + i_batch*nb21 + i_stream*nb23); @@ -49,7 +49,7 @@ static __global__ void lightning_indexer_kernel( for (int h = 0; h < n_head; ++h) { const float4 q_vec = *(const float4 *) (q_base + h*nb01 + i_lane*4*sizeof(float)); const float w_val = w_base[h]; - + float qk[KVS_PER_WARP] = {0.0f}; #pragma unroll @@ -64,11 +64,11 @@ static __global__ void lightning_indexer_kernel( #pragma unroll for (int k = 0; k < KVS_PER_WARP; ++k) { float sum = warp_reduce_sum(qk[k]); - + // scale_embd, ReLU, weight if (i_lane == 0) { sum *= scale_embd; - sum = (sum > 0.0f) ? sum : 0.0f; + sum = (sum > 0.0f) ? sum : 0.0f; score_k[k] += sum * w_val; } } diff --git a/src/models/deepseek32.cpp b/src/models/deepseek32.cpp index 685a6947baf..cb4171ca940 100644 --- a/src/models/deepseek32.cpp +++ b/src/models/deepseek32.cpp @@ -75,19 +75,19 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ // split into {n_embd_indexer_head_rope, n_indexer_head, n_tokens} ggml_tensor * indexer_q_pe = ggml_view_3d(ctx0, indexer_q, n_embd_indexer_head_rope, n_indexer_head, n_tokens, - ggml_row_size(indexer_q->type, n_embd_indexer_head), - ggml_row_size(indexer_q->type, n_embd_indexer_head) * n_indexer_head, 0); + ggml_row_size(indexer_q->type, n_embd_indexer_head), + ggml_row_size(indexer_q->type, n_embd_indexer_head) * n_indexer_head, 0); cb(indexer_q_pe, "indexer_q_pe", il); // and {n_embd_indexer_head_nope, n_indexer_head, n_tokens} ggml_tensor * indexer_q_nope = ggml_view_3d(ctx0, indexer_q, n_embd_indexer_head_nope, n_indexer_head, n_tokens, - ggml_row_size(indexer_q->type, n_embd_indexer_head), + ggml_row_size(indexer_q->type, n_embd_indexer_head), ggml_row_size(indexer_q->type, n_embd_indexer_head) * n_indexer_head, ggml_row_size(indexer_q->type, n_embd_indexer_head_nope)); cb(indexer_q_nope, "indexer_q_nope", il); - indexer_q_pe = ggml_rope_ext(ctx0, indexer_q_pe, inp_pos, nullptr, n_rot, + indexer_q_pe = ggml_rope_ext(ctx0, indexer_q_pe, inp_pos, nullptr, n_rot, LLAMA_ROPE_TYPE_NEOX, n_ctx_orig, freq_base, freq_scale, ext_factor, attn_factor, beta_fast, beta_slow); cb(indexer_q_pe, "indexer_q_pe", il); @@ -105,19 +105,19 @@ llm_build_deepseek32::llm_build_deepseek32(const llama_model & model, const llm_ // split into {n_embd_indexer_head_rope, 1, n_tokens} ggml_tensor * indexer_k_pe = ggml_view_3d(ctx0, indexer_k, n_embd_indexer_head_rope, 1, n_tokens, - ggml_row_size(indexer_k->type, n_embd_indexer_head), - ggml_row_size(indexer_k->type, n_embd_indexer_head) * 1, 0); + ggml_row_size(indexer_k->type, n_embd_indexer_head), + ggml_row_size(indexer_k->type, n_embd_indexer_head) * 1, 0); cb(indexer_k_pe, "indexer_k_pe", il); // and {n_embd_indexer_head_nope, 1, n_tokens} ggml_tensor * indexer_k_nope = ggml_view_3d(ctx0, indexer_k, n_embd_indexer_head_nope, 1, n_tokens, - ggml_row_size(indexer_k->type, n_embd_indexer_head), + ggml_row_size(indexer_k->type, n_embd_indexer_head), ggml_row_size(indexer_k->type, n_embd_indexer_head) * 1, ggml_row_size(indexer_k->type, n_embd_indexer_head_nope)); cb(indexer_k_nope, "indexer_k_nope", il); - indexer_k_pe = ggml_rope_ext(ctx0, indexer_k_pe, inp_pos, nullptr, n_rot, + indexer_k_pe = ggml_rope_ext(ctx0, indexer_k_pe, inp_pos, nullptr, n_rot, LLAMA_ROPE_TYPE_NEOX, n_ctx_orig, freq_base, freq_scale, ext_factor, attn_factor, beta_fast, beta_slow); cb(indexer_k_pe, "indexer_k_pe", il); From 5715c365ad78fb9f6a06cefcc5832a0852f03601 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 13 Apr 2026 14:30:24 +0200 Subject: [PATCH 35/46] ggml : bump RPC version --- ggml/include/ggml-rpc.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ggml/include/ggml-rpc.h b/ggml/include/ggml-rpc.h index 1c11495b66e..0373df057be 100644 --- a/ggml/include/ggml-rpc.h +++ b/ggml/include/ggml-rpc.h @@ -8,10 +8,10 @@ extern "C" { #define RPC_PROTO_MAJOR_VERSION 3 #define RPC_PROTO_MINOR_VERSION 6 -#define RPC_PROTO_PATCH_VERSION 1 +#define RPC_PROTO_PATCH_VERSION 2 #ifdef __cplusplus -static_assert(GGML_OP_COUNT == 96, "GGML_OP_COUNT has changed - update RPC_PROTO_PATCH_VERSION"); +static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT has changed - update RPC_PROTO_PATCH_VERSION"); #endif #define GGML_RPC_MAX_SERVERS 16 From e0fcb2274fe5851bde2df374a0c2f82bcc99e25c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 13 Apr 2026 15:01:55 +0200 Subject: [PATCH 36/46] chore : silence Python Type-Check CI error --- convert_hf_to_gguf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/convert_hf_to_gguf.py b/convert_hf_to_gguf.py index 813825b7802..4bab4a435cf 100755 --- a/convert_hf_to_gguf.py +++ b/convert_hf_to_gguf.py @@ -9197,7 +9197,7 @@ def __init__(self, *args, **kwargs): def set_vocab(self): from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained(self.dir_model) - assert tokenizer.add_bos_token, "Change value of add_bos_token to true in tokenizer_config.json file." + assert getattr(tokenizer, "add_bos_token", False), "Change value of add_bos_token to true in tokenizer_config.json file." self._set_vocab_gpt2() def set_gguf_parameters(self): From 45294c5bb07dff036f779eee90c266b009a86b36 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 13 Apr 2026 18:52:49 +0200 Subject: [PATCH 37/46] ggml : more assertions in GGML_OP_SCATTER since there is no broadcasting --- ggml/src/ggml.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index d02bdb9a42d..0ba9249778b 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -6219,6 +6219,8 @@ static struct ggml_tensor * ggml_scatter_impl( GGML_ASSERT(a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16); GGML_ASSERT(ids->type == GGML_TYPE_I32); GGML_ASSERT(a->ne[1] == ids->ne[1]); + GGML_ASSERT(a->ne[2] == ids->ne[2]); + GGML_ASSERT(a->ne[3] == ids->ne[3]); struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a); From 66ec7be183ece50d19e909f21668f83564b26a9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 13 Apr 2026 19:07:27 +0200 Subject: [PATCH 38/46] model : corrected number of layers for 685B.A37B DeepseekV32ForCausalLM models --- src/llama-model.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/llama-model.cpp b/src/llama-model.cpp index aa9e68a7ac4..cfb644ed303 100644 --- a/src/llama-model.cpp +++ b/src/llama-model.cpp @@ -2061,7 +2061,7 @@ void llama_model::load_hparams(llama_model_loader & ml) { hparams.n_layer_kv_from_start = hparams.n_layer - hparams.nextn_predict_layers; switch (hparams.n_layer) { - case 61: type = LLM_TYPE_685B_A37B; break; + case 62: type = LLM_TYPE_685B_A37B; break; default: type = LLM_TYPE_UNKNOWN; } } break; From eea1a6e1eb642048a0076afa117a267a18bd4da0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Tue, 14 Apr 2026 11:03:44 +0200 Subject: [PATCH 39/46] llama : set lightning indexer head count and key dimension to real values in test-llama-archs to prevent crashes due to unhandled values in lightning indexer CUDA kernel --- tests/test-llama-archs.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test-llama-archs.cpp b/tests/test-llama-archs.cpp index 6c2492278e9..81d4b8c9926 100644 --- a/tests/test-llama-archs.cpp +++ b/tests/test-llama-archs.cpp @@ -195,8 +195,8 @@ static gguf_context_ptr get_gguf_ctx(const llm_arch arch, const bool moe) { ms.add_kv(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, uint32_t(2)); } - ms.add_kv(LLM_KV_ATTENTION_INDEXER_HEAD_COUNT, uint32_t(1)); - ms.add_kv(LLM_KV_ATTENTION_INDEXER_KEY_LENGTH, uint32_t(64)); + ms.add_kv(LLM_KV_ATTENTION_INDEXER_HEAD_COUNT, uint32_t(64)); + ms.add_kv(LLM_KV_ATTENTION_INDEXER_KEY_LENGTH, uint32_t(128)); ms.add_kv(LLM_KV_ATTENTION_INDEXER_TOP_K, uint32_t(8)); ms.add_kv(LLM_KV_ROPE_DIMENSION_SECTIONS, std::vector({n_embd_head/4, n_embd_head/4, n_embd_head/4, n_embd_head/4})); ms.add_kv(LLM_KV_TOKENIZER_MODEL, "no_vocab"); From 5dc8a87388a73cabd8dec2431354bda53287e69d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Tue, 14 Apr 2026 18:32:40 +0200 Subject: [PATCH 40/46] chore : whitespace formatting, comments --- ggml/src/ggml-cuda/ggml-cuda.cu | 1 + src/llama-graph.cpp | 1 - src/llama-graph.h | 1 - src/llama-kv-cache-dsa.h | 6 +++--- tests/test-backend-ops.cpp | 2 ++ 5 files changed, 6 insertions(+), 5 deletions(-) diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu index c2cda5710fd..cc3535206cf 100644 --- a/ggml/src/ggml-cuda/ggml-cuda.cu +++ b/ggml/src/ggml-cuda/ggml-cuda.cu @@ -5064,6 +5064,7 @@ static bool ggml_backend_cuda_device_supports_op(ggml_backend_dev_t dev, const g case GGML_OP_SCATTER: case GGML_OP_LIGHTNING_INDEXER: return true; + default: return false; } diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index 1c78a556a33..763e82cc447 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -2332,7 +2332,6 @@ ggml_tensor * llm_graph_context::build_attn( return cur; } - ggml_tensor * llm_graph_context::build_attn( llm_graph_input_attn_kv_iswa * inp, ggml_tensor * wo, diff --git a/src/llama-graph.h b/src/llama-graph.h index 3ee401b9409..a2a28e415eb 100644 --- a/src/llama-graph.h +++ b/src/llama-graph.h @@ -393,7 +393,6 @@ class llm_graph_input_attn_k_dsa : public llm_graph_input_i { const llama_kv_cache_dsa_context * mctx; }; - class llm_graph_input_attn_kv_iswa : public llm_graph_input_i { public: llm_graph_input_attn_kv_iswa( diff --git a/src/llama-kv-cache-dsa.h b/src/llama-kv-cache-dsa.h index 6d57c741967..e2b330993b8 100644 --- a/src/llama-kv-cache-dsa.h +++ b/src/llama-kv-cache-dsa.h @@ -8,9 +8,9 @@ // llama_kv_cache_dsa // -// utilizes two KV cache instances: llama_kv_cache and llama_kv_cache -// the first instance is for caching key tensors of the model, -// the second instance is for caching lightning indexer key tensors +// utilizes two instances of llama_kv_cache: +// - the first instance is for caching key tensors of the model, +// - the second instance is for caching lightning indexer key tensors class llama_kv_cache_dsa : public llama_memory_i { public: diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index c6790f41307..d38d080280d 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -8805,6 +8805,7 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, false)); + // lightning_indexer test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_1, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); @@ -9094,6 +9095,7 @@ static std::vector> make_test_cases_perf() { test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); + // lightning_indexer test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_1, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); From d9a1703a0ecbf689400e0f2aef9500064c6eda95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 15 Apr 2026 08:55:11 +0200 Subject: [PATCH 41/46] chore : comments --- ggml/src/ggml-cpu/ops.cpp | 2 -- ggml/src/ggml-cuda/lightning_indexer.cu | 1 - 2 files changed, 3 deletions(-) diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index 30692547bde..a55621f0b9b 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11437,8 +11437,6 @@ void ggml_compute_forward_lightning_indexer( const int ir0 = dr*ith; const int ir1 = MIN(ir0 + dr, nr); - // TODO handle quantized KV cache - for (int i_stream = 0; i_stream < n_stream; ++i_stream) { for (int i_batch = 0; i_batch < n_batch; ++i_batch) { for (int i_kv = ir0; i_kv < ir1; ++i_kv) { diff --git a/ggml/src/ggml-cuda/lightning_indexer.cu b/ggml/src/ggml-cuda/lightning_indexer.cu index 784a7c777b5..6563d349b64 100644 --- a/ggml/src/ggml-cuda/lightning_indexer.cu +++ b/ggml/src/ggml-cuda/lightning_indexer.cu @@ -125,7 +125,6 @@ void ggml_cuda_op_lightning_indexer(ggml_backend_cuda_context & ctx, ggml_tensor const float scale_embd = ggml_get_op_params_f32(dst, 0); const float scale_heads = ggml_get_op_params_f32(dst, 1); - // TODO handle quantized KV cache GGML_ASSERT(dst->type == GGML_TYPE_F32); GGML_ASSERT(src0->type == GGML_TYPE_F32); GGML_ASSERT(src2->type == GGML_TYPE_F32); From 4054f0ddea147945db81bf0ee38dfedb67870070 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 15 Apr 2026 09:06:48 +0200 Subject: [PATCH 42/46] tests : f16 GGML_OP_FILL tests --- tests/test-backend-ops.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index d38d080280d..c968588aa22 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -8625,6 +8625,10 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_fill(2.0f, GGML_TYPE_F32, { 303, 207, 11, 3 })); test_cases.emplace_back(new test_fill(-152.0f, GGML_TYPE_F32, { 800, 600, 4, 4 })); test_cases.emplace_back(new test_fill(3.5f, GGML_TYPE_F32, { 2048, 512, 2, 2 })); + test_cases.emplace_back(new test_fill(0.0f, GGML_TYPE_F16)); + test_cases.emplace_back(new test_fill(2.0f, GGML_TYPE_F16, { 303, 207, 11, 3 })); + test_cases.emplace_back(new test_fill(-152.0f, GGML_TYPE_F16, { 800, 600, 4, 4 })); + test_cases.emplace_back(new test_fill(3.5f, GGML_TYPE_F16, { 2048, 512, 2, 2 })); test_cases.emplace_back(new test_diag()); test_cases.emplace_back(new test_diag(GGML_TYPE_F32, { 79, 1, 19, 13 })); From 81209f9bafa49427ad24014375a7a44e5d32e85d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 15 Apr 2026 11:45:51 +0200 Subject: [PATCH 43/46] llama : replaced ggml_scatter() usage in DSA implementation with ggml_set_rows() by using 1-element rows ggml, tests : remove GGML_OP_SCATTER --- ggml/include/ggml-rpc.h | 2 +- ggml/include/ggml.h | 13 --- ggml/src/ggml-cpu/ggml-cpu.c | 5 -- ggml/src/ggml-cpu/ops.cpp | 145 -------------------------------- ggml/src/ggml-cpu/ops.h | 1 - ggml/src/ggml-cuda/ggml-cuda.cu | 5 -- ggml/src/ggml-cuda/scatter.cu | 88 ------------------- ggml/src/ggml.c | 49 +---------- src/llama-graph.cpp | 21 ++++- tests/test-backend-ops.cpp | 74 ---------------- 10 files changed, 22 insertions(+), 381 deletions(-) delete mode 100644 ggml/src/ggml-cuda/scatter.cu diff --git a/ggml/include/ggml-rpc.h b/ggml/include/ggml-rpc.h index 0373df057be..d9ab2d6e419 100644 --- a/ggml/include/ggml-rpc.h +++ b/ggml/include/ggml-rpc.h @@ -11,7 +11,7 @@ extern "C" { #define RPC_PROTO_PATCH_VERSION 2 #ifdef __cplusplus -static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT has changed - update RPC_PROTO_PATCH_VERSION"); +static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT has changed - update RPC_PROTO_PATCH_VERSION"); #endif #define GGML_RPC_MAX_SERVERS 16 diff --git a/ggml/include/ggml.h b/ggml/include/ggml.h index 8317d1efae2..f43f9a6863a 100644 --- a/ggml/include/ggml.h +++ b/ggml/include/ggml.h @@ -561,7 +561,6 @@ extern "C" { GGML_OP_RWKV_WKV7, GGML_OP_SOLVE_TRI, GGML_OP_GATED_DELTA_NET, - GGML_OP_SCATTER, GGML_OP_LIGHTNING_INDEXER, GGML_OP_UNARY, @@ -2487,18 +2486,6 @@ extern "C" { struct ggml_tensor * beta, struct ggml_tensor * state); - GGML_API struct ggml_tensor * ggml_scatter( - struct ggml_context * ctx, - struct ggml_tensor * a, - struct ggml_tensor * ids, - float c); - - GGML_API struct ggml_tensor * ggml_scatter_inplace( - struct ggml_context * ctx, - struct ggml_tensor * a, - struct ggml_tensor * ids, - float c); - GGML_API struct ggml_tensor * ggml_lightning_indexer( struct ggml_context * ctx, struct ggml_tensor * q, diff --git a/ggml/src/ggml-cpu/ggml-cpu.c b/ggml/src/ggml-cpu/ggml-cpu.c index 3b8e34a97c5..9d146f1051b 100644 --- a/ggml/src/ggml-cpu/ggml-cpu.c +++ b/ggml/src/ggml-cpu/ggml-cpu.c @@ -2037,10 +2037,6 @@ static void ggml_compute_forward(struct ggml_compute_params * params, struct ggm { ggml_compute_forward_gated_delta_net(params, tensor); } break; - case GGML_OP_SCATTER: - { - ggml_compute_forward_scatter(params, tensor); - } break; case GGML_OP_LIGHTNING_INDEXER: { ggml_compute_forward_lightning_indexer(params, tensor); @@ -2364,7 +2360,6 @@ static int ggml_get_n_tasks(struct ggml_tensor * node, int n_threads) { case GGML_OP_FLASH_ATTN_BACK: case GGML_OP_SSM_CONV: case GGML_OP_SSM_SCAN: - case GGML_OP_SCATTER: case GGML_OP_LIGHTNING_INDEXER: { n_tasks = n_threads; diff --git a/ggml/src/ggml-cpu/ops.cpp b/ggml/src/ggml-cpu/ops.cpp index a55621f0b9b..efd960823a3 100644 --- a/ggml/src/ggml-cpu/ops.cpp +++ b/ggml/src/ggml-cpu/ops.cpp @@ -11247,151 +11247,6 @@ void ggml_compute_forward_opt_step_sgd(const ggml_compute_params * params, ggml_ } } -// ggml_compute_forward_scatter - -static void ggml_compute_forward_scatter_f32( - const ggml_compute_params * params, - ggml_tensor * dst) { - - const ggml_tensor * src0 = dst->src[0]; - const ggml_tensor * src1 = dst->src[1]; - - const float c = ggml_get_op_params_f32(dst, 0); - const bool inplace = ggml_get_op_params_i32(dst, 1); - - GGML_ASSERT(ggml_are_same_shape(src0, dst)); - - GGML_ASSERT(dst->type == GGML_TYPE_F32); - GGML_ASSERT(src0->type == GGML_TYPE_F32); - GGML_ASSERT(src1->type == GGML_TYPE_I32); - - GGML_ASSERT(src0->nb[0] == sizeof(float)); - - const int ith = params->ith; - const int nth = params->nth; - - const int nr = ggml_nrows(src0); - - GGML_TENSOR_BINARY_OP_LOCALS - - GGML_ASSERT( nb0 == sizeof(float)); - GGML_ASSERT(nb00 == sizeof(float)); - - // rows per thread - const int dr = (nr + nth - 1)/nth; - - // row range for this thread - const int ir0 = dr*ith; - const int ir1 = MIN(ir0 + dr, nr); - - for (int ir = ir0; ir < ir1; ++ir) { - // src0 indices - const int i3 = ir/(ne2*ne1); - const int i2 = (ir - i3*ne2*ne1)/ne1; - const int i1 = (ir - i3*ne2*ne1 - i2*ne1); - - const float * src0_ptr = (float *) ((char *) src0->data + i3*nb3 + i2*nb2 + i1*nb1 ); - const int32_t * ids_ptr = (int32_t *) ((char *) src1->data + i3*nb13 + i2*nb12 + i1*nb11); - float * dst_ptr = (float *) ((char *) dst->data + i3*nb3 + i2*nb2 + i1*nb1 ); - - // copy whole row from src0 - if (!inplace) { - ggml_vec_cpy_f32(ne00, dst_ptr, src0_ptr); - } - - // set dst elements indicated by indices in src1 to c - for (int j = 0; j < ne10; ++j) { - int id = ids_ptr[j]; - GGML_ASSERT(id >= 0 && id < ne00); - dst_ptr[id] = c; - } - } -} - -static void ggml_compute_forward_scatter_f16( - const ggml_compute_params * params, - ggml_tensor * dst) { - - const ggml_tensor * src0 = dst->src[0]; - const ggml_tensor * src1 = dst->src[1]; - - const ggml_fp16_t c = GGML_CPU_FP32_TO_FP16(ggml_get_op_params_f32(dst, 0)); - const bool inplace = ggml_get_op_params_i32(dst, 1); - - GGML_ASSERT(ggml_are_same_shape(src0, dst)); - - GGML_ASSERT(dst->type == GGML_TYPE_F16); - GGML_ASSERT(src0->type == GGML_TYPE_F16); - GGML_ASSERT(src1->type == GGML_TYPE_I32); - - GGML_ASSERT(src0->nb[0] == sizeof(ggml_fp16_t)); - - const int ith = params->ith; - const int nth = params->nth; - - const int nr = ggml_nrows(src0); - - GGML_TENSOR_BINARY_OP_LOCALS - - GGML_ASSERT( nb0 == sizeof(ggml_fp16_t)); - GGML_ASSERT(nb00 == sizeof(ggml_fp16_t)); - - // rows per thread - const int dr = (nr + nth - 1)/nth; - - // row range for this thread - const int ir0 = dr*ith; - const int ir1 = MIN(ir0 + dr, nr); - - for (int ir = ir0; ir < ir1; ++ir) { - // src0 indices - const int i3 = ir/(ne2*ne1); - const int i2 = (ir - i3*ne2*ne1)/ne1; - const int i1 = (ir - i3*ne2*ne1 - i2*ne1); - - const ggml_fp16_t * src0_ptr = (ggml_fp16_t *) ((char *) src0->data + i3*nb3 + i2*nb2 + i1*nb1 ); - const int32_t * ids_ptr = (int32_t *) ((char *) src1->data + i3*nb13 + i2*nb12 + i1*nb11); - ggml_fp16_t * dst_ptr = (ggml_fp16_t *) ((char *) dst->data + i3*nb3 + i2*nb2 + i1*nb1 ); - - // copy whole row from src0 - if (!inplace) { - // ggml_vec_cpy_f16(ne00, dst_ptr, src0_ptr) - for (int i = 0; i < ne00; ++i) { - dst_ptr[i] = src0_ptr[i]; - } - } - - // set dst elements indicated by indices in src1 to c - for (int j = 0; j < ne10; ++j) { - int id = ids_ptr[j]; - GGML_ASSERT(id >= 0 && id < ne00); - dst_ptr[id] = c; - } - } -} - -void ggml_compute_forward_scatter( - const ggml_compute_params * params, - ggml_tensor * dst) { - - const ggml_tensor * src0 = dst->src[0]; - - switch (src0->type) { - case GGML_TYPE_F32: - { - ggml_compute_forward_scatter_f32(params, dst); - } break; - case GGML_TYPE_F16: - { - ggml_compute_forward_scatter_f16(params, dst); - } break; - default: - { - GGML_ABORT("unsupported type for ggml_compute_forward_scatter: %s", ggml_type_name(src0->type)); - } - } -} - // ggml_compute_forward_lightning_indexer void ggml_compute_forward_lightning_indexer( diff --git a/ggml/src/ggml-cpu/ops.h b/ggml/src/ggml-cpu/ops.h index e38f48e349a..c3f4a0a6c07 100644 --- a/ggml/src/ggml-cpu/ops.h +++ b/ggml/src/ggml-cpu/ops.h @@ -103,7 +103,6 @@ void ggml_compute_forward_rwkv_wkv7(const struct ggml_compute_params * params, s void ggml_compute_forward_solve_tri(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_gla(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_gated_delta_net(const struct ggml_compute_params * params, struct ggml_tensor * dst); -void ggml_compute_forward_scatter(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_lightning_indexer(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom1(const struct ggml_compute_params * params, struct ggml_tensor * dst); void ggml_compute_forward_map_custom2(const struct ggml_compute_params * params, struct ggml_tensor * dst); diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu index cc3535206cf..9e3a829c41e 100644 --- a/ggml/src/ggml-cuda/ggml-cuda.cu +++ b/ggml/src/ggml-cuda/ggml-cuda.cu @@ -61,7 +61,6 @@ #include "ggml-cuda/tri.cuh" #include "ggml-cuda/cumsum.cuh" #include "ggml-cuda/fill.cuh" -#include "ggml-cuda/scatter.cuh" #include "ggml-cuda/lightning_indexer.cuh" #include "ggml.h" @@ -2876,9 +2875,6 @@ static bool ggml_cuda_compute_forward(ggml_backend_cuda_context & ctx, struct gg case GGML_OP_FILL: ggml_cuda_op_fill(ctx, dst); break; - case GGML_OP_SCATTER: - ggml_cuda_op_scatter(ctx, dst); - break; case GGML_OP_LIGHTNING_INDEXER: ggml_cuda_op_lightning_indexer(ctx, dst); break; @@ -5061,7 +5057,6 @@ static bool ggml_backend_cuda_device_supports_op(ggml_backend_dev_t dev, const g case GGML_OP_TRI: case GGML_OP_DIAG: case GGML_OP_SOLVE_TRI: - case GGML_OP_SCATTER: case GGML_OP_LIGHTNING_INDEXER: return true; diff --git a/ggml/src/ggml-cuda/scatter.cu b/ggml/src/ggml-cuda/scatter.cu deleted file mode 100644 index 6dacb28b521..00000000000 --- a/ggml/src/ggml-cuda/scatter.cu +++ /dev/null @@ -1,88 +0,0 @@ -#include "scatter.cuh" -#include "convert.cuh" - -template -static __global__ void scatter_kernel( - const int32_t * src0, T * dst, const T c, - int64_t ne00, int64_t ne01, int64_t ne02, int64_t ne03, - size_t nb1, size_t nb2, size_t nb3, - size_t nb01, size_t nb02, size_t nb03 - ) { - - const int64_t total_blocks = ne01 * ne02 * ne03; - - for (int64_t block_idx = blockIdx.x; block_idx < total_blocks; block_idx += gridDim.x) { - - const int64_t i1 = block_idx % ne01; - const int64_t i2 = (block_idx / ne01) % ne02; - const int64_t i3 = block_idx / (ne01 * ne02); - - T * dst_row = (T *)((char *)dst + i1*nb1 + i2*nb2 + i3*nb3); - const int * src0_row = (const int *)((const char *)src0 + i1*nb01 + i2*nb02 + i3*nb03); - - for (int64_t i0 = threadIdx.x; i0 < ne00; i0 += blockDim.x) { - const int32_t id = src0_row[i0]; - dst_row[id] = c; - } - } -} - -void ggml_cuda_op_scatter(ggml_backend_cuda_context & ctx, ggml_tensor * dst) { - const ggml_tensor * src0 = dst->src[0]; - const ggml_tensor * src1 = dst->src[1]; - - GGML_TENSOR_BINARY_OP_LOCALS - - GGML_ASSERT(ggml_is_contiguous(dst)); - GGML_ASSERT(ggml_is_contiguous(src0)); - GGML_ASSERT(ggml_is_contiguous(src1)); - - GGML_ASSERT(dst->type == src0->type); - GGML_ASSERT(src1->type == GGML_TYPE_I32); - - GGML_ASSERT(nb10 == sizeof(int32_t)); - - GGML_ASSERT(ggml_nbytes(src0) == ggml_nbytes(dst)); - - float c = ggml_get_op_params_f32(dst, 0); - bool inplace = ggml_get_op_params_i32(dst, 1); - - // step 1 - copy whole src0 to dst - if (!inplace) { - cudaStream_t main_stream = ctx.stream(); - char * dst_ddc = (char *) dst->data; - char * src0_ddc = (char *) src0->data; - - CUDA_CHECK(cudaMemcpyAsync(dst_ddc, src0_ddc, ggml_nbytes(src0), cudaMemcpyDeviceToDevice, main_stream)); - } - - // step 2 - set elements in dst indicated by ids to c - const int32_t * src1_d = (const int32_t *) src1->data; - void * dst_d = dst->data; - - int threads = std::min((int) ne10, 512); // ids - - int64_t total_blocks = ne11 * ne12 * ne13; - int blocks = (int) std::min((int64_t) 65535, total_blocks); - - switch (dst->type) { - case GGML_TYPE_F32: - scatter_kernel<<>>( - src1_d, (float *) dst_d, c, - ne10, ne11, ne12, ne13, - nb1, nb2, nb3, - nb11, nb12, nb13 - ); - break; - case GGML_TYPE_F16: - scatter_kernel<<>>( - src1_d, (half *) dst_d, ggml_cuda_cast(c), - ne10, ne11, ne12, ne13, - nb1, nb2, nb3, - nb11, nb12, nb13 - ); - break; - default: - GGML_ABORT("unsupported type"); - } -} diff --git a/ggml/src/ggml.c b/ggml/src/ggml.c index 0ba9249778b..84125014747 100644 --- a/ggml/src/ggml.c +++ b/ggml/src/ggml.c @@ -1048,7 +1048,6 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "RWKV_WKV7", "SOLVE_TRI", "GATED_DELTA_NET", - "SCATTER", "LIGHTNING_INDEXER", "UNARY", @@ -1067,7 +1066,7 @@ static const char * GGML_OP_NAME[GGML_OP_COUNT] = { "GLU", }; -static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT != 98"); +static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "none", @@ -1160,7 +1159,6 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "rwkv_wkv7(r, w, k, v, a, b, s)", "A X = B, A triangular, solve X", "gated_delta_net(q, k, v, g, beta, s)", - "scatter(x,ids,c)", "lightning_indexer(q, k, weights, scale_embd, scale_heads)", "unary(x)", @@ -1179,7 +1177,7 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = { "glu(x)", }; -static_assert(GGML_OP_COUNT == 98, "GGML_OP_COUNT != 98"); +static_assert(GGML_OP_COUNT == 97, "GGML_OP_COUNT != 97"); static_assert(GGML_OP_POOL_COUNT == 2, "GGML_OP_POOL_COUNT != 2"); @@ -6207,49 +6205,6 @@ struct ggml_tensor * ggml_gated_delta_net( return result; } -// ggml_scatter - -static struct ggml_tensor * ggml_scatter_impl( - struct ggml_context * ctx, - struct ggml_tensor * a, - struct ggml_tensor * ids, - float c, - bool inplace) { - - GGML_ASSERT(a->type == GGML_TYPE_F32 || a->type == GGML_TYPE_F16); - GGML_ASSERT(ids->type == GGML_TYPE_I32); - GGML_ASSERT(a->ne[1] == ids->ne[1]); - GGML_ASSERT(a->ne[2] == ids->ne[2]); - GGML_ASSERT(a->ne[3] == ids->ne[3]); - - struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a); - - ggml_set_op_params_f32(result, 0, c); - ggml_set_op_params_i32(result, 1, inplace ? 1 : 0); - - result->op = GGML_OP_SCATTER; - result->src[0] = a; - result->src[1] = ids; - - return result; -} - -struct ggml_tensor * ggml_scatter( - struct ggml_context * ctx, - struct ggml_tensor * a, - struct ggml_tensor * ids, - float c) { - return ggml_scatter_impl(ctx, a, ids, c, false); -} - -struct ggml_tensor * ggml_scatter_inplace( - struct ggml_context * ctx, - struct ggml_tensor * a, - struct ggml_tensor * ids, - float c) { - return ggml_scatter_impl(ctx, a, ids, c, true); -} - // ggml_lightning_indexer struct ggml_tensor * ggml_lightning_indexer( diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index 763e82cc447..2cf85c06858 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -2304,8 +2304,25 @@ ggml_tensor * llm_graph_context::build_attn( // prepare new kq mask - starts filled with -INFINITY ggml_tensor * kq_mask_all = ggml_fill(ctx0, kq_mask, -INFINITY); - // modify it by unmasking tokens that are in top_k indices - ggml_tensor * kq_mask_top_k = ggml_scatter(ctx0, kq_mask_all, top_k, 0); + // reshape KQ mask into tensor with rows of size 1: + // [n_kv, n_batch, 1, n_stream] -> [1, n_kv, n_batch, n_stream] + kq_mask_all = ggml_view_4d(ctx0, kq_mask_all, 1, kq_mask_all->ne[0], kq_mask_all->ne[1], kq_mask_all->ne[3], kq_mask_all->nb[0], kq_mask_all->nb[1], kq_mask_all->nb[2], 0); + + // reshape top_k indices: [n_top_k, n_batch, 1, n_stream] -> [n_top_k, n_batch, n_stream, 1] + top_k = ggml_view_4d(ctx0, top_k, top_k->ne[0], top_k->ne[1], top_k->ne[3], 1, top_k->nb[1], top_k->nb[2], top_k->ne[3]*top_k->nb[3], 0); + + // prepare zero-filled tensor with rows of size 1: [1, n_top_k, n_batch, n_stream] + // this will be our source of zero values for unmasking top k mask elements + ggml_tensor * zeros = ggml_new_tensor_4d(ctx0, GGML_TYPE_F32, 1, top_k->ne[0], top_k->ne[1], top_k->ne[2]); + zeros = ggml_fill(ctx0, zeros, 0.0f); + + // modify KQ mask by unmasking elements that are in top_k indices + // ggml_set_rows([1, n_kv, n_batch, n_stream], [1, n_top_k, n_batch, n_stream], [n_top_k, n_batch, n_stream, 1]) + ggml_tensor * kq_mask_top_k = ggml_set_rows(ctx0, kq_mask_all, zeros, top_k); + + // reshape to restore the original shape of KQ mask: + // [1, n_kv, n_batch, n_stream] -> [n_kv, n_batch, 1, n_stream] + kq_mask_top_k = ggml_view_4d(ctx0, kq_mask_top_k, kq_mask_top_k->ne[1], kq_mask_top_k->ne[2], 1, kq_mask_top_k->ne[3], kq_mask_top_k->nb[2], kq_mask_top_k->nb[3], kq_mask_top_k->nb[3], 0); // combine with the original kq mask kq_mask_top_k = ggml_add(ctx0, kq_mask_top_k, kq_mask); diff --git a/tests/test-backend-ops.cpp b/tests/test-backend-ops.cpp index c968588aa22..52b4d771a33 100644 --- a/tests/test-backend-ops.cpp +++ b/tests/test-backend-ops.cpp @@ -6622,64 +6622,6 @@ struct test_diag : public test_case { } }; -// GGML_OP_SCATTER -struct test_scatter : public test_case { - const ggml_type type_a; - const ggml_type type_ids; - const std::array ne_a; - const std::array ne_ids; - float c; - bool inplace; - - std::string vars() override { - return VARS_TO_STR6(type_a, type_ids, ne_a, ne_ids, c, inplace); - } - - test_scatter(ggml_type type_a = GGML_TYPE_F32, - ggml_type type_ids = GGML_TYPE_I32, - std::array ne_a = {10, 10, 10, 10}, - std::array ne_ids = {3, 10, 10, 10}, - float c = 2.0f, - bool inplace = false) - : type_a(type_a), type_ids(type_ids), ne_a(ne_a), ne_ids(ne_ids), c(c), inplace(inplace) {} - - ggml_tensor * build_graph(ggml_context * ctx) override { - ggml_tensor * a = ggml_new_tensor(ctx, type_a, 4, ne_a.data()); - ggml_set_param(a); - ggml_set_name(a, "a"); - - ggml_tensor * ids = ggml_new_tensor(ctx, type_ids, 4, ne_ids.data()); - ggml_set_param(ids); - ggml_set_name(ids, "ids"); - - ggml_tensor * out; - if (inplace) { - out = ggml_scatter_inplace(ctx, a, ids, c); - } else { - out = ggml_scatter(ctx, a, ids, c); - } - ggml_set_name(out, "out"); - - return out; - } - - void initialize_tensors(ggml_context * ctx) override { - for (ggml_tensor * t = ggml_get_first_tensor(ctx); t != NULL; t = ggml_get_next_tensor(ctx, t)) { - if (t->type == GGML_TYPE_I32) { - // ids - const int num_pos_ids = ggml_nelements(t); - std::vector data(num_pos_ids); - for (int i = 0; i < num_pos_ids; i++) { - data[i] = rand() % ne_a[0]; - } - ggml_backend_tensor_set(t, data.data(), 0, num_pos_ids * sizeof(int)); - } else { - init_tensor_uniform(t); - } - } - } -}; - // GGML_OP_LIGHTNING_INDEXER struct test_lightning_indexer : public test_case { const ggml_type type_a; @@ -8799,16 +8741,6 @@ static std::vector> make_test_cases_eval() { test_cases.emplace_back(new test_falcon(2)); #endif - // scatter - test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, true)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, false)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, true)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, false)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, true)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 1, 1, 1}, {3, 1, 1, 1}, 0.0f, false)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, true)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {10, 10, 10, 10}, {3, 10, 10, 10}, 0.0f, false)); - // lightning_indexer test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); @@ -9093,12 +9025,6 @@ static std::vector> make_test_cases_perf() { test_cases.emplace_back(new test_gated_delta_net(GGML_TYPE_F32, 4, 128, 1024, 1)); // 4h PP-1024 test_cases.emplace_back(new test_gated_delta_net(GGML_TYPE_F32, 32, 128, 64, 1, 1, false, true)); // KDA PP-64 - // scatter - test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F32, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, true)); - test_cases.emplace_back(new test_scatter(GGML_TYPE_F16, GGML_TYPE_I32, {65536, 1, 1, 1}, {2048, 1, 1, 1}, 0.0f, false)); - // lightning_indexer test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_F16, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); test_cases.emplace_back(new test_lightning_indexer(GGML_TYPE_F32, GGML_TYPE_Q4_0, GGML_TYPE_F32, {128, 64, 128, 1}, {128, 1, 256, 1}, {64, 128, 1, 1}, 1.0f / sqrtf(float(128)), 1.0f / sqrtf(float(64)))); From 24215b2c60fa2978a95f1da36f5779fa91f327b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 15 Apr 2026 12:21:41 +0200 Subject: [PATCH 44/46] chore : whitespaces --- src/llama-graph.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/llama-graph.cpp b/src/llama-graph.cpp index 2cf85c06858..1e9474102d3 100644 --- a/src/llama-graph.cpp +++ b/src/llama-graph.cpp @@ -2304,7 +2304,7 @@ ggml_tensor * llm_graph_context::build_attn( // prepare new kq mask - starts filled with -INFINITY ggml_tensor * kq_mask_all = ggml_fill(ctx0, kq_mask, -INFINITY); - // reshape KQ mask into tensor with rows of size 1: + // reshape KQ mask into tensor with rows of size 1: // [n_kv, n_batch, 1, n_stream] -> [1, n_kv, n_batch, n_stream] kq_mask_all = ggml_view_4d(ctx0, kq_mask_all, 1, kq_mask_all->ne[0], kq_mask_all->ne[1], kq_mask_all->ne[3], kq_mask_all->nb[0], kq_mask_all->nb[1], kq_mask_all->nb[2], 0); From e0c767e48998e149afb9a7dfdae6da467bd7a8e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Wed, 15 Apr 2026 12:26:19 +0200 Subject: [PATCH 45/46] ggml : remove unused file --- ggml/src/ggml-cuda/scatter.cuh | 3 --- 1 file changed, 3 deletions(-) delete mode 100644 ggml/src/ggml-cuda/scatter.cuh diff --git a/ggml/src/ggml-cuda/scatter.cuh b/ggml/src/ggml-cuda/scatter.cuh deleted file mode 100644 index b435c992a64..00000000000 --- a/ggml/src/ggml-cuda/scatter.cuh +++ /dev/null @@ -1,3 +0,0 @@ -#include "common.cuh" - -void ggml_cuda_op_scatter(ggml_backend_cuda_context & ctx, ggml_tensor * dst); From 9695fc8dc38bb938a70a87afd5ef0cad23b7002a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stanis=C5=82aw=20Szymczyk?= Date: Mon, 20 Apr 2026 08:55:45 +0200 Subject: [PATCH 46/46] chore : whitespaces --- ggml/src/ggml-cuda/lightning_indexer.cu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ggml/src/ggml-cuda/lightning_indexer.cu b/ggml/src/ggml-cuda/lightning_indexer.cu index 6563d349b64..c8a2d829da9 100644 --- a/ggml/src/ggml-cuda/lightning_indexer.cu +++ b/ggml/src/ggml-cuda/lightning_indexer.cu @@ -87,7 +87,7 @@ static __global__ void lightning_indexer_kernel( } } -#define DECL_LIGHTNING_INDEXER_CASE(n_embd, n_head, type_K) \ +#define DECL_LIGHTNING_INDEXER_CASE(n_embd, n_head, type_K) \ template __global__ void lightning_indexer_kernel ( \ const float * src0, const char * src1, const float * src2, float * dst, \ const float scale_embd, const float scale_heads, \