mirror of
https://github.com/ggerganov/whisper.cpp.git
synced 2025-06-01 07:25:49 +02:00
vulkan: KHR_coopmat flash attention (llama/13506)
This shader uses coopmat1 to do the Q*K^T multiply. The P*V multiply is more difficult for various reasons so I haven't done it. Performance for this shader is around 2.5x better than for the scalar shader when doing prompt processing. Some of the benefit may be from other optimizations like staging through shared memory, or splitting by rows.
This commit is contained in:
Jeff Bolz
Georgi Gerganov
parent
a221288dc6
commit
162bbe8220
@ -288,6 +288,9 @@ struct vk_device_struct {
|
|||||||
bool coopmat_acc_f32_support {};
|
bool coopmat_acc_f32_support {};
|
||||||
bool coopmat_acc_f16_support {};
|
bool coopmat_acc_f16_support {};
|
||||||
bool coopmat_bf16_support {};
|
bool coopmat_bf16_support {};
|
||||||
|
bool coopmat_support_16x16x16_f16acc {};
|
||||||
|
bool coopmat_support_16x16x16_f32acc {};
|
||||||
|
bool coopmat1_fa_support {};
|
||||||
uint32_t coopmat_m;
|
uint32_t coopmat_m;
|
||||||
uint32_t coopmat_n;
|
uint32_t coopmat_n;
|
||||||
uint32_t coopmat_k;
|
uint32_t coopmat_k;
|
||||||
@ -410,6 +413,13 @@ struct vk_device_struct {
|
|||||||
vk_pipeline pipeline_flash_attn_f32_f16_D128_cm2[GGML_TYPE_COUNT][2][2][2];
|
vk_pipeline pipeline_flash_attn_f32_f16_D128_cm2[GGML_TYPE_COUNT][2][2][2];
|
||||||
vk_pipeline pipeline_flash_attn_f32_f16_D256_cm2[GGML_TYPE_COUNT][2][2][2];
|
vk_pipeline pipeline_flash_attn_f32_f16_D256_cm2[GGML_TYPE_COUNT][2][2][2];
|
||||||
|
|
||||||
|
vk_pipeline pipeline_flash_attn_f32_f16_D64_cm1[GGML_TYPE_COUNT][2][2][2];
|
||||||
|
vk_pipeline pipeline_flash_attn_f32_f16_D80_cm1[GGML_TYPE_COUNT][2][2][2];
|
||||||
|
vk_pipeline pipeline_flash_attn_f32_f16_D96_cm1[GGML_TYPE_COUNT][2][2][2];
|
||||||
|
vk_pipeline pipeline_flash_attn_f32_f16_D112_cm1[GGML_TYPE_COUNT][2][2][2];
|
||||||
|
vk_pipeline pipeline_flash_attn_f32_f16_D128_cm1[GGML_TYPE_COUNT][2][2][2];
|
||||||
|
vk_pipeline pipeline_flash_attn_f32_f16_D256_cm1[GGML_TYPE_COUNT][2][2][2];
|
||||||
|
|
||||||
vk_pipeline pipeline_flash_attn_f32_f16_D64[GGML_TYPE_COUNT][2][2][2];
|
vk_pipeline pipeline_flash_attn_f32_f16_D64[GGML_TYPE_COUNT][2][2][2];
|
||||||
vk_pipeline pipeline_flash_attn_f32_f16_D80[GGML_TYPE_COUNT][2][2][2];
|
vk_pipeline pipeline_flash_attn_f32_f16_D80[GGML_TYPE_COUNT][2][2][2];
|
||||||
vk_pipeline pipeline_flash_attn_f32_f16_D96[GGML_TYPE_COUNT][2][2][2];
|
vk_pipeline pipeline_flash_attn_f32_f16_D96[GGML_TYPE_COUNT][2][2][2];
|
||||||
@ -1588,19 +1598,36 @@ static void ggml_vk_wait_events(vk_context& ctx, std::vector<vk::Event>&& events
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
enum FaCodePath {
|
||||||
|
FA_SCALAR,
|
||||||
|
FA_COOPMAT1,
|
||||||
|
FA_COOPMAT2,
|
||||||
|
};
|
||||||
|
|
||||||
// number of rows/cols for flash attention shader
|
// number of rows/cols for flash attention shader
|
||||||
static constexpr uint32_t flash_attention_num_small_rows = 32;
|
static constexpr uint32_t flash_attention_num_small_rows = 32;
|
||||||
static constexpr uint32_t scalar_flash_attention_num_small_rows = 1;
|
static constexpr uint32_t scalar_flash_attention_num_small_rows = 1;
|
||||||
static constexpr uint32_t scalar_flash_attention_num_large_rows = 8;
|
static constexpr uint32_t scalar_flash_attention_num_large_rows = 8;
|
||||||
|
|
||||||
static uint32_t get_fa_num_small_rows(bool scalar) {
|
// The FA coopmat1 shader assumes 16x16x16 matrix multiply support.
|
||||||
return scalar ? scalar_flash_attention_num_small_rows : flash_attention_num_small_rows;
|
// 128 threads split into four subgroups, each subgroup does 1/4
|
||||||
|
// of the Bc dimension.
|
||||||
|
static constexpr uint32_t coopmat1_flash_attention_num_large_rows = 16;
|
||||||
|
static constexpr uint32_t scalar_flash_attention_Bc = 64;
|
||||||
|
static constexpr uint32_t scalar_flash_attention_workgroup_size = 128;
|
||||||
|
|
||||||
|
static uint32_t get_fa_num_small_rows(FaCodePath path) {
|
||||||
|
if (path == FA_COOPMAT2) {
|
||||||
|
return flash_attention_num_small_rows;
|
||||||
|
} else {
|
||||||
|
return scalar_flash_attention_num_small_rows;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static std::array<uint32_t, 2> fa_rows_cols(bool scalar, uint32_t D, uint32_t clamp, ggml_type type, bool small_rows) {
|
static std::array<uint32_t, 2> fa_rows_cols(FaCodePath path, uint32_t D, uint32_t clamp, ggml_type type, bool small_rows) {
|
||||||
GGML_UNUSED(clamp);
|
GGML_UNUSED(clamp);
|
||||||
|
|
||||||
if (scalar) {
|
if (path == FA_SCALAR) {
|
||||||
if (small_rows) {
|
if (small_rows) {
|
||||||
return {scalar_flash_attention_num_small_rows, 64};
|
return {scalar_flash_attention_num_small_rows, 64};
|
||||||
} else {
|
} else {
|
||||||
@ -1608,9 +1635,17 @@ static std::array<uint32_t, 2> fa_rows_cols(bool scalar, uint32_t D, uint32_t cl
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (path == FA_COOPMAT1) {
|
||||||
|
if (small_rows) {
|
||||||
|
return {scalar_flash_attention_num_small_rows, scalar_flash_attention_Bc};
|
||||||
|
} else {
|
||||||
|
return {coopmat1_flash_attention_num_large_rows, scalar_flash_attention_Bc};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// small rows, large cols
|
// small rows, large cols
|
||||||
if (small_rows) {
|
if (small_rows) {
|
||||||
return {get_fa_num_small_rows(scalar), 32};
|
return {get_fa_num_small_rows(FA_COOPMAT2), 32};
|
||||||
}
|
}
|
||||||
|
|
||||||
// small cols to reduce register count
|
// small cols to reduce register count
|
||||||
@ -1907,17 +1942,19 @@ static void ggml_vk_load_shaders(vk_device& device) {
|
|||||||
parameter_count, wg_denoms, specialization_constants, disable_robustness, require_full_subgroups, required_subgroup_size));
|
parameter_count, wg_denoms, specialization_constants, disable_robustness, require_full_subgroups, required_subgroup_size));
|
||||||
};
|
};
|
||||||
|
|
||||||
auto const &fa_wg_denoms = [&](bool scalar, uint32_t D, uint32_t clamp, ggml_type type, bool small_rows) -> std::array<uint32_t, 3> {
|
auto const &fa_wg_denoms = [&](FaCodePath path, uint32_t D, uint32_t clamp, ggml_type type, bool small_rows) -> std::array<uint32_t, 3> {
|
||||||
return {fa_rows_cols(scalar, D, clamp, type, small_rows)[0], 1, 1};
|
return {fa_rows_cols(path, D, clamp, type, small_rows)[0], 1, 1};
|
||||||
};
|
};
|
||||||
|
|
||||||
auto const &fa_spec_constants = [&](bool scalar, uint32_t D, uint32_t clamp, ggml_type type, bool small_rows) -> std::vector<uint32_t> {
|
auto const &fa_spec_constants = [&](FaCodePath path, uint32_t D, uint32_t clamp, ggml_type type, bool small_rows) -> std::vector<uint32_t> {
|
||||||
// For large number of rows, 128 invocations seems to work best.
|
// For large number of rows, 128 invocations seems to work best.
|
||||||
// For small number of rows (e.g. N==1), 256 works better. But matrix granularity for 256 is 32, so we
|
// For small number of rows (e.g. N==1), 256 works better. But matrix granularity for 256 is 32, so we
|
||||||
// can't use 256 for D==80.
|
// can't use 256 for D==80.
|
||||||
// For scalar, use 128 (arbitrary)
|
// For scalar, use 128 (arbitrary)
|
||||||
uint32_t wg_size = scalar ? 128 : ((small_rows && (D % 32) == 0) ? 256 : 128);
|
uint32_t wg_size = (path == FA_SCALAR || path == FA_COOPMAT1)
|
||||||
auto rows_cols = fa_rows_cols(scalar, D, clamp, type, small_rows);
|
? scalar_flash_attention_workgroup_size
|
||||||
|
: ((small_rows && (D % 32) == 0) ? 256 : 128);
|
||||||
|
auto rows_cols = fa_rows_cols(path, D, clamp, type, small_rows);
|
||||||
|
|
||||||
// D_split can't be larger than a subgroup because we use subgroupShuffle to reduce it.
|
// D_split can't be larger than a subgroup because we use subgroupShuffle to reduce it.
|
||||||
// D_split can't be larger than the LSB of D divided by 4 due to vectorization in the shader.
|
// D_split can't be larger than the LSB of D divided by 4 due to vectorization in the shader.
|
||||||
@ -1929,36 +1966,43 @@ static void ggml_vk_load_shaders(vk_device& device) {
|
|||||||
return {wg_size, rows_cols[0], rows_cols[1], (D), clamp, D_split};
|
return {wg_size, rows_cols[0], rows_cols[1], (D), clamp, D_split};
|
||||||
};
|
};
|
||||||
|
|
||||||
#define CREATE_FA2(TYPE, NAMELC, SCALAR, SUFFIX, D) \
|
#define CREATE_FA2(TYPE, NAMELC, FAPATH, SUFFIX, D) \
|
||||||
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][0][0][0], "flash_attn_f32_f16_D" #D "_f16acc" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(SCALAR, D,1,TYPE,false), fa_spec_constants(SCALAR, D,1,TYPE,false), 1, true); \
|
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][0][0][0], "flash_attn_f32_f16_D" #D "_f16acc" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(FAPATH, D,1,TYPE,false), fa_spec_constants(FAPATH, D,1,TYPE,false), 1, true, FAPATH==FA_COOPMAT1, (FAPATH==FA_COOPMAT1 ? 32 : 0)); \
|
||||||
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][0][0][1], "flash_attn_f32_f16_D" #D "_aligned_f16acc" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(SCALAR, D,0,TYPE,false), fa_spec_constants(SCALAR, D,0,TYPE,false), fa_rows_cols(SCALAR,D,0,TYPE,false)[1], true); \
|
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][0][0][1], "flash_attn_f32_f16_D" #D "_aligned_f16acc" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(FAPATH, D,0,TYPE,false), fa_spec_constants(FAPATH, D,0,TYPE,false), fa_rows_cols(FAPATH,D,0,TYPE,false)[1], true, FAPATH==FA_COOPMAT1, (FAPATH==FA_COOPMAT1 ? 32 : 0)); \
|
||||||
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][1][0][0], "flash_attn_f32_f16_D" #D "_f32acc" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(SCALAR, D,1,TYPE,false), fa_spec_constants(SCALAR, D,1,TYPE,false), 1, true); \
|
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][1][0][0], "flash_attn_f32_f16_D" #D "_f32acc" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(FAPATH, D,1,TYPE,false), fa_spec_constants(FAPATH, D,1,TYPE,false), 1, true, FAPATH==FA_COOPMAT1, (FAPATH==FA_COOPMAT1 ? 32 : 0)); \
|
||||||
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][1][0][1], "flash_attn_f32_f16_D" #D "_aligned_f32acc" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(SCALAR, D,0,TYPE,false), fa_spec_constants(SCALAR, D,0,TYPE,false), fa_rows_cols(SCALAR,D,0,TYPE,false)[1], true); \
|
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][1][0][1], "flash_attn_f32_f16_D" #D "_aligned_f32acc" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(FAPATH, D,0,TYPE,false), fa_spec_constants(FAPATH, D,0,TYPE,false), fa_rows_cols(FAPATH,D,0,TYPE,false)[1], true, FAPATH==FA_COOPMAT1, (FAPATH==FA_COOPMAT1 ? 32 : 0)); \
|
||||||
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][0][1][0], "flash_attn_f32_f16_D" #D "_f16acc_smallrows" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(SCALAR, D,1,TYPE,true), fa_spec_constants(SCALAR, D,1,TYPE,true), 1, true); \
|
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][0][1][0], "flash_attn_f32_f16_D" #D "_f16acc_smallrows" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(FAPATH, D,1,TYPE,true), fa_spec_constants(FAPATH, D,1,TYPE,true), 1, true, FAPATH==FA_COOPMAT1, (FAPATH==FA_COOPMAT1 ? 32 : 0)); \
|
||||||
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][0][1][1], "flash_attn_f32_f16_D" #D "_aligned_f16acc_smallrows" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(SCALAR, D,0,TYPE,true), fa_spec_constants(SCALAR, D,0,TYPE,true), fa_rows_cols(SCALAR,D,0,TYPE,true)[1], true); \
|
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][0][1][1], "flash_attn_f32_f16_D" #D "_aligned_f16acc_smallrows" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## _f16acc ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(FAPATH, D,0,TYPE,true), fa_spec_constants(FAPATH, D,0,TYPE,true), fa_rows_cols(FAPATH,D,0,TYPE,true)[1], true, FAPATH==FA_COOPMAT1, (FAPATH==FA_COOPMAT1 ? 32 : 0)); \
|
||||||
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][1][1][0], "flash_attn_f32_f16_D" #D "_f32acc_smallrows" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(SCALAR, D,1,TYPE,true), fa_spec_constants(SCALAR, D,1,TYPE,true), 1, true); \
|
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][1][1][0], "flash_attn_f32_f16_D" #D "_f32acc_smallrows" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(FAPATH, D,1,TYPE,true), fa_spec_constants(FAPATH, D,1,TYPE,true), 1, true, FAPATH==FA_COOPMAT1, (FAPATH==FA_COOPMAT1 ? 32 : 0)); \
|
||||||
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][1][1][1], "flash_attn_f32_f16_D" #D "_aligned_f32acc_smallrows" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(SCALAR, D,0,TYPE,true), fa_spec_constants(SCALAR, D,0,TYPE,true), fa_rows_cols(SCALAR,D,0,TYPE,true)[1], true); \
|
ggml_vk_create_pipeline(device, device->pipeline_flash_attn_f32_f16_D ## D ## SUFFIX[TYPE][1][1][1], "flash_attn_f32_f16_D" #D "_aligned_f32acc_smallrows" #NAMELC #SUFFIX, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _len, flash_attn_f32_f16_ ## NAMELC ## SUFFIX ## _data, "main", 5, sizeof(vk_flash_attn_push_constants), fa_wg_denoms(FAPATH, D,0,TYPE,true), fa_spec_constants(FAPATH, D,0,TYPE,true), fa_rows_cols(FAPATH,D,0,TYPE,true)[1], true, FAPATH==FA_COOPMAT1, (FAPATH==FA_COOPMAT1 ? 32 : 0)); \
|
||||||
|
|
||||||
#define CREATE_FA(TYPE, NAMELC, SCALAR, SUFFIX) \
|
#define CREATE_FA(TYPE, NAMELC, FAPATH, SUFFIX) \
|
||||||
CREATE_FA2(TYPE, NAMELC, SCALAR, SUFFIX, 64) \
|
CREATE_FA2(TYPE, NAMELC, FAPATH, SUFFIX, 64) \
|
||||||
CREATE_FA2(TYPE, NAMELC, SCALAR, SUFFIX, 80) \
|
CREATE_FA2(TYPE, NAMELC, FAPATH, SUFFIX, 80) \
|
||||||
CREATE_FA2(TYPE, NAMELC, SCALAR, SUFFIX, 96) \
|
CREATE_FA2(TYPE, NAMELC, FAPATH, SUFFIX, 96) \
|
||||||
CREATE_FA2(TYPE, NAMELC, SCALAR, SUFFIX, 112) \
|
CREATE_FA2(TYPE, NAMELC, FAPATH, SUFFIX, 112) \
|
||||||
CREATE_FA2(TYPE, NAMELC, SCALAR, SUFFIX, 128) \
|
CREATE_FA2(TYPE, NAMELC, FAPATH, SUFFIX, 128) \
|
||||||
CREATE_FA2(TYPE, NAMELC, SCALAR, SUFFIX, 256)
|
CREATE_FA2(TYPE, NAMELC, FAPATH, SUFFIX, 256)
|
||||||
|
|
||||||
CREATE_FA(GGML_TYPE_F16, f16, true, )
|
CREATE_FA(GGML_TYPE_F16, f16, FA_SCALAR, )
|
||||||
CREATE_FA(GGML_TYPE_Q4_0, q4_0, true, )
|
CREATE_FA(GGML_TYPE_Q4_0, q4_0, FA_SCALAR, )
|
||||||
CREATE_FA(GGML_TYPE_Q8_0, q8_0, true, )
|
CREATE_FA(GGML_TYPE_Q8_0, q8_0, FA_SCALAR, )
|
||||||
|
#if defined(VK_KHR_cooperative_matrix) && defined(GGML_VULKAN_COOPMAT_GLSLC_SUPPORT)
|
||||||
|
if (device->coopmat1_fa_support) {
|
||||||
|
CREATE_FA(GGML_TYPE_F16, f16, FA_COOPMAT1, _cm1)
|
||||||
|
CREATE_FA(GGML_TYPE_Q4_0, q4_0, FA_COOPMAT1, _cm1)
|
||||||
|
CREATE_FA(GGML_TYPE_Q8_0, q8_0, FA_COOPMAT1, _cm1)
|
||||||
|
}
|
||||||
|
#endif
|
||||||
#if defined(VK_NV_cooperative_matrix2) && defined(GGML_VULKAN_COOPMAT2_GLSLC_SUPPORT)
|
#if defined(VK_NV_cooperative_matrix2) && defined(GGML_VULKAN_COOPMAT2_GLSLC_SUPPORT)
|
||||||
if (device->coopmat2) {
|
if (device->coopmat2) {
|
||||||
CREATE_FA(GGML_TYPE_F16, f16, false, _cm2)
|
CREATE_FA(GGML_TYPE_F16, f16, FA_COOPMAT2, _cm2)
|
||||||
CREATE_FA(GGML_TYPE_Q4_0, q4_0, false, _cm2)
|
CREATE_FA(GGML_TYPE_Q4_0, q4_0, FA_COOPMAT2, _cm2)
|
||||||
CREATE_FA(GGML_TYPE_Q4_1, q4_1, false, _cm2)
|
CREATE_FA(GGML_TYPE_Q4_1, q4_1, FA_COOPMAT2, _cm2)
|
||||||
CREATE_FA(GGML_TYPE_Q5_0, q5_0, false, _cm2)
|
CREATE_FA(GGML_TYPE_Q5_0, q5_0, FA_COOPMAT2, _cm2)
|
||||||
CREATE_FA(GGML_TYPE_Q5_1, q5_1, false, _cm2)
|
CREATE_FA(GGML_TYPE_Q5_1, q5_1, FA_COOPMAT2, _cm2)
|
||||||
CREATE_FA(GGML_TYPE_Q8_0, q8_0, false, _cm2)
|
CREATE_FA(GGML_TYPE_Q8_0, q8_0, FA_COOPMAT2, _cm2)
|
||||||
CREATE_FA(GGML_TYPE_IQ4_NL, iq4_nl, false, _cm2)
|
CREATE_FA(GGML_TYPE_IQ4_NL, iq4_nl, FA_COOPMAT2, _cm2)
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
#undef CREATE_FA2
|
#undef CREATE_FA2
|
||||||
@ -2041,17 +2085,17 @@ static void ggml_vk_load_shaders(vk_device& device) {
|
|||||||
// Create 6 variants, {s,m,l}x{unaligned,aligned}
|
// Create 6 variants, {s,m,l}x{unaligned,aligned}
|
||||||
#define CREATE_MM(TYPE, PIPELINE_NAME, NAMELC, F16ACC, WG_DENOMS, WARPTILE, PUSHCONST, PARAMCOUNT, ID) \
|
#define CREATE_MM(TYPE, PIPELINE_NAME, NAMELC, F16ACC, WG_DENOMS, WARPTILE, PUSHCONST, PARAMCOUNT, ID) \
|
||||||
if (device->mul_mat ## ID ## _l[TYPE]) \
|
if (device->mul_mat ## ID ## _l[TYPE]) \
|
||||||
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->l, #NAMELC #F16ACC "_l", NAMELC ## F16ACC ## _coopmat_len, NAMELC ## F16ACC ## _coopmat_data, "main", PARAMCOUNT, sizeof(PUSHCONST), l_ ## WG_DENOMS, l_ ## WARPTILE, 1, false, true); \
|
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->l, #NAMELC #F16ACC "_l", NAMELC ## F16ACC ## _cm1_len, NAMELC ## F16ACC ## _cm1_data, "main", PARAMCOUNT, sizeof(PUSHCONST), l_ ## WG_DENOMS, l_ ## WARPTILE, 1, false, true); \
|
||||||
if (device->mul_mat ## ID ## _m[TYPE]) \
|
if (device->mul_mat ## ID ## _m[TYPE]) \
|
||||||
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->m, #NAMELC #F16ACC "_m", NAMELC ## F16ACC ## _coopmat_len, NAMELC ## F16ACC ## _coopmat_data, "main", PARAMCOUNT, sizeof(PUSHCONST), m_ ## WG_DENOMS, m_ ## WARPTILE, 1, false, true); \
|
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->m, #NAMELC #F16ACC "_m", NAMELC ## F16ACC ## _cm1_len, NAMELC ## F16ACC ## _cm1_data, "main", PARAMCOUNT, sizeof(PUSHCONST), m_ ## WG_DENOMS, m_ ## WARPTILE, 1, false, true); \
|
||||||
if (device->mul_mat ## ID ## _s[TYPE]) \
|
if (device->mul_mat ## ID ## _s[TYPE]) \
|
||||||
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->s, #NAMELC #F16ACC "_s", NAMELC ## F16ACC ## _coopmat_len, NAMELC ## F16ACC ## _coopmat_data, "main", PARAMCOUNT, sizeof(PUSHCONST), s_ ## WG_DENOMS, s_ ## WARPTILE, 1, false, true); \
|
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->s, #NAMELC #F16ACC "_s", NAMELC ## F16ACC ## _cm1_len, NAMELC ## F16ACC ## _cm1_data, "main", PARAMCOUNT, sizeof(PUSHCONST), s_ ## WG_DENOMS, s_ ## WARPTILE, 1, false, true); \
|
||||||
if (device->mul_mat ## ID ## _l[TYPE]) \
|
if (device->mul_mat ## ID ## _l[TYPE]) \
|
||||||
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->a_l, #NAMELC #F16ACC "_aligned_l", NAMELC ## _aligned ## F16ACC ## _coopmat_len, NAMELC ## _aligned ## F16ACC ## _coopmat_data, "main", PARAMCOUNT, sizeof(PUSHCONST), l_ ## WG_DENOMS, l_ ## WARPTILE, l_align, false, true); \
|
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->a_l, #NAMELC #F16ACC "_aligned_l", NAMELC ## _aligned ## F16ACC ## _cm1_len, NAMELC ## _aligned ## F16ACC ## _cm1_data, "main", PARAMCOUNT, sizeof(PUSHCONST), l_ ## WG_DENOMS, l_ ## WARPTILE, l_align, false, true); \
|
||||||
if (device->mul_mat ## ID ## _m[TYPE]) \
|
if (device->mul_mat ## ID ## _m[TYPE]) \
|
||||||
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->a_m, #NAMELC #F16ACC "_aligned_m", NAMELC ## _aligned ## F16ACC ## _coopmat_len, NAMELC ## _aligned ## F16ACC ## _coopmat_data, "main", PARAMCOUNT, sizeof(PUSHCONST), m_ ## WG_DENOMS, m_ ## WARPTILE, m_align, false, true); \
|
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->a_m, #NAMELC #F16ACC "_aligned_m", NAMELC ## _aligned ## F16ACC ## _cm1_len, NAMELC ## _aligned ## F16ACC ## _cm1_data, "main", PARAMCOUNT, sizeof(PUSHCONST), m_ ## WG_DENOMS, m_ ## WARPTILE, m_align, false, true); \
|
||||||
if (device->mul_mat ## ID ## _s[TYPE]) \
|
if (device->mul_mat ## ID ## _s[TYPE]) \
|
||||||
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->a_s, #NAMELC #F16ACC "_aligned_s", NAMELC ## _aligned ## F16ACC ## _coopmat_len, NAMELC ## _aligned ## F16ACC ## _coopmat_data, "main", PARAMCOUNT, sizeof(PUSHCONST), s_ ## WG_DENOMS, s_ ## WARPTILE, s_align, false, true); \
|
ggml_vk_create_pipeline(device, device-> PIPELINE_NAME ->a_s, #NAMELC #F16ACC "_aligned_s", NAMELC ## _aligned ## F16ACC ## _cm1_len, NAMELC ## _aligned ## F16ACC ## _cm1_data, "main", PARAMCOUNT, sizeof(PUSHCONST), s_ ## WG_DENOMS, s_ ## WARPTILE, s_align, false, true); \
|
||||||
|
|
||||||
// Create 2 variants, {f16,f32} accumulator
|
// Create 2 variants, {f16,f32} accumulator
|
||||||
#define CREATE_MM2(TYPE, PIPELINE_NAME, NAMELC, WG_DENOMS, WARPTILE, PUSHCONST, PARAMCOUNT, ID) \
|
#define CREATE_MM2(TYPE, PIPELINE_NAME, NAMELC, WG_DENOMS, WARPTILE, PUSHCONST, PARAMCOUNT, ID) \
|
||||||
@ -3009,6 +3053,11 @@ static vk_device ggml_vk_get_device(size_t idx) {
|
|||||||
|
|
||||||
#if defined(VK_KHR_cooperative_matrix)
|
#if defined(VK_KHR_cooperative_matrix)
|
||||||
device->coopmat_support = device->coopmat_support && coopmat_features.cooperativeMatrix;
|
device->coopmat_support = device->coopmat_support && coopmat_features.cooperativeMatrix;
|
||||||
|
|
||||||
|
// coopmat1 fa shader currently assumes 32 invocations per subgroup
|
||||||
|
device->coopmat1_fa_support = device->coopmat_support && device->subgroup_require_full_support &&
|
||||||
|
device->subgroup_size_control && device->subgroup_min_size <= 32 &&
|
||||||
|
device->subgroup_max_size >= 32;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
if (coopmat2_support) {
|
if (coopmat2_support) {
|
||||||
@ -3143,6 +3192,9 @@ static vk_device ggml_vk_get_device(size_t idx) {
|
|||||||
// Only enable if shape is identical
|
// Only enable if shape is identical
|
||||||
device->coopmat_acc_f32_support = true;
|
device->coopmat_acc_f32_support = true;
|
||||||
}
|
}
|
||||||
|
if (prop.MSize == 16 && prop.NSize == 16 && prop.KSize == 16) {
|
||||||
|
device->coopmat_support_16x16x16_f32acc = true;
|
||||||
|
}
|
||||||
} else if ((vk::ComponentTypeKHR)prop.CType == vk::ComponentTypeKHR::eFloat16 &&
|
} else if ((vk::ComponentTypeKHR)prop.CType == vk::ComponentTypeKHR::eFloat16 &&
|
||||||
(vk::ComponentTypeKHR)prop.ResultType == vk::ComponentTypeKHR::eFloat16) {
|
(vk::ComponentTypeKHR)prop.ResultType == vk::ComponentTypeKHR::eFloat16) {
|
||||||
// coopmat sizes not set yet
|
// coopmat sizes not set yet
|
||||||
@ -3155,6 +3207,9 @@ static vk_device ggml_vk_get_device(size_t idx) {
|
|||||||
// Only enable if shape is identical
|
// Only enable if shape is identical
|
||||||
device->coopmat_acc_f16_support = true;
|
device->coopmat_acc_f16_support = true;
|
||||||
}
|
}
|
||||||
|
if (prop.MSize == 16 && prop.NSize == 16 && prop.KSize == 16) {
|
||||||
|
device->coopmat_support_16x16x16_f16acc = true;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
} else if ((vk::ComponentTypeKHR)prop.AType == vk::ComponentTypeKHR::eSint8 &&
|
} else if ((vk::ComponentTypeKHR)prop.AType == vk::ComponentTypeKHR::eSint8 &&
|
||||||
(vk::ComponentTypeKHR)prop.BType == vk::ComponentTypeKHR::eSint8 &&
|
(vk::ComponentTypeKHR)prop.BType == vk::ComponentTypeKHR::eSint8 &&
|
||||||
@ -5688,6 +5743,36 @@ static void ggml_vk_mul_mat_id(ggml_backend_vk_context * ctx, vk_context& subctx
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static bool ggml_vk_flash_attn_coopmat_shmem_support(const vk_device& device, const uint32_t D, bool f32acc) {
|
||||||
|
// Needs to be kept up to date on shader changes
|
||||||
|
const uint32_t wg_size = scalar_flash_attention_workgroup_size;
|
||||||
|
const uint32_t Br = scalar_flash_attention_num_large_rows;
|
||||||
|
const uint32_t Bc = scalar_flash_attention_Bc;
|
||||||
|
|
||||||
|
const uint32_t acctype = f32acc ? 4 : 2;
|
||||||
|
const uint32_t f16vec4 = 8;
|
||||||
|
|
||||||
|
const uint32_t tmpsh = wg_size * sizeof(float);
|
||||||
|
const uint32_t tmpshv4 = wg_size * 4 * acctype;
|
||||||
|
|
||||||
|
const uint32_t Qf = Br * (D / 4 + 2) * f16vec4;
|
||||||
|
|
||||||
|
const uint32_t sfshstride = (D <= 128) ? (Br + 8) : Br;
|
||||||
|
const uint32_t sfsh = Bc * sfshstride * acctype;
|
||||||
|
|
||||||
|
const uint32_t kshstride = D / 4 + 2;
|
||||||
|
const uint32_t ksh = Bc * kshstride * f16vec4;
|
||||||
|
|
||||||
|
const uint32_t slope = Br * sizeof(float);
|
||||||
|
|
||||||
|
const uint32_t total_size = tmpsh + tmpshv4 + Qf + sfsh + ksh + slope;
|
||||||
|
const bool supported = total_size <= device->properties.limits.maxComputeSharedMemorySize;
|
||||||
|
|
||||||
|
VK_LOG_DEBUG("ggml_vk_flash_attn_coopmat_shmem_support(D=" << D << ", f32acc=" << f32acc << ", total_size=" << total_size << ", supported=" << supported);
|
||||||
|
|
||||||
|
return supported;
|
||||||
|
}
|
||||||
|
|
||||||
static void ggml_vk_flash_attn(ggml_backend_vk_context * ctx, vk_context& subctx, const ggml_tensor * q, const ggml_tensor * k, const ggml_tensor * v, const ggml_tensor * mask, ggml_tensor * dst, bool dryrun = false) {
|
static void ggml_vk_flash_attn(ggml_backend_vk_context * ctx, vk_context& subctx, const ggml_tensor * q, const ggml_tensor * k, const ggml_tensor * v, const ggml_tensor * mask, ggml_tensor * dst, bool dryrun = false) {
|
||||||
VK_LOG_DEBUG("ggml_vk_flash_attn((" << q << ", name=" << q->name << ", type=" << q->type << ", ne0=" << q->ne[0] << ", ne1=" << q->ne[1] << ", ne2=" << q->ne[2] << ", ne3=" << q->ne[3] << ", nb0=" << q->nb[0] << ", nb1=" << q->nb[1] << ", nb2=" << q->nb[2] << ", nb3=" << q->nb[3];
|
VK_LOG_DEBUG("ggml_vk_flash_attn((" << q << ", name=" << q->name << ", type=" << q->type << ", ne0=" << q->ne[0] << ", ne1=" << q->ne[1] << ", ne2=" << q->ne[2] << ", ne3=" << q->ne[3] << ", nb0=" << q->nb[0] << ", nb1=" << q->nb[1] << ", nb2=" << q->nb[2] << ", nb3=" << q->nb[3];
|
||||||
std::cerr << "), (" << k << ", name=" << k->name << ", type=" << k->type << ", ne0=" << k->ne[0] << ", ne1=" << k->ne[1] << ", ne2=" << k->ne[2] << ", ne3=" << k->ne[3] << ", nb0=" << k->nb[0] << ", nb1=" << k->nb[1] << ", nb2=" << k->nb[2] << ", nb3=" << k->nb[3];
|
std::cerr << "), (" << k << ", name=" << k->name << ", type=" << k->type << ", ne0=" << k->ne[0] << ", ne1=" << k->ne[1] << ", ne2=" << k->ne[2] << ", ne3=" << k->ne[3] << ", nb0=" << k->nb[0] << ", nb1=" << k->nb[1] << ", nb2=" << k->nb[2] << ", nb3=" << k->nb[3];
|
||||||
@ -5738,7 +5823,19 @@ static void ggml_vk_flash_attn(ggml_backend_vk_context * ctx, vk_context& subctx
|
|||||||
assert(q->type == GGML_TYPE_F32);
|
assert(q->type == GGML_TYPE_F32);
|
||||||
assert(k->type == v->type);
|
assert(k->type == v->type);
|
||||||
|
|
||||||
bool scalar = !ctx->device->coopmat2;
|
FaCodePath path = ctx->device->coopmat2 ? FA_COOPMAT2 :
|
||||||
|
ctx->device->coopmat1_fa_support ? FA_COOPMAT1 : FA_SCALAR;
|
||||||
|
|
||||||
|
if (path == FA_COOPMAT1) {
|
||||||
|
const bool coopmat_shape_supported = (dst->op_params[3] == GGML_PREC_F32 && ctx->device->coopmat_support_16x16x16_f32acc) ||
|
||||||
|
(dst->op_params[3] != GGML_PREC_F32 && ctx->device->coopmat_support_16x16x16_f16acc);
|
||||||
|
|
||||||
|
const bool coopmat_shmem_supported = ggml_vk_flash_attn_coopmat_shmem_support(ctx->device, D, dst->op_params[3] == GGML_PREC_F32);
|
||||||
|
|
||||||
|
if (!coopmat_shape_supported || !coopmat_shmem_supported) {
|
||||||
|
path = FA_SCALAR;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
uint32_t gqa_ratio = 1;
|
uint32_t gqa_ratio = 1;
|
||||||
uint32_t qk_ratio = neq2 / nek2;
|
uint32_t qk_ratio = neq2 / nek2;
|
||||||
@ -5746,9 +5843,21 @@ static void ggml_vk_flash_attn(ggml_backend_vk_context * ctx, vk_context& subctx
|
|||||||
uint32_t workgroups_y = (uint32_t)neq2;
|
uint32_t workgroups_y = (uint32_t)neq2;
|
||||||
uint32_t workgroups_z = (uint32_t)neq3;
|
uint32_t workgroups_z = (uint32_t)neq3;
|
||||||
|
|
||||||
// For scalar FA, we can use the "large" size to accommodate qga.
|
// For scalar/coopmat1 FA, we can use the "large" size to accommodate qga.
|
||||||
// For coopmat FA, we always use the small size (which is still pretty large for gqa).
|
// For coopmat2 FA, we always use the small size (which is still pretty large for gqa).
|
||||||
const uint32_t max_gqa = scalar ? scalar_flash_attention_num_large_rows : get_fa_num_small_rows(false);
|
uint32_t max_gqa;
|
||||||
|
switch (path) {
|
||||||
|
case FA_SCALAR:
|
||||||
|
case FA_COOPMAT1:
|
||||||
|
// We may switch from coopmat1 to scalar, so use the scalar limit for both
|
||||||
|
max_gqa = scalar_flash_attention_num_large_rows;
|
||||||
|
break;
|
||||||
|
case FA_COOPMAT2:
|
||||||
|
max_gqa = get_fa_num_small_rows(FA_COOPMAT2);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
GGML_ASSERT(0);
|
||||||
|
}
|
||||||
|
|
||||||
if (N == 1 && qk_ratio > 1 && qk_ratio <= max_gqa &&
|
if (N == 1 && qk_ratio > 1 && qk_ratio <= max_gqa &&
|
||||||
qk_ratio * nek2 == neq2 && nek2 == nev2 && neq3 == 1 && nek3 == 1 && nev3 == 1) {
|
qk_ratio * nek2 == neq2 && nek2 == nev2 && neq3 == 1 && nek3 == 1 && nev3 == 1) {
|
||||||
@ -5761,11 +5870,16 @@ static void ggml_vk_flash_attn(ggml_backend_vk_context * ctx, vk_context& subctx
|
|||||||
}
|
}
|
||||||
|
|
||||||
vk_pipeline *pipelines;
|
vk_pipeline *pipelines;
|
||||||
// XXX TODO other backends may be changing accumulator precision to default to f32 soon
|
bool small_rows = N <= get_fa_num_small_rows(path);
|
||||||
bool f32acc = scalar || dst->op_params[3] == GGML_PREC_F32;
|
|
||||||
bool small_rows = N <= get_fa_num_small_rows(scalar);
|
|
||||||
|
|
||||||
if (scalar) {
|
if (small_rows && path == FA_COOPMAT1) {
|
||||||
|
path = FA_SCALAR;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool f32acc = path == FA_SCALAR || dst->op_params[3] == GGML_PREC_F32;
|
||||||
|
|
||||||
|
switch (path) {
|
||||||
|
case FA_SCALAR:
|
||||||
switch (D) {
|
switch (D) {
|
||||||
case 64: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D64[k->type][f32acc][small_rows][0]; break;
|
case 64: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D64[k->type][f32acc][small_rows][0]; break;
|
||||||
case 80: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D80[k->type][f32acc][small_rows][0]; break;
|
case 80: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D80[k->type][f32acc][small_rows][0]; break;
|
||||||
@ -5777,7 +5891,21 @@ static void ggml_vk_flash_attn(ggml_backend_vk_context * ctx, vk_context& subctx
|
|||||||
GGML_ASSERT(!"unsupported D value");
|
GGML_ASSERT(!"unsupported D value");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
} else {
|
break;
|
||||||
|
case FA_COOPMAT1:
|
||||||
|
switch (D) {
|
||||||
|
case 64: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D64_cm1[k->type][f32acc][small_rows][0]; break;
|
||||||
|
case 80: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D80_cm1[k->type][f32acc][small_rows][0]; break;
|
||||||
|
case 96: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D96_cm1[k->type][f32acc][small_rows][0]; break;
|
||||||
|
case 112: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D112_cm1[k->type][f32acc][small_rows][0]; break;
|
||||||
|
case 128: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D128_cm1[k->type][f32acc][small_rows][0]; break;
|
||||||
|
case 256: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D256_cm1[k->type][f32acc][small_rows][0]; break;
|
||||||
|
default:
|
||||||
|
GGML_ASSERT(!"unsupported D value");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case FA_COOPMAT2:
|
||||||
switch (D) {
|
switch (D) {
|
||||||
case 64: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D64_cm2[k->type][f32acc][small_rows][0]; break;
|
case 64: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D64_cm2[k->type][f32acc][small_rows][0]; break;
|
||||||
case 80: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D80_cm2[k->type][f32acc][small_rows][0]; break;
|
case 80: pipelines = &ctx->device->pipeline_flash_attn_f32_f16_D80_cm2[k->type][f32acc][small_rows][0]; break;
|
||||||
@ -5789,6 +5917,9 @@ static void ggml_vk_flash_attn(ggml_backend_vk_context * ctx, vk_context& subctx
|
|||||||
GGML_ASSERT(!"unsupported D value");
|
GGML_ASSERT(!"unsupported D value");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
GGML_ASSERT(0);
|
||||||
}
|
}
|
||||||
assert(pipelines);
|
assert(pipelines);
|
||||||
|
|
||||||
|
|||||||
506
ggml/src/ggml-vulkan/vulkan-shaders/flash_attn_cm1.comp
Normal file
506
ggml/src/ggml-vulkan/vulkan-shaders/flash_attn_cm1.comp
Normal file
@ -0,0 +1,506 @@
|
|||||||
|
#version 450
|
||||||
|
|
||||||
|
#extension GL_EXT_control_flow_attributes : enable
|
||||||
|
#extension GL_EXT_shader_16bit_storage : require
|
||||||
|
|
||||||
|
#extension GL_EXT_shader_explicit_arithmetic_types_float16 : require
|
||||||
|
#extension GL_EXT_shader_explicit_arithmetic_types_int32 : require
|
||||||
|
|
||||||
|
#extension GL_KHR_shader_subgroup_basic : enable
|
||||||
|
#extension GL_KHR_memory_scope_semantics : enable
|
||||||
|
#extension GL_KHR_cooperative_matrix : enable
|
||||||
|
|
||||||
|
#include "types.comp"
|
||||||
|
|
||||||
|
layout(local_size_x_id = 0, local_size_y = 1, local_size_z = 1) in;
|
||||||
|
|
||||||
|
layout (constant_id = 1) const uint32_t Br = 1;
|
||||||
|
layout (constant_id = 2) const uint32_t Bc = 32;
|
||||||
|
layout (constant_id = 3) const uint32_t D = 32;
|
||||||
|
|
||||||
|
layout (constant_id = 5) const uint32_t D_split = 16;
|
||||||
|
|
||||||
|
const uint32_t D_per_thread = D / D_split;
|
||||||
|
const uint32_t row_split = 4;
|
||||||
|
const uint32_t rows_per_thread = Br / row_split;
|
||||||
|
const uint32_t cols_per_iter = gl_WorkGroupSize.x / D_split / row_split;
|
||||||
|
const uint32_t cols_per_thread = Bc / cols_per_iter;
|
||||||
|
|
||||||
|
layout (push_constant) uniform parameter {
|
||||||
|
uint32_t N;
|
||||||
|
uint32_t KV;
|
||||||
|
|
||||||
|
uint32_t ne1;
|
||||||
|
uint32_t ne2;
|
||||||
|
uint32_t ne3;
|
||||||
|
|
||||||
|
uint32_t neq2;
|
||||||
|
uint32_t neq3;
|
||||||
|
uint32_t nek2;
|
||||||
|
uint32_t nek3;
|
||||||
|
uint32_t nev2;
|
||||||
|
uint32_t nev3;
|
||||||
|
uint32_t nem1;
|
||||||
|
|
||||||
|
uint32_t nb01;
|
||||||
|
uint32_t nb02;
|
||||||
|
uint32_t nb03;
|
||||||
|
uint32_t nb11;
|
||||||
|
uint32_t nb12;
|
||||||
|
uint32_t nb13;
|
||||||
|
uint32_t nb21;
|
||||||
|
uint32_t nb22;
|
||||||
|
uint32_t nb23;
|
||||||
|
uint32_t nb31;
|
||||||
|
|
||||||
|
float scale;
|
||||||
|
float max_bias;
|
||||||
|
float logit_softcap;
|
||||||
|
|
||||||
|
uint32_t mask;
|
||||||
|
uint32_t n_head_log2;
|
||||||
|
float m0;
|
||||||
|
float m1;
|
||||||
|
|
||||||
|
uint32_t gqa_ratio;
|
||||||
|
uint32_t split_kv;
|
||||||
|
uint32_t k_num;
|
||||||
|
} p;
|
||||||
|
|
||||||
|
layout (binding = 0) readonly buffer Q {float data_q[];};
|
||||||
|
layout (binding = 0) readonly buffer QV4 {vec4 data_qv4[];};
|
||||||
|
layout (binding = 1) readonly buffer K {float16_t data_k[];};
|
||||||
|
layout (binding = 1) readonly buffer KV4 {f16vec4 data_kv4[];};
|
||||||
|
layout (binding = 2) readonly buffer V {float16_t data_v[];};
|
||||||
|
layout (binding = 2) readonly buffer VV4 {f16vec4 data_vv4[];};
|
||||||
|
layout (binding = 3) readonly buffer M {float16_t data_m[];};
|
||||||
|
layout (binding = 4) writeonly buffer O {D_TYPE data_o[];};
|
||||||
|
|
||||||
|
#if defined(A_TYPE_PACKED16)
|
||||||
|
#define BINDING_IDX_K 0
|
||||||
|
#define BINDING_IDX_V 1
|
||||||
|
layout (binding = 1) readonly buffer KV_PACKED16 {A_TYPE_PACKED16 data_packed16[];} kv_packed[2];
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(DATA_A_Q4_0)
|
||||||
|
#define BLOCK_BYTE_SIZE 18
|
||||||
|
|
||||||
|
vec4 dequantize4(uint ib, uint iqs, uint a_offset, uint binding_idx) {
|
||||||
|
uint vui_lo = uint(kv_packed[binding_idx].data_packed16[a_offset + ib].qs[(iqs & 0xF) / 2 + 0]);
|
||||||
|
uint vui_hi = uint(kv_packed[binding_idx].data_packed16[a_offset + ib].qs[(iqs & 0xF) / 2 + 1]);
|
||||||
|
uint shift = (iqs & 0x10) >> 2;
|
||||||
|
vui_lo >>= shift;
|
||||||
|
vui_hi >>= shift;
|
||||||
|
|
||||||
|
return float(kv_packed[binding_idx].data_packed16[a_offset + ib].d) * (vec4(vui_lo & 0xF, (vui_lo >> 8) & 0xF, vui_hi & 0xF, (vui_hi >> 8) & 0xF) - 8.0f);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(DATA_A_Q8_0)
|
||||||
|
#define BLOCK_BYTE_SIZE 34
|
||||||
|
vec4 dequantize4(uint ib, uint iqs, uint a_offset, uint binding_idx) {
|
||||||
|
const i8vec2 v0 = unpack8(int32_t(kv_packed[binding_idx].data_packed16[a_offset + ib].qs[iqs / 2])).xy; // vec4 used due to #12147
|
||||||
|
const i8vec2 v1 = unpack8(int32_t(kv_packed[binding_idx].data_packed16[a_offset + ib].qs[iqs / 2 + 1])).xy;
|
||||||
|
|
||||||
|
return float(kv_packed[binding_idx].data_packed16[a_offset + ib].d) * vec4(v0.x, v0.y, v1.x, v1.y);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define CEIL_DIV(a, b) (((a) + (b) - 1) / (b))
|
||||||
|
|
||||||
|
// Store the output when doing grouped query attention.
|
||||||
|
// Rows index by Q's dimension 2, and the first N rows are valid.
|
||||||
|
D_TYPE perElemOpGqaStore(const in uint32_t r, const in uint32_t c, const in D_TYPE elem, const in uint32_t o_offset, const in uint32_t iq2, const in uint32_t N)
|
||||||
|
{
|
||||||
|
uint32_t offset = (iq2 + r) * D + c;
|
||||||
|
data_o[o_offset + offset] = D_TYPE(elem);
|
||||||
|
return elem;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Store column zero. This is used to save per-row m and L values for split_k.
|
||||||
|
ACC_TYPE perElemOpStoreCol0(const in uint32_t r, const in uint32_t c, const in ACC_TYPE elem, const in uint32_t o_offset, const in uint32_t iq2, const in uint32_t N)
|
||||||
|
{
|
||||||
|
if (r < N && c == 0) {
|
||||||
|
uint32_t offset = iq2 + r;
|
||||||
|
data_o[o_offset + offset] = D_TYPE(elem);
|
||||||
|
}
|
||||||
|
return elem;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Load the slope matrix, indexed by Q's dimension 2.
|
||||||
|
ACC_TYPE perElemOpComputeSlope(const in uint32_t r, const in uint32_t c, const in ACC_TYPE elem, const in uint32_t iq2)
|
||||||
|
{
|
||||||
|
const uint32_t h = iq2 + (r % p.gqa_ratio);
|
||||||
|
|
||||||
|
const ACC_TYPE base = ACC_TYPE(h < p.n_head_log2 ? p.m0 : p.m1);
|
||||||
|
const int exph = int(h < p.n_head_log2 ? h + 1 : 2*(h - p.n_head_log2) + 1);
|
||||||
|
|
||||||
|
return ACC_TYPE(pow(base, ACC_TYPE(exph)));
|
||||||
|
}
|
||||||
|
|
||||||
|
// These need to be supported N,M values for a MatBc x MatBr x 16 coopmatmuladd
|
||||||
|
const uint32_t MatBr = 16;
|
||||||
|
const uint32_t MatBc = 16;
|
||||||
|
|
||||||
|
shared FLOAT_TYPE tmpsh[gl_WorkGroupSize.x];
|
||||||
|
shared ACC_TYPEV4 tmpshv4[gl_WorkGroupSize.x];
|
||||||
|
|
||||||
|
const uint32_t qstride = D / 4 + 2; // in units of f16vec4
|
||||||
|
shared f16vec4 Qf[Br * qstride];
|
||||||
|
|
||||||
|
// Avoid padding for D==256 to make it fit in 48KB shmem.
|
||||||
|
const uint32_t sfshstride = (D <= 128) ? (Br + 8) : Br;
|
||||||
|
shared ACC_TYPE sfsh[Bc * sfshstride];
|
||||||
|
|
||||||
|
const uint32_t kshstride = D / 4 + 2; // in units of f16vec4
|
||||||
|
shared f16vec4 ksh[Bc * kshstride];
|
||||||
|
|
||||||
|
shared float slope[Br];
|
||||||
|
|
||||||
|
void main() {
|
||||||
|
#ifdef NEEDS_INIT_IQ_SHMEM
|
||||||
|
init_iq_shmem(gl_WorkGroupSize);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
const uint32_t tid = gl_LocalInvocationIndex;
|
||||||
|
const uint32_t N = p.N;
|
||||||
|
const uint32_t KV = p.KV;
|
||||||
|
|
||||||
|
const uint32_t threads_per_rowgroup = gl_WorkGroupSize.x / row_split;
|
||||||
|
const uint32_t row_tid = gl_LocalInvocationIndex / threads_per_rowgroup;
|
||||||
|
const uint32_t d_tid = gl_LocalInvocationIndex % D_split;
|
||||||
|
const uint32_t col_tid = (gl_LocalInvocationIndex % threads_per_rowgroup) / D_split;
|
||||||
|
|
||||||
|
#define tile_row(r) (row_tid * rows_per_thread + (r))
|
||||||
|
|
||||||
|
uint32_t i = gl_WorkGroupID.x;
|
||||||
|
uint32_t split_k_index = 0;
|
||||||
|
|
||||||
|
if (p.k_num > 1) {
|
||||||
|
i = 0;
|
||||||
|
split_k_index = gl_WorkGroupID.x;
|
||||||
|
}
|
||||||
|
|
||||||
|
const uint32_t Tr = CEIL_DIV(N, Br);
|
||||||
|
|
||||||
|
const uint32_t start_j = split_k_index * p.split_kv / Bc;
|
||||||
|
const uint32_t end_j = CEIL_DIV(min(KV, (split_k_index + 1) * p.split_kv), Bc);
|
||||||
|
|
||||||
|
// When not using grouped query attention, all rows share the same iq2, equal to gl_WorkGroupID.y.
|
||||||
|
// When using grouped query attention, each workgroup does gqa_ratio consecutive values of iq2.
|
||||||
|
const uint32_t iq2 = gl_WorkGroupID.y * p.gqa_ratio;
|
||||||
|
const uint32_t iq3 = gl_WorkGroupID.z;
|
||||||
|
|
||||||
|
// broadcast factors
|
||||||
|
const uint32_t rk2 = p.neq2/p.nek2;
|
||||||
|
const uint32_t rk3 = p.neq3/p.nek3;
|
||||||
|
|
||||||
|
const uint32_t rv2 = p.neq2/p.nev2;
|
||||||
|
const uint32_t rv3 = p.neq3/p.nev3;
|
||||||
|
|
||||||
|
// k indices
|
||||||
|
const uint32_t ik3 = iq3 / rk3;
|
||||||
|
const uint32_t ik2 = iq2 / rk2;
|
||||||
|
|
||||||
|
// v indices
|
||||||
|
const uint32_t iv3 = iq3 / rv3;
|
||||||
|
const uint32_t iv2 = iq2 / rv2;
|
||||||
|
|
||||||
|
// nb?1 are already divided by the type size and are in units of elements.
|
||||||
|
// When using grouped query attention, Q is indexed by iq2, so the stride
|
||||||
|
// should be nb02 (which is in bytes).
|
||||||
|
uint32_t q_stride = p.gqa_ratio > 1 ? (p.nb02 / 4) : p.nb01;
|
||||||
|
uint32_t k_stride = p.nb11;
|
||||||
|
uint32_t v_stride = p.nb21;
|
||||||
|
// When using grouped query attention, all rows use the same mask (stride 0).
|
||||||
|
// "p.gqa_ratio >> 16" is just a roundabout way of writing zero
|
||||||
|
// that prevents the compiler from folding the "&" through the select
|
||||||
|
// and breaking the alignment detection.
|
||||||
|
uint32_t m_stride = (p.gqa_ratio > 1) ? (p.gqa_ratio >> 16) : KV;
|
||||||
|
|
||||||
|
uint32_t q_offset = (iq2*p.nb02+iq3*p.nb03) / 4;
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t idx = 0; idx < Br * D / 4; idx += gl_WorkGroupSize.x) {
|
||||||
|
uint32_t d = (idx + tid) % (D / 4);
|
||||||
|
uint32_t r = (idx + tid) / (D / 4);
|
||||||
|
if (r < Br && d < D / 4 &&
|
||||||
|
i * Br + r < N) {
|
||||||
|
Qf[r * qstride + d] = f16vec4(data_qv4[q_offset / 4 + (i * Br + r) * q_stride / 4 + d] * p.scale);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
barrier();
|
||||||
|
|
||||||
|
ACC_TYPEV4 Of[rows_per_thread][D_per_thread / 4];
|
||||||
|
[[unroll]] for (uint32_t d = 0; d < D_per_thread / 4; ++d) {
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
Of[r][d] = ACC_TYPEV4(0.0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
float Lf[rows_per_thread], Mf[rows_per_thread];
|
||||||
|
|
||||||
|
// Use -FLT_MAX/2 rather than -inf to reduce the possibility of NaNs, e.g. when computing Mold-M.
|
||||||
|
const float NEG_FLT_MAX_OVER_2 = uintBitsToFloat(0xFEFFFFFF);
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
Lf[r] = 0;
|
||||||
|
Mf[r] = NEG_FLT_MAX_OVER_2;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ALiBi
|
||||||
|
if (p.max_bias > 0.0f) {
|
||||||
|
if (tid < Br) {
|
||||||
|
uint r = tid;
|
||||||
|
slope[r] = perElemOpComputeSlope(r, col_tid, ACC_TYPE(0), iq2);
|
||||||
|
}
|
||||||
|
barrier();
|
||||||
|
} else {
|
||||||
|
if (tid < Br) {
|
||||||
|
uint r = tid;
|
||||||
|
slope[r] = 1.0;
|
||||||
|
}
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
|
||||||
|
#if BLOCK_SIZE > 1
|
||||||
|
uint32_t k_offset = (ik2*p.nb12 + ik3*p.nb13) / BLOCK_BYTE_SIZE;
|
||||||
|
uint32_t v_offset = (iv2*p.nb22 + iv3*p.nb23) / BLOCK_BYTE_SIZE;
|
||||||
|
#else
|
||||||
|
uint32_t k_offset = (ik2*p.nb12 + ik3*p.nb13) / 2;
|
||||||
|
uint32_t v_offset = (iv2*p.nb22 + iv3*p.nb23) / 2;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
[[dont_unroll]]
|
||||||
|
for (uint32_t j = start_j; j < end_j; ++j) {
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t idx = 0; idx < Bc * D / 4; idx += gl_WorkGroupSize.x) {
|
||||||
|
uint32_t d = (idx + tid) % (D / 4);
|
||||||
|
uint32_t c = (idx + tid) / (D / 4);
|
||||||
|
if (c < Bc && d < D / 4) {
|
||||||
|
#if BLOCK_SIZE > 1
|
||||||
|
uint coord = (j * Bc + c) * k_stride * BLOCK_SIZE + 4 * d;
|
||||||
|
uint ib = coord / BLOCK_SIZE;
|
||||||
|
uint iqs = (coord % BLOCK_SIZE);
|
||||||
|
f16vec4 K_Tf = f16vec4(dequantize4(ib, iqs, k_offset, BINDING_IDX_K));
|
||||||
|
#else
|
||||||
|
f16vec4 K_Tf = f16vec4(data_kv4[k_offset / 4 + (j * Bc + c) * k_stride / 4 + d]);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
ksh[c * kshstride + d] = K_Tf;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
barrier();
|
||||||
|
|
||||||
|
// K * Q^T -> S^T: Bc x D * D x Br -> Bc x Br
|
||||||
|
// Bc split across workgroup (four subgroups), loop over D in chunks of 16: 16 x 16 * 16 x 16 -> 16 x 16
|
||||||
|
// This is written transposed in order to allow for N being 8 if implementations need it
|
||||||
|
coopmat<ACC_TYPE, gl_ScopeSubgroup, MatBc, MatBr, gl_MatrixUseAccumulator> SfMat = coopmat<ACC_TYPE, gl_ScopeSubgroup, MatBc, MatBr, gl_MatrixUseAccumulator>(0);
|
||||||
|
coopmat<float16_t, gl_ScopeSubgroup, MatBc, 16, gl_MatrixUseA> KMat;
|
||||||
|
coopmat<float16_t, gl_ScopeSubgroup, 16, MatBr, gl_MatrixUseB> QMat;
|
||||||
|
|
||||||
|
for (uint32_t d = 0; d < D / 16; ++d) {
|
||||||
|
coopMatLoad(QMat, Qf, d * 16 / 4, qstride, gl_CooperativeMatrixLayoutColumnMajor);
|
||||||
|
|
||||||
|
uint coord = (gl_SubgroupID * MatBc) * kshstride + d * 16 / 4;
|
||||||
|
coopMatLoad(KMat, ksh, coord, kshstride, gl_CooperativeMatrixLayoutRowMajor);
|
||||||
|
|
||||||
|
SfMat = coopMatMulAdd(KMat, QMat, SfMat);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint coord = gl_SubgroupID * MatBc * sfshstride;
|
||||||
|
coopMatStore(SfMat, sfsh, coord, sfshstride, gl_CooperativeMatrixLayoutRowMajor);
|
||||||
|
barrier();
|
||||||
|
|
||||||
|
if (p.logit_softcap != 0.0f) {
|
||||||
|
[[unroll]] for (uint32_t idx = 0; idx < Bc * Br; idx += gl_WorkGroupSize.x) {
|
||||||
|
uint32_t c = (idx + tid) / Br;
|
||||||
|
uint32_t r = (idx + tid) % Br;
|
||||||
|
if (idx + tid < Bc * Br || idx + gl_WorkGroupSize.x <= Bc * Br) {
|
||||||
|
sfsh[c * sfshstride + r] = ACC_TYPE(p.logit_softcap * tanh(sfsh[c * sfshstride + r]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (p.mask != 0) {
|
||||||
|
[[unroll]] for (uint32_t idx = 0; idx < Bc * Br; idx += gl_WorkGroupSize.x) {
|
||||||
|
uint32_t c = (idx + tid) % Bc;
|
||||||
|
uint32_t r = (idx + tid) / Bc;
|
||||||
|
if (idx + tid < Bc * Br || idx + gl_WorkGroupSize.x <= Bc * Br) {
|
||||||
|
sfsh[c * sfshstride + r] += ACC_TYPE(slope[r] * float(data_m[(i * Br + r) * m_stride + (j * Bc + c)]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
|
||||||
|
float eMf[rows_per_thread];
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
float rowmaxf = sfsh[tile_row(r) + (0 * cols_per_iter + col_tid) * sfshstride];
|
||||||
|
[[unroll]] for (uint32_t c = 0; c < cols_per_thread; ++c) {
|
||||||
|
rowmaxf = max(rowmaxf, float(sfsh[tile_row(r) + (c * cols_per_iter + col_tid) * sfshstride]));
|
||||||
|
}
|
||||||
|
float Moldf = Mf[r];
|
||||||
|
|
||||||
|
// M = max(rowmax, Mold)
|
||||||
|
// P = e^(S - M)
|
||||||
|
// eM = e^(Mold - M)
|
||||||
|
Mf[r] = max(rowmaxf, Moldf);
|
||||||
|
eMf[r] = exp(Moldf - Mf[r]);
|
||||||
|
}
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t d = 0; d < D_per_thread / 4; ++d) {
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
Of[r][d] = float16_t(eMf[r]) * Of[r][d];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
Lf[r] = eMf[r]*Lf[r];
|
||||||
|
}
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t c = 0; c < cols_per_thread; ++c) {
|
||||||
|
float Pf[rows_per_thread];
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
Pf[r] = exp(sfsh[tile_row(r) + (c * cols_per_iter + col_tid) * sfshstride] - Mf[r]);
|
||||||
|
Lf[r] += Pf[r];
|
||||||
|
}
|
||||||
|
[[unroll]] for (uint32_t d = 0; d < D_per_thread / 4; ++d) {
|
||||||
|
#if BLOCK_SIZE > 1
|
||||||
|
uint coord = (j * Bc + c * cols_per_iter + col_tid) * v_stride * BLOCK_SIZE + 4 * (d * D_split + d_tid);
|
||||||
|
uint ib = coord / BLOCK_SIZE;
|
||||||
|
uint iqs = (coord % BLOCK_SIZE);
|
||||||
|
vec4 Vf = dequantize4(ib, iqs, v_offset, BINDING_IDX_V);
|
||||||
|
#else
|
||||||
|
vec4 Vf = vec4(data_vv4[v_offset / 4 + (j * Bc + c * cols_per_iter + col_tid) * v_stride / 4 + d * D_split + d_tid]);
|
||||||
|
#endif
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
Of[r][d] += float16_t(Pf[r]) * ACC_TYPEV4(Vf);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
|
||||||
|
// reduce across threads
|
||||||
|
|
||||||
|
float rowmaxf[rows_per_thread], eMf[rows_per_thread], Moldf[rows_per_thread];
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
FLOAT_TYPE M = Mf[r];
|
||||||
|
tmpsh[tid] = M;
|
||||||
|
// Compute max across the row
|
||||||
|
barrier();
|
||||||
|
[[unroll]] for (int s = int(gl_WorkGroupSize.x / row_split) / 2; s >= D_split; s >>= 1) {
|
||||||
|
M = max(M, tmpsh[tid ^ s]);
|
||||||
|
barrier();
|
||||||
|
tmpsh[tid] = M;
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
rowmaxf[r] = tmpsh[d_tid + row_tid * threads_per_rowgroup];
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
Moldf[r] = Mf[r];
|
||||||
|
|
||||||
|
// M = max(rowmax, Mold)
|
||||||
|
// eM = e^(Mold - M)
|
||||||
|
Mf[r] = max(rowmaxf[r], Moldf[r]);
|
||||||
|
eMf[r] = exp(Moldf[r] - Mf[r]);
|
||||||
|
|
||||||
|
Lf[r] = eMf[r]*Lf[r];
|
||||||
|
}
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
FLOAT_TYPE L = Lf[r];
|
||||||
|
tmpsh[tid] = L;
|
||||||
|
// Compute sum across the row
|
||||||
|
barrier();
|
||||||
|
[[unroll]] for (int s = int(gl_WorkGroupSize.x / row_split) / 2; s >= D_split; s >>= 1) {
|
||||||
|
L += tmpsh[tid ^ s];
|
||||||
|
barrier();
|
||||||
|
tmpsh[tid] = L;
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
Lf[r] = tmpsh[d_tid + row_tid * threads_per_rowgroup];
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
[[unroll]] for (uint32_t d = 0; d < D_per_thread / 4; ++d) {
|
||||||
|
|
||||||
|
Of[r][d] = float16_t(eMf[r]) * Of[r][d];
|
||||||
|
tmpshv4[tid] = Of[r][d];
|
||||||
|
|
||||||
|
barrier();
|
||||||
|
[[unroll]] for (int s = int(gl_WorkGroupSize.x / row_split) / 2; s >= D_split; s >>= 1) {
|
||||||
|
Of[r][d] += tmpshv4[tid ^ s];
|
||||||
|
barrier();
|
||||||
|
tmpshv4[tid] = Of[r][d];
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
Of[r][d] = tmpshv4[d_tid + row_tid * threads_per_rowgroup];
|
||||||
|
barrier();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// If there is split_k, then the split_k resolve shader does the final
|
||||||
|
// division by L. Store the intermediate O value and per-row m and L values.
|
||||||
|
if (p.k_num > 1) {
|
||||||
|
uint32_t o_offset = D * p.ne1 * split_k_index;
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
if (tile_row(r) < N) {
|
||||||
|
[[unroll]] for (uint32_t d = 0; d < D_per_thread / 4; ++d) {
|
||||||
|
[[unroll]] for (uint32_t comp = 0; comp < 4; ++comp) {
|
||||||
|
perElemOpGqaStore(tile_row(r), 4*(d * D_split + d_tid) + comp, float(Of[r][d][comp]), o_offset, iq2, N);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
o_offset = D * p.ne1 * p.k_num + p.ne1 * split_k_index * 2;
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
if (tile_row(r) < N) {
|
||||||
|
perElemOpStoreCol0(tile_row(r), 0u, ACC_TYPE(Lf[r]), o_offset, iq2, N);
|
||||||
|
perElemOpStoreCol0(tile_row(r), 0u, ACC_TYPE(Mf[r]), o_offset + p.ne1, iq2, N);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
float Lfrcp[rows_per_thread];
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
Lfrcp[r] = 1.0 / Lf[r];
|
||||||
|
}
|
||||||
|
|
||||||
|
[[unroll]] for (uint32_t d = 0; d < D_per_thread / 4; ++d) {
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
Of[r][d] *= float16_t(Lfrcp[r]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t o_offset = iq3*p.ne2*p.ne1;
|
||||||
|
|
||||||
|
if (p.gqa_ratio > 1) {
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
if (tile_row(r) < N) {
|
||||||
|
[[unroll]] for (uint32_t d = 0; d < D_per_thread / 4; ++d) {
|
||||||
|
[[unroll]] for (uint32_t comp = 0; comp < 4; ++comp) {
|
||||||
|
perElemOpGqaStore(tile_row(r), 4*(d * D_split + d_tid) + comp, float(Of[r][d][comp]), o_offset, iq2, N);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
[[unroll]] for (uint32_t r = 0; r < rows_per_thread; ++r) {
|
||||||
|
if (i * Br + tile_row(r) < N) {
|
||||||
|
[[unroll]] for (uint32_t d = 0; d < D_per_thread / 4; ++d) {
|
||||||
|
[[unroll]] for (uint32_t comp = 0; comp < 4; ++comp) {
|
||||||
|
data_o[o_offset + iq2 * D + (i * Br + tile_row(r)) * p.ne1 * D + 4*(d * D_split + d_tid) + comp] = D_TYPE(Of[r][d][comp]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -215,7 +215,7 @@ static std::mutex compile_count_mutex;
|
|||||||
static std::condition_variable compile_count_cond;
|
static std::condition_variable compile_count_cond;
|
||||||
|
|
||||||
void string_to_spv_func(const std::string& _name, const std::string& in_fname, const std::map<std::string, std::string>& defines, bool fp16 = true, bool coopmat = false, bool coopmat2 = false, bool f16acc = false) {
|
void string_to_spv_func(const std::string& _name, const std::string& in_fname, const std::map<std::string, std::string>& defines, bool fp16 = true, bool coopmat = false, bool coopmat2 = false, bool f16acc = false) {
|
||||||
std::string name = _name + (f16acc ? "_f16acc" : "") + (coopmat ? "_coopmat" : "") + (coopmat2 ? "_cm2" : (fp16 ? "" : "_fp32"));
|
std::string name = _name + (f16acc ? "_f16acc" : "") + (coopmat ? "_cm1" : "") + (coopmat2 ? "_cm2" : (fp16 ? "" : "_fp32"));
|
||||||
std::string out_fname = join_paths(output_dir, name + ".spv");
|
std::string out_fname = join_paths(output_dir, name + ".spv");
|
||||||
std::string in_path = join_paths(input_dir, in_fname);
|
std::string in_path = join_paths(input_dir, in_fname);
|
||||||
|
|
||||||
@ -424,6 +424,7 @@ void process_shaders() {
|
|||||||
// flash attention
|
// flash attention
|
||||||
for (const auto& f16acc : {false, true}) {
|
for (const auto& f16acc : {false, true}) {
|
||||||
std::string acctype = f16acc ? "float16_t" : "float";
|
std::string acctype = f16acc ? "float16_t" : "float";
|
||||||
|
std::string acctypev4 = f16acc ? "f16vec4" : "vec4";
|
||||||
|
|
||||||
for (const auto& tname : type_names) {
|
for (const auto& tname : type_names) {
|
||||||
if (tname == "f32") {
|
if (tname == "f32") {
|
||||||
@ -440,6 +441,16 @@ void process_shaders() {
|
|||||||
string_to_spv("flash_attn_f32_f16_" + tname, "flash_attn_cm2.comp",
|
string_to_spv("flash_attn_f32_f16_" + tname, "flash_attn_cm2.comp",
|
||||||
merge_maps(base_dict, {{data_a_key, "1"}, {"Q_TYPE", "float"}, {"D_TYPE", "float"}, {"ACC_TYPE", acctype}, {"DEQUANTFUNC", "dequantFunc"+to_uppercase(tname) }, {"BLOCK_SIZE", "QUANT_K_"+to_uppercase(tname) }}), true, false, true, f16acc);
|
merge_maps(base_dict, {{data_a_key, "1"}, {"Q_TYPE", "float"}, {"D_TYPE", "float"}, {"ACC_TYPE", acctype}, {"DEQUANTFUNC", "dequantFunc"+to_uppercase(tname) }, {"BLOCK_SIZE", "QUANT_K_"+to_uppercase(tname) }}), true, false, true, f16acc);
|
||||||
}
|
}
|
||||||
|
#endif
|
||||||
|
#if defined(GGML_VULKAN_COOPMAT_GLSLC_SUPPORT)
|
||||||
|
if (tname == "f16") {
|
||||||
|
string_to_spv("flash_attn_f32_f16_" + tname, "flash_attn_cm1.comp",
|
||||||
|
merge_maps(base_dict, {{"Q_TYPE", "float"}, {"D_TYPE", "float"}, {"ACC_TYPE", acctype}, {"ACC_TYPEV4", acctypev4}, {"COOPMAT", "1"}}), true, true, false, f16acc);
|
||||||
|
} else if (tname == "q4_0" || tname == "q8_0") {
|
||||||
|
std::string data_a_key = "DATA_A_" + to_uppercase(tname);
|
||||||
|
string_to_spv("flash_attn_f32_f16_" + tname, "flash_attn_cm1.comp",
|
||||||
|
merge_maps(base_dict, {{data_a_key, "1"}, {"Q_TYPE", "float"}, {"D_TYPE", "float"}, {"ACC_TYPE", acctype}, {"ACC_TYPEV4", acctypev4}, {"BLOCK_SIZE", "QUANT_K_"+to_uppercase(tname)}, {"COOPMAT", "1"}}), true, true, false, f16acc);
|
||||||
|
}
|
||||||
#endif
|
#endif
|
||||||
if (tname == "f16") {
|
if (tname == "f16") {
|
||||||
string_to_spv("flash_attn_f32_f16_" + tname, "flash_attn.comp",
|
string_to_spv("flash_attn_f32_f16_" + tname, "flash_attn.comp",
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user