[GPU] Fix GDN func test to use TEMPLATE plugin as reference (#36081)

### Details:
- *Ticket:*
[CVS-187512](https://jira.devtools.intel.com/browse/CVS-187512)

### Problem:
The GPU functional test `smoke_GatedDeltaNetStatic` was failing on A770
(Linux) because it used the CPU plugin as a reference for output
comparison, but the CPU plugin is not registered on that test platform.

### Solution:
1. **Add `evaluate()` method to `GatedDeltaNet` op** — implements the
reference GDN algorithm directly in the core op, enabling the TEMPLATE
plugin to evaluate it.
2. **Update the GPU functional test** — replace
`core.compile_model(model, "CPU")` with
`ov::test::utils::infer_on_template()`, which uses the TEMPLATE plugin
(interpreter backend) as reference.

### Changes:
- `src/core/dev_api/openvino/op/gated_delta_net.hpp` — declare
`evaluate()` and `has_evaluate()` overrides
- `src/core/src/op/gated_delta_net.cpp` — implement `evaluate()` with
the GDN reference algorithm (f32 only)
-
`src/plugins/intel_gpu/tests/functional/single_layer_tests/gated_delta_net.cpp`
— use `infer_on_template` instead of CPU plugin

---------

Co-authored-by: Pawel Raasz <pawel.raasz@intel.com>

Author: wine99

src/core/reference/include/openvino/reference/gated_delta_net.hpp

@@ -0,0 +1,120 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <cmath>
+#include <vector>
+
+#include "openvino/core/shape.hpp"
+#include "openvino/reference/normalize_l2.hpp"
+
+namespace ov::reference {
+
+template <typename T>
+void gated_delta_net(const T* q_data,
+                     const T* k_data,
+                     const T* v_data,
+                     const T* state_data,
+                     const T* gate_data,
+                     const T* beta_data,
+                     T* out_data,
+                     T* out_state,
+                     const Shape& q_shape,
+                     const Shape& v_shape,
+                     bool fuse_qk_l2norm,
+                     T q_l2_norm_eps,
+                     T k_l2_norm_eps) {
+    const size_t B = q_shape[0];
+    const size_t S = q_shape[1];
+    const size_t qk_H = q_shape[2];
+    const size_t D = q_shape[3];
+    const size_t v_H = v_shape[2];
+    const size_t Dv = v_shape[3];
+    const size_t group_size = v_H / qk_H;
+
+    const T attn_scale = static_cast<T>(1) / std::sqrt(static_cast<T>(D));
+
+    const size_t qk_stride_batch = S * qk_H * D;
+    const size_t v_stride_batch = S * v_H * Dv;
+    const size_t gate_beta_stride_batch = S * v_H;
+
+    auto dot_product = [](const T* a, const T* b, size_t n) {
+        T result = static_cast<T>(0);
+        for (size_t i = 0; i < n; i++) {
+            result += a[i] * b[i];
+        }
+        return result;
+    };
+
+    const Shape norm_shape{D};
+    const AxisSet norm_axes{0};
+
+    for (size_t b = 0; b < B; b++) {
+        for (size_t h_v = 0; h_v < v_H; h_v++) {
+            const size_t h_qk = h_v / group_size;
+            for (size_t d_v = 0; d_v < Dv; d_v++) {
+                const size_t state_offset = b * v_H * D * Dv + h_v * D * Dv + d_v;
+                T* state_ptr = out_state + state_offset;
+
+                std::vector<T> local_state(D);
+                const T* src_state = state_data + state_offset;
+                for (size_t d = 0; d < D; d++) {
+                    local_state[d] = src_state[d * Dv];
+                }
+
+                for (size_t t = 0; t < S; t++) {
+                    const T* q_ptr = q_data + b * qk_stride_batch + t * qk_H * D + h_qk * D;
+                    const T* k_ptr = k_data + b * qk_stride_batch + t * qk_H * D + h_qk * D;
+
+                    std::vector<T> q_vec(q_ptr, q_ptr + D);
+                    std::vector<T> k_vec(k_ptr, k_ptr + D);
+
+                    if (fuse_qk_l2norm) {
+                        normalize_l2(q_vec.data(),
+                                     q_vec.data(),
+                                     norm_shape,
+                                     norm_axes,
+                                     static_cast<float>(q_l2_norm_eps),
+                                     op::EpsMode::ADD);
+                        normalize_l2(k_vec.data(),
+                                     k_vec.data(),
+                                     norm_shape,
+                                     norm_axes,
+                                     static_cast<float>(k_l2_norm_eps),
+                                     op::EpsMode::ADD);
+                    }
+
+                    for (size_t i = 0; i < D; i++)
+                        q_vec[i] *= attn_scale;
+
+                    T g = std::exp(gate_data[b * gate_beta_stride_batch + t * v_H + h_v]);
+                    T bt = beta_data[b * gate_beta_stride_batch + t * v_H + h_v];
+
+                    for (size_t d = 0; d < D; d++) {
+                        local_state[d] *= g;
+                    }
+
+                    T h_k = dot_product(local_state.data(), k_vec.data(), D);
+
+                    T v_val = v_data[b * v_stride_batch + t * v_H * Dv + h_v * Dv + d_v] - h_k;
+
+                    T update_scale = v_val * bt;
+                    for (size_t d = 0; d < D; d++) {
+                        local_state[d] += k_vec[d] * update_scale;
+                    }
+
+                    out_data[b * v_stride_batch + t * v_H * Dv + h_v * Dv + d_v] =
+                        dot_product(local_state.data(), q_vec.data(), D);
+                }
+
+                for (size_t d = 0; d < D; d++) {
+                    state_ptr[d * Dv] = local_state[d];
+                }
+            }
+        }
+    }
+}
+
+}  // namespace ov::reference

src/core/shape_inference/include/gated_delta_net_shape_inference.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "dimension_util.hpp"
 #include "openvino/op/gated_delta_net.hpp"
 #include "utils.hpp"
 
@@ -28,6 +29,7 @@ std::vector<TRShape> shape_infer(const GatedDeltaNet* op, const std::vector<T>&
     const auto& k_head_size = key_ps[3];
     const auto& q_head_size = query_ps[3];
     const auto& v_head_size = value_ps[3];
+    auto out_shape = TRShape(value_ps);
 
     NODE_SHAPE_INFER_CHECK(op,
                            input_shapes,
@@ -45,6 +47,15 @@ std::vector<TRShape> shape_infer(const GatedDeltaNet* op, const std::vector<T>&
                            " and ",
                            q_head_size);
 
+    NODE_SHAPE_INFER_CHECK(
+        op,
+        input_shapes,
+        q_head_num.is_dynamic() || ov::util::dim::is_divisible(out_shape[2], q_head_num.get_length()),
+        "The number of value heads must be a multiple of query/key heads (GQA), but got v_H=",
+        v_head_num,
+        " and qk_H=",
+        q_head_num);
+
     const auto& gate_head_num = gate_ps[2];
     const auto& beta_head_num = beta_ps[2];
 
@@ -84,6 +95,6 @@ std::vector<TRShape> shape_infer(const GatedDeltaNet* op, const std::vector<T>&
         v_head_size);
     // output has the same shape and type as input value, output state has the same shape and type as input
     // recurrent_state
-    return {value_ps, state_ps};
+    return {out_shape, state_ps};
 }
 }  // namespace ov::op::internal

src/plugins/intel_gpu/tests/functional/single_layer_tests/gated_delta_net.cpp

@@ -2,23 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "openvino/op/gated_delta_net.hpp"
+
+#include "common_test_utils/common_utils.hpp"
 #include "common_test_utils/ov_tensor_utils.hpp"
+#include "common_test_utils/ov_test_utils.hpp"
 #include "common_test_utils/test_common.hpp"
-#include "common_test_utils/common_utils.hpp"
 #include "openvino/op/parameter.hpp"
 #include "openvino/op/result.hpp"
-#include "openvino/op/gated_delta_net.hpp"
 #include "openvino/runtime/core.hpp"
 
 namespace {
 
-using GatedDeltaNetParams = std::tuple<
-    std::vector<ov::Shape>,  // Input shapes: query, key, value, state, gate, beta
-    ov::element::Type,       // Input precision
-    bool>;                   // fuse_qk_l2norm
+using GatedDeltaNetParams = std::tuple<std::vector<ov::Shape>,  // Input shapes: query, key, value, state, gate, beta
+                                       ov::element::Type,       // Input precision
+                                       bool>;                   // fuse_qk_l2norm
 
-class GatedDeltaNetStaticTest : public testing::WithParamInterface<GatedDeltaNetParams>,
-                                public ov::test::TestsCommon {
+class GatedDeltaNetStaticTest : public testing::WithParamInterface<GatedDeltaNetParams>, public ov::test::TestsCommon {
 public:
     static std::string getTestCaseName(const testing::TestParamInfo<GatedDeltaNetParams>& obj) {
         const auto& [input_shapes, precision, fuse_qk_l2norm] = obj.param;
@@ -46,16 +46,12 @@ class GatedDeltaNetStaticTest : public testing::WithParamInterface<GatedDeltaNet
         auto gate = std::make_shared<ov::op::v0::Parameter>(precision, input_shapes[4]);
         auto beta = std::make_shared<ov::op::v0::Parameter>(precision, input_shapes[5]);
 
-        auto gdn = std::make_shared<ov::op::internal::GatedDeltaNet>(
-            query, key, value, state, gate, beta, fuse_qk_l2norm);
+        auto gdn = std::make_shared<ov::op::internal::GatedDeltaNet>(query, key, value, state, gate, beta, fuse_qk_l2norm);
 
         auto result0 = std::make_shared<ov::op::v0::Result>(gdn->output(0));
         auto result1 = std::make_shared<ov::op::v0::Result>(gdn->output(1));
 
-        model = std::make_shared<ov::Model>(
-            ov::ResultVector{result0, result1},
-            ov::ParameterVector{query, key, value, state, gate, beta},
-            "GatedDeltaNetTest");
+        model = std::make_shared<ov::Model>(ov::ResultVector{result0, result1}, ov::ParameterVector{query, key, value, state, gate, beta}, "GatedDeltaNetTest");
     }
 
     std::map<std::shared_ptr<ov::op::v0::Parameter>, ov::Tensor> generate_inputs() {
@@ -66,29 +62,28 @@ class GatedDeltaNetStaticTest : public testing::WithParamInterface<GatedDeltaNet
             if (i == 4) {
                 in_data = ov::test::utils::InputGenerateData(-1, 1, 1000, 1);
             }
-            inputs[params[i]] = ov::test::utils::create_and_fill_tensor(
-                params[i]->get_element_type(), params[i]->get_shape(), in_data);
+            inputs[params[i]] = ov::test::utils::create_and_fill_tensor(params[i]->get_element_type(), params[i]->get_shape(), in_data);
         }
         return inputs;
     }
 
     std::shared_ptr<ov::Model> model;
 };
 
-TEST_P(GatedDeltaNetStaticTest, CompareWithCPU) {
+TEST_P(GatedDeltaNetStaticTest, CompareWithTemplate) {
     auto inputs = generate_inputs();
 
-    ov::Core core;
-
-    // Run on CPU (reference)
-    auto compiled_cpu = core.compile_model(model, "CPU");
-    auto req_cpu = compiled_cpu.create_infer_request();
-    for (const auto& [param, tensor] : inputs) {
-        req_cpu.set_tensor(param->output(0), tensor);
+    // Build input tensor vector for infer_on_template
+    ov::TensorVector input_tensors;
+    for (const auto& param : model->get_parameters()) {
+        input_tensors.push_back(inputs.at(param));
     }
-    req_cpu.infer();
+
+    // Run on TEMPLATE (reference)
+    auto ref_outputs = ov::test::utils::infer_on_template(model, input_tensors);
 
     // Run on GPU
+    ov::Core core;
     auto compiled_gpu = core.compile_model(model, "GPU");
     auto req_gpu = compiled_gpu.create_infer_request();
     for (const auto& [param, tensor] : inputs) {
@@ -98,30 +93,28 @@ TEST_P(GatedDeltaNetStaticTest, CompareWithCPU) {
 
     // Compare outputs
     for (size_t i = 0; i < model->get_output_size(); i++) {
-        auto out_cpu = req_cpu.get_output_tensor(i);
         auto out_gpu = req_gpu.get_output_tensor(i);
-        ov::test::utils::compare(out_cpu, out_gpu, 1e-2, 1e-2);
+        ov::test::utils::compare(ref_outputs[i], out_gpu, 1e-2, 1e-2);
     }
 }
 
-// Shapes: query[B,S,H,D], key[B,S,H,D], value[B,S,H,Dv], state[B,H,D,Dv], gate[B,S,H], beta[B,S,H]
+// Shapes: query[B,S,qk_H,D], key[B,S,qk_H,D], value[B,S,v_H,Dv], state[B,v_H,D,Dv], gate[B,S,v_H], beta[B,S,v_H]
 const std::vector<std::vector<ov::Shape>> static_shapes = {
-    // B=1, S=1, H=4, D=16, Dv=16 (minimal)
+    // B=1, S=1, qk_H=4, v_H=4, D=16, Dv=16 (minimal)
     {{1, 1, 4, 16}, {1, 1, 4, 16}, {1, 1, 4, 16}, {1, 4, 16, 16}, {1, 1, 4}, {1, 1, 4}},
-    // B=1, S=1, H=32, D=128, Dv=128 (typical LLM decode)
+    // B=1, S=1, qk_H=32, v_H=32, D=128, Dv=128 (typical LLM decode)
     {{1, 1, 32, 128}, {1, 1, 32, 128}, {1, 1, 32, 128}, {1, 32, 128, 128}, {1, 1, 32}, {1, 1, 32}},
-    // B=1, S=16, H=2, D=16, Dv=32 (seq_len > 1, different D and Dv)
+    // B=1, S=16, qk_H=2, v_H=2, D=16, Dv=32 (seq_len > 1, different D and Dv)
     {{1, 16, 2, 16}, {1, 16, 2, 16}, {1, 16, 2, 32}, {1, 2, 16, 32}, {1, 16, 2}, {1, 16, 2}},
-    // B=2, S=1, H=8, D=64, Dv=64 (batch > 1)
+    // B=2, S=1, qk_H=8, v_H=8, D=64, Dv=64 (batch > 1)
     {{2, 1, 8, 64}, {2, 1, 8, 64}, {2, 1, 8, 64}, {2, 8, 64, 64}, {2, 1, 8}, {2, 1, 8}},
+    // B=1, S=4, qk_H=2, v_H=8, D=16, Dv=16 (GQA: v_H is multiple of qk_H)
+    {{1, 4, 2, 16}, {1, 4, 2, 16}, {1, 4, 8, 16}, {1, 8, 16, 16}, {1, 4, 8}, {1, 4, 8}},
 };
 
-INSTANTIATE_TEST_SUITE_P(
-    smoke_GatedDeltaNetStatic,
-    GatedDeltaNetStaticTest,
-    ::testing::Combine(::testing::ValuesIn(static_shapes),
-                       ::testing::Values(ov::element::f32),
-                       ::testing::Values(false, true)),
-    GatedDeltaNetStaticTest::getTestCaseName);
+INSTANTIATE_TEST_SUITE_P(smoke_GatedDeltaNetStatic,
+                         GatedDeltaNetStaticTest,
+                         ::testing::Combine(::testing::ValuesIn(static_shapes), ::testing::Values(ov::element::f32), ::testing::Values(false, true)),
+                         GatedDeltaNetStaticTest::getTestCaseName);
 
 }  // namespace

src/plugins/template/backend/ops/gated_delta_net.cpp

@@ -0,0 +1,51 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "openvino/reference/gated_delta_net.hpp"
+
+#include "evaluate_node.hpp"
+#include "gated_delta_net_shape_inference.hpp"
+#include "openvino/core/type/element_type_traits.hpp"
+#include "openvino/op/gated_delta_net.hpp"
+
+template <ov::element::Type_t ET>
+bool evaluate(const std::shared_ptr<ov::op::internal::GatedDeltaNet>& op,
+              ov::TensorVector& outputs,
+              const ov::TensorVector& inputs) {
+    using T = typename ov::element_type_traits<ET>::value_type;
+
+    const auto input_shapes = ov::util::get_tensors_partial_shapes(inputs);
+    const auto output_shapes = ov::op::internal::shape_infer(op.get(), input_shapes);
+    outputs[0].set_shape(output_shapes[0].to_shape());
+    outputs[1].set_shape(output_shapes[1].to_shape());
+
+    ov::reference::gated_delta_net<T>(inputs[0].data<const T>(),
+                                      inputs[1].data<const T>(),
+                                      inputs[2].data<const T>(),
+                                      inputs[3].data<const T>(),
+                                      inputs[4].data<const T>(),
+                                      inputs[5].data<const T>(),
+                                      outputs[0].data<T>(),
+                                      outputs[1].data<T>(),
+                                      inputs[0].get_shape(),
+                                      inputs[2].get_shape(),
+                                      op->get_fuse_qk_l2norm(),
+                                      static_cast<T>(op->get_q_l2_norm_eps()),
+                                      static_cast<T>(op->get_k_l2_norm_eps()));
+    return true;
+}
+
+template <>
+bool evaluate_node<ov::op::internal::GatedDeltaNet>(std::shared_ptr<ov::Node> node,
+                                                    ov::TensorVector& outputs,
+                                                    const ov::TensorVector& inputs) {
+    const auto& element_type = node->get_input_element_type(0);
+
+    switch (element_type) {
+    case ov::element::f32:
+        return evaluate<ov::element::f32>(ov::as_type_ptr<ov::op::internal::GatedDeltaNet>(node), outputs, inputs);
+    default:
+        OPENVINO_THROW("Unhandled data type ", element_type, " in evaluate_node()");
+    }
+}

src/plugins/template/backend/ops/ops_evaluates.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 #include "evaluate_node.hpp"
+#include "openvino/op/gated_delta_net.hpp"
 #include "openvino/op/ops.hpp"
 #include "openvino/op/paged_attention.hpp"
 #include "openvino/op/rms_norm.hpp"
@@ -549,6 +550,10 @@ extern template bool evaluate_node<ov::op::internal::AUGRUSequence>(std::shared_
                                                                     ov::TensorVector& outputs,
                                                                     const ov::TensorVector& inputs);
 
+extern template bool evaluate_node<ov::op::internal::GatedDeltaNet>(std::shared_ptr<ov::Node> node,
+                                                                    ov::TensorVector& outputs,
+                                                                    const ov::TensorVector& inputs);
+
 extern template bool evaluate_node<ov::op::internal::RMS>(std::shared_ptr<ov::Node> node,
                                                           ov::TensorVector& outputs,
                                                           const ov::TensorVector& inputs);

src/plugins/template/backend/opset_int_tbl.hpp

@@ -188,6 +188,7 @@ _OPENVINO_OP_REG(OneHot, ov::op::v16)
 
 _OPENVINO_OP_REG(AUGRUCell, ov::op::internal)
 _OPENVINO_OP_REG(AUGRUSequence, ov::op::internal)
+_OPENVINO_OP_REG(GatedDeltaNet, ov::op::internal)
 _OPENVINO_OP_REG(RMS, ov::op::internal)
 _OPENVINO_OP_REG(RMSNorm, ov::op::internal)
 _OPENVINO_OP_REG(PagedAttentionExtension, ov::op)