/src/llama.cpp/src/llama-hparams.cpp

Source
#include "llama-hparams.h"

#include "ggml.h"

#include <algorithm>
#include <cassert>

void llama_hparams::set_swa_pattern(uint32_t n_pattern, bool dense_first) {
    if (dense_first) {
        for (uint32_t il = 0; il < n_layer; ++il) {
            swa_layers[il] = n_pattern == 0 || (il % n_pattern != 0);
        }
    } else {
        for (uint32_t il = 0; il < n_layer; ++il) {
            swa_layers[il] = n_pattern == 0 || (il % n_pattern < (n_pattern - 1));
        }
    }
}

bool llama_hparams::is_swa_any() const {
    for (uint32_t il = 0; il < n_layer; ++il) {
        if (swa_layers[il]) {
            return true;
        }
    }

    return false;
}

uint32_t llama_hparams::n_head(uint32_t il) const {
    if (il < n_layer) {
        return n_head_arr[il];
    }

    GGML_ABORT("fatal error");
}

uint32_t llama_hparams::n_head_kv(uint32_t il) const {
    if (il < n_layer) {
        return n_head_kv_arr[il];
    }

    GGML_ABORT("fatal error");
}

uint32_t llama_hparams::n_ff(uint32_t il) const {
    if (il < n_layer) {
        return n_ff_arr[il];
    }

    GGML_ABORT("fatal error");
}

uint32_t llama_hparams::n_gqa(uint32_t il) const {
    const uint32_t n_head    = this->n_head(il);
    const uint32_t n_head_kv = this->n_head_kv(il);

    if (n_head_kv == 0) {
        return 0;
    }

    return n_head/n_head_kv;
}

uint32_t llama_hparams::n_rot(uint32_t il) const {
    if (il < n_layer) {
        return is_swa(il) ? n_rot_swa : n_rot_full;
    }

    GGML_ABORT("fatal error");
}

uint32_t llama_hparams::n_embd_inp() const {
    uint32_t n_embd_inp = n_embd;

    if (n_deepstack_layers > 0) {
        n_embd_inp += n_embd * n_deepstack_layers;
    }

    return n_embd_inp;
}

uint32_t llama_hparams::n_embd_out() const {
    return n_embd_out_impl > 0 ? n_embd_out_impl : n_embd;
}

uint32_t llama_hparams::n_embd_head_k(uint32_t il) const {
    if (il < n_layer) {
        return is_swa(il) ? n_embd_head_k_swa : n_embd_head_k_full;
    }

    GGML_ABORT("fatal error");
}

uint32_t llama_hparams::n_embd_head_v(uint32_t il) const {
    if (il < n_layer) {
        return is_swa(il) ? n_embd_head_v_swa : n_embd_head_v_full;
    }

    GGML_ABORT("fatal error");
}

uint32_t llama_hparams::n_embd_k_gqa(uint32_t il) const {
    const uint32_t n_head_kv = this->n_head_kv(il);

    return n_embd_head_k(il) * n_head_kv;
}

uint32_t llama_hparams::n_embd_v_gqa(uint32_t il) const {
    const uint32_t n_head_kv = this->n_head_kv(il);

    return n_embd_head_v(il) * n_head_kv;
}

bool llama_hparams::is_n_embd_k_gqa_variable() const {
    const uint32_t val = n_embd_k_gqa();
    for (uint32_t il = 0; il < n_layer; ++il) {
        if (val != n_embd_k_gqa(il)) {
            return true;
        }
    }

    return false;
}

bool llama_hparams::is_n_embd_v_gqa_variable() const {
    const uint32_t val = n_embd_v_gqa();
    for (uint32_t il = 0; il < n_layer; ++il) {
        if (val != n_embd_v_gqa(il)) {
            return true;
        }
    }

    return false;
}

uint32_t llama_hparams::n_embd_k_gqa_max() const {
    uint32_t val = n_embd_k_gqa();
    for (uint32_t il = 0; il < n_layer; ++il) {
        val = std::max(val, n_embd_k_gqa(il));
    }

    return val;
}

uint32_t llama_hparams::n_embd_v_gqa_max() const {
    uint32_t val = n_embd_v_gqa();
    for (uint32_t il = 0; il < n_layer; ++il) {
        val = std::max(val, n_embd_v_gqa(il));
    }

    return val;
}

uint32_t llama_hparams::n_embd_r() const {
    if (wkv_head_size != 0) {
        // for RWKV models
        return token_shift_count * n_embd;
    }

    if (n_shortconv_l_cache != 0) {
        // for LFM2 models
        return n_embd * (n_shortconv_l_cache - 1);
    }

    if (n_embd_head_kda != 0) {
        // for Kimi KDA layers
        // Conv state for Q, K, V: 3 * (d_conv - 1) * n_head * head_dim
        const uint32_t d_inner = n_head() * n_embd_head_kda;  // 32 * 128 = 4096
        return 3 * (ssm_d_conv > 0 ? ssm_d_conv - 1 : 3) * d_inner;
    }

    // TODO: maybe support other convolution strides than 1
    // NOTE: since the first column of the conv_state is shifted out each time, it's not actually needed
    // Corresponds to Mamba's conv_states size
    return (ssm_d_conv > 0 ? ssm_d_conv - 1 : 0) * (ssm_d_inner + 2*ssm_n_group*ssm_d_state);
}

uint32_t llama_hparams::n_embd_s() const {
    if (wkv_head_size != 0) {
        // corresponds to RWKV's wkv_states size
        return n_embd * wkv_head_size;
    }

    if (n_embd_head_kda != 0) {
        // for Kimi KDA layers
        // Full recurrent state: head_dim * head_dim * n_head
        // h tensor shape for delta attention: [head_dim, head_dim, n_head]
        return n_embd_head_kda * n_embd_head_kda * n_head();  // 128 * 128 * 32 = 524288
    }

    // corresponds to Mamba's ssm_states size
    return ssm_d_state * ssm_d_inner;
}

bool llama_hparams::is_recurrent(uint32_t il) const {
    if (il < n_layer) {
        return recurrent_layer_arr[il];
    }

    GGML_ABORT("%s: il (%u) out of bounds (n_layer: %u)\n", __func__, il, n_layer);
}

uint32_t llama_hparams::n_pos_per_embd() const {
    return rope_type == LLAMA_ROPE_TYPE_MROPE || rope_type == LLAMA_ROPE_TYPE_IMROPE ? 4 : 1;
}

bool llama_hparams::is_swa(uint32_t il) const {
    if (il < n_layer) {
        return swa_layers[il];
    }

    GGML_ABORT("fatal error");
}

bool llama_hparams::is_mla() const {
    assert((n_embd_head_k_mla_impl == 0 && n_embd_head_v_mla_impl == 0) ||
           (n_embd_head_k_mla_impl != 0 && n_embd_head_v_mla_impl != 0));

    return n_embd_head_k_mla_impl != 0 && n_embd_head_v_mla_impl != 0;
}

uint32_t llama_hparams::n_embd_head_k_mla() const {
    return is_mla() ? n_embd_head_k_mla_impl : n_embd_head_k();
}

uint32_t llama_hparams::n_embd_head_v_mla() const {
    return is_mla() ? n_embd_head_v_mla_impl : n_embd_head_v();
}

bool llama_hparams::has_kv(uint32_t il) const {
    if (n_layer_kv_from_start >= 0) {
        if (il < (uint32_t) n_layer_kv_from_start) {
            return true;
        }

        return false;
    }

    // by default, all layers have kv
    return true;
}

uint32_t llama_hparams::n_layer_kv() const {
    uint32_t res = 0;

    for (uint32_t il = 0; il < n_layer; ++il) {
        if (has_kv(il)) {
            res++;
        }
    }

    return res;
}

bool llama_hparams::use_mrope() const {
    return rope_sections[0] > 0 && rope_sections[1] > 0;
}

Coverage Report

Created: 2026-04-12 06:40

Line	Count	Source
1		#include "llama-hparams.h"
2
3		#include "ggml.h"
4
5		#include <algorithm>
6		#include <cassert>
7
8	0	void llama_hparams::set_swa_pattern(uint32_t n_pattern, bool dense_first) {
9	0	if (dense_first) {
10	0	for (uint32_t il = 0; il < n_layer; ++il) {
11	0	swa_layers[il] = n_pattern == 0 \|\| (il % n_pattern != 0);
12	0	}
13	0	} else {
14	0	for (uint32_t il = 0; il < n_layer; ++il) {
15	0	swa_layers[il] = n_pattern == 0 \|\| (il % n_pattern < (n_pattern - 1));
16	0	}
17	0	}
18	0	}
19
20	0	bool llama_hparams::is_swa_any() const {
21	0	for (uint32_t il = 0; il < n_layer; ++il) {
22	0	if (swa_layers[il]) {
23	0	return true;
24	0	}
25	0	}
26
27	0	return false;
28	0	}
29
30	0	uint32_t llama_hparams::n_head(uint32_t il) const {
31	0	if (il < n_layer) {
32	0	return n_head_arr[il];
33	0	}
34
35	0	GGML_ABORT("fatal error");
36	0	}
37
38	0	uint32_t llama_hparams::n_head_kv(uint32_t il) const {
39	0	if (il < n_layer) {
40	0	return n_head_kv_arr[il];
41	0	}
42
43	0	GGML_ABORT("fatal error");
44	0	}
45
46	0	uint32_t llama_hparams::n_ff(uint32_t il) const {
47	0	if (il < n_layer) {
48	0	return n_ff_arr[il];
49	0	}
50
51	0	GGML_ABORT("fatal error");
52	0	}
53
54	0	uint32_t llama_hparams::n_gqa(uint32_t il) const {
55	0	const uint32_t n_head = this->n_head(il);
56	0	const uint32_t n_head_kv = this->n_head_kv(il);
57
58	0	if (n_head_kv == 0) {
59	0	return 0;
60	0	}
61
62	0	return n_head/n_head_kv;
63	0	}
64
65	0	uint32_t llama_hparams::n_rot(uint32_t il) const {
66	0	if (il < n_layer) {
67	0	return is_swa(il) ? n_rot_swa : n_rot_full;
68	0	}
69
70	0	GGML_ABORT("fatal error");
71	0	}
72
73	0	uint32_t llama_hparams::n_embd_inp() const {
74	0	uint32_t n_embd_inp = n_embd;
75
76	0	if (n_deepstack_layers > 0) {
77	0	n_embd_inp += n_embd * n_deepstack_layers;
78	0	}
79
80	0	return n_embd_inp;
81	0	}
82
83	0	uint32_t llama_hparams::n_embd_out() const {
84	0	return n_embd_out_impl > 0 ? n_embd_out_impl : n_embd;
85	0	}
86
87	0	uint32_t llama_hparams::n_embd_head_k(uint32_t il) const {
88	0	if (il < n_layer) {
89	0	return is_swa(il) ? n_embd_head_k_swa : n_embd_head_k_full;
90	0	}
91
92	0	GGML_ABORT("fatal error");
93	0	}
94
95	0	uint32_t llama_hparams::n_embd_head_v(uint32_t il) const {
96	0	if (il < n_layer) {
97	0	return is_swa(il) ? n_embd_head_v_swa : n_embd_head_v_full;
98	0	}
99
100	0	GGML_ABORT("fatal error");
101	0	}
102
103	0	uint32_t llama_hparams::n_embd_k_gqa(uint32_t il) const {
104	0	const uint32_t n_head_kv = this->n_head_kv(il);
105
106	0	return n_embd_head_k(il) * n_head_kv;
107	0	}
108
109	0	uint32_t llama_hparams::n_embd_v_gqa(uint32_t il) const {
110	0	const uint32_t n_head_kv = this->n_head_kv(il);
111
112	0	return n_embd_head_v(il) * n_head_kv;
113	0	}
114
115	0	bool llama_hparams::is_n_embd_k_gqa_variable() const {
116	0	const uint32_t val = n_embd_k_gqa();
117	0	for (uint32_t il = 0; il < n_layer; ++il) {
118	0	if (val != n_embd_k_gqa(il)) {
119	0	return true;
120	0	}
121	0	}
122
123	0	return false;
124	0	}
125
126	0	bool llama_hparams::is_n_embd_v_gqa_variable() const {
127	0	const uint32_t val = n_embd_v_gqa();
128	0	for (uint32_t il = 0; il < n_layer; ++il) {
129	0	if (val != n_embd_v_gqa(il)) {
130	0	return true;
131	0	}
132	0	}
133
134	0	return false;
135	0	}
136
137	0	uint32_t llama_hparams::n_embd_k_gqa_max() const {
138	0	uint32_t val = n_embd_k_gqa();
139	0	for (uint32_t il = 0; il < n_layer; ++il) {
140	0	val = std::max(val, n_embd_k_gqa(il));
141	0	}
142
143	0	return val;
144	0	}
145
146	0	uint32_t llama_hparams::n_embd_v_gqa_max() const {
147	0	uint32_t val = n_embd_v_gqa();
148	0	for (uint32_t il = 0; il < n_layer; ++il) {
149	0	val = std::max(val, n_embd_v_gqa(il));
150	0	}
151
152	0	return val;
153	0	}
154
155	0	uint32_t llama_hparams::n_embd_r() const {
156	0	if (wkv_head_size != 0) {
157		// for RWKV models
158	0	return token_shift_count * n_embd;
159	0	}
160
161	0	if (n_shortconv_l_cache != 0) {
162		// for LFM2 models
163	0	return n_embd * (n_shortconv_l_cache - 1);
164	0	}
165
166	0	if (n_embd_head_kda != 0) {
167		// for Kimi KDA layers
168		// Conv state for Q, K, V: 3 * (d_conv - 1) * n_head * head_dim
169	0	const uint32_t d_inner = n_head() * n_embd_head_kda; // 32 * 128 = 4096
170	0	return 3 * (ssm_d_conv > 0 ? ssm_d_conv - 1 : 3) * d_inner;
171	0	}
172
173		// TODO: maybe support other convolution strides than 1
174		// NOTE: since the first column of the conv_state is shifted out each time, it's not actually needed
175		// Corresponds to Mamba's conv_states size
176	0	return (ssm_d_conv > 0 ? ssm_d_conv - 1 : 0) * (ssm_d_inner + 2ssm_n_groupssm_d_state);
177	0	}
178
179	0	uint32_t llama_hparams::n_embd_s() const {
180	0	if (wkv_head_size != 0) {
181		// corresponds to RWKV's wkv_states size
182	0	return n_embd * wkv_head_size;
183	0	}
184
185	0	if (n_embd_head_kda != 0) {
186		// for Kimi KDA layers
187		// Full recurrent state: head_dim * head_dim * n_head
188		// h tensor shape for delta attention: [head_dim, head_dim, n_head]
189	0	return n_embd_head_kda * n_embd_head_kda * n_head(); // 128 * 128 * 32 = 524288
190	0	}
191
192		// corresponds to Mamba's ssm_states size
193	0	return ssm_d_state * ssm_d_inner;
194	0	}
195
196	0	bool llama_hparams::is_recurrent(uint32_t il) const {
197	0	if (il < n_layer) {
198	0	return recurrent_layer_arr[il];
199	0	}
200
201	0	GGML_ABORT("%s: il (%u) out of bounds (n_layer: %u)\n", __func__, il, n_layer);
202	0	}
203
204	0	uint32_t llama_hparams::n_pos_per_embd() const {
205	0	return rope_type == LLAMA_ROPE_TYPE_MROPE \|\| rope_type == LLAMA_ROPE_TYPE_IMROPE ? 4 : 1;
206	0	}
207
208	0	bool llama_hparams::is_swa(uint32_t il) const {
209	0	if (il < n_layer) {
210	0	return swa_layers[il];
211	0	}
212
213	0	GGML_ABORT("fatal error");
214	0	}
215
216	0	bool llama_hparams::is_mla() const {
217	0	assert((n_embd_head_k_mla_impl == 0 && n_embd_head_v_mla_impl == 0) \|\|
218	0	(n_embd_head_k_mla_impl != 0 && n_embd_head_v_mla_impl != 0));
219
220	0	return n_embd_head_k_mla_impl != 0 && n_embd_head_v_mla_impl != 0;
221	0	}
222
223	0	uint32_t llama_hparams::n_embd_head_k_mla() const {
224	0	return is_mla() ? n_embd_head_k_mla_impl : n_embd_head_k();
225	0	}
226
227	0	uint32_t llama_hparams::n_embd_head_v_mla() const {
228	0	return is_mla() ? n_embd_head_v_mla_impl : n_embd_head_v();
229	0	}
230
231	0	bool llama_hparams::has_kv(uint32_t il) const {
232	0	if (n_layer_kv_from_start >= 0) {
233	0	if (il < (uint32_t) n_layer_kv_from_start) {
234	0	return true;
235	0	}
236
237	0	return false;
238	0	}
239
240		// by default, all layers have kv
241	0	return true;
242	0	}
243
244	0	uint32_t llama_hparams::n_layer_kv() const {
245	0	uint32_t res = 0;
246
247	0	for (uint32_t il = 0; il < n_layer; ++il) {
248	0	if (has_kv(il)) {
249	0	res++;
250	0	}
251	0	}
252
253	0	return res;
254	0	}
255
256	0	bool llama_hparams::use_mrope() const {
257	0	return rope_sections[0] > 0 && rope_sections[1] > 0;
258	0	}