numkong 7.4.4 → 7.5.0

package/include/numkong/dots/sme.h

@@ -63,7 +63,7 @@
 
 #include "numkong/types.h"
 #include "numkong/cast/serial.h" // `nk_e4m3_to_f16_serial`, `nk_e5m2_to_f16_serial`
-#include "numkong/dots/serial.h" // `nk_dots_reduce_sumsq_f16_`, `nk_dots_reduce_sumsq_i8_`, etc.
+#include "numkong/dots/serial.h" // `nk_dots_reduce_sumsq_f16_`, `nk_dots_reduce_sumsq_i8_`
 
 #if defined(__cplusplus)
 extern "C" {
@@ -146,9 +146,9 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_bf16_sme(nk_size_t columns, nk_size_t de
  *
  *  Replaces the scalar scatter loop with hardware-accelerated tile transpose.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_pack_b16_sme_streaming_( //
-    void const *b, nk_size_t columns, nk_size_t depth,                               //
-    nk_size_t b_stride_bytes, void *tiles_ptr) {
+__arm_new("za") static void nk_dots_pack_b16_sme_streaming_( //
+    void const *b, nk_size_t columns, nk_size_t depth,       //
+    nk_size_t b_stride_bytes, void *tiles_ptr) NK_STREAMING_ {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = svcntw();
@@ -200,9 +200,8 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_pack_b16_sme_streami
  *  required by SMOPA/UMOPA: each i32 word in the output vector holds four 8-bit values
  *  from the same column but adjacent depth positions.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_pack_b8_sme_streaming_( //
-    void const *b, nk_size_t columns, nk_size_t depth,                              //
-    nk_size_t b_stride_bytes, void *tiles_ptr) {
+__arm_new("za") static void nk_dots_pack_b8_sme_streaming_( //
+    void const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_bytes, void *tiles_ptr) NK_STREAMING_ {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = svcntw();
@@ -267,7 +266,9 @@ NK_PUBLIC void nk_dots_pack_f16_sme(                       //
 
     nk_f16_t *tiles_ptr = (nk_f16_t *)((char *)b_packed + sizeof(nk_dots_sme_packed_header_t));
 
+    nk_sme_start_streaming_();
     nk_dots_pack_b16_sme_streaming_(b, columns, depth, b_stride_in_bytes, tiles_ptr);
+    nk_sme_stop_streaming_();
 
     nk_size_t const data_size = total_vectors * vector_elements * sizeof(nk_f16_t);
     header->norms_offset = (nk_u32_t)(sizeof(nk_dots_sme_packed_header_t) + data_size);
@@ -299,7 +300,9 @@ NK_PUBLIC void nk_dots_pack_bf16_sme(                       //
 
     nk_bf16_t *tiles_ptr = (nk_bf16_t *)((char *)b_packed + sizeof(nk_dots_sme_packed_header_t));
 
+    nk_sme_start_streaming_();
     nk_dots_pack_b16_sme_streaming_(b, columns, depth, b_stride_in_bytes, tiles_ptr);
+    nk_sme_stop_streaming_();
 
     nk_size_t const data_size = total_vectors * vector_elements * sizeof(nk_bf16_t);
     header->norms_offset = (nk_u32_t)(sizeof(nk_dots_sme_packed_header_t) + data_size);
@@ -321,10 +324,9 @@ NK_PUBLIC void nk_dots_pack_bf16_sme(                       //
  *  - Zm[2*d+k] = B[column_start+d, depth_base+k]   (pre-packed interleaved)
  *  - Loop over depth in steps of 2 (expansion factor)
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_f16_sme_streaming_( //
-    nk_f16_t const *a, void const *b_packed, nk_f32_t *c,                              //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                                //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_f16_sme_streaming_( //
+    nk_f16_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -469,10 +471,9 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_packed_f16_sme_strea
  *  `bf16` → `f32` GEMM core kernel using SME outer products.
  *  Same interleaved algorithm as f16 kernel, using BFMOPA bf16 → f32.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_bf16_sme_streaming_( //
-    nk_bf16_t const *a, void const *b_packed, nk_f32_t *c,                              //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                                 //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_bf16_sme_streaming_( //
+    nk_bf16_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -614,7 +615,9 @@ NK_PUBLIC void nk_dots_packed_f16_sme(                    //
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_f16_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_f32_t);
 
+    nk_sme_start_streaming_();
     nk_dots_packed_f16_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
 NK_PUBLIC void nk_dots_packed_bf16_sme(                    //
@@ -625,7 +628,9 @@ NK_PUBLIC void nk_dots_packed_bf16_sme(                    //
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_bf16_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_f32_t);
 
+    nk_sme_start_streaming_();
     nk_dots_packed_bf16_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
 /**
@@ -634,9 +639,9 @@ NK_PUBLIC void nk_dots_packed_bf16_sme(                    //
  *   pre-reads A columns into Z registers, then reloads ZA0 with B data
  *   per column tile. Eliminates all scalar B-packing loops.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_f16_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_f16_sme_streaming_( //
     nk_f16_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_f32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = svcntw(); // 16
@@ -827,19 +832,21 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_f16_sme_st
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_f16_sme(nk_f16_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                         nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
-                                         nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_f16_sme( //
+    nk_f16_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_f32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_f16_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_f16_sme_streaming_(vectors, vectors_count, depth, stride_elements, result, result_stride_elements,
                                          row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_bf16_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_bf16_sme_streaming_( //
     nk_bf16_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_f32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = svcntw();
@@ -1020,14 +1027,16 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_bf16_sme_s
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_bf16_sme(nk_bf16_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
-                                          nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_bf16_sme( //
+    nk_bf16_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_f32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_bf16_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_bf16_sme_streaming_(vectors, vectors_count, depth, stride_elements, result,
                                           result_stride_elements, row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
 #pragma endregion F16 Floats
@@ -1061,9 +1070,8 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_i8_sme(nk_size_t columns, nk_size_t dept
     return size;
 }
 
-NK_PUBLIC void nk_dots_pack_i8_sme(                       //
-    nk_i8_t const *b, nk_size_t columns, nk_size_t depth, //
-    nk_size_t b_stride_in_bytes, void *b_packed) {
+NK_PUBLIC void nk_dots_pack_i8_sme( //
+    nk_i8_t const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_in_bytes, void *b_packed) {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = nk_sme_cntw_();
@@ -1082,7 +1090,9 @@ NK_PUBLIC void nk_dots_pack_i8_sme(                       //
 
     nk_i8_t *tiles_ptr = (nk_i8_t *)((char *)b_packed + sizeof(nk_dots_sme_packed_header_t));
 
+    nk_sme_start_streaming_();
     nk_dots_pack_b8_sme_streaming_(b, columns, depth, b_stride_in_bytes, tiles_ptr);
+    nk_sme_stop_streaming_();
 
     nk_size_t const data_size = total_vectors * vector_elements * sizeof(nk_i8_t);
     header->norms_offset = (nk_u32_t)(sizeof(nk_dots_sme_packed_header_t) + data_size);
@@ -1104,10 +1114,9 @@ NK_PUBLIC void nk_dots_pack_i8_sme(                       //
  *  - Zm[4*d+k] = B[column_start+d, depth_base+k]   (pre-packed interleaved)
  *  - Loop over depth in steps of 4 (expansion factor)
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_i8_sme_streaming_( //
-    nk_i8_t const *a, void const *b_packed, nk_i32_t *c,                              //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                               //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_i8_sme_streaming_( //
+    nk_i8_t const *a, void const *b_packed, nk_i32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -1244,13 +1253,14 @@ NK_PUBLIC void nk_dots_packed_i8_sme(                    //
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_i8_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_i32_t);
 
+    nk_sme_start_streaming_();
     nk_dots_packed_i8_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
-// expansion=4: each i32 word packs 4 i8 values
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_i8_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_i8_sme_streaming_( //
     nk_i8_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_i32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = svcntw();
@@ -1417,14 +1427,16 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_i8_sme_str
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_i8_sme(nk_i8_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                        nk_size_t stride_in_bytes, nk_i32_t *result, nk_size_t result_stride_in_bytes,
-                                        nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_i8_sme( //
+    nk_i8_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_i32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_i8_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_i32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_i8_sme_streaming_(vectors, vectors_count, depth, stride_elements, result, result_stride_elements,
                                         row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
 #pragma endregion I8 Integers
@@ -1519,10 +1531,9 @@ NK_PUBLIC svfloat16_t nk_e5m2x_to_f16x_ssve_(svbool_t predicate_b16x, svuint8_t
  *  Fused `e4m3` × `e4m3` → `f32` GEMM kernel using interleaved FMOPA.
  *  Converts `e4m3` → `f16` on-the-fly for A, B is pre-converted during packing.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_e4m3_sme_streaming_( //
-    nk_e4m3_t const *a, void const *b_packed, nk_f32_t *c,                              //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                                 //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_e4m3_sme_streaming_( //
+    nk_e4m3_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -1667,8 +1678,8 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_e4m3_sme(nk_size_t columns, nk_size_t de
 }
 
 /** @brief Streaming e4m3 → f16 pack using ZA tile transpose. */
-__arm_locally_streaming __arm_new("za") static void nk_dots_pack_e4m3_to_b16_sme_streaming_( //
-    void const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_bytes, void *tiles_ptr) {
+__arm_new("za") static void nk_dots_pack_e4m3_to_b16_sme_streaming_( //
+    void const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_bytes, void *tiles_ptr) NK_STREAMING_ {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = svcntw();
@@ -1712,8 +1723,8 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_pack_e4m3_to_b16_sme
 }
 
 /** @brief Streaming e5m2 → f16 pack using ZA tile transpose. */
-__arm_locally_streaming __arm_new("za") static void nk_dots_pack_e5m2_to_b16_sme_streaming_( //
-    void const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_bytes, void *tiles_ptr) {
+__arm_new("za") static void nk_dots_pack_e5m2_to_b16_sme_streaming_( //
+    void const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_bytes, void *tiles_ptr) NK_STREAMING_ {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = svcntw();
@@ -1777,7 +1788,9 @@ NK_PUBLIC void nk_dots_pack_e4m3_sme(                       //
 
     nk_f16_t *tiles_ptr = (nk_f16_t *)((char *)b_packed + sizeof(nk_dots_sme_packed_header_t));
 
+    nk_sme_start_streaming_();
     nk_dots_pack_e4m3_to_b16_sme_streaming_(b, columns, depth, b_stride_in_bytes, tiles_ptr);
+    nk_sme_stop_streaming_();
 
     nk_size_t const data_size = total_vectors * vector_elements * sizeof(nk_f16_t);
     header->norms_offset = (nk_u32_t)(sizeof(nk_dots_sme_packed_header_t) + data_size);
@@ -1796,7 +1809,9 @@ NK_PUBLIC void nk_dots_packed_e4m3_sme(                    //
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_e4m3_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_f32_t);
 
+    nk_sme_start_streaming_();
     nk_dots_packed_e4m3_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
 /**
@@ -1805,9 +1820,9 @@ NK_PUBLIC void nk_dots_packed_e4m3_sme(                    //
  *  Pre-reads A columns into Z registers, then reloads ZA0 with converted B data
  *  per column tile. Eliminates all scalar B-packing loops.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_e4m3_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_e4m3_sme_streaming_( //
     nk_e4m3_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_f32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = svcntw();
@@ -2005,14 +2020,16 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_e4m3_sme_s
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_e4m3_sme(nk_e4m3_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
-                                          nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_e4m3_sme( //
+    nk_e4m3_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_f32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_e4m3_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_e4m3_sme_streaming_(vectors, vectors_count, depth, stride_elements, result,
                                           result_stride_elements, row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
 #pragma endregion E4M3 Floats
@@ -2031,10 +2048,9 @@ NK_PUBLIC void nk_dots_symmetric_e4m3_sme(nk_e4m3_t const *vectors, nk_size_t ve
  *  Fused `e5m2` × `e5m2` → `f32` GEMM kernel using interleaved FMOPA.
  *  Converts `e5m2` → `f16` on-the-fly for A, B is pre-converted during packing.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_e5m2_sme_streaming_( //
-    nk_e5m2_t const *a, void const *b_packed, nk_f32_t *c,                              //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                                 //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_e5m2_sme_streaming_( //
+    nk_e5m2_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -2196,7 +2212,9 @@ NK_PUBLIC void nk_dots_pack_e5m2_sme(nk_e5m2_t const *b, nk_size_t columns, nk_s
 
     nk_f16_t *tiles_ptr = (nk_f16_t *)((char *)b_packed + sizeof(nk_dots_sme_packed_header_t));
 
+    nk_sme_start_streaming_();
     nk_dots_pack_e5m2_to_b16_sme_streaming_(b, columns, depth, b_stride_in_bytes, tiles_ptr);
+    nk_sme_stop_streaming_();
 
     nk_size_t const data_size = total_vectors * vector_elements * sizeof(nk_f16_t);
     header->norms_offset = (nk_u32_t)(sizeof(nk_dots_sme_packed_header_t) + data_size);
@@ -2210,15 +2228,16 @@ NK_PUBLIC void nk_dots_pack_e5m2_sme(nk_e5m2_t const *b, nk_size_t columns, nk_s
 /*  `e5m2` × `e5m2` → `f32` GEMM: public interface.
  *  Predicate-based edge handling eliminates scalar fallbacks.
  */
-NK_PUBLIC void nk_dots_packed_e5m2_sme(                    //
-    nk_e5m2_t const *a, void const *b_packed, nk_f32_t *c, //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,    //
+NK_PUBLIC void nk_dots_packed_e5m2_sme( //
+    nk_e5m2_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
     nk_size_t a_stride_in_bytes, nk_size_t c_stride_in_bytes) {
 
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_e5m2_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_f32_t);
 
+    nk_sme_start_streaming_();
     nk_dots_packed_e5m2_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
 /**
@@ -2227,9 +2246,9 @@ NK_PUBLIC void nk_dots_packed_e5m2_sme(                    //
  *  Pre-reads A columns into Z registers, then reloads ZA0 with converted B data
  *  per column tile. Eliminates all scalar B-packing loops.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_e5m2_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_e5m2_sme_streaming_( //
     nk_e5m2_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_f32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = svcntw();
@@ -2425,14 +2444,16 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_e5m2_sme_s
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_e5m2_sme(nk_e5m2_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
-                                          nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_e5m2_sme( //
+    nk_e5m2_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_f32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_e5m2_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_e5m2_sme_streaming_(vectors, vectors_count, depth, stride_elements, result,
                                           result_stride_elements, row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
 #pragma endregion E5M2 Floats
@@ -2490,10 +2511,9 @@ NK_PUBLIC svint8_t nk_e2m3x_to_i8x_ssve_(svbool_t predicate_b8x, svuint8_t raw_b
  *  Converts `e2m3` → `i8` on-the-fly for A, B is pre-converted during packing.
  *  Accumulates in `i32` via `svmopa_za32_s8_m`, then converts to `f32` with 1/256 scaling.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_e2m3_sme_streaming_( //
-    nk_e2m3_t const *a, void const *b_packed, nk_f32_t *c,                              //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                                 //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_e2m3_sme_streaming_( //
+    nk_e2m3_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -2648,9 +2668,8 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_e2m3_sme(nk_size_t columns, nk_size_t de
 }
 
 /** @brief Streaming pack helper for e2m3 → i8 conversion + quad-interleave using ZA tile transpose. */
-__arm_locally_streaming __arm_new("za") static void nk_dots_pack_e2m3_to_b8_sme_streaming_( //
-    void const *b, nk_size_t columns, nk_size_t depth,                                      //
-    nk_size_t b_stride_bytes, void *tiles_ptr) {
+__arm_new("za") static void nk_dots_pack_e2m3_to_b8_sme_streaming_( //
+    void const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_bytes, void *tiles_ptr) NK_STREAMING_ {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = svcntw();
@@ -2693,9 +2712,8 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_pack_e2m3_to_b8_sme_
     }
 }
 
-NK_PUBLIC void nk_dots_pack_e2m3_sme(                       //
-    nk_e2m3_t const *b, nk_size_t columns, nk_size_t depth, //
-    nk_size_t b_stride_in_bytes, void *b_packed) {
+NK_PUBLIC void nk_dots_pack_e2m3_sme( //
+    nk_e2m3_t const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_in_bytes, void *b_packed) {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = nk_sme_cntw_();
@@ -2714,7 +2732,9 @@ NK_PUBLIC void nk_dots_pack_e2m3_sme(                       //
 
     nk_i8_t *tiles_ptr = (nk_i8_t *)((char *)b_packed + sizeof(nk_dots_sme_packed_header_t));
 
+    nk_sme_start_streaming_();
     nk_dots_pack_e2m3_to_b8_sme_streaming_(b, columns, depth, b_stride_in_bytes, tiles_ptr);
+    nk_sme_stop_streaming_();
 
     nk_size_t const data_size = total_vectors * vector_elements * sizeof(nk_i8_t);
     header->norms_offset = (nk_u32_t)(sizeof(nk_dots_sme_packed_header_t) + data_size);
@@ -2725,15 +2745,16 @@ NK_PUBLIC void nk_dots_pack_e2m3_sme(                       //
     }
 }
 
-NK_PUBLIC void nk_dots_packed_e2m3_sme(                    //
-    nk_e2m3_t const *a, void const *b_packed, nk_f32_t *c, //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,    //
+NK_PUBLIC void nk_dots_packed_e2m3_sme( //
+    nk_e2m3_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
     nk_size_t a_stride_in_bytes, nk_size_t c_stride_in_bytes) {
 
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_e2m3_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_f32_t);
 
+    nk_sme_start_streaming_();
     nk_dots_packed_e2m3_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
 /**
@@ -2742,9 +2763,9 @@ NK_PUBLIC void nk_dots_packed_e2m3_sme(                    //
  *  Pre-reads A columns into Z registers, then reloads ZA0 with converted B data
  *  per column tile. Accumulates in i32, converts to f32 with 1/256 scaling.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_e2m3_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_e2m3_sme_streaming_( //
     nk_e2m3_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_f32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = svcntw();
@@ -2947,14 +2968,16 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_e2m3_sme_s
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_e2m3_sme(nk_e2m3_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
-                                          nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_e2m3_sme( //
+    nk_e2m3_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_f32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_e2m3_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_e2m3_sme_streaming_(vectors, vectors_count, depth, stride_elements, result,
                                           result_stride_elements, row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
 #pragma endregion E2M3 Floats
@@ -3012,10 +3035,9 @@ NK_PUBLIC svfloat16_t nk_e3m2x_to_f16x_ssve_(svbool_t predicate_b16x, svuint8_t
  *  Fused `e3m2` × `e3m2` → `f32` GEMM kernel using interleaved FMOPA.
  *  Converts `e3m2` → `f16` on-the-fly for A, B is pre-converted during packing.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_e3m2_sme_streaming_( //
-    nk_e3m2_t const *a, void const *b_packed, nk_f32_t *c,                              //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                                 //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_e3m2_sme_streaming_( //
+    nk_e3m2_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -3158,8 +3180,8 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_e3m2_sme(nk_size_t columns, nk_size_t de
 }
 
 /** @brief Streaming e3m2 → f16 pack using ZA tile transpose. */
-__arm_locally_streaming __arm_new("za") static void nk_dots_pack_e3m2_to_b16_sme_streaming_( //
-    void const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_bytes, void *tiles_ptr) {
+__arm_new("za") static void nk_dots_pack_e3m2_to_b16_sme_streaming_( //
+    void const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_bytes, void *tiles_ptr) NK_STREAMING_ {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = svcntw();
@@ -3202,8 +3224,8 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_pack_e3m2_to_b16_sme
     }
 }
 
-NK_PUBLIC void nk_dots_pack_e3m2_sme(nk_e3m2_t const *b, nk_size_t columns, nk_size_t depth,
-                                     nk_size_t b_stride_in_bytes, void *b_packed) {
+NK_PUBLIC void nk_dots_pack_e3m2_sme( //
+    nk_e3m2_t const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_in_bytes, void *b_packed) {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = nk_sme_cntw_();
@@ -3222,7 +3244,9 @@ NK_PUBLIC void nk_dots_pack_e3m2_sme(nk_e3m2_t const *b, nk_size_t columns, nk_s
 
     nk_f16_t *tiles_ptr = (nk_f16_t *)((char *)b_packed + sizeof(nk_dots_sme_packed_header_t));
 
+    nk_sme_start_streaming_();
     nk_dots_pack_e3m2_to_b16_sme_streaming_(b, columns, depth, b_stride_in_bytes, tiles_ptr);
+    nk_sme_stop_streaming_();
 
     nk_size_t const data_size = total_vectors * vector_elements * sizeof(nk_f16_t);
     header->norms_offset = (nk_u32_t)(sizeof(nk_dots_sme_packed_header_t) + data_size);
@@ -3236,15 +3260,16 @@ NK_PUBLIC void nk_dots_pack_e3m2_sme(nk_e3m2_t const *b, nk_size_t columns, nk_s
 /*  `e3m2` × `e3m2` → `f32` GEMM: public interface.
  *  Predicate-based edge handling eliminates scalar fallbacks.
  */
-NK_PUBLIC void nk_dots_packed_e3m2_sme(                    //
-    nk_e3m2_t const *a, void const *b_packed, nk_f32_t *c, //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,    //
+NK_PUBLIC void nk_dots_packed_e3m2_sme( //
+    nk_e3m2_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
     nk_size_t a_stride_in_bytes, nk_size_t c_stride_in_bytes) {
 
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_e3m2_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_f32_t);
 
+    nk_sme_start_streaming_();
     nk_dots_packed_e3m2_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
 /**
@@ -3253,9 +3278,9 @@ NK_PUBLIC void nk_dots_packed_e3m2_sme(                    //
  *  Pre-reads A columns into Z registers, then reloads ZA0 with converted B data
  *  per column tile. Eliminates all scalar B-packing loops.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_e3m2_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_e3m2_sme_streaming_( //
     nk_e3m2_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_f32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 2;
     nk_size_t const tile_dimension = svcntw();
@@ -3451,14 +3476,16 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_e3m2_sme_s
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_e3m2_sme(nk_e3m2_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
-                                          nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_e3m2_sme( //
+    nk_e3m2_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_f32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_e3m2_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_e3m2_sme_streaming_(vectors, vectors_count, depth, stride_elements, result,
                                           result_stride_elements, row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
 #pragma endregion I8 Integers
@@ -3481,9 +3508,8 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_u8_sme(nk_size_t columns, nk_size_t dept
     return nk_dots_packed_size_i8_sme(columns, depth);
 }
 
-NK_PUBLIC void nk_dots_pack_u8_sme(                       //
-    nk_u8_t const *b, nk_size_t columns, nk_size_t depth, //
-    nk_size_t b_stride_in_bytes, void *b_packed) {
+NK_PUBLIC void nk_dots_pack_u8_sme( //
+    nk_u8_t const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_in_bytes, void *b_packed) {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = nk_sme_cntw_();
@@ -3502,7 +3528,9 @@ NK_PUBLIC void nk_dots_pack_u8_sme(                       //
 
     nk_u8_t *tiles_ptr = (nk_u8_t *)((char *)b_packed + sizeof(nk_dots_sme_packed_header_t));
 
+    nk_sme_start_streaming_();
     nk_dots_pack_b8_sme_streaming_(b, columns, depth, b_stride_in_bytes, tiles_ptr);
+    nk_sme_stop_streaming_();
 
     nk_size_t const data_size = total_vectors * vector_elements * sizeof(nk_u8_t);
     header->norms_offset = (nk_u32_t)(sizeof(nk_dots_sme_packed_header_t) + data_size);
@@ -3517,10 +3545,9 @@ NK_PUBLIC void nk_dots_pack_u8_sme(                       //
  *  `u8` × `u8` → `u32` GEMM core kernel using SME outer products.
  *  Same interleaved algorithm as i8 kernel, using UMOPA u8→u32.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_u8_sme_streaming_( //
-    nk_u8_t const *a, void const *b_packed, nk_u32_t *c,                              //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                               //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_u8_sme_streaming_( //
+    nk_u8_t const *a, void const *b_packed, nk_u32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -3651,21 +3678,21 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_packed_u8_sme_stream
     }
 }
 
-NK_PUBLIC void nk_dots_packed_u8_sme(                    //
-    nk_u8_t const *a, void const *b_packed, nk_u32_t *c, //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,  //
+NK_PUBLIC void nk_dots_packed_u8_sme( //
+    nk_u8_t const *a, void const *b_packed, nk_u32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
     nk_size_t a_stride_in_bytes, nk_size_t c_stride_in_bytes) {
 
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_u8_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_u32_t);
 
+    nk_sme_start_streaming_();
     nk_dots_packed_u8_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
-// expansion=4: each u32 word packs 4 u8 values
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_u8_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_u8_sme_streaming_( //
     nk_u8_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_u32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = svcntw();
@@ -3833,14 +3860,16 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_u8_sme_str
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_u8_sme(nk_u8_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                        nk_size_t stride_in_bytes, nk_u32_t *result, nk_size_t result_stride_in_bytes,
-                                        nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_u8_sme( //
+    nk_u8_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_u32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_u8_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_u32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_u8_sme_streaming_(vectors, vectors_count, depth, stride_elements, result, result_stride_elements,
                                         row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
 #pragma endregion U8 Integers
@@ -3876,9 +3905,8 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_u4_sme(nk_size_t columns, nk_size_t dept
     return size;
 }
 
-NK_PUBLIC void nk_dots_pack_u4_sme(                         //
-    nk_u4x2_t const *b, nk_size_t columns, nk_size_t depth, //
-    nk_size_t b_stride_in_bytes, void *b_packed) {
+NK_PUBLIC void nk_dots_pack_u4_sme( //
+    nk_u4x2_t const *b, nk_size_t columns, nk_size_t depth, nk_size_t b_stride_in_bytes, void *b_packed) {
 
     nk_size_t const tile_dimension = nk_sme_cntw_();
     nk_size_t const vector_elements = nk_sme_cntb_();
@@ -3945,10 +3973,9 @@ NK_PUBLIC void nk_dots_pack_u4_sme(                         //
  *  B input is pre-split low/high nibble vectors from nk_dots_pack_u4_sme.
  *  Two UMOPAs per depth step: one for low nibbles, one for high nibbles.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_u4_sme_streaming_( //
-    nk_u4x2_t const *a, void const *b_packed, nk_u32_t *c,                            //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                               //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_u4_sme_streaming_( //
+    nk_u4x2_t const *a, void const *b_packed, nk_u32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -4123,14 +4150,15 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_packed_u4_sme_stream
     }
 }
 
-NK_PUBLIC void nk_dots_packed_u4_sme(                      //
-    nk_u4x2_t const *a, void const *b_packed, nk_u32_t *c, //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,    //
+NK_PUBLIC void nk_dots_packed_u4_sme( //
+    nk_u4x2_t const *a, void const *b_packed, nk_u32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
     nk_size_t a_stride_in_bytes, nk_size_t c_stride_in_bytes) {
 
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_u4x2_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_u32_t);
+    nk_sme_start_streaming_();
     nk_dots_packed_u4_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
 #pragma endregion Unsigned Integers
@@ -4222,10 +4250,9 @@ NK_PUBLIC void nk_dots_pack_i4_sme(                         //
  *  B input is pre-split sign-extended nibble vectors from nk_dots_pack_i4_sme.
  *  Two SMOPAs per depth step: one for low nibbles, one for high nibbles.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_packed_i4_sme_streaming_( //
-    nk_i4x2_t const *a, void const *b_packed, nk_i32_t *c,                            //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,                               //
-    nk_size_t a_stride_elements, nk_size_t c_stride_elements) {
+__arm_new("za") static void nk_dots_packed_i4_sme_streaming_( //
+    nk_i4x2_t const *a, void const *b_packed, nk_i32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
+    nk_size_t a_stride_elements, nk_size_t c_stride_elements) NK_STREAMING_ {
 
     nk_dots_sme_packed_header_t const *header = (nk_dots_sme_packed_header_t const *)b_packed;
     nk_size_t const column_tile_count = header->column_tile_count;
@@ -4406,14 +4433,15 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_packed_i4_sme_stream
     }
 }
 
-NK_PUBLIC void nk_dots_packed_i4_sme(                      //
-    nk_i4x2_t const *a, void const *b_packed, nk_i32_t *c, //
-    nk_size_t rows, nk_size_t columns, nk_size_t depth,    //
+NK_PUBLIC void nk_dots_packed_i4_sme( //
+    nk_i4x2_t const *a, void const *b_packed, nk_i32_t *c, nk_size_t rows, nk_size_t columns, nk_size_t depth,
     nk_size_t a_stride_in_bytes, nk_size_t c_stride_in_bytes) {
 
     nk_size_t const a_stride_elements = a_stride_in_bytes / sizeof(nk_i4x2_t);
     nk_size_t const c_stride_elements = c_stride_in_bytes / sizeof(nk_i32_t);
+    nk_sme_start_streaming_();
     nk_dots_packed_i4_sme_streaming_(a, b_packed, c, rows, columns, depth, a_stride_elements, c_stride_elements);
+    nk_sme_stop_streaming_();
 }
 
 /**
@@ -4421,9 +4449,9 @@ NK_PUBLIC void nk_dots_packed_i4_sme(                      //
  *  Loads packed nibble bytes directly into ZA0, splits into low/high nibbles in registers,
  *  issues 2 UMOPAs per depth step. ZA0 = staging tile, ZA1-ZA3 = accumulators.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_u4_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_u4_sme_streaming_( //
     nk_u4x2_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_u32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = svcntw();
@@ -4695,14 +4723,16 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_u4_sme_str
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_u4_sme(nk_u4x2_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                        nk_size_t stride_in_bytes, nk_u32_t *result, nk_size_t result_stride_in_bytes,
-                                        nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_u4_sme( //
+    nk_u4x2_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_u32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_u4x2_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_u32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_u4_sme_streaming_(vectors, vectors_count, depth, stride_elements, result, result_stride_elements,
                                         row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
 /**
@@ -4710,9 +4740,9 @@ NK_PUBLIC void nk_dots_symmetric_u4_sme(nk_u4x2_t const *vectors, nk_size_t vect
  *  Loads packed nibble bytes directly into ZA0, sign-extends via LSL+ASR in registers,
  *  issues 2 SMOPAs per depth step. ZA0 = staging tile, ZA1-ZA3 = accumulators.
  */
-__arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_i4_sme_streaming_(
+__arm_new("za") static void nk_dots_symmetric_i4_sme_streaming_( //
     nk_i4x2_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_elements, nk_i32_t *result,
-    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t result_stride_elements, nk_size_t row_start, nk_size_t row_count) NK_STREAMING_ {
 
     nk_size_t const expansion = 4;
     nk_size_t const tile_dimension = svcntw();
@@ -4983,14 +5013,16 @@ __arm_locally_streaming __arm_new("za") static void nk_dots_symmetric_i4_sme_str
     }
 }
 
-NK_PUBLIC void nk_dots_symmetric_i4_sme(nk_i4x2_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
-                                        nk_size_t stride_in_bytes, nk_i32_t *result, nk_size_t result_stride_in_bytes,
-                                        nk_size_t row_start, nk_size_t row_count) {
+NK_PUBLIC void nk_dots_symmetric_i4_sme( //
+    nk_i4x2_t const *vectors, nk_size_t vectors_count, nk_size_t depth, nk_size_t stride_in_bytes, nk_i32_t *result,
+    nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_i4x2_t);
     nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_i32_t);
+    nk_sme_start_streaming_();
     nk_dots_symmetric_i4_sme_streaming_(vectors, vectors_count, depth, stride_elements, result, result_stride_elements,
                                         row_start, row_count);
+    nk_sme_stop_streaming_();
 }
 
 #pragma endregion Signed Integers