[GPU] Using accumulator dtype for computations in rms_gpu_bfyx_opt

Author: Lyamin-Roman

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

@@ -12,12 +12,14 @@
 #if SUBGROUP_BLOCK_SIZE == 1
 #define BLOCK_READ(ptr, offset) DT_INPUT_BLOCK_READ(ptr, offset)
 #define BLOCK_WRITE(ptr, offset, val) DT_OUTPUT_BLOCK_WRITE(ptr, offset, val)
-#define INPUT_VEC_TYPE INPUT0_TYPE
+#define ACC_TYPE ACCUMULATOR_TYPE
+#define TO_ACC_TYPE(x) TO_ACCUMULATOR_TYPE(x)
 #define OUTPUT_VEC_TYPE OUTPUT_TYPE
 #else
 #define BLOCK_READ(ptr, offset) CAT(DT_INPUT_BLOCK_READ, SUBGROUP_BLOCK_SIZE)(ptr, offset)
 #define BLOCK_WRITE(ptr, offset, val) CAT(DT_OUTPUT_BLOCK_WRITE, SUBGROUP_BLOCK_SIZE)(ptr, offset, val)
-#define INPUT_VEC_TYPE MAKE_VECTOR_TYPE(INPUT0_TYPE, SUBGROUP_BLOCK_SIZE)
+#define ACC_TYPE MAKE_VECTOR_TYPE(ACCUMULATOR_TYPE, SUBGROUP_BLOCK_SIZE)
+#define TO_ACC_TYPE(x) CAT(convert_, ACC_TYPE)(x)
 #define OUTPUT_VEC_TYPE MAKE_VECTOR_TYPE(OUTPUT_TYPE, SUBGROUP_BLOCK_SIZE)
 #endif
 
@@ -38,7 +40,7 @@ KERNEL(rms_gpu_bfyx_opt)(
     const uint data_offset = data_idx * data_size;
     const uint subgroup_offset = get_sub_group_id() * get_sub_group_size() * items_num;
 
-    INPUT0_TYPE data[STACK_SIZE];
+    ACCUMULATOR_TYPE data[STACK_SIZE];
     ACCUMULATOR_TYPE rms = ACCUMULATOR_VAL_ZERO;
 
     __local ACCUMULATOR_TYPE slm_buf[SLM_SIZE];
@@ -48,15 +50,15 @@ KERNEL(rms_gpu_bfyx_opt)(
     {
         for (; i < items_num - (items_num % SUBGROUP_BLOCK_SIZE); i += SUBGROUP_BLOCK_SIZE)
         {
-            INPUT_VEC_TYPE vec_tmp = BLOCK_READ(input, data_offset + subgroup_offset + i * get_sub_group_size());
+            ACC_TYPE vec_tmp = TO_ACC_TYPE(BLOCK_READ(input, data_offset + subgroup_offset + i * get_sub_group_size()));
 #if SUBGROUP_BLOCK_SIZE == 1
-            rms += TO_ACCUMULATOR_TYPE(native_powr(vec_tmp, 2));
+            rms += native_powr(vec_tmp, 2);
             data[i] = vec_tmp;
 #else
             unroll_for (int j = 0; j < SUBGROUP_BLOCK_SIZE; j++)
             {
-                INPUT0_TYPE tmp = vec_tmp[j];
-                rms += TO_ACCUMULATOR_TYPE(native_powr(tmp, 2));
+                ACCUMULATOR_TYPE tmp = vec_tmp[j];
+                rms += native_powr(tmp, 2);
                 data[i + j] = tmp;
             }
 #endif
@@ -65,15 +67,15 @@ KERNEL(rms_gpu_bfyx_opt)(
 
     for (; i < items_num; i++)
     {
-        INPUT0_TYPE tmp = input[data_offset + subgroup_offset + get_sub_group_local_id() + i * get_sub_group_size()];
-        rms += TO_ACCUMULATOR_TYPE(native_powr(tmp, 2));
+        ACCUMULATOR_TYPE tmp = TO_ACCUMULATOR_TYPE(input[data_offset + subgroup_offset + get_sub_group_local_id() + i * get_sub_group_size()]);
+        rms += native_powr(tmp, 2);
         data[i] = tmp;
     }
 
     if (in_data_idx < leftovers)
     {
-        INPUT0_TYPE tmp = input[data_offset + workers_per_data * items_num + in_data_idx];
-        rms += TO_ACCUMULATOR_TYPE(native_powr(tmp, 2));
+        ACCUMULATOR_TYPE tmp = TO_ACCUMULATOR_TYPE(input[data_offset + workers_per_data * items_num + in_data_idx]);
+        rms += native_powr(tmp, 2);
         data[items_num] = tmp;
     }
 
@@ -103,32 +105,33 @@ KERNEL(rms_gpu_bfyx_opt)(
     {
         for (; i < items_num - (items_num % SUBGROUP_BLOCK_SIZE); i += SUBGROUP_BLOCK_SIZE)
         {
-            INPUT_VEC_TYPE vec_gamma = BLOCK_READ(gamma, subgroup_offset + i * get_sub_group_size());
+            ACC_TYPE vec_gamma = TO_ACC_TYPE(BLOCK_READ(gamma, subgroup_offset + i * get_sub_group_size()));
             OUTPUT_VEC_TYPE vec_tmp;
 #if SUBGROUP_BLOCK_SIZE == 1
-            vec_tmp = TO_OUTPUT_TYPE(rms * TO_ACCUMULATOR_TYPE(data[i]) * TO_ACCUMULATOR_TYPE(vec_gamma));
+            vec_tmp = TO_OUTPUT_TYPE(rms * data[i] * vec_gamma);
 #else
             unroll_for (int j = 0; j < SUBGROUP_BLOCK_SIZE; j++)
-                vec_tmp[j] = TO_OUTPUT_TYPE(rms * TO_ACCUMULATOR_TYPE(data[i + j]) * TO_ACCUMULATOR_TYPE(vec_gamma[j]));
+                vec_tmp[j] = TO_OUTPUT_TYPE(rms * data[i + j] * vec_gamma[j]);
 #endif
             BLOCK_WRITE(output, data_offset + subgroup_offset + i * get_sub_group_size(), vec_tmp);
         }
     }
 
     for (; i < items_num; i++)
     {
-        INPUT1_TYPE temp = gamma[subgroup_offset + get_sub_group_local_id() + i * get_sub_group_size()];
-        output[data_offset + subgroup_offset + get_sub_group_local_id() + i * get_sub_group_size()] = TO_OUTPUT_TYPE(rms * TO_ACCUMULATOR_TYPE(data[i]) * TO_ACCUMULATOR_TYPE(temp));
+        ACCUMULATOR_TYPE temp = TO_ACCUMULATOR_TYPE(gamma[subgroup_offset + get_sub_group_local_id() + i * get_sub_group_size()]);
+        output[data_offset + subgroup_offset + get_sub_group_local_id() + i * get_sub_group_size()] = TO_OUTPUT_TYPE(rms * data[i] * temp);
     }
 
     if (in_data_idx < leftovers)
     {
-        INPUT1_TYPE temp = gamma[workers_per_data * items_num + in_data_idx];
-        output[data_offset + workers_per_data * items_num + in_data_idx] = TO_OUTPUT_TYPE(rms * TO_ACCUMULATOR_TYPE(data[items_num]) * TO_ACCUMULATOR_TYPE(temp));
+        ACCUMULATOR_TYPE temp = TO_ACCUMULATOR_TYPE(gamma[workers_per_data * items_num + in_data_idx]);
+        output[data_offset + workers_per_data * items_num + in_data_idx] = TO_OUTPUT_TYPE(rms * data[items_num] * temp);
     }
 }
 #undef USE_BLOCK_WRITE
 #undef BLOCK_READ
 #undef BLOCK_WRITE
-#undef INPUT_VEC_TYPE
+#undef ACC_TYPE
+#undef TO_ACC_TYPE
 #undef OUTPUT_VEC_TYPE