add shared test

Author: zhangYiIntel

src/core/dev_api/openvino/op/gated_delta_net.hpp

@@ -15,15 +15,24 @@ class OPENVINO_API GatedDeltaNet : public ov::op::Op {
     OPENVINO_OP("GatedDeltaNet");
 
     GatedDeltaNet() = default;
-
+    struct Config {
+        bool fuse_qk_l2norm = false;
+        bool fuse_q_scale = false;
+    };
     GatedDeltaNet(const ov::OutputVector& args);
     void validate_and_infer_types() override;
     std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector& new_args) const override;
-
+    const Config& get_config() const {
+        return m_config;
+    }
+    void set_config(const Config& config) {
+        m_config = config;
+    }
     void set_out_type(int index, const ov::element::Type& output_type);
 
 protected:
     std::vector<ov::element::Type> m_output_type = {ov::element::dynamic, ov::element::dynamic, ov::element::dynamic};
+    Config m_config;
 };
 
 }  // namespace op

src/core/src/op/gated_delta_net.cpp

@@ -76,15 +76,15 @@ void GatedDeltaNet::validate_and_infer_types() {
     input_check(this, 0, "query", {4}, {});
     input_check(this, 1, "key", {4}, {});
     input_check(this, 2, "value", {4}, {});
-    input_check(this, 5, "recurrent_state", {4}, {});
-    input_check(this, 3, "gate", {3}, {});
-    input_check(this, 4, "beta", {3}, {});
+    input_check(this, 3, "recurrent_state", {4}, {});
+    input_check(this, 4, "gate", {3}, {});
+    input_check(this, 5, "beta", {3}, {});
 
     // value head_size may be not same with key
     auto out_ps = get_input_partial_shape(2);
-    const auto&  h_ps= get_input_partial_shape(5);
+    const auto&  h_ps= get_input_partial_shape(3);
     set_output_type(0, get_input_element_type(0), out_ps);
-    set_output_type(1, get_input_element_type(5), h_ps);
+    set_output_type(1, get_input_element_type(3), h_ps);
 }
 
 std::shared_ptr<ov::Node> GatedDeltaNet::clone_with_new_inputs(const ov::OutputVector& new_args) const {

src/plugins/intel_cpu/src/nodes/gated_delta_net.cpp

@@ -72,7 +72,7 @@ void GatedDeltaNet::execute([[maybe_unused]] const dnnl::stream& strm) {
     for (size_t i = 0; i < orginInputNumber; i++) {
         inputs[i] = getSrcMemoryAtPort(i);
     }
-    std::vector<VectorDims> output_dims = {inputs[0]->getStaticDims(), inputs[5]->getStaticDims()};
+    std::vector<VectorDims> output_dims = {inputs[0]->getStaticDims(), inputs[3]->getStaticDims()};
     redefineOutputMemory(output_dims);
 
     outputs[0] = getDstMemoryAtPort(0);
@@ -85,7 +85,7 @@ void GatedDeltaNet::execute([[maybe_unused]] const dnnl::stream& strm) {
     PlainTensor gate(inputs[4]);
     PlainTensor beta(inputs[5]);
     PlainTensor output_attn(outputs[0]);
-    PlainTensor output_recurrent_state(inputs[1]);
+    PlainTensor output_recurrent_state(outputs[1]);
     recurrent_linear_attn(query, key, value, recurrent_state, gate, beta, output_attn, output_recurrent_state);
 }
 

src/plugins/intel_cpu/src/nodes/kernels/linear_attn/recurrent_linear_attn.cpp

@@ -192,7 +192,8 @@ void recurrent_linear_attn(const ov::intel_cpu::PlainTensor& query,
             // scale(init_state, b_g, K_HEAD_DIMS);
             multiply_scalar(init_state, init_state, b_g, K_HEAD_DIMS);
 			float h_k = dot_product(init_state, b_k, K_HEAD_DIMS);
-			float b_v = v_ptr[i_v + i * H* K_HEAD_DIMS];
+            // B, T, H, V
+			float b_v = v_ptr[i_v + i * H * K_HEAD_DIMS];
 			b_v -= h_k;
 			// b_v * b_k
 			b_v *= b_beta;

src/plugins/intel_cpu/tests/functional/shared_tests_instances/subgraph_tests/gated_delta_net.cpp

@@ -0,0 +1,20 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "subgraph_tests/gated_delta_net.hpp"
+
+namespace ov {
+namespace test {
+
+std::vector<gated_delta_net_params> test_cases = {
+    {1, 1, 2, 2, 16, ov::element::f32, "CPU"},
+    {2, 16, 2, 2, 16, ov::element::f32, "CPU"},
+    {1, 16, 2, 2, 128, ov::element::f32, "CPU"},
+};
+INSTANTIATE_TEST_SUITE_P(smoke_GatedDeltaNet,
+                         GatedDeltaNet,
+                         ::testing::ValuesIn(test_cases),
+                         GatedDeltaNet::getTestCaseName);
+}  // namespace test
+}  // namespace ov

src/tests/functional/plugin/shared/include/shared_test_classes/subgraph/gated_delta_net.hpp

@@ -0,0 +1,40 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "shared_test_classes/base/ov_subgraph.hpp"
+
+namespace ov {
+namespace test {
+
+using gated_delta_net_params = std::tuple<int32_t,            // B
+                                          int32_t,            // T
+                                          int32_t,            // qk_head_nums
+                                          int32_t,            // v_head_nums
+                                          int32_t,            // head_size
+                                          ov::element::Type,  // infer_precision
+                                          std::string         // device
+                                          >;
+
+class GatedDeltaNet : public testing::WithParamInterface<gated_delta_net_params>, public ov::test::SubgraphBaseTest {
+private:
+    std::shared_ptr<ov::Model> buildLoopedGDN(int32_t batch,
+                                              int32_t seq_len,
+                                              int32_t qk_head_num,
+                                              int32_t v_head_num,
+                                              int32_t head_size);
+
+public:
+    void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override;
+    static std::string getTestCaseName(const testing::TestParamInfo<gated_delta_net_params>& obj);
+
+protected:
+    void compare(const std::vector<ov::Tensor>& expected, const std::vector<ov::Tensor>& actual) override;
+    void SetUp() override;
+    void TearDown() override;
+};
+
+}  // namespace test
+}  // namespace ov

src/tests/functional/plugin/shared/include/subgraph_tests/gated_delta_net.hpp

@@ -0,0 +1,18 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "shared_test_classes/subgraph/gated_delta_net.hpp"
+
+namespace ov {
+namespace test {
+
+TEST_P(GatedDeltaNet, CompareWithRefs) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED();
+    run();
+    auto function = compiledModel.get_runtime_model();
+};
+}  // namespace test
+}  // namespace ov