[GPU] Enable f8e4m3fn quantized-KV GroupQueryAttention (dynamic path)

Extends the GPU quantized-KV GroupQueryAttention support (i8/i4) to the
f8e4m3fn KV cache on the dynamic (Slice+Concat) cache-assembly path. f8e4m3fn
KV is part of the com.microsoft GQA spec (T_CACHE) and already worked on
CPU/TEMPLATE via the device-agnostic decomposition; only GPU primitive gaps
remained.

fp8e4m3_t is a 1-byte struct with no arithmetic/convert overloads, so the
reference kernels needed f8-aware handling on top of the type-list widenings:

- Slice / Concat / ScatterUpdate ref kernels: include f8_utils.cl for the
  fp8e4m3_t typedef, and on the identity (no-activation) store copy the byte
  directly when the tensor is fp8 - ACTIVATION/TO_OUTPUT_TYPE do not compile on
  the struct. Gated by an INPUT*_IS_FP8 jit flag; non-fp8 paths are unchanged.
- reorder_data.cl: (a) f8->f8 layout reorder stores the already-encoded value
  directly; (b) for a non-float input reordered to fp8, encode from float to
  resolve the ambiguous fp8 encoder overload. Both gated on fp8 flags.
- Add f8e4m3 to the Slice/Concat/ScatterUpdate impl and kernel supported-type
  lists.

Tests: un-skip the 2 IE_GPU gqa_f8e4m3fnkv tests (dynamic). GQA quant suite is
36/36 across GPU/CPU/INTERPRETER (i8/i4/f8); 356 GPU reorder unit tests green
(no regression from the shared-kernel change).

Out of scope: the static (ScatterUpdate) f8 path still fails impl selection in
add_required_reorders for the fp8 dtype (i8/i4 static pass); tracked as a
follow-up. No static f8 GQA test is added here.

Author: ankitm3k

src/frontends/onnx/tests/runtime/ie/unit_test.manifest

@@ -359,13 +359,6 @@ IE_GPU.onnx_model_gather_elements_int32_axis_0
 IE_GPU.onnx_model_gather_elements_int8_axis_1
 IE_GPU.onnx_model_gather_elements_float_3D_axis_2
 
-# GroupQueryAttention with an f8e4m3 quantized KV cache: the GPU plugin has no f8e4m3 Slice/reorder
-# layout yet ("No layout format available"), so the fp8 variants remain skipped on GPU. The i8/i4
-# variants are enabled (see KeepGQAKVScalePrecision + i8/u8 ScatterUpdate/Slice support). fp8 GPU is
-# tracked as a separate follow-up; numerics stay covered on CPU/INTERPRETER meanwhile.
-IE_GPU.onnx_model_gqa_f8e4m3fnkv_per_channel
-IE_GPU.onnx_model_gqa_f8e4m3fnkv_per_tensor
-
 IE_CPU/ElemTypesTests/1.onnx_test_add_abc_set_precission
 
 # RuntimeError: Unsupported dynamic ops: v4::Interpolate - Ticket: 50691

src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp

@@ -95,14 +95,7 @@ struct concatenation_impl : typed_primitive_impl_ocl<concatenation> {
 namespace detail {
 
 attach_concatenation_impl::attach_concatenation_impl() {
-    auto dyn_types = {
-        data_types::i8,
-        data_types::u8,
-        data_types::f16,
-        data_types::f32,
-        data_types::i32,
-        data_types::i64
-    };
+    auto dyn_types = {data_types::i8, data_types::u8, data_types::f16, data_types::f32, data_types::i32, data_types::i64, data_types::f8e4m3};
 
     auto dyn_formats = {
         format::bfyx,

src/plugins/intel_gpu/src/graph/impls/ocl/scatter_update.hpp

@@ -37,18 +37,16 @@ struct ScatterUpdateImplementationManager : public ImplementationManager {
             format::bfwzyx
         };
 
-        static const std::vector<ov::element::Type_t> supported_in_types = {ov::element::f32,
-                                                                            ov::element::f16,
-                                                                            ov::element::i32,
-                                                                            ov::element::i8,
-                                                                            ov::element::u8};
+        static const std::vector<ov::element::Type_t> supported_in_types =
+            {ov::element::f32, ov::element::f16, ov::element::i32, ov::element::i8, ov::element::u8, ov::element::f8e4m3};
 
         static const std::vector<ov::element::Type_t> supported_out_types = {
             ov::element::f32,
             ov::element::f16,
             ov::element::i32,
             ov::element::i8,
             ov::element::u8,
+            ov::element::f8e4m3,
         };
 
         const auto& in0_layout = node.get_input_layout(0);

src/plugins/intel_gpu/src/graph/impls/ocl/slice.cpp

@@ -181,14 +181,7 @@ struct slice_impl : typed_primitive_impl_ocl<slice> {
 namespace detail {
 
 attach_slice_impl::attach_slice_impl() {
-    auto types = {
-        data_types::f32,
-        data_types::f16,
-        data_types::i8,
-        data_types::u8,
-        data_types::i32,
-        data_types::i64
-    };
+    auto types = {data_types::f32, data_types::f16, data_types::i8, data_types::u8, data_types::i32, data_types::i64, data_types::f8e4m3};
 
     auto formats = {
         format::bfyx,

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

@@ -3,6 +3,7 @@
 //
 
 #include "include/batch_headers/fetch_data.cl"
+#include "include/f8_utils.cl"  // fp8e4m3_t typedef
 
 #define GET_INDEX(prefix, ORDER) CAT(prefix, _GET_INDEX)(ORDER)
 
@@ -34,6 +35,10 @@ KERNEL(concatenation_gpu_ref)(
 #if HAS_FUSED_OPS
         FUSED_OPS;
         output[output_offset] = TO_OUTPUT_TYPE(FUSED_OPS_RESULT);
+#elif INPUT0_IS_FP8
+        // fp8 is a 1-byte struct; Concat just moves data (in/out dtype match), so copy the byte
+        // (TO_OUTPUT_TYPE/ACTIVATION won't compile on it).
+        output[output_offset] = result;
 #else
         output[output_offset] = TO_OUTPUT_TYPE(ACTIVATION(result, ACTIVATION_PARAMS));
 #endif

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

@@ -232,6 +232,10 @@ KERNEL (reorder_data)(
     #else
         #define __TO_OUTPUT_REORDER_TYPE(res) TO_OUTPUT_REORDER_TYPE_SAT(res)
     #endif
+    #elif F8E5M2_OUTPUT || F8E4M3_OUTPUT || F8E8M0_OUTPUT
+        // fp8 encoders are overloaded on float/half only; a non-float `res` (e.g. uchar from an integer
+        // input) makes the call ambiguous, so encode from float. (f8->f8 identity is handled below.)
+        #define __TO_OUTPUT_REORDER_TYPE(res) TO_OUTPUT_REORDER_TYPE(convert_float(res))
     #else
         #define __TO_OUTPUT_REORDER_TYPE(res) TO_OUTPUT_REORDER_TYPE(res)
     #endif
@@ -261,6 +265,10 @@ KERNEL (reorder_data)(
 
         atomic_and(&output_u32[main_idx], ~(0x0F << shift));
         atomic_or(&output_u32[main_idx], (val_u32 << shift));
+    #elif (F8E5M2_INPUT && F8E5M2_OUTPUT) || (F8E4M3_INPUT && F8E4M3_OUTPUT) || (F8E8M0_INPUT && F8E8M0_OUTPUT)
+        // f8->f8 layout reorder: `res` is already the fp8 OUTPUT_TYPE, so store it directly. Re-encoding
+        // via TO_OUTPUT_TYPE/ACTIVATION has no overload for the fp8 struct (and a copy needs none).
+        output[output_idx] = res;
     #else
         output[output_idx] = ACTIVATION_TYPED(OUTPUT_REORDER, __TO_OUTPUT_REORDER_TYPE(res), ACTIVATION_PARAMS_TYPED);
     #endif

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

@@ -3,6 +3,7 @@
 //
 
 #include "include/batch_headers/fetch_data.cl"
+#include "include/f8_utils.cl"  // fp8e4m3_t typedef
 
 #define AXIS_B (0)
 #define AXIS_F (1)
@@ -132,6 +133,9 @@ KERNEL(scatter_update_ref)(OPTIONAL_SHAPE_INFO_ARG
     #if HAS_FUSED_OPS
         FUSED_OPS_FIRST_KERNEL;
         output[output_idx] = TO_OUTPUT_TYPE(FUSED_OPS_RESULT_FIRST_KERNEL);
+    #elif INPUT0_IS_FP8
+        // fp8 is a 1-byte struct; ScatterUpdate just moves data, so copy the byte (ACTIVATION won't compile on it).
+        output[output_idx] = val;
     #else
         output[output_idx] = ACTIVATION(val, ACTIVATION_PARAMS);
     #endif
@@ -232,6 +236,9 @@ KERNEL(scatter_update_ref)(OPTIONAL_SHAPE_INFO_ARG
     #if HAS_FUSED_OPS
         FUSED_OPS_SECOND_KERNEL;
         output[output_idx] = TO_OUTPUT_TYPE(FUSED_OPS_RESULT_SECOND_KERNEL);
+    #elif INPUT2_IS_FP8
+        // fp8 is a 1-byte struct; ScatterUpdate just moves data, so copy the byte (ACTIVATION won't compile on it).
+        output[output_idx] = val;
     #else
         output[output_idx] = ACTIVATION(val, ACTIVATION_PARAMS);
     #endif

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

@@ -3,6 +3,7 @@
 //
 
 #include "include/batch_headers/fetch_data.cl"
+#include "include/f8_utils.cl"  // fp8e4m3_t typedef
 
 #define BRING_INTO_RANGE(VAL, MAX) \
     clamp((long)VAL < 0l ? (long)VAL + (long)MAX : (long)VAL, 0l, (long)MAX-1l);
@@ -84,7 +85,12 @@ KERNEL(slice_ref)(OPTIONAL_SHAPE_INFO_ARG
         slice_begin_dim4 + output_dim4 * slice_step[4]);
 #endif
 
+#if INPUT0_IS_FP8
+    // fp8 is a 1-byte struct; Slice just moves data, so copy the byte (ACTIVATION won't compile on it).
+    output[output_index] = input[input_index];
+#else
     output[output_index] = ACTIVATION(input[input_index], ACTIVATION_PARAMS);
+#endif
 }
 
 #undef LOAD_BUFFER;

src/plugins/intel_gpu/src/kernel_selector/kernels/concatenation/concatenation_kernel_ref.cpp

@@ -17,12 +17,14 @@ ParamsKey ConcatenationKernelRef::GetSupportedKey() const {
     k.EnableInputDataType(Datatype::UINT8);
     k.EnableInputDataType(Datatype::INT32);
     k.EnableInputDataType(Datatype::INT64);
+    k.EnableInputDataType(Datatype::F8E4M3);
     k.EnableOutputDataType(Datatype::F16);
     k.EnableOutputDataType(Datatype::F32);
     k.EnableOutputDataType(Datatype::INT8);
     k.EnableOutputDataType(Datatype::UINT8);
     k.EnableOutputDataType(Datatype::INT32);
     k.EnableOutputDataType(Datatype::INT64);
+    k.EnableOutputDataType(Datatype::F8E4M3);
     k.EnableInputLayout(DataLayout::bf);
     k.EnableInputLayout(DataLayout::fb);
     k.EnableInputLayout(DataLayout::bfyx);
@@ -66,6 +68,10 @@ JitConstants ConcatenationKernelRef::GetJitConstants(const concatenation_params&
     auto cldnnJit = ConcatenationKernelBase::GetJitConstants(params);
     auto input_format = params.inputs[0].GetLayout();
 
+    // Flag fp8 input so the kernel copies the byte instead of running ACTIVATION on the fp8 struct
+    // (see concatenation_gpu_ref.cl).
+    cldnnJit.AddConstant(MakeJitConstant("INPUT0_IS_FP8", params.inputs[0].GetDType() == Datatype::F8E4M3));
+
     if (params.inputs[0].Feature().v != 1) {
         cldnnJit.AddConstant(MakeJitConstant("CHECK_FEATURES", 1));
         int f_channel = DataTensor::Channelndex(params.outputs[0].GetLayout(), Tensor::DataChannelName::FEATURE);

src/plugins/intel_gpu/src/kernel_selector/kernels/scatter_update/scatter_update_kernel_ref.cpp

@@ -39,11 +39,13 @@ ParamsKey ScatterUpdateKernelRef::GetSupportedKey() const {
     k.EnableInputDataType(Datatype::INT32);
     k.EnableInputDataType(Datatype::INT8);
     k.EnableInputDataType(Datatype::UINT8);
+    k.EnableInputDataType(Datatype::F8E4M3);
     k.EnableOutputDataType(Datatype::F16);
     k.EnableOutputDataType(Datatype::F32);
     k.EnableOutputDataType(Datatype::INT32);
     k.EnableOutputDataType(Datatype::INT8);
     k.EnableOutputDataType(Datatype::UINT8);
+    k.EnableOutputDataType(Datatype::F8E4M3);
     k.EnableAllInputLayout();
     k.EnableAllOutputLayout();
     k.EnableTensorOffset();
@@ -186,6 +188,11 @@ JitConstants ScatterUpdateKernelRef::GetJitConstants(const scatter_update_params
     JitConstants jit = MakeBaseParamsJitConstants(params);
     size_t axis_value = GetScatterUpdateChannelIndex(params);
 
+    // Flag fp8 inputs so the kernel copies the byte instead of running ACTIVATION on the fp8 struct
+    // (see scatter_update_ref.cl). INPUT0 = dictionary (first kernel), INPUT2 = updates (second).
+    jit.AddConstant(MakeJitConstant("INPUT0_IS_FP8", params.inputs[0].GetDType() == Datatype::F8E4M3));
+    jit.AddConstant(MakeJitConstant("INPUT2_IS_FP8", params.inputs[2].GetDType() == Datatype::F8E4M3));
+
     const auto input2_has_padding = params.inputs[2].has_dynamic_pad() || params.inputs[2].PitchesDifferFromLogicalDims();
 
     // In case of padded input2 (updates), we also need non-planar indexing, because UPDATES_INDEX is calculated based on output sizes