From 9f9ad4b655693448fffeaf06f6d39970987fc182 Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Fri, 13 Nov 2026 17:36:30 -0400 Subject: [PATCH 1/2] hrx: define the 16 dequant motifs the #327 merge left declared, in this line's format codes (engine#2138) The #327 merge kept our motifs/dequant.loom and took AMD's callers, so eight functions were func.decl'd and called with no definition anywhere in the corpus (ggml_codebook_f16/f32_vector4, ggml_{iq4xs,q5k,q1_0}_load_decode_state and _preloaded_f32_vector4). Every kernel that reaches them fails at JIT link with "unresolved exact declaration": the routed SwiGLU pair kernels (ggml_mul_mat_id_{skinny,tiled}_pair_input_f32_swiglu_publish_f32), i.e. every MoE model, plus the codebook/IQ4_XS/Q5_K tiled preload and Q1_0 decode-pair kernels. Main's pin (e6c80014e) declares none of them. This adds AMD's definitions (9bf5871 motifs/dequant.loom) for those eight and the eight helpers they call that our file lacks (seven *_global_f32_vector4 IQ decoders and ggml_iq2xs_sign_mask), 16 in all, in AMD's order. The five shared helpers they call (iq2s_value_f32, iq3s_signed_value_f32, iq4nl_lookup_i8_vector4, iq4xs_table_codes4, q5k_high_bit_f32) have identical signatures here. Format codes: this line numbers IQ1_S 26, IQ1_M 27, IQ3_XXS 28 (common_mul_mat_format_config_value); AMD's file uses 19, 29, 18. The copied ggml_codebook_f32_vector4 and the two AMD-sourced routed callers (motifs/matmul_id/pair_input_f32_dequant_accumulate_f32.loom, ops/mul_mat_id_swiglu_f32_f32_wmma.loom, both comparing IQ3_XXS to 18) take this line's codes, so an IQ3_XXS routed weight is decoded as IQ3_XXS rather than falling through to the IQ2_S branch. Co-Authored-By: Claude Opus 5.5 --- .../kernels/loom-libs/motifs/dequant.loom | 948 ++++++++++++++++++ ...pair_input_f32_dequant_accumulate_f32.loom | 3 +- .../ops/mul_mat_id_swiglu_f32_f32_wmma.loom | 3 +- 3 files changed, 952 insertions(+), 2 deletions(-) diff --git a/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/motifs/dequant.loom b/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/motifs/dequant.loom index c30912bed1b7..d2707db309c6 100644 --- a/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/motifs/dequant.loom +++ b/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/motifs/dequant.loom @@ -12097,3 +12097,951 @@ func.def inline @ggml_dequant_f32_vector4(%iq4nl_table: vector<16xi8>, %iq3s_gri %selected = scf.select %is_prism_ptq1, %prism_ptq1_values, %selected1 : vector<4xf32> func.return %selected : vector<4xf32> } + +// engine#2138: AMD's definitions (9bf5871 motifs/dequant.loom) that this file's own line never had. +// The #327 merge kept this file and took AMD's callers, so these 16 were declared (func.decl) and +// called but not defined: the codebook (IQ*) MoE path, the IQ4_XS/Q5_K tiled preload and the Q1_0 +// decode pair could not link ("unresolved exact declaration"). Copied in AMD's order, verbatim except +// ggml_codebook_f32_vector4's format codes: this line numbers IQ1_S 26, IQ1_M 27, IQ3_XXS 28 +// (common_mul_mat_format_config_value), where AMD's file has 19, 29, 18. + +func.def inline @ggml_q1_0_load_decode_state(%weight: buffer, %row_byte_base: offset, %k: index) -> (vector<1xf16>) { + %c0 = index.constant 0 : index + %c128 = index.constant 128 : index + %block_bytes = index.constant 18 : offset + %block = index.div %k, %c128 : index + %block_byte_add = index.scale %block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %d_view = buffer.view %weight[%block_byte_base] : buffer -> view<1xf16> + %d_vector = vector.load %d_view[%c0] : view<1xf16> -> vector<1xf16> + func.return %d_vector : vector<1xf16> +} + +func.def inline @ggml_q1_0_preloaded_f32_vector4(%weight: buffer, %row_byte_base: offset, %k: index, %d_vector: vector<1xf16>) -> (vector<4xf32>) { + %c1_i32 = scalar.constant 1 : i32 + %c2_i32 = scalar.constant 2 : i32 + %c3_i32 = scalar.constant 3 : i32 + %c8 = index.constant 8 : index + %c128 = index.constant 128 : index + %c0_i32 = scalar.constant 0 : i32 + %c0_f32 = scalar.constant 0.0 : f32 + %block_bytes = index.constant 18 : offset + %code_offset = index.constant 2 : offset + %block = index.div %k, %c128 : index + %k_in_block = index.rem %k, %c128 : index + %byte_index0 = index.div %k_in_block, %c8 : index + %byte_index = index.assume %byte_index0 [range(%byte_index0, 0, 15)] : index + %bit_base_index = index.rem %k_in_block, %c8 : index + %bit_base = index.cast %bit_base_index : index to i32 + %block_byte_add = index.scale %block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %code_byte_base = index.add %block_byte_base, %code_offset : offset + %code_view = buffer.view %weight[%code_byte_base] : buffer -> view<16xi8> + %d_f16 = vector.extract %d_vector[0] : vector<1xf16> -> f16 + %d = scalar.extf %d_f16 : f16 to f32 + %neg_d = scalar.subf %c0_f32, %d : f32 + %q_i8 = view.load %code_view[%byte_index] : view<16xi8> -> i8 + %q = scalar.extui %q_i8 : i8 to i32 + %bit1 = scalar.addi %bit_base, %c1_i32 : i32 + %bit2 = scalar.addi %bit_base, %c2_i32 : i32 + %bit3 = scalar.addi %bit_base, %c3_i32 : i32 + %q0_shift = scalar.shrui %q, %bit_base : i32 + %q1_shift = scalar.shrui %q, %bit1 : i32 + %q2_shift = scalar.shrui %q, %bit2 : i32 + %q3_shift = scalar.shrui %q, %bit3 : i32 + %q0_mask = scalar.andi %q0_shift, %c1_i32 : i32 + %q1_mask = scalar.andi %q1_shift, %c1_i32 : i32 + %q2_mask = scalar.andi %q2_shift, %c1_i32 : i32 + %q3_mask = scalar.andi %q3_shift, %c1_i32 : i32 + %q0_set = scalar.cmpi ne, %q0_mask, %c0_i32 : i32 + %q1_set = scalar.cmpi ne, %q1_mask, %c0_i32 : i32 + %q2_set = scalar.cmpi ne, %q2_mask, %c0_i32 : i32 + %q3_set = scalar.cmpi ne, %q3_mask, %c0_i32 : i32 + %v0 = scf.select %q0_set, %d, %neg_d : f32 + %v1 = scf.select %q1_set, %d, %neg_d : f32 + %v2 = scf.select %q2_set, %d, %neg_d : f32 + %v3 = scf.select %q3_set, %d, %neg_d : f32 + %result = vector.from_elements %v0, %v1, %v2, %v3 : vector<4xf32> + func.return %result : vector<4xf32> +} + +func.def inline @ggml_iq2s_global_f32_vector4(%grid: buffer, %weight: buffer, %row_byte_base: offset, %iq2_block: index, %iq2_group: index, %packet: index) -> (vector<4xf32>) { + %c0 = index.constant 0 : index + %c1 = index.constant 1 : index + %c2 = index.constant 2 : index + %c4 = index.constant 4 : index + %c7 = index.constant 7 : index + %c8 = index.constant 8 : index + %c16 = index.constant 16 : index + %c32 = index.constant 32 : index + %c0_offset = index.constant 0 : offset + %c0_i32 = scalar.constant 0 : i32 + %c1_i32 = scalar.constant 1 : i32 + %c2_i32 = scalar.constant 2 : i32 + %c4_i32 = scalar.constant 4 : i32 + %c8_i32 = scalar.constant 8 : i32 + %c15_i32 = scalar.constant 15 : i32 + %c16_i32 = scalar.constant 16 : i32 + %c24_i32 = scalar.constant 24 : i32 + %c32_i32 = scalar.constant 32 : i32 + %c64_i32 = scalar.constant 64 : i32 + %c128_i32 = scalar.constant 128 : i32 + %c768_i32 = scalar.constant 768 : i32 + %c05_f32 = scalar.constant 0.5 : f32 + %c025_f32 = scalar.constant 0.25 : f32 + %block_bytes = index.constant 82 : offset + %qs_offset = index.constant 2 : offset + %qh_offset = index.constant 66 : offset + %scales_offset = index.constant 74 : offset + %block_byte_add = index.scale %iq2_block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %qs_byte_base = index.add %block_byte_base, %qs_offset : offset + %qh_byte_base = index.add %block_byte_base, %qh_offset : offset + %scales_byte_base = index.add %block_byte_base, %scales_offset : offset + %d_view = buffer.view %weight[%block_byte_base] : buffer -> view<1xf16> + %qs_view = buffer.view %weight[%qs_byte_base] : buffer -> view<64xi8> + %qh_view = buffer.view %weight[%qh_byte_base] : buffer -> view<8xi8> + %scales_view = buffer.view %weight[%scales_byte_base] : buffer -> view<8xi8> + %grid_view = buffer.view %grid[%c0_offset] : buffer -> view<2048xi32> + %bounded_group = index.assume %iq2_group [range(%iq2_group, 0, 7)] : index + %bounded_packet = index.assume %packet [range(%packet, 0, 63)] : index + %packet_in_group0 = index.rem %bounded_packet, %c8 : index + %l0 = index.div %packet_in_group0, %c2 : index + %l = index.assume %l0 [range(%l0, 0, 3)] : index + %word_index = index.rem %packet_in_group0, %c2 : index + %qs_group_base = index.mul %bounded_group, %c4 : index + %qs_index = index.add %qs_group_base, %l : index + %signs_index = index.add %qs_index, %c32 : index + %scale_half = index.div %l, %c2 : index + %uses_high_scale = index.cmp eq, %scale_half, %c1 : index + %d_f16 = view.load %d_view[%c0] : view<1xf16> -> f16 + %d = scalar.extf %d_f16 : f16 to f32 + %qs_i8 = view.load %qs_view[%qs_index] : view<64xi8> -> i8 + %qh_i8 = view.load %qh_view[%bounded_group] : view<8xi8> -> i8 + %signs_i8 = view.load %qs_view[%signs_index] : view<64xi8> -> i8 + %scale_i8 = view.load %scales_view[%bounded_group] : view<8xi8> -> i8 + %qs = scalar.extui %qs_i8 : i8 to i32 + %qh = scalar.extui %qh_i8 : i8 to i32 + %signs = scalar.extui %signs_i8 : i8 to i32 + %scale_byte = scalar.extui %scale_i8 : i8 to i32 + %scale_low = scalar.andi %scale_byte, %c15_i32 : i32 + %scale_high_shift = scalar.shrui %scale_byte, %c4_i32 : i32 + %scale_high = scalar.andi %scale_high_shift, %c15_i32 : i32 + %scale_i32 = scf.select %uses_high_scale, %scale_high, %scale_low : i32 + %scale_base = scalar.uitofp %scale_i32 : i32 to f32 + %scale_plus = scalar.addf %scale_base, %c05_f32 : f32 + %scale_mul = scalar.mulf %d, %scale_plus : f32 + %scale = scalar.mulf %scale_mul, %c025_f32 : f32 + %l_i32 = index.cast %l : index to i32 + %two_l = scalar.muli %l_i32, %c2_i32 : i32 + %qh_shift = scalar.subi %c8_i32, %two_l : i32 + %qh_shifted = scalar.shli %qh, %qh_shift : i32 + %qh_masked = scalar.andi %qh_shifted, %c768_i32 : i32 + %grid_index_i32 = scalar.ori %qs, %qh_masked : i32 + %grid_index0 = index.cast %grid_index_i32 : i32 to index + %grid_index = index.assume %grid_index0 [range(%grid_index0, 0, 1023)] : index + %grid_word_base = index.mul %grid_index, %c2 : index + %grid_word_index0 = index.add %grid_word_base, %word_index : index + %grid_word_index = index.assume %grid_word_index0 [range(%grid_word_index0, 0, 2047)] : index + %grid_word = view.load %grid_view[%grid_word_index] : view<2048xi32> -> i32 + %uses_word1 = index.cmp eq, %word_index, %c1 : index + %sign_bit0 = scf.select %uses_word1, %c16_i32, %c1_i32 : i32 + %sign_bit1 = scf.select %uses_word1, %c32_i32, %c2_i32 : i32 + %sign_bit2 = scf.select %uses_word1, %c64_i32, %c4_i32 : i32 + %sign_bit3 = scf.select %uses_word1, %c128_i32, %c8_i32 : i32 + %v0 = func.call @ggml_iq2s_value_f32(%grid_word, %c0_i32, %signs, %sign_bit0, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %v1 = func.call @ggml_iq2s_value_f32(%grid_word, %c8_i32, %signs, %sign_bit1, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %v2 = func.call @ggml_iq2s_value_f32(%grid_word, %c16_i32, %signs, %sign_bit2, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %v3 = func.call @ggml_iq2s_value_f32(%grid_word, %c24_i32, %signs, %sign_bit3, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %result = vector.from_elements %v0, %v1, %v2, %v3 : vector<4xf32> + func.return %result : vector<4xf32> +} + +func.def inline @ggml_iq2xs_sign_mask(%sign_code: i32) -> (i32) { + %c1_i32 = scalar.constant 1 : i32 + %c7_i32 = scalar.constant 7 : i32 + %population = scalar.ctpopi %sign_code : i32 + %parity = scalar.andi %population, %c1_i32 : i32 + %high_bit = scalar.shli %parity, %c7_i32 : i32 + %sign_mask = scalar.ori %sign_code, %high_bit : i32 + func.return %sign_mask : i32 +} + +func.def inline @ggml_iq2xxs_global_f32_vector4(%grid: buffer, %weight: buffer, %row_byte_base: offset, %iq2_block: index, %iq2_group: index, %packet: index) -> (vector<4xf32>) { + %c0 = index.constant 0 : index + %c1 = index.constant 1 : index + %c2 = index.constant 2 : index + %c0_offset = index.constant 0 : offset + %c0_i32 = scalar.constant 0 : i32 + %c1_i32 = scalar.constant 1 : i32 + %c2_i32 = scalar.constant 2 : i32 + %c4_i32 = scalar.constant 4 : i32 + %c7_i32 = scalar.constant 7 : i32 + %c8_i32 = scalar.constant 8 : i32 + %c16_i32 = scalar.constant 16 : i32 + %c24_i32 = scalar.constant 24 : i32 + %c28_i32 = scalar.constant 28 : i32 + %c32_i32 = scalar.constant 32 : i32 + %c64_i32 = scalar.constant 64 : i32 + %c127_i32 = scalar.constant 127 : i32 + %c128_i32 = scalar.constant 128 : i32 + %c255_i32 = scalar.constant 255 : i32 + %c05_f32 = scalar.constant 0.5 : f32 + %c025_f32 = scalar.constant 0.25 : f32 + %block_bytes = index.constant 66 : offset + %qs_offset = index.constant 2 : offset + %bounded_group = index.assume %iq2_group [range(%iq2_group, 0, 7)] : index + %bounded_packet = index.assume %packet [range(%packet, 0, 7)] : index + %block_byte_add = index.scale %iq2_block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %qs_byte_base = index.add %block_byte_base, %qs_offset : offset + %d_view = buffer.view %weight[%block_byte_base] : buffer -> view<1xf16> + %qs_view = buffer.view %weight[%qs_byte_base] : buffer -> view<16xi32> + %grid_view = buffer.view %grid[%c0_offset] : buffer -> view<512xi32> + %metadata_index0 = index.mul %bounded_group, %c2 : index + %metadata_index = index.add %metadata_index0, %c1 : index + %indices_word = view.load %qs_view[%metadata_index0] : view<16xi32> -> i32 + %metadata_word = view.load %qs_view[%metadata_index] : view<16xi32> -> i32 + %l = index.div %bounded_packet, %c2 : index + %word_index = index.rem %bounded_packet, %c2 : index + %l_i32 = index.cast %l : index to i32 + %grid_shift = scalar.muli %l_i32, %c8_i32 : i32 + %grid_shifted = scalar.shrui %indices_word, %grid_shift : i32 + %grid_index_i32 = scalar.andi %grid_shifted, %c255_i32 : i32 + %grid_index0 = index.cast %grid_index_i32 : i32 to index + %grid_index = index.assume %grid_index0 [range(%grid_index0, 0, 255)] : index + %grid_word_base = index.mul %grid_index, %c2 : index + %grid_word_index0 = index.add %grid_word_base, %word_index : index + %grid_word_index = index.assume %grid_word_index0 [range(%grid_word_index0, 0, 511)] : index + %grid_word = view.load %grid_view[%grid_word_index] : view<512xi32> -> i32 + %sign_shift = scalar.muli %l_i32, %c7_i32 : i32 + %sign_shifted = scalar.shrui %metadata_word, %sign_shift : i32 + %sign_code = scalar.andi %sign_shifted, %c127_i32 : i32 + %signs = func.call @ggml_iq2xs_sign_mask(%sign_code) : (i32) -> (i32) + %scale_code = scalar.shrui %metadata_word, %c28_i32 : i32 + %scale_base = scalar.uitofp %scale_code : i32 to f32 + %scale_plus = scalar.addf %scale_base, %c05_f32 : f32 + %d_f16 = view.load %d_view[%c0] : view<1xf16> -> f16 + %d = scalar.extf %d_f16 : f16 to f32 + %scale_mul = scalar.mulf %d, %scale_plus : f32 + %scale = scalar.mulf %scale_mul, %c025_f32 : f32 + %uses_word1 = index.cmp eq, %word_index, %c1 : index + %sign_bit0 = scf.select %uses_word1, %c16_i32, %c1_i32 : i32 + %sign_bit1 = scf.select %uses_word1, %c32_i32, %c2_i32 : i32 + %sign_bit2 = scf.select %uses_word1, %c64_i32, %c4_i32 : i32 + %sign_bit3 = scf.select %uses_word1, %c128_i32, %c8_i32 : i32 + %v0 = func.call @ggml_iq2s_value_f32(%grid_word, %c0_i32, %signs, %sign_bit0, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %v1 = func.call @ggml_iq2s_value_f32(%grid_word, %c8_i32, %signs, %sign_bit1, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %v2 = func.call @ggml_iq2s_value_f32(%grid_word, %c16_i32, %signs, %sign_bit2, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %v3 = func.call @ggml_iq2s_value_f32(%grid_word, %c24_i32, %signs, %sign_bit3, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %result = vector.from_elements %v0, %v1, %v2, %v3 : vector<4xf32> + func.return %result : vector<4xf32> +} + +func.def inline @ggml_iq2xs_global_f32_vector4(%grid: buffer, %weight: buffer, %row_byte_base: offset, %iq2_block: index, %iq2_group: index, %packet: index) -> (vector<4xf32>) { + %c0 = index.constant 0 : index + %c1 = index.constant 1 : index + %c2 = index.constant 2 : index + %c4 = index.constant 4 : index + %c0_offset = index.constant 0 : offset + %c0_i32 = scalar.constant 0 : i32 + %c1_i32 = scalar.constant 1 : i32 + %c2_i32 = scalar.constant 2 : i32 + %c4_i32 = scalar.constant 4 : i32 + %c8_i32 = scalar.constant 8 : i32 + %c9_i32 = scalar.constant 9 : i32 + %c15_i32 = scalar.constant 15 : i32 + %c16_i32 = scalar.constant 16 : i32 + %c24_i32 = scalar.constant 24 : i32 + %c32_i32 = scalar.constant 32 : i32 + %c64_i32 = scalar.constant 64 : i32 + %c128_i32 = scalar.constant 128 : i32 + %c511_i32 = scalar.constant 511 : i32 + %c05_f32 = scalar.constant 0.5 : f32 + %c025_f32 = scalar.constant 0.25 : f32 + %block_bytes = index.constant 74 : offset + %qs_offset = index.constant 2 : offset + %scales_offset = index.constant 66 : offset + %bounded_group = index.assume %iq2_group [range(%iq2_group, 0, 7)] : index + %bounded_packet = index.assume %packet [range(%packet, 0, 7)] : index + %block_byte_add = index.scale %iq2_block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %qs_byte_base = index.add %block_byte_base, %qs_offset : offset + %scales_byte_base = index.add %block_byte_base, %scales_offset : offset + %d_view = buffer.view %weight[%block_byte_base] : buffer -> view<1xf16> + %qs_view = buffer.view %weight[%qs_byte_base] : buffer -> view<32xi16> + %scales_view = buffer.view %weight[%scales_byte_base] : buffer -> view<8xi8> + %grid_view = buffer.view %grid[%c0_offset] : buffer -> view<1024xi32> + %l = index.div %bounded_packet, %c2 : index + %word_index = index.rem %bounded_packet, %c2 : index + %group_qs_base = index.mul %bounded_group, %c4 : index + %qs_index0 = index.add %group_qs_base, %l : index + %qs_index = index.assume %qs_index0 [range(%qs_index0, 0, 31)] : index + %q_i16 = view.load %qs_view[%qs_index] : view<32xi16> -> i16 + %q = scalar.extui %q_i16 : i16 to i32 + %grid_index_i32 = scalar.andi %q, %c511_i32 : i32 + %grid_index0 = index.cast %grid_index_i32 : i32 to index + %grid_index = index.assume %grid_index0 [range(%grid_index0, 0, 511)] : index + %grid_word_base = index.mul %grid_index, %c2 : index + %grid_word_index0 = index.add %grid_word_base, %word_index : index + %grid_word_index = index.assume %grid_word_index0 [range(%grid_word_index0, 0, 1023)] : index + %grid_word = view.load %grid_view[%grid_word_index] : view<1024xi32> -> i32 + %sign_code = scalar.shrui %q, %c9_i32 : i32 + %signs = func.call @ggml_iq2xs_sign_mask(%sign_code) : (i32) -> (i32) + %scale_i8 = view.load %scales_view[%bounded_group] : view<8xi8> -> i8 + %scale_byte = scalar.extui %scale_i8 : i8 to i32 + %scale_half = index.div %l, %c2 : index + %scale_half_i32 = index.cast %scale_half : index to i32 + %scale_shift = scalar.muli %scale_half_i32, %c4_i32 : i32 + %scale_shifted = scalar.shrui %scale_byte, %scale_shift : i32 + %scale_code = scalar.andi %scale_shifted, %c15_i32 : i32 + %scale_base = scalar.uitofp %scale_code : i32 to f32 + %scale_plus = scalar.addf %scale_base, %c05_f32 : f32 + %d_f16 = view.load %d_view[%c0] : view<1xf16> -> f16 + %d = scalar.extf %d_f16 : f16 to f32 + %scale_mul = scalar.mulf %d, %scale_plus : f32 + %scale = scalar.mulf %scale_mul, %c025_f32 : f32 + %uses_word1 = index.cmp eq, %word_index, %c1 : index + %sign_bit0 = scf.select %uses_word1, %c16_i32, %c1_i32 : i32 + %sign_bit1 = scf.select %uses_word1, %c32_i32, %c2_i32 : i32 + %sign_bit2 = scf.select %uses_word1, %c64_i32, %c4_i32 : i32 + %sign_bit3 = scf.select %uses_word1, %c128_i32, %c8_i32 : i32 + %v0 = func.call @ggml_iq2s_value_f32(%grid_word, %c0_i32, %signs, %sign_bit0, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %v1 = func.call @ggml_iq2s_value_f32(%grid_word, %c8_i32, %signs, %sign_bit1, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %v2 = func.call @ggml_iq2s_value_f32(%grid_word, %c16_i32, %signs, %sign_bit2, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %v3 = func.call @ggml_iq2s_value_f32(%grid_word, %c24_i32, %signs, %sign_bit3, %scale) : (i32, i32, i32, i32, f32) -> (f32) + %result = vector.from_elements %v0, %v1, %v2, %v3 : vector<4xf32> + func.return %result : vector<4xf32> +} + +func.def inline @ggml_iq3xxs_global_f32_vector4(%grid: buffer, %weight: buffer, %row_byte_base: offset, %iq3_block: index, %iq3_group: index, %packet: index) -> (vector<4xf32>) { + %c0 = index.constant 0 : index + %c0_offset = index.constant 0 : offset + %c1 = index.constant 1 : index + %c2 = index.constant 2 : index + %c4 = index.constant 4 : index + %c8 = index.constant 8 : index + %c0_i32 = scalar.constant 0 : i32 + %c1_i32 = scalar.constant 1 : i32 + %c2_i32 = scalar.constant 2 : i32 + %c3_i32 = scalar.constant 3 : i32 + %c4_i32 = scalar.constant 4 : i32 + %c5_i32 = scalar.constant 5 : i32 + %c6_i32 = scalar.constant 6 : i32 + %c7_i32 = scalar.constant 7 : i32 + %c8_i32 = scalar.constant 8 : i32 + %c16_i32 = scalar.constant 16 : i32 + %c24_i32 = scalar.constant 24 : i32 + %c28_i32 = scalar.constant 28 : i32 + %c127_i32 = scalar.constant 127 : i32 + %c025_f32 = scalar.constant 0.25 : f32 + %block_bytes = index.constant 98 : offset + %qs_offset = index.constant 2 : offset + %aux_offset = index.constant 66 : offset + %bounded_group = index.assume %iq3_group [range(%iq3_group, 0, 7)] : index + %bounded_packet = index.assume %packet [range(%packet, 0, 7)] : index + %block_byte_add = index.scale %iq3_block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %qs_byte_base = index.add %block_byte_base, %qs_offset : offset + %aux_byte_base = index.add %block_byte_base, %aux_offset : offset + %d_view = buffer.view %weight[%block_byte_base] : buffer -> view<1xf16> + %qs_view = buffer.view %weight[%qs_byte_base] : buffer -> view<64xi8> + %aux_view = buffer.view %weight[%aux_byte_base] : buffer -> view<32xi8> + %grid_view = buffer.view %grid[%c0_offset] : buffer -> view<256xi32> + %iqs_base = index.mul %bounded_group, %c8 : index + %iqs0 = index.add %iqs_base, %bounded_packet : index + %iqs = index.assume %iqs0 [range(%iqs0, 0, 63)] : index + %grid_index_i8 = view.load %qs_view[%iqs] : view<64xi8> -> i8 + %grid_index_i32 = scalar.extui %grid_index_i8 : i8 to i32 + %grid_index0 = index.cast %grid_index_i32 : i32 to index + %grid_index = index.assume %grid_index0 [range(%grid_index0, 0, 255)] : index + %grid_word = view.load %grid_view[%grid_index] : view<256xi32> -> i32 + %aux_base = index.mul %bounded_group, %c4 : index + %aux1_index = index.add %aux_base, %c1 : index + %aux2_index = index.add %aux_base, %c2 : index + %aux3_index = index.add %aux_base, %c4 : index + %aux3_index0 = index.sub %aux3_index, %c1 : index + %aux0_i8 = view.load %aux_view[%aux_base] : view<32xi8> -> i8 + %aux1_i8 = view.load %aux_view[%aux1_index] : view<32xi8> -> i8 + %aux2_i8 = view.load %aux_view[%aux2_index] : view<32xi8> -> i8 + %aux3_i8 = view.load %aux_view[%aux3_index0] : view<32xi8> -> i8 + %aux0 = scalar.extui %aux0_i8 : i8 to i32 + %aux1_0 = scalar.extui %aux1_i8 : i8 to i32 + %aux2_0 = scalar.extui %aux2_i8 : i8 to i32 + %aux3_0 = scalar.extui %aux3_i8 : i8 to i32 + %aux1 = scalar.shli %aux1_0, %c8_i32 : i32 + %aux2 = scalar.shli %aux2_0, %c16_i32 : i32 + %aux3 = scalar.shli %aux3_0, %c24_i32 : i32 + %aux01 = scalar.ori %aux0, %aux1 : i32 + %aux23 = scalar.ori %aux2, %aux3 : i32 + %aux = scalar.ori %aux01, %aux23 : i32 + %pair = index.div %bounded_packet, %c2 : index + %pair_i32 = index.cast %pair : index to i32 + %sign_shift = scalar.muli %pair_i32, %c7_i32 : i32 + %sign_index0 = scalar.shrui %aux, %sign_shift : i32 + %sign_index = scalar.andi %sign_index0, %c127_i32 : i32 + %p1 = scalar.shrui %sign_index, %c1_i32 : i32 + %p2 = scalar.shrui %sign_index, %c2_i32 : i32 + %p3 = scalar.shrui %sign_index, %c3_i32 : i32 + %p4 = scalar.shrui %sign_index, %c4_i32 : i32 + %p5 = scalar.shrui %sign_index, %c5_i32 : i32 + %p6 = scalar.shrui %sign_index, %c6_i32 : i32 + %p01 = scalar.addi %sign_index, %p1 : i32 + %p23 = scalar.addi %p2, %p3 : i32 + %p45 = scalar.addi %p4, %p5 : i32 + %p0123 = scalar.addi %p01, %p23 : i32 + %p456 = scalar.addi %p45, %p6 : i32 + %parity_sum = scalar.addi %p0123, %p456 : i32 + %parity = scalar.andi %parity_sum, %c1_i32 : i32 + %parity_bit = scalar.shli %parity, %c7_i32 : i32 + %signs = scalar.ori %sign_index, %parity_bit : i32 + %half = index.rem %bounded_packet, %c2 : index + %half_i32 = index.cast %half : index to i32 + %half_shift = scalar.muli %half_i32, %c4_i32 : i32 + %shifted_signs = scalar.shrui %signs, %half_shift : i32 + %scale0 = scalar.shrui %aux, %c28_i32 : i32 + %scale2 = scalar.muli %scale0, %c2_i32 : i32 + %scale_code = scalar.addi %scale2, %c1_i32 : i32 + %scale_f32 = scalar.uitofp %scale_code : i32 to f32 + %d_f16 = view.load %d_view[%c0] : view<1xf16> -> f16 + %d = scalar.extf %d_f16 : f16 to f32 + %d_quarter = scalar.mulf %d, %c025_f32 : f32 + %db = scalar.mulf %d_quarter, %scale_f32 : f32 + %v0_base = func.call @ggml_iq3s_signed_value_f32(%grid_word, %c0_i32, %shifted_signs, %c1_i32) : (i32, i32, i32, i32) -> (f32) + %v1_base = func.call @ggml_iq3s_signed_value_f32(%grid_word, %c8_i32, %shifted_signs, %c2_i32) : (i32, i32, i32, i32) -> (f32) + %v2_base = func.call @ggml_iq3s_signed_value_f32(%grid_word, %c16_i32, %shifted_signs, %c4_i32) : (i32, i32, i32, i32) -> (f32) + %v3_base = func.call @ggml_iq3s_signed_value_f32(%grid_word, %c24_i32, %shifted_signs, %c8_i32) : (i32, i32, i32, i32) -> (f32) + %v0 = scalar.mulf %db, %v0_base : f32 + %v1 = scalar.mulf %db, %v1_base : f32 + %v2 = scalar.mulf %db, %v2_base : f32 + %v3 = scalar.mulf %db, %v3_base : f32 + %result = vector.from_elements %v0, %v1, %v2, %v3 : vector<4xf32> + func.return %result : vector<4xf32> +} + +func.def inline @ggml_iq3s_global_f32_vector4(%grid: buffer, %weight: buffer, %row_byte_base: offset, %iq3_block: index, %iq3_group: index, %packet: index) -> (vector<4xf32>) { + %c0 = index.constant 0 : index + %c0_offset = index.constant 0 : offset + %c0_i32 = scalar.constant 0 : i32 + %c1_i32 = scalar.constant 1 : i32 + %c2 = index.constant 2 : index + %c2_i32 = scalar.constant 2 : i32 + %c4_i32 = scalar.constant 4 : i32 + %c8 = index.constant 8 : index + %c8_i32 = scalar.constant 8 : i32 + %c15_i32 = scalar.constant 15 : i32 + %c16 = index.constant 16 : index + %c16_i32 = scalar.constant 16 : i32 + %c24_i32 = scalar.constant 24 : i32 + %c256_i32 = scalar.constant 256 : i32 + %block_bytes = index.constant 110 : offset + %qs_offset = index.constant 2 : offset + %qh_offset = index.constant 66 : offset + %signs_offset = index.constant 74 : offset + %scales_offset = index.constant 106 : offset + %bounded_group = index.assume %iq3_group [range(%iq3_group, 0, 7)] : index + %bounded_packet = index.assume %packet [range(%packet, 0, 7)] : index + %block_byte_add = index.scale %iq3_block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %qs_byte_base = index.add %block_byte_base, %qs_offset : offset + %qh_byte_base = index.add %block_byte_base, %qh_offset : offset + %signs_byte_base = index.add %block_byte_base, %signs_offset : offset + %scales_byte_base = index.add %block_byte_base, %scales_offset : offset + %d_view = buffer.view %weight[%block_byte_base] : buffer -> view<1xf16> + %qs_view = buffer.view %weight[%qs_byte_base] : buffer -> view<64xi8> + %qh_view = buffer.view %weight[%qh_byte_base] : buffer -> view<8xi8> + %signs_view = buffer.view %weight[%signs_byte_base] : buffer -> view<32xi8> + %scales_view = buffer.view %weight[%scales_byte_base] : buffer -> view<4xi8> + %grid_view = buffer.view %grid[%c0_offset] : buffer -> view<512xi32> + %iqs_group_base = index.mul %bounded_group, %c8 : index + %iqs0 = index.add %iqs_group_base, %bounded_packet : index + %iqs = index.assume %iqs0 [range(%iqs0, 0, 63)] : index + %signs_index0 = index.div %iqs, %c2 : index + %signs_index = index.assume %signs_index0 [range(%signs_index0, 0, 31)] : index + %scale_index0 = index.div %iqs, %c16 : index + %scale_index = index.assume %scale_index0 [range(%scale_index0, 0, 3)] : index + %iqs_mod8_index = index.rem %iqs, %c8 : index + %high_shift_index = index.sub %c8, %iqs_mod8_index : index + %high_shift = index.cast %high_shift_index : index to i32 + %scale_shift_index = index.rem %bounded_group, %c2 : index + %scale_shift_base = index.cast %scale_shift_index : index to i32 + %scale_shift = scalar.muli %scale_shift_base, %c4_i32 : i32 + %sign_shift_index = index.rem %bounded_packet, %c2 : index + %sign_shift_base = index.cast %sign_shift_index : index to i32 + %sign_shift = scalar.muli %sign_shift_base, %c4_i32 : i32 + %q_i8 = view.load %qs_view[%iqs] : view<64xi8> -> i8 + %qh_i8 = view.load %qh_view[%bounded_group] : view<8xi8> -> i8 + %signs_i8 = view.load %signs_view[%signs_index] : view<32xi8> -> i8 + %scale_i8 = view.load %scales_view[%scale_index] : view<4xi8> -> i8 + %q_i32 = scalar.extui %q_i8 : i8 to i32 + %qh_i32 = scalar.extui %qh_i8 : i8 to i32 + %signs_i32 = scalar.extui %signs_i8 : i8 to i32 + %scale_i32 = scalar.extui %scale_i8 : i8 to i32 + %qh_shifted = scalar.shli %qh_i32, %high_shift : i32 + %qh_high = scalar.andi %qh_shifted, %c256_i32 : i32 + %grid_index_i32 = scalar.ori %q_i32, %qh_high : i32 + %grid_index0 = index.cast %grid_index_i32 : i32 to index + %grid_index = index.assume %grid_index0 [range(%grid_index0, 0, 511)] : index + %grid_word = view.load %grid_view[%grid_index] : view<512xi32> -> i32 + %scale_shifted = scalar.shrui %scale_i32, %scale_shift : i32 + %local_scale = scalar.andi %scale_shifted, %c15_i32 : i32 + %local_scale2 = scalar.muli %local_scale, %c2_i32 : i32 + %scale_code = scalar.addi %local_scale2, %c1_i32 : i32 + %scale_f32 = scalar.uitofp %scale_code : i32 to f32 + %d_f16 = view.load %d_view[%c0] : view<1xf16> -> f16 + %d = scalar.extf %d_f16 : f16 to f32 + %db = scalar.mulf %d, %scale_f32 : f32 + %shifted_signs = scalar.shrui %signs_i32, %sign_shift : i32 + %v0_base = func.call @ggml_iq3s_signed_value_f32(%grid_word, %c0_i32, %shifted_signs, %c1_i32) : (i32, i32, i32, i32) -> (f32) + %v1_base = func.call @ggml_iq3s_signed_value_f32(%grid_word, %c8_i32, %shifted_signs, %c2_i32) : (i32, i32, i32, i32) -> (f32) + %v2_base = func.call @ggml_iq3s_signed_value_f32(%grid_word, %c16_i32, %shifted_signs, %c4_i32) : (i32, i32, i32, i32) -> (f32) + %v3_base = func.call @ggml_iq3s_signed_value_f32(%grid_word, %c24_i32, %shifted_signs, %c8_i32) : (i32, i32, i32, i32) -> (f32) + %v0 = scalar.mulf %db, %v0_base : f32 + %v1 = scalar.mulf %db, %v1_base : f32 + %v2 = scalar.mulf %db, %v2_base : f32 + %v3 = scalar.mulf %db, %v3_base : f32 + %result = vector.from_elements %v0, %v1, %v2, %v3 : vector<4xf32> + func.return %result : vector<4xf32> +} + +func.def inline @ggml_iq1s_global_f32_vector4(%grid: buffer, %weight: buffer, %row_byte_base: offset, %iq1_block: index, %iq1_group: index, %packet: index) -> (vector<4xf32>) { + %c0 = index.constant 0 : index + %c2 = index.constant 2 : index + %c4 = index.constant 4 : index + %c8 = index.constant 8 : index + %c0_offset = index.constant 0 : offset + %c0_i32 = scalar.constant 0 : i32 + %c1_i32 = scalar.constant 1 : i32 + %c2_i32 = scalar.constant 2 : i32 + %c3_i32 = scalar.constant 3 : i32 + %c7_i32 = scalar.constant 7 : i32 + %c8_i32 = scalar.constant 8 : i32 + %c12_i32 = scalar.constant 12 : i32 + %c15_i32 = scalar.constant 15 : i32 + %c32768_i32 = scalar.constant 32768 : i32 + %delta_positive = scalar.constant 0.125 : f32 + %delta_negative = scalar.constant -0.125 : f32 + %block_bytes = index.constant 50 : offset + %qs_offset = index.constant 2 : offset + %qh_offset = index.constant 34 : offset + %bounded_group = index.assume %iq1_group [range(%iq1_group, 0, 7)] : index + %bounded_packet = index.assume %packet [range(%packet, 0, 7)] : index + %block_byte_add = index.scale %iq1_block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %qs_byte_base = index.add %block_byte_base, %qs_offset : offset + %qh_byte_base = index.add %block_byte_base, %qh_offset : offset + %d_view = buffer.view %weight[%block_byte_base] : buffer -> view<1xf16> + %qs_view = buffer.view %weight[%qs_byte_base] : buffer -> view<32xi8> + %qh_view = buffer.view %weight[%qh_byte_base] : buffer -> view<8xi16> + %grid_view = buffer.view %grid[%c0_offset] : buffer -> view<16384xi8> + %entry_in_group = index.div %bounded_packet, %c2 : index + %qs_group_base = index.mul %bounded_group, %c4 : index + %qs_index0 = index.add %qs_group_base, %entry_in_group : index + %qs_index = index.assume %qs_index0 [range(%qs_index0, 0, 31)] : index + %qs_i8 = view.load %qs_view[%qs_index] : view<32xi8> -> i8 + %qs_i32 = scalar.extui %qs_i8 : i8 to i32 + %qh_i16 = view.load %qh_view[%bounded_group] : view<8xi16> -> i16 + %qh_i32 = scalar.extui %qh_i16 : i16 to i32 + %entry_i32 = index.cast %entry_in_group : index to i32 + %high_shift = scalar.muli %entry_i32, %c3_i32 : i32 + %qh_shifted = scalar.shrui %qh_i32, %high_shift : i32 + %grid_high = scalar.andi %qh_shifted, %c7_i32 : i32 + %grid_high_shifted = scalar.shli %grid_high, %c8_i32 : i32 + %grid_index_i32 = scalar.ori %qs_i32, %grid_high_shifted : i32 + %grid_index0 = index.cast %grid_index_i32 : i32 to index + %grid_index = index.assume %grid_index0 [range(%grid_index0, 0, 2047)] : index + %grid_byte_base0 = index.mul %grid_index, %c8 : index + %packet_half = index.rem %bounded_packet, %c2 : index + %grid_packet_add = index.mul %packet_half, %c4 : index + %grid_byte_base1 = index.add %grid_byte_base0, %grid_packet_add : index + %grid_byte_base = index.assume %grid_byte_base1 [range(%grid_byte_base1, 0, 16380)] : index + %grid_values_i8 = vector.load %grid_view[%grid_byte_base] : view<16384xi8> -> vector<4xi8> + %grid_values = vector.sitofp %grid_values_i8 : vector<4xi8> to vector<4xf32> + %negative_mask = scalar.andi %qh_i32, %c32768_i32 : i32 + %uses_negative_delta = scalar.cmpi ne, %negative_mask, %c0_i32 : i32 + %delta = scf.select %uses_negative_delta, %delta_negative, %delta_positive : f32 + %delta_vector = vector.splat %delta : vector<4xf32> + %adjusted = vector.addf %grid_values, %delta_vector : vector<4xf32> + %scale_code0 = scalar.shrui %qh_i32, %c12_i32 : i32 + %scale_code = scalar.andi %scale_code0, %c7_i32 : i32 + %scale_twice = scalar.muli %scale_code, %c2_i32 : i32 + %scale_odd = scalar.addi %scale_twice, %c1_i32 : i32 + %scale_odd_f32 = scalar.uitofp %scale_odd : i32 to f32 + %d_f16 = view.load %d_view[%c0] : view<1xf16> -> f16 + %d = scalar.extf %d_f16 : f16 to f32 + %scale = scalar.mulf %d, %scale_odd_f32 : f32 + %scale_vector = vector.splat %scale : vector<4xf32> + %result = vector.mulf %adjusted, %scale_vector : vector<4xf32> + func.return %result : vector<4xf32> +} + +func.def inline @ggml_iq1m_global_f32_vector4(%grid: buffer, %weight: buffer, %row_byte_base: offset, %iq1_block: index, %iq1_group: index, %packet: index) -> (vector<4xf32>) { + %c0 = index.constant 0 : index + %c1 = index.constant 1 : index + %c2 = index.constant 2 : index + %c3 = index.constant 3 : index + %c4 = index.constant 4 : index + %c8 = index.constant 8 : index + %c0_offset = index.constant 0 : offset + %c0_i32 = scalar.constant 0 : i32 + %c1_i32 = scalar.constant 1 : i32 + %c2_i32 = scalar.constant 2 : i32 + %c3_i32 = scalar.constant 3 : i32 + %c4_i32 = scalar.constant 4 : i32 + %c6_i32 = scalar.constant 6 : i32 + %c7_i32 = scalar.constant 7 : i32 + %c8_i32 = scalar.constant 8 : i32 + %c12_i32 = scalar.constant 12 : i32 + %c15_i32 = scalar.constant 15 : i32 + %c61440_i32 = scalar.constant 61440 : i32 + %delta_positive = scalar.constant 0.125 : f32 + %delta_negative = scalar.constant -0.125 : f32 + %block_bytes = index.constant 56 : offset + %qh_offset = index.constant 32 : offset + %scales_offset = index.constant 48 : offset + %bounded_group = index.assume %iq1_group [range(%iq1_group, 0, 7)] : index + %bounded_packet = index.assume %packet [range(%packet, 0, 7)] : index + %block_byte_add = index.scale %iq1_block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %qh_byte_base = index.add %block_byte_base, %qh_offset : offset + %scales_byte_base = index.add %block_byte_base, %scales_offset : offset + %qs_view = buffer.view %weight[%block_byte_base] : buffer -> view<32xi8> + %qh_view = buffer.view %weight[%qh_byte_base] : buffer -> view<16xi8> + %scales_view = buffer.view %weight[%scales_byte_base] : buffer -> view<4xi16> + %grid_view = buffer.view %grid[%c0_offset] : buffer -> view<16384xi8> + %entry_in_group = index.div %bounded_packet, %c2 : index + %qs_group_base = index.mul %bounded_group, %c4 : index + %qs_index0 = index.add %qs_group_base, %entry_in_group : index + %qs_index = index.assume %qs_index0 [range(%qs_index0, 0, 31)] : index + %qs_i8 = view.load %qs_view[%qs_index] : view<32xi8> -> i8 + %qs_i32 = scalar.extui %qs_i8 : i8 to i32 + %qh_group_base = index.mul %bounded_group, %c2 : index + %entry_pair = index.div %entry_in_group, %c2 : index + %qh_index0 = index.add %qh_group_base, %entry_pair : index + %qh_index = index.assume %qh_index0 [range(%qh_index0, 0, 15)] : index + %qh_i8 = view.load %qh_view[%qh_index] : view<16xi8> -> i8 + %qh_i32 = scalar.extui %qh_i8 : i8 to i32 + %entry_nibble = index.rem %entry_in_group, %c2 : index + %qh_shift_index = index.mul %entry_nibble, %c4 : index + %qh_shift = index.cast %qh_shift_index : index to i32 + %qh_nibble0 = scalar.shrui %qh_i32, %qh_shift : i32 + %qh_nibble = scalar.andi %qh_nibble0, %c15_i32 : i32 + %grid_high = scalar.andi %qh_nibble, %c7_i32 : i32 + %grid_high_shifted = scalar.shli %grid_high, %c8_i32 : i32 + %grid_index_i32 = scalar.ori %qs_i32, %grid_high_shifted : i32 + %grid_index0 = index.cast %grid_index_i32 : i32 to index + %grid_index = index.assume %grid_index0 [range(%grid_index0, 0, 2047)] : index + %grid_byte_base0 = index.mul %grid_index, %c8 : index + %packet_half = index.rem %bounded_packet, %c2 : index + %grid_packet_add = index.mul %packet_half, %c4 : index + %grid_byte_base1 = index.add %grid_byte_base0, %grid_packet_add : index + %grid_byte_base = index.assume %grid_byte_base1 [range(%grid_byte_base1, 0, 16380)] : index + %grid_values_i8 = vector.load %grid_view[%grid_byte_base] : view<16384xi8> -> vector<4xi8> + %grid_values = vector.sitofp %grid_values_i8 : vector<4xi8> to vector<4xf32> + %delta_mask = scalar.andi %qh_nibble, %c8_i32 : i32 + %uses_negative_delta = scalar.cmpi ne, %delta_mask, %c0_i32 : i32 + %delta = scf.select %uses_negative_delta, %delta_negative, %delta_positive : f32 + %delta_vector = vector.splat %delta : vector<4xf32> + %adjusted = vector.addf %grid_values, %delta_vector : vector<4xf32> + %scale0_i16 = view.load %scales_view[%c0] : view<4xi16> -> i16 + %scale1_i16 = view.load %scales_view[%c1] : view<4xi16> -> i16 + %scale2_i16 = view.load %scales_view[%c2] : view<4xi16> -> i16 + %scale3_i16 = view.load %scales_view[%c3] : view<4xi16> -> i16 + %scale0_i32 = scalar.extui %scale0_i16 : i16 to i32 + %scale1_i32 = scalar.extui %scale1_i16 : i16 to i32 + %scale2_i32 = scalar.extui %scale2_i16 : i16 to i32 + %scale3_i32 = scalar.extui %scale3_i16 : i16 to i32 + %base0_shifted = scalar.shrui %scale0_i32, %c12_i32 : i32 + %base0 = scalar.andi %base0_shifted, %c15_i32 : i32 + %base1_shifted = scalar.shrui %scale1_i32, %c12_i32 : i32 + %base1_masked = scalar.andi %base1_shifted, %c15_i32 : i32 + %base1 = scalar.shli %base1_masked, %c4_i32 : i32 + %base2_shifted = scalar.shrui %scale2_i32, %c12_i32 : i32 + %base2_masked = scalar.andi %base2_shifted, %c15_i32 : i32 + %base2 = scalar.shli %base2_masked, %c8_i32 : i32 + %base3_masked = scalar.andi %scale3_i32, %c61440_i32 : i32 + %base01 = scalar.ori %base0, %base1 : i32 + %base23 = scalar.ori %base2, %base3_masked : i32 + %base_bits = scalar.ori %base01, %base23 : i32 + %base_i16 = scalar.trunci %base_bits : i32 to i16 + %base_i16_vector = vector.splat %base_i16 : vector<1xi16> + %base_f16_vector = vector.bitcast %base_i16_vector : vector<1xi16> to vector<1xf16> + %base_f16 = vector.extract %base_f16_vector[0] : vector<1xf16> -> f16 + %base = scalar.extf %base_f16 : f16 to f32 + %scale_word_index = index.div %bounded_group, %c2 : index + %scale_word = view.load %scales_view[%scale_word_index] : view<4xi16> -> i16 + %scale_word_i32 = scalar.extui %scale_word : i16 to i32 + %group_half = index.rem %bounded_group, %c2 : index + %group_half_i32 = index.cast %group_half : index to i32 + %group_shift = scalar.muli %group_half_i32, %c6_i32 : i32 + %packet_scale_half = index.div %bounded_packet, %c4 : index + %packet_scale_i32 = index.cast %packet_scale_half : index to i32 + %packet_shift = scalar.muli %packet_scale_i32, %c3_i32 : i32 + %scale_shift = scalar.addi %group_shift, %packet_shift : i32 + %local_scale0 = scalar.shrui %scale_word_i32, %scale_shift : i32 + %local_scale = scalar.andi %local_scale0, %c7_i32 : i32 + %local_scale_twice = scalar.muli %local_scale, %c2_i32 : i32 + %local_scale_odd = scalar.addi %local_scale_twice, %c1_i32 : i32 + %local_scale_f32 = scalar.uitofp %local_scale_odd : i32 to f32 + %scale = scalar.mulf %base, %local_scale_f32 : f32 + %scale_vector = vector.splat %scale : vector<4xf32> + %result = vector.mulf %adjusted, %scale_vector : vector<4xf32> + func.return %result : vector<4xf32> +} + +func.def public inline @ggml_codebook_f32_vector4(%weight_format: index, %codebook: buffer, %weight: buffer, %row_byte_base: offset, %quant_block: index, %quant_group: index, %packet: index) -> (vector<4xf32>) { + %iq1_s_format = index.constant 26 : index + %iq3_xxs_format = index.constant 28 : index + %iq3_s_format = index.constant 21 : index + %iq1_m_format = index.constant 27 : index + %iq2_xxs_format = index.constant 24 : index + %iq2_xs_format = index.constant 25 : index + %is_iq1_s = index.cmp eq, %weight_format, %iq1_s_format : index + %is_iq3_xxs = index.cmp eq, %weight_format, %iq3_xxs_format : index + %is_iq3_s = index.cmp eq, %weight_format, %iq3_s_format : index + %is_iq1_m = index.cmp eq, %weight_format, %iq1_m_format : index + %is_iq2_xxs = index.cmp eq, %weight_format, %iq2_xxs_format : index + %is_iq2_xs = index.cmp eq, %weight_format, %iq2_xs_format : index + %other_values = scf.if %is_iq3_s -> (vector<4xf32>) { + %values = func.call @ggml_iq3s_global_f32_vector4(%codebook, %weight, %row_byte_base, %quant_block, %quant_group, %packet) : (buffer, buffer, offset, index, index, index) -> (vector<4xf32>) + scf.yield %values : vector<4xf32> + } else { + %iq2_values = scf.if %is_iq2_xxs -> (vector<4xf32>) { + %values = func.call @ggml_iq2xxs_global_f32_vector4(%codebook, %weight, %row_byte_base, %quant_block, %quant_group, %packet) : (buffer, buffer, offset, index, index, index) -> (vector<4xf32>) + scf.yield %values : vector<4xf32> + } else { + %xs_or_s = scf.if %is_iq2_xs -> (vector<4xf32>) { + %values = func.call @ggml_iq2xs_global_f32_vector4(%codebook, %weight, %row_byte_base, %quant_block, %quant_group, %packet) : (buffer, buffer, offset, index, index, index) -> (vector<4xf32>) + scf.yield %values : vector<4xf32> + } else { + %values = func.call @ggml_iq2s_global_f32_vector4(%codebook, %weight, %row_byte_base, %quant_block, %quant_group, %packet) : (buffer, buffer, offset, index, index, index) -> (vector<4xf32>) + scf.yield %values : vector<4xf32> + } + scf.yield %xs_or_s : vector<4xf32> + } + scf.yield %iq2_values : vector<4xf32> + } + %iq3_xxs_or_other = scf.if %is_iq3_xxs -> (vector<4xf32>) { + %values = func.call @ggml_iq3xxs_global_f32_vector4(%codebook, %weight, %row_byte_base, %quant_block, %quant_group, %packet) : (buffer, buffer, offset, index, index, index) -> (vector<4xf32>) + scf.yield %values : vector<4xf32> + } else { + scf.yield %other_values : vector<4xf32> + } + %iq1_m_or_other = scf.if %is_iq1_m -> (vector<4xf32>) { + %values = func.call @ggml_iq1m_global_f32_vector4(%codebook, %weight, %row_byte_base, %quant_block, %quant_group, %packet) : (buffer, buffer, offset, index, index, index) -> (vector<4xf32>) + scf.yield %values : vector<4xf32> + } else { + scf.yield %iq3_xxs_or_other : vector<4xf32> + } + %result = scf.if %is_iq1_s -> (vector<4xf32>) { + %values = func.call @ggml_iq1s_global_f32_vector4(%codebook, %weight, %row_byte_base, %quant_block, %quant_group, %packet) : (buffer, buffer, offset, index, index, index) -> (vector<4xf32>) + scf.yield %values : vector<4xf32> + } else { + scf.yield %iq1_m_or_other : vector<4xf32> + } + func.return %result : vector<4xf32> +} + +func.def public inline @ggml_codebook_f16_vector4(%weight_format: index, %codebook: buffer, %weight: buffer, %row_byte_base: offset, %quant_block: index, %quant_group: index, %packet: index) -> (vector<4xf16>) { + %values_f32 = func.call @ggml_codebook_f32_vector4(%weight_format, %codebook, %weight, %row_byte_base, %quant_block, %quant_group, %packet) : (index, buffer, buffer, offset, index, index, index) -> (vector<4xf32>) + %values = vector.fptrunc %values_f32 : vector<4xf32> to vector<4xf16> + func.return %values : vector<4xf16> +} + +func.def inline @ggml_q5k_load_decode_state(%weight: buffer, %row_base: offset, %block: index, %packet: index) -> (vector<2xf16>, vector<3xi32>, vector<4xi8>) { + %c0 = index.constant 0 : index + %c4 = index.constant 4 : index + %block_bytes = index.constant 176 : offset + %qh_offset = index.constant 16 : offset + %block_add = index.scale %block, %block_bytes : index, offset -> offset + %block_base = index.add %row_base, %block_add : offset + %qh_base = index.add %block_base, %qh_offset : offset + %header_view = buffer.view %weight[%block_base] : buffer -> view<4xi32> + %header = vector.load %header_view[%c0] : view<4xi32> -> vector<4xi32> + %dm_word = vector.extract %header[0] : vector<4xi32> -> i32 + %dm_vector = vector.from_elements %dm_word : vector<1xi32> + %dm = vector.bitcast %dm_vector : vector<1xi32> to vector<2xf16> + %s0 = vector.extract %header[1] : vector<4xi32> -> i32 + %s1 = vector.extract %header[2] : vector<4xi32> -> i32 + %s2 = vector.extract %header[3] : vector<4xi32> -> i32 + %scales = vector.from_elements %s0, %s1, %s2 : vector<3xi32> + %qh_view = buffer.view %weight[%qh_base] : buffer -> view<32xi8> + %packet_base = index.mul %packet, %c4 : index + %qh = vector.load %qh_view[%packet_base] : view<32xi8> -> vector<4xi8> + func.return %dm, %scales, %qh : vector<2xf16>, vector<3xi32>, vector<4xi8> +} + +func.def inline @ggml_q5k_preloaded_f32_vector4(%weight: buffer, %row_byte_base: offset, %q5_block: index, %q5_group: index, %packet: index, %dm: vector<2xf16>, %scales: vector<3xi32>, %qh_bytes: vector<4xi8>) -> (vector<4xf32>) { + %c2 = index.constant 2 : index + %c4 = index.constant 4 : index + %c8 = index.constant 8 : index + %block_bytes = index.constant 176 : offset + %code_offset = index.constant 48 : offset + %c1_i32 = scalar.constant 1 : i32 + %c2_i32 = scalar.constant 2 : i32 + %c4_i32 = scalar.constant 4 : i32 + %c15 = vector.constant 15 : vector<1xi32> + %c48 = vector.constant 48 : vector<1xi32> + %q4_mask = vector.constant 252645135 : vector<1xi32> + %bounded_group = index.assume %q5_group [range(%q5_group, 0, 7)] : index + %bounded_packet = index.assume %packet [range(%packet, 0, 7)] : index + %block_byte_add = index.scale %q5_block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %code_byte_base = index.add %block_byte_base, %code_offset : offset + %code_view = buffer.view %weight[%code_byte_base] : buffer -> view<32xi32> + %d_f16 = vector.extract %dm[0] : vector<2xf16> -> f16 + %dmin_f16 = vector.extract %dm[1] : vector<2xf16> -> f16 + %d = scalar.extf %d_f16 : f16 to f32 + %dmin = scalar.extf %dmin_f16 : f16 to f32 + %q_page0 = index.div %bounded_group, %c2 : index + %q_page = index.mul %q_page0, %c8 : index + %q_word_index0 = index.add %q_page, %bounded_packet : index + %q_word_index = index.assume %q_word_index0 [range(%q_word_index0, 0, 31)] : index + %is_low = index.cmp ult, %bounded_group, %c4 : index + %scale_lane = index.rem %bounded_group, %c4 : index + %scale_shift_index = index.mul %scale_lane, %c8 : index + %scale_shift_i32 = index.cast %scale_shift_index : index to i32 + %scale_shift = vector.splat %scale_shift_i32 : vector<1xi32> + %scale0_i32 = vector.extract %scales[0] : vector<3xi32> -> i32 + %scale1_i32 = vector.extract %scales[1] : vector<3xi32> -> i32 + %scale2_i32 = vector.extract %scales[2] : vector<3xi32> -> i32 + %scale0 = vector.splat %scale0_i32 : vector<1xi32> + %scale1 = vector.splat %scale1_i32 : vector<1xi32> + %scale2 = vector.splat %scale2_i32 : vector<1xi32> + %high_shift_i32 = scalar.addi %scale_shift_i32, %c2_i32 : i32 + %minimum_shift_i32 = scalar.addi %scale_shift_i32, %c4_i32 : i32 + %selected_scale_source = scf.select %is_low, %scale0, %scale2 : vector<1xi32> + %selected_minimum_source = scf.select %is_low, %scale1, %scale2 : vector<1xi32> + %selected_scale_high_shift_i32 = scf.select %is_low, %scale_shift_i32, %high_shift_i32 : i32 + %selected_minimum_low_shift_i32 = scf.select %is_low, %scale_shift_i32, %minimum_shift_i32 : i32 + %selected_scale_high_shift = vector.splat %selected_scale_high_shift_i32 : vector<1xi32> + %selected_minimum_low_shift = vector.splat %selected_minimum_low_shift_i32 : vector<1xi32> + %scale_low0 = vector.shrui %selected_scale_source, %scale_shift : vector<1xi32> + %scale_low = vector.andi %scale_low0, %c15 : vector<1xi32> + %scale_high0 = vector.shrui %scale0, %selected_scale_high_shift : vector<1xi32> + %scale_high = vector.andi %scale_high0, %c48 : vector<1xi32> + %scale = vector.ori %scale_low, %scale_high : vector<1xi32> + %minimum_low0 = vector.shrui %selected_minimum_source, %selected_minimum_low_shift : vector<1xi32> + %minimum_low = vector.andi %minimum_low0, %c15 : vector<1xi32> + %minimum_high0 = vector.shrui %scale1, %selected_scale_high_shift : vector<1xi32> + %minimum_high = vector.andi %minimum_high0, %c48 : vector<1xi32> + %minimum = vector.ori %minimum_low, %minimum_high : vector<1xi32> + %scale_f32 = vector.uitofp %scale : vector<1xi32> to vector<1xf32> + %minimum_f32 = vector.uitofp %minimum : vector<1xi32> to vector<1xf32> + %d_vector1 = vector.splat %d : vector<1xf32> + %dmin_vector1 = vector.splat %dmin : vector<1xf32> + %d_scale_vector1 = vector.mulf %d_vector1, %scale_f32 : vector<1xf32> + %minimum_scale_vector1 = vector.mulf %dmin_vector1, %minimum_f32 : vector<1xf32> + %d_scale = vector.extract %d_scale_vector1[0] : vector<1xf32> -> f32 + %minimum_scale = vector.extract %minimum_scale_vector1[0] : vector<1xf32> -> f32 + %q_word = vector.load %code_view[%q_word_index] : view<32xi32> -> vector<1xi32> + %q_half = index.rem %bounded_group, %c2 : index + %q_shift_index = index.mul %q_half, %c4 : index + %q_shift_i32 = index.cast %q_shift_index : index to i32 + %q_shift = vector.splat %q_shift_i32 : vector<1xi32> + %shifted_q = vector.shrui %q_word, %q_shift : vector<1xi32> + %masked_q = vector.andi %shifted_q, %q4_mask : vector<1xi32> + %q_i8 = vector.bitcast %masked_q : vector<1xi32> to vector<4xi8> + %q_f32 = vector.uitofp %q_i8 : vector<4xi8> to vector<4xf32> + %qh_shift_i32 = index.cast %bounded_group : index to i32 + %qh_bit = scalar.shli %c1_i32, %qh_shift_i32 : i32 + %qh0 = vector.extract %qh_bytes[0] : vector<4xi8> -> i8 + %qh1 = vector.extract %qh_bytes[1] : vector<4xi8> -> i8 + %qh2 = vector.extract %qh_bytes[2] : vector<4xi8> -> i8 + %qh3 = vector.extract %qh_bytes[3] : vector<4xi8> -> i8 + %high0 = func.call @ggml_q5k_high_bit_f32(%qh0, %qh_bit) : (i8, i32) -> (f32) + %high1 = func.call @ggml_q5k_high_bit_f32(%qh1, %qh_bit) : (i8, i32) -> (f32) + %high2 = func.call @ggml_q5k_high_bit_f32(%qh2, %qh_bit) : (i8, i32) -> (f32) + %high3 = func.call @ggml_q5k_high_bit_f32(%qh3, %qh_bit) : (i8, i32) -> (f32) + %q0_low = vector.extract %q_f32[0] : vector<4xf32> -> f32 + %q1_low = vector.extract %q_f32[1] : vector<4xf32> -> f32 + %q2_low = vector.extract %q_f32[2] : vector<4xf32> -> f32 + %q3_low = vector.extract %q_f32[3] : vector<4xf32> -> f32 + %q0 = scalar.addf %q0_low, %high0 : f32 + %q1 = scalar.addf %q1_low, %high1 : f32 + %q2 = scalar.addf %q2_low, %high2 : f32 + %q3 = scalar.addf %q3_low, %high3 : f32 + %negative_minimum_scale = scalar.negf %minimum_scale : f32 + %value0 = scalar.fmaf %q0, %d_scale, %negative_minimum_scale : f32 + %value1 = scalar.fmaf %q1, %d_scale, %negative_minimum_scale : f32 + %value2 = scalar.fmaf %q2, %d_scale, %negative_minimum_scale : f32 + %value3 = scalar.fmaf %q3, %d_scale, %negative_minimum_scale : f32 + %result = vector.from_elements %value0, %value1, %value2, %value3 : vector<4xf32> + func.return %result : vector<4xf32> +} + +func.def inline @ggml_iq4xs_load_decode_state(%weight: buffer, %row_base: offset, %block: index) -> (i32, i32) { + %c0 = index.constant 0 : index + %block_bytes = index.constant 136 : offset + %block_add = index.scale %block, %block_bytes : index, offset -> offset + %block_base = index.add %row_base, %block_add : offset + %header_view = buffer.view %weight[%block_base] : buffer -> view<2xi32> + %header = vector.load %header_view[%c0] : view<2xi32> -> vector<2xi32> + %high = vector.extract %header[0] : vector<2xi32> -> i32 + %low = vector.extract %header[1] : vector<2xi32> -> i32 + func.return %high, %low : i32, i32 +} + +func.def inline @ggml_iq4xs_preloaded_f32_vector4(%iq4nl_table: vector<16xi8>, %weight: buffer, %row_byte_base: offset, %iq4_block: index, %iq4_group: index, %packet: index, %header: i32, %scales_l: i32) -> (vector<4xf32>) { + %c2 = index.constant 2 : index + %c4 = index.constant 4 : index + %block_bytes = index.constant 136 : offset + %code_offset = index.constant 8 : offset + %c3_i32 = scalar.constant 3 : i32 + %c4_i32 = scalar.constant 4 : i32 + %c15_i32 = scalar.constant 15 : i32 + %c16_i32 = scalar.constant 16 : i32 + %c32_i32 = scalar.constant 32 : i32 + %c65535_i32 = scalar.constant 65535 : i32 + %bounded_group = index.assume %iq4_group [range(%iq4_group, 0, 7)] : index + %bounded_packet = index.assume %packet [range(%packet, 0, 7)] : index + %block_byte_add = index.scale %iq4_block, %block_bytes : index, offset -> offset + %block_byte_base = index.add %row_byte_base, %block_byte_add : offset + %code_byte_base = index.add %block_byte_base, %code_offset : offset + %code_view = buffer.view %weight[%code_byte_base] : buffer -> view<32xi32> + %header_vector = vector.from_elements %header : vector<1xi32> + %header_halves = vector.bitcast %header_vector : vector<1xi32> to vector<2xf16> + %d_f16 = vector.extract %header_halves[0] : vector<2xf16> -> f16 + %d = scalar.extf %d_f16 : f16 to f32 + %scales_h_shifted = scalar.shrui %header, %c16_i32 : i32 + %scales_h = scalar.andi %scales_h_shifted, %c65535_i32 : i32 + %scale_l_shift_index = index.mul %bounded_group, %c4 : index + %scale_l_shift = index.cast %scale_l_shift_index : index to i32 + %scale_l_shifted = scalar.shrui %scales_l, %scale_l_shift : i32 + %scale_l = scalar.andi %scale_l_shifted, %c15_i32 : i32 + %scale_h_shift_index = index.mul %bounded_group, %c2 : index + %scale_h_shift = index.cast %scale_h_shift_index : index to i32 + %scale_h_shifted = scalar.shrui %scales_h, %scale_h_shift : i32 + %scale_h = scalar.andi %scale_h_shifted, %c3_i32 : i32 + %scale_h_high = scalar.shli %scale_h, %c4_i32 : i32 + %local_scale = scalar.ori %scale_l, %scale_h_high : i32 + %centered_scale = scalar.subi %local_scale, %c32_i32 : i32 + %centered_scale_f32 = scalar.sitofp %centered_scale : i32 to f32 + %block_scale = scalar.mulf %d, %centered_scale_f32 : f32 + %packet_page = index.rem %bounded_packet, %c4 : index + %q_word_base = index.mul %bounded_group, %c4 : index + %q_word_index0 = index.add %q_word_base, %packet_page : index + %q_word_index = index.assume %q_word_index0 [range(%q_word_index0, 0, 31)] : index + %q_word = vector.load %code_view[%q_word_index] : view<32xi32> -> vector<1xi32> + %uses_high = index.cmp uge, %bounded_packet, %c4 : index + %codes = func.call @ggml_iq4xs_table_codes4(%q_word, %uses_high) : (vector<1xi32>, i1) -> (vector<4xi8>) + %lookup_i8 = func.call @ggml_iq4nl_lookup_i8_vector4(%iq4nl_table, %codes) : (vector<16xi8>, vector<4xi8>) -> (vector<4xi8>) + %lookup0_i8 = vector.extract %lookup_i8[0] : vector<4xi8> -> i8 + %lookup1_i8 = vector.extract %lookup_i8[1] : vector<4xi8> -> i8 + %lookup2_i8 = vector.extract %lookup_i8[2] : vector<4xi8> -> i8 + %lookup3_i8 = vector.extract %lookup_i8[3] : vector<4xi8> -> i8 + %lookup0_i32 = scalar.extsi %lookup0_i8 : i8 to i32 + %lookup1_i32 = scalar.extsi %lookup1_i8 : i8 to i32 + %lookup2_i32 = scalar.extsi %lookup2_i8 : i8 to i32 + %lookup3_i32 = scalar.extsi %lookup3_i8 : i8 to i32 + %lookup0 = scalar.sitofp %lookup0_i32 : i32 to f32 + %lookup1 = scalar.sitofp %lookup1_i32 : i32 to f32 + %lookup2 = scalar.sitofp %lookup2_i32 : i32 to f32 + %lookup3 = scalar.sitofp %lookup3_i32 : i32 to f32 + %value0 = scalar.mulf %block_scale, %lookup0 : f32 + %value1 = scalar.mulf %block_scale, %lookup1 : f32 + %value2 = scalar.mulf %block_scale, %lookup2 : f32 + %value3 = scalar.mulf %block_scale, %lookup3 : f32 + %result = vector.from_elements %value0, %value1, %value2, %value3 : vector<4xf32> + func.return %result : vector<4xf32> +} diff --git a/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/motifs/matmul_id/pair_input_f32_dequant_accumulate_f32.loom b/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/motifs/matmul_id/pair_input_f32_dequant_accumulate_f32.loom index b9e887e1b9f4..dcb669728d40 100644 --- a/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/motifs/matmul_id/pair_input_f32_dequant_accumulate_f32.loom +++ b/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/motifs/matmul_id/pair_input_f32_dequant_accumulate_f32.loom @@ -59,7 +59,8 @@ template.def<@ggml.matmul_id.pair_f32_swiglu.body> device @ggml_mul_mat_id_pair_ %c64 = index.constant 64 : index %c255 = index.constant 255 : index %c256 = index.constant 256 : index - %iq3_xxs_format = index.constant 18 : index + // engine#2138: this line's IQ3_XXS code is 28 (dispatch-mul-mat-weight-format.h); AMD's file numbers it 18. + %iq3_xxs_format = index.constant 28 : index %c0_offset = index.constant 0 : offset %c4_bytes = index.constant 4 : offset %weight_stage_bytes = index.constant 5120 : offset diff --git a/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/ops/mul_mat_id_swiglu_f32_f32_wmma.loom b/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/ops/mul_mat_id_swiglu_f32_f32_wmma.loom index efaa4a9f0176..a1b7cf88f375 100644 --- a/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/ops/mul_mat_id_swiglu_f32_f32_wmma.loom +++ b/ggml/src/ggml-hrx/kernel-corpus/kernels/loom-libs/ops/mul_mat_id_swiglu_f32_f32_wmma.loom @@ -94,7 +94,8 @@ template.def<@ggml.mul_mat_id_swiglu.body> device @ggml_mul_mat_id_swiglu_f32_f3 %c64 = index.constant 64 : index %c255 = index.constant 255 : index %c256 = index.constant 256 : index - %iq3_xxs_format = index.constant 18 : index + // engine#2138: this line's IQ3_XXS code is 28 (dispatch-mul-mat-weight-format.h); AMD's file numbers it 18. + %iq3_xxs_format = index.constant 28 : index %c0_offset = index.constant 0 : offset %c4_bytes = index.constant 4 : offset %weight_stage_bytes = index.constant 5120 : offset From f9145d75b9071f9d76f64a55418b61fb8d51812b Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Fri, 13 Nov 2026 18:00:54 -0400 Subject: [PATCH 2/2] tests: test-hrx-loom-jit links the routed gate/up pair kernels (engine#2138) Compiles ggml_mul_mat_id_{skinny,tiled}_pair_input_f32_swiglu_publish_f32 with the dispatch's own compile parameters, for Q4_K, Q6_K and IQ3_XXS (28) weights. On the previous commit's parent this aborts with "unresolved exact declaration '@ggml_codebook_f16_vector4'", the failure every MoE model hit at serve; the rest of this suite passed there, so nothing caught it. Co-Authored-By: Claude Opus 5.5 --- tests/test-hrx-loom-jit.cpp | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/tests/test-hrx-loom-jit.cpp b/tests/test-hrx-loom-jit.cpp index 09f3b8489d75..4489cb010ecb 100644 --- a/tests/test-hrx-loom-jit.cpp +++ b/tests/test-hrx-loom-jit.cpp @@ -609,6 +609,32 @@ int main() { std::printf("async Loom JIT compiled %zu kernels\n", refs.size()); + // engine#2138: the routed gate/up pair kernels the dispatch selects (dispatch-gated-mul-mat-id.cpp: skinny at + // <= 5 tokens, tiled above) link the motifs/dequant.loom codebook and preload functions. The #327 merge left + // those declared and undefined, so every MoE model failed here with "unresolved exact declaration" while the + // rest of this suite passed. The configs are the ones the dispatch emits; 28 is this line's IQ3_XXS code. + for (const char * pair_kernel : { "ggml_mul_mat_id_skinny_pair_input_f32_swiglu_publish_f32", + "ggml_mul_mat_id_tiled_pair_input_f32_swiglu_publish_f32" }) { + const ggml::hrx::KernelDefinition & pair = find_kernel(pair_kernel); + const bool skinny = std::strstr(pair_kernel, "skinny") != nullptr; + const int64_t tokens = skinny ? 1 : 16; + for (const char * format : { "4", "6", "28" }) { + const std::string key = std::string(skinny ? "pair-skinny-" : "pair-tiled-") + format; + require_compiled_kernel(compile_kernel(*sync_jit, key, pair, token_count_workload(tokens), + { + { "ggml.workload.token_capacity", std::to_string(tokens) }, + { "ggml.mul_mat_id_swiglu.input_size", "2048" }, + { "ggml.mul_mat_id_swiglu.output_size", "768" }, + { "ggml.mul_mat_id_swiglu.expert_count", "128" }, + { "ggml.mul_mat_id_swiglu.route_count", "8" }, + { "ggml.mul_mat_id_swiglu.input_route_count", "1" }, + { "ggml.mul_mat_id_swiglu.gate_weight_format", format }, + { "ggml.mul_mat_id_swiglu.up_weight_format", format }, + })); + std::printf("Loom JIT linked %s with weight format %s\n", pair_kernel, format); + } + } + const auto & q6_prefill = find_kernel("ggml_mul_mat_q6_k_f16_wmma_prefill_wave32"); const struct { int64_t tokens;