[GPU] Limit sdpa_micro attention mask load to avoid compilation error

Earlier 3b84486 commit has caused kernel compilation error for shape
of [batch, num_heads, 1, 1].  For this shape, restore to earlier tiled_load_t.

Author: clee30

src/plugins/intel_gpu/src/kernel_selector/cl_kernels/sdpa_micro.cl

@@ -404,14 +404,18 @@ KERNEL(micro_sdpa)(OPTIONAL_SHAPE_INFO_ARG
 #if WITH_ATTN_MASK
         /* Load mask. No remainder handling needed assuming k block size is a power of 2. */
         mask_tile_type mask_tile;
-        const uint mask_m = MSK_D2;
-        const uint mask_n = MSK_D3;
-        // Check if attention mask has a single Query dimension (e.g., [batch, num_heads, 1, sequence_length])
-        // In the case of single query dimension, set ld and offset_r to zero
-        // to avoid exceeding bounds for single dimension.
-        const uint mask_ld = (mask_m == 1)? 0 : mask_n;
-        const uint mask_offset_r = (mask_m == 1)? 0 : sg_j0_kq + wg_j0;
-        tile_load_t(&mask_tile, msk, mask_m, mask_n, mask_ld, mask_offset_r, k0 + sg_i0_kq);
+        if (MSK_D2 == 1 && MSK_D3 > 1) {
+            // Check if attention mask has a single Query dimension (e.g., [batch, num_heads, 1, sequence_length])
+            // In the case of single query dimension, set ld and offset_r to zero
+            // to avoid exceeding bounds for single dimension.
+            const uint mask_m = MSK_D2;
+            const uint mask_n = MSK_D3;
+            const uint mask_ld = (mask_m == 1)? 0 : mask_n;
+            const uint mask_offset_r = (mask_m == 1)? 0 : sg_j0_kq + wg_j0;
+            tile_load_t(&mask_tile, msk, mask_m, mask_n, mask_ld, mask_offset_r, k0 + sg_i0_kq);
+        } else {
+            tile_load_t(&mask_tile, msk, q, k, sg_j0_kq + wg_j0, k0 + sg_i0_kq);
+        }
 #endif
 
 #if REMAINDER_K

src/plugins/intel_gpu/tests/unit/test_cases/sdpa_gpu_test.cpp

@@ -35,22 +35,25 @@ struct sdpa_test_params {
     int sequence_length_q;
     int sequence_length_kv;
     int batch;
+    bool dynamic;
     bool use_scalar_scale_val;
     float scale_val;
     bool use_scalar_attn_mask;
     float attn_mask_val;
 
     // Constructor for basic tests (backward compatibility)
-    sdpa_test_params(int h_size, int n_heads, int seq_q, int seq_kv, int b)
+    sdpa_test_params(int h_size, int n_heads, int seq_q, int seq_kv, int b,
+                     bool dynamic_shape)
         : head_size(h_size), num_heads(n_heads), sequence_length_q(seq_q),
-          sequence_length_kv(seq_kv), batch(b), use_scalar_scale_val(false),
-          scale_val(1.0f), use_scalar_attn_mask(false), attn_mask_val(0.0f) {}
+          sequence_length_kv(seq_kv), batch(b), dynamic(dynamic_shape),
+          use_scalar_scale_val(false), scale_val(1.0f), use_scalar_attn_mask(false),
+          attn_mask_val(0.0f) {}
 
     // Constructor for advanced caching tests
     sdpa_test_params(int h_size, int n_heads, int seq_q, int seq_kv, int b,
                      bool use_scale, float scale, bool use_mask, float mask)
-        : head_size(h_size), num_heads(n_heads), sequence_length_q(seq_q),
-          sequence_length_kv(seq_kv), batch(b), use_scalar_scale_val(use_scale),
+        : head_size(h_size), num_heads(n_heads), sequence_length_q(seq_q), sequence_length_kv(seq_kv),
+          batch(b), dynamic(true), use_scalar_scale_val(use_scale),
           scale_val(scale), use_scalar_attn_mask(use_mask), attn_mask_val(mask) {}
 };
 
@@ -69,10 +72,10 @@ struct sdpa_gpu_test : public ::testing::TestWithParam<sdpa_test_params> {
     }
 
     std::tuple<cldnn::memory::ptr, cldnn::network::ptr> run_network(bool is_caching_test, bool use_micro_sdpa,
-            cldnn::layout input0_dyn_layout,
-            cldnn::layout input1_dyn_layout,
-            cldnn::layout input2_dyn_layout,
-            cldnn::layout input3_dyn_layout,
+            cldnn::layout input0_layout,
+            cldnn::layout input1_layout,
+            cldnn::layout input2_layout,
+            cldnn::layout input3_layout,
             cldnn::memory::ptr input0,
             cldnn::memory::ptr input1,
             cldnn::memory::ptr input2,
@@ -83,10 +86,10 @@ struct sdpa_gpu_test : public ::testing::TestWithParam<sdpa_test_params> {
             float attn_mask_val = 0.0f) {
         auto& engine = get_test_engine();
         topology topo;
-        topo.add(input_layout("input0", input0_dyn_layout));
-        topo.add(input_layout("input1", input1_dyn_layout));
-        topo.add(input_layout("input2", input2_dyn_layout));
-        topo.add(input_layout("input3", input3_dyn_layout));
+        topo.add(input_layout("input0", input0_layout));
+        topo.add(input_layout("input1", input1_layout));
+        topo.add(input_layout("input2", input2_layout));
+        topo.add(input_layout("input3", input3_layout));
 
         auto sdpa_prim = scaled_dot_product_attention("sdpa", {input_info("input0"), input_info("input1"), input_info("input2"), input_info("input3")},
             false, -1, {0,2,1,3}, {0,2,1,3}, {0,2,1,3}, {0,1,2,3}, {}, false);
@@ -137,15 +140,30 @@ struct sdpa_gpu_test : public ::testing::TestWithParam<sdpa_test_params> {
         const auto attn_mask_val = p.attn_mask_val;
 
         auto& engine = get_test_engine();
-        cldnn::layout input0_dyn_layout({-1, -1, num_heads, head_size}, data_types::f16, format::bfyx);
-        cldnn::layout input1_dyn_layout({-1, -1, num_heads, head_size}, data_types::f16, format::bfyx);
-        cldnn::layout input2_dyn_layout({-1, -1, num_heads, head_size}, data_types::f16, format::bfyx);
-        cldnn::layout input3_dyn_layout({-1, num_heads, -1, -1}, data_types::f16, format::bfyx);
-
-        cldnn::layout input0_static_layout({batch, seq_length_q,  num_heads, head_size}, data_types::f16, format::bfyx);
-        cldnn::layout input1_static_layout({batch, seq_length_kv, num_heads, head_size}, data_types::f16, format::bfyx);
-        cldnn::layout input2_static_layout({batch, seq_length_kv, num_heads, head_size}, data_types::f16, format::bfyx);
-        cldnn::layout input3_static_layout({batch, num_heads,     1,     seq_length_kv}, data_types::f16, format::bfyx);
+        cldnn::layout input0_layout, input1_layout, input2_layout, input3_layout;
+        cldnn::layout input0_static_layout, input1_static_layout, input2_static_layout, input3_static_layout;
+
+        if (p.dynamic) {
+            input0_layout = cldnn::layout({-1, -1, num_heads, head_size}, data_types::f16, format::bfyx);
+            input1_layout = cldnn::layout({-1, -1, num_heads, head_size}, data_types::f16, format::bfyx);
+            input2_layout = cldnn::layout({-1, -1, num_heads, head_size}, data_types::f16, format::bfyx);
+            input3_layout = cldnn::layout({-1, num_heads, -1, -1}, data_types::f16, format::bfyx);
+
+            input0_static_layout = cldnn::layout({batch, seq_length_q,  num_heads, head_size}, data_types::f16, format::bfyx);
+            input1_static_layout = cldnn::layout({batch, seq_length_kv, num_heads, head_size}, data_types::f16, format::bfyx);
+            input2_static_layout = cldnn::layout({batch, seq_length_kv, num_heads, head_size}, data_types::f16, format::bfyx);
+            input3_static_layout = cldnn::layout({batch, num_heads,     1,     seq_length_kv}, data_types::f16, format::bfyx);
+        } else {
+            input0_static_layout = cldnn::layout({batch, seq_length_q,  num_heads, head_size}, data_types::f16, format::bfyx);
+            input1_static_layout = cldnn::layout({batch, seq_length_kv, num_heads, head_size}, data_types::f16, format::bfyx);
+            input2_static_layout = cldnn::layout({batch, seq_length_kv, num_heads, head_size}, data_types::f16, format::bfyx);
+            input3_static_layout = cldnn::layout({batch, num_heads,     1,     seq_length_kv}, data_types::f16, format::bfyx);
+
+            input0_layout = input0_static_layout;
+            input1_layout = input1_static_layout;
+            input2_layout = input2_static_layout;
+            input3_layout = input3_static_layout;
+        }
 
         auto input0 = engine.allocate_memory(input0_static_layout);
         auto input1 = engine.allocate_memory(input1_static_layout);
@@ -158,11 +176,11 @@ struct sdpa_gpu_test : public ::testing::TestWithParam<sdpa_test_params> {
         load_input(input3, 3);
 
         auto [mem_ref_ptr, net_ref_ptr] = run_network(is_caching_test, false,
-                                        input0_dyn_layout, input1_dyn_layout, input2_dyn_layout, input3_dyn_layout,
+                                        input0_layout, input1_layout, input2_layout, input3_layout,
                                         input0, input1, input2, input3,
                                         use_scalar_scale_val, scale_val, use_scalar_attn_mask, attn_mask_val);
         auto [mem_opt_ptr, net_opt_ptr] = run_network(is_caching_test, true,
-                                        input0_dyn_layout, input1_dyn_layout, input2_dyn_layout, input3_dyn_layout,
+                                        input0_layout, input1_layout, input2_layout, input3_layout,
                                         input0, input1, input2, input3,
                                         use_scalar_scale_val, scale_val, use_scalar_attn_mask, attn_mask_val);
 
@@ -225,6 +243,10 @@ struct sdpa_gpu_test : public ::testing::TestWithParam<sdpa_test_params> {
             result += "_mask_" + std::to_string(static_cast<int>(info.param.attn_mask_val * 1000));
         }
 
+        if (!info.param.dynamic) {
+            result += "_static";
+        }
+
         return result;
     }
 };
@@ -233,7 +255,10 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_sdpa_gpu_test,
     sdpa_gpu_test,
     ::testing::Values(
-        sdpa_test_params{64, 32, 990, 128, 2},
+        sdpa_test_params{64, 32, 990, 128, 2, true}, // dynamic
+        sdpa_test_params{64, 32, 990, 128, 2, false}, // static
+        sdpa_test_params{64, 32, 990, 1, 2, true}, // dynamic
+        sdpa_test_params{64, 32, 990, 1, 2, false}, // static
         sdpa_test_params{64, 32, 128, 128, 2, true, 0.125f, false, 0.0f},  // scale_val only
         sdpa_test_params{64, 32, 128, 128, 2, false, 1.0f, true, 0.5f}     // attn_mask only
     ),