From 66ea57adddb82c184213c9db949b0a8141ddea5e Mon Sep 17 00:00:00 2001 From: Oleg Pipikin Date: Fri, 31 Mar 2023 19:55:55 +0200 Subject: [PATCH] Move memory tests from core to template plugin tests (#16460) * Move memory tests from core to template plugin tests * Rewrite tests to use template plugin * Don't clone model in INTExecutable * Add reset and modify tests * Delete old test * Fix clang-format * Fix VariableState::set_state * Enable and add var modify tests * Fix INTExecutable * Apply comments --- src/core/tests/CMakeLists.txt | 7 - src/core/tests/op_eval/memory.cpp | 296 ------- src/plugins/template/backend/executable.hpp | 4 + .../template/backend/int_executable.cpp | 4 + .../template/backend/int_executable.hpp | 2 + .../template/src/sync_infer_request.cpp | 3 +- src/plugins/template/src/variable_state.hpp | 9 +- .../tests/functional/op_reference/memory.cpp | 823 +++++++++++++++++- 8 files changed, 841 insertions(+), 307 deletions(-) delete mode 100644 src/core/tests/op_eval/memory.cpp diff --git a/src/core/tests/CMakeLists.txt b/src/core/tests/CMakeLists.txt index a2ccb021abb..829f1822a21 100644 --- a/src/core/tests/CMakeLists.txt +++ b/src/core/tests/CMakeLists.txt @@ -27,13 +27,6 @@ list(APPEND UNIT_TESTS_DEPENDENCIES openvino_template_extension) list(APPEND UNIT_TESTS_DEPENDENCIES template_extension) list(APPEND EXCLUDE_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/dnnl.cpp) -if (ENABLE_TEMPLATE) - list(APPEND UNIT_TESTS_DEPENDENCIES openvino_template_plugin) -else() - list(APPEND EXCLUDE_TESTS - # It should be a part of template plugin - ${CMAKE_CURRENT_SOURCE_DIR}/op_eval/memory.cpp) -endif() ov_add_test_target( NAME ${TARGET_NAME} diff --git a/src/core/tests/op_eval/memory.cpp b/src/core/tests/op_eval/memory.cpp deleted file mode 100644 index 81ca0f0ce7f..00000000000 --- a/src/core/tests/op_eval/memory.cpp +++ /dev/null @@ -1,296 +0,0 @@ -// Copyright (C) 2018-2023 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include - -#include "engines_util/execute_tools.hpp" -#include "gtest/gtest.h" -#include "ngraph/op/util/variable.hpp" -#include "ngraph/op/util/variable_context.hpp" -#include "ngraph/opsets/opset7.hpp" -#include "ngraph/util.hpp" -#include "ngraph/validation_util.hpp" -#include "util/all_close_f.hpp" -#include "util/test_tools.hpp" - -using namespace std; -using namespace ngraph; -using namespace ngraph::opset7; - -OPENVINO_SUPPRESS_DEPRECATED_START - -shared_ptr AssignReadGraph() { - auto p = make_shared(element::f32, Shape{3}); - auto variable = make_shared(VariableInfo{PartialShape::dynamic(), element::dynamic, "var_1"}); - auto read_value = make_shared(p, variable); - auto assign = make_shared(read_value, variable); - return make_shared(OutputVector{assign}, ParameterVector{p}, VariableVector{variable}); -} - -shared_ptr AssignReadAddGraph() { - auto p = make_shared(element::f32, Shape{3}); - auto c = std::make_shared(element::f32, Shape{3}, std::vector({0, 0, 0})); - auto variable = make_shared(VariableInfo{PartialShape::dynamic(), element::dynamic, "var_1"}); - auto read_value = make_shared(c, variable); - auto add = make_shared(p, read_value); - auto assign = make_shared(add, variable); - return make_shared(OutputVector{assign}, ParameterVector{p}, VariableVector{variable}); -} - -shared_ptr AssignReadMultiVariableGraph() { - auto c = std::make_shared(element::f32, Shape{3}, std::vector({0, 0, 0})); - - auto variable = make_shared(VariableInfo{PartialShape::dynamic(), element::dynamic, "var_1"}); - auto variable_2 = make_shared(VariableInfo{PartialShape::dynamic(), element::dynamic, "var_2"}); - - auto read_value = make_shared(c, variable); - auto read_value_2 = make_shared(c, variable_2); - - auto add = make_shared(read_value_2, read_value); - - auto assign = make_shared(add, variable); - auto assign_2 = make_shared(read_value_2, variable_2); - - return make_shared(OutputVector{assign}, ParameterVector{}, VariableVector{variable, variable_2}); -} - -TEST(op_eval, assign_readvalue_without_evaluation_context) { - auto fun = AssignReadGraph(); - auto result = make_shared(); - - const int COUNT_RUNS = 10; - std::vector inputs{-5, 0, 5}; - std::vector expected_result{0, 0, 0}; - for (int i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor(Shape{3}, inputs)})); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } -} - -TEST(op_eval, assign_readvalue_evaluation_context) { - auto fun = AssignReadGraph(); - auto result = make_shared(); - const auto& variables = fun->get_variables(); - EXPECT_EQ(variables.size(), 1); - - std::vector inputs{-5, 0, 5}; - std::vector expected_result{0, 0, 0}; - - EvaluationContext eval_context; - HostTensorPtr h_tensor = make_host_tensor(Shape{3}, inputs); - VariableContext variable_context; - variable_context.set_variable_value(variables[0], std::make_shared(h_tensor)); - eval_context.emplace("VariableContext", variable_context); - - const int COUNT_RUNS = 10; - for (int i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor(Shape{3}, inputs)}, eval_context)); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } -} - -TEST(op_eval, assign_readvalue_add) { - auto fun = AssignReadAddGraph(); - const auto& variables = fun->get_variables(); - EXPECT_EQ(variables.size(), 1); - - std::vector inputs{-5, 0, 5}; - - // creating context - EvaluationContext eval_context; - auto variable_context = VariableContext(); - auto variable_value = make_shared(make_host_tensor(Shape{3}, inputs)); - variable_context.set_variable_value(variables[0], variable_value); - eval_context.emplace("VariableContext", variable_context); - - auto result = make_shared(); - const int COUNT_RUNS = 10; - for (int i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor(Shape{3}, inputs)}, eval_context)); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - auto result_data = read_vector(result); - - auto cnt = static_cast(i + 1); - std::vector expected_result{inputs[0] * cnt, inputs[1] * cnt, inputs[2] * cnt}; - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } -} - -TEST(op_eval, assign_readvalue_reset_before_evaluate) { - auto fun = AssignReadAddGraph(); - const auto& variables = fun->get_variables(); - EXPECT_EQ(variables.size(), 1); - - std::vector inputs{-5, 0, 5}; - - // creating context - EvaluationContext eval_context; - auto variable_context = VariableContext(); - auto variable_value = make_shared(make_host_tensor(Shape{3}, inputs)); - variable_value->set_reset(false); - variable_context.set_variable_value(variables[0], variable_value); - eval_context.emplace("VariableContext", variable_context); - - auto result = make_shared(); - const int COUNT_RUNS = 10; - for (int i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor(Shape{3}, inputs)}, eval_context)); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - auto result_data = read_vector(result); - - auto cnt = static_cast(i + 2); - std::vector expected_result{inputs[0] * cnt, inputs[1] * cnt, inputs[2] * cnt}; - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } -} - -TEST(op_eval, assign_readvalue_add_reset) { - auto fun = AssignReadAddGraph(); - std::vector inputs{-5, 0, 5}; - const auto& variables = fun->get_variables(); - EXPECT_EQ(variables.size(), 1); - - // creating a Context - EvaluationContext eval_context; - auto variable_context = VariableContext(); - auto variable_value = make_shared(make_host_tensor(Shape{3}, inputs)); - variable_context.set_variable_value(variables[0], variable_value); - eval_context.emplace("VariableContext", variable_context); - - auto result = make_shared(); - const int COUNT_RUNS = 10; - for (int i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor(Shape{3}, inputs)}, eval_context)); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - auto result_data = read_vector(result); - - auto cnt = static_cast(i + 1); - std::vector expected_result{inputs[0] * cnt, inputs[1] * cnt, inputs[2] * cnt}; - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } - - const auto& found_context = eval_context.find("VariableContext"); - EXPECT_NE(found_context, eval_context.end()); - found_context->second.as().reset_variable_context(); - - for (int i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor(Shape{3}, inputs)}, eval_context)); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - auto result_data = read_vector(result); - - auto cnt = static_cast(i + 1); - std::vector expected_result{inputs[0] * cnt, inputs[1] * cnt, inputs[2] * cnt}; - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } -} - -TEST(op_eval, assign_readvalue_add_modify) { - auto fun = AssignReadAddGraph(); - std::vector inputs{-5, 0, 5}; - const auto& variables = fun->get_variables(); - EXPECT_EQ(variables.size(), 1); - - // creating context - EvaluationContext eval_context; - auto variable_context = VariableContext(); - auto variable_value = make_shared(make_host_tensor(Shape{3}, inputs)); - variable_context.set_variable_value(variables[0], variable_value); - eval_context.emplace("VariableContext", variable_context); - - auto result = make_shared(); - const int COUNT_RUNS = 10; - for (int i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor(Shape{3}, inputs)}, eval_context)); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - - auto cnt = static_cast(i + 1); - std::vector expected_result{inputs[0] * cnt, inputs[1] * cnt, inputs[2] * cnt}; - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } - - const auto& found_context = eval_context.find("VariableContext"); - EXPECT_NE(found_context, eval_context.end()); - const auto& var_value = found_context->second.as().get_variable_value(variables[0]); - EXPECT_NE(var_value, nullptr); - var_value->set_value(make_host_tensor(Shape{3}, {1, 2, 3})); - - for (int i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor(Shape{3}, inputs)}, eval_context)); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - - auto cnt = static_cast(i + 1); - std::vector expected_result{1 + inputs[0] * cnt, 2 + inputs[1] * cnt, 3 + inputs[2] * cnt}; - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } -} - -TEST(op_eval, assign_readvalue_add_modify_multi_variables) { - auto fun = AssignReadMultiVariableGraph(); - std::vector inputs_1{2, 2, 2}; - std::vector inputs_2{1, 3, 5}; - auto var_1 = fun->get_variable_by_id("var_1"); - auto var_2 = fun->get_variable_by_id("var_2"); - EXPECT_NE(var_1, nullptr); - EXPECT_NE(var_2, nullptr); - - // creating context - EvaluationContext eval_context; - auto variable_context = VariableContext(); - auto variable_value_1 = make_shared(make_host_tensor(Shape{3}, inputs_1)); - auto variable_value_2 = make_shared(make_host_tensor(Shape{3}, inputs_2)); - variable_value_1->set_reset(false); - variable_value_2->set_reset(false); - variable_context.set_variable_value(var_1, variable_value_1); - variable_context.set_variable_value(var_2, variable_value_2); - eval_context.emplace("VariableContext", variable_context); - - auto result = make_shared(); - const int COUNT_RUNS = 10; - - std::vector expected_result = inputs_1; - for (size_t i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {}, eval_context)); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - - for (size_t j = 0; j < expected_result.size(); ++j) { - expected_result[j] += inputs_2[j]; - } - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } - - const auto& found_context = eval_context.find("VariableContext"); - EXPECT_NE(found_context, eval_context.end()); - auto var_context = found_context->second.as(); - - auto var_value = variable_context.get_variable_value(var_1); - EXPECT_NE(var_value, nullptr); - var_value->set_value(make_host_tensor(Shape{3}, {1, 2, 3})); - - auto var_value_2 = variable_context.get_variable_value(var_2); - EXPECT_NE(var_value_2, nullptr); - var_value_2->set_reset(true); - - expected_result = {1, 2, 3}; - for (int i = 0; i < COUNT_RUNS; ++i) { - ASSERT_TRUE(fun->evaluate({result}, {}, eval_context)); - EXPECT_EQ(result->get_element_type(), element::f32); - EXPECT_EQ(result->get_shape(), Shape{3}); - - ASSERT_TRUE(test::all_close_f(read_vector(result), expected_result)); - } -} diff --git a/src/plugins/template/backend/executable.hpp b/src/plugins/template/backend/executable.hpp index 0794488c334..c9c60be9606 100644 --- a/src/plugins/template/backend/executable.hpp +++ b/src/plugins/template/backend/executable.hpp @@ -51,6 +51,10 @@ public: /// \returns an ngraph::ResultVector of all input parameters const ov::ResultVector& get_results() const; + /// \brief Query the internal model + /// \returns model which is used inside executable + virtual std::shared_ptr get_model() const = 0; + /// \brief Create an input Tensor /// \param input_index The index position in the input Parameter vector. This would be the same /// order of Parameters passed into the inputs in the call() method. diff --git a/src/plugins/template/backend/int_executable.cpp b/src/plugins/template/backend/int_executable.cpp index 49253aec58f..6091a62e3f0 100644 --- a/src/plugins/template/backend/int_executable.cpp +++ b/src/plugins/template/backend/int_executable.cpp @@ -274,3 +274,7 @@ bool ov::runtime::interpreter::INTExecutable::evaluate_node(const std::shared_pt } return res; } + +std::shared_ptr ov::runtime::interpreter::INTExecutable::get_model() const { + return m_model; +} diff --git a/src/plugins/template/backend/int_executable.hpp b/src/plugins/template/backend/int_executable.hpp index 2610a82ee23..8f2561811f1 100644 --- a/src/plugins/template/backend/int_executable.hpp +++ b/src/plugins/template/backend/int_executable.hpp @@ -41,6 +41,8 @@ public: std::vector create_output_tensor(size_t output_index, size_t pipeline_depth) override; + std::shared_ptr get_model() const override; + protected: std::shared_ptr get_parameter(size_t index) const; std::shared_ptr get_result(size_t index) const; diff --git a/src/plugins/template/src/sync_infer_request.cpp b/src/plugins/template/src/sync_infer_request.cpp index 7a274cf94b3..070518a56e7 100644 --- a/src/plugins/template/src/sync_infer_request.cpp +++ b/src/plugins/template/src/sync_infer_request.cpp @@ -79,8 +79,7 @@ ov::template_plugin::InferRequest::InferRequest(const std::shared_ptrm_model->get_variables()) { - auto value = std::make_shared(); + for (const auto& variable : m_executable->get_model()->get_variables()) { if (!variable_context.get_variable_value(variable)) { auto shape = variable->get_info().data_shape.is_dynamic() ? ov::Shape{0} : variable->get_info().data_shape.to_shape(); diff --git a/src/plugins/template/src/variable_state.hpp b/src/plugins/template/src/variable_state.hpp index c95fec677f9..2dfe4111010 100644 --- a/src/plugins/template/src/variable_state.hpp +++ b/src/plugins/template/src/variable_state.hpp @@ -12,8 +12,15 @@ namespace template_plugin { class VariableState : public ov::IVariableState { public: VariableState(const std::string& name, const ov::Tensor& tensor) : ov::IVariableState(name) { - set_state(tensor); + m_state = tensor; } + void set_state(const ov::Tensor& state) override { + OPENVINO_ASSERT(state.get_shape() == m_state.get_shape(), "Wrong tensor shape."); + OPENVINO_ASSERT(state.get_element_type() == state.get_element_type(), "Wrong tensor type."); + OPENVINO_ASSERT(state.get_byte_size() == state.get_byte_size(), "Blob size of tensors are not equal."); + std::memcpy(m_state.data(), state.data(), state.get_byte_size()); + } + void reset() override { std::memset(m_state.data(), 0, m_state.get_byte_size()); } diff --git a/src/plugins/template/tests/functional/op_reference/memory.cpp b/src/plugins/template/tests/functional/op_reference/memory.cpp index 0fca42b6940..f0492964cab 100644 --- a/src/plugins/template/tests/functional/op_reference/memory.cpp +++ b/src/plugins/template/tests/functional/op_reference/memory.cpp @@ -5,6 +5,8 @@ #include #include "base_reference_test.hpp" +#include "functional_test_utils/ov_plugin_cache.hpp" +#include "openvino/op/add.hpp" #include "openvino/op/constant.hpp" #include "openvino/op/read_value.hpp" #include "openvino/op/util/variable.hpp" @@ -107,10 +109,20 @@ private: TEST_P(ReferenceReadValueAssignV3LayerTest, ReadValueAssignWithHardcodedRefs) { Exec(); + const int COUNT_RUNS = 10; + for (int i = 0; i < COUNT_RUNS; ++i) { + Infer(); + Validate(); + } } TEST_P(ReferenceReadValueAssignV6LayerTest, ReadValueAssignWithHardcodedRefs) { Exec(); + const int COUNT_RUNS = 10; + for (int i = 0; i < COUNT_RUNS; ++i) { + Infer(); + Validate(); + } } template @@ -141,7 +153,13 @@ std::vector generateParamsForReadValueAssignBoolean() { using T = typename element_type_traits::value_type; std::vector params{ - ReadValueAssignParams(ov::Shape{1}, ov::Shape{1}, IN_ET, IN_ET, std::vector{true}, std::vector{true}, "v0"), + ReadValueAssignParams(ov::Shape{1}, + ov::Shape{1}, + IN_ET, + IN_ET, + std::vector{true}, + std::vector{true}, + "v0"), ReadValueAssignParams(ov::Shape{2, 2}, ov::Shape{2, 2}, IN_ET, @@ -197,3 +215,806 @@ INSTANTIATE_TEST_SUITE_P(smoke_ReadValue_Assign_With_Hardcoded_Refs, ReferenceReadValueAssignV6LayerTest::getTestCaseName); } // namespace + +namespace { +struct MemoryTestParams { + template + MemoryTestParams(const ov::Shape& input_shape, + const ov::Shape& output_shape, + const ov::element::Type& input_type, + const ov::element::Type& ouput_type, + const std::vector& input_values, + const std::vector>& output_values, + const size_t& count_runs, + const std::vector& variable_id, + const size_t& reset_on_run = 0) + : m_input_shape(input_shape), + m_output_shape(output_shape), + m_input_type(input_type), + m_output_type(ouput_type), + m_input_data(reference_tests::CreateTensor(input_shape, input_type, input_values)), + m_expected_data(reference_tests::CreateTensor(output_shape, ouput_type, output_values[0])), + m_variable_id(variable_id), + m_count_runs(count_runs), + m_reset_on_run(reset_on_run) { + for (size_t i = 0; i < m_count_runs; i++) { + m_expected_data_vector.push_back(reference_tests::CreateTensor(output_shape, ouput_type, output_values[i])); + } + } + ov::Shape m_input_shape; + ov::Shape m_output_shape; + ov::element::Type m_input_type; + ov::element::Type m_output_type; + ov::runtime::Tensor m_input_data; + ov::runtime::Tensor m_expected_data; + std::vector m_variable_id; + size_t m_count_runs; + size_t m_reset_on_run; + std::vector m_expected_data_vector; +}; + +class ReferenceMemoryTest : public testing::TestWithParam { +public: + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto params = obj.param; + std::ostringstream result; + result << "shape=" << params.m_input_shape << "_"; + result << "iType=" << params.m_input_type << "_"; + result << "shape=" << params.m_output_shape << "_"; + result << "oType=" << params.m_output_type; + return result.str(); + } + +protected: + const std::string targetDevice; + std::shared_ptr core; + std::shared_ptr function; + ov::CompiledModel executableNetwork; + ov::InferRequest inferRequest; + + ReferenceMemoryTest() : targetDevice("TEMPLATE"), function(), executableNetwork(), inferRequest() { + core = ov::test::utils::PluginCache::get().core(targetDevice); + }; + + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params.m_input_shape, params.m_input_type, params.m_variable_id); + executableNetwork = core->compile_model(function, targetDevice); + inferRequest = executableNetwork.create_infer_request(); + } + + void CommonTestSteps(const std::function& custom_step = nullptr) { + auto params = GetParam(); + + const auto& functionParams = function->get_parameters(); + inferRequest.set_tensor(executableNetwork.input(0), params.m_input_data); + for (size_t i = 0; i < params.m_count_runs; ++i) { + if (custom_step) { + custom_step(i, inferRequest); + } + inferRequest.infer(); + auto actualOutData = inferRequest.get_tensor(executableNetwork.output(0)); + reference_tests::CommonReferenceTest::ValidateBlobs(params.m_expected_data_vector[i], + actualOutData, + i, + 1e-2f, + -1.f, + 0); + } + } + + virtual std::shared_ptr CreateFunction(const ov::Shape& input_shape, + const ov::element::Type& input_type, + const std::vector& variable_id) = 0; +}; + +std::shared_ptr CreateFunction_ReadValueAssingAdd(const ov::Shape& input_shape, + const ov::element::Type& input_type, + const std::vector& variable_id) { + auto in = std::make_shared(input_type, input_shape); + auto c = std::make_shared(input_type, input_shape, 0); + auto variable = std::make_shared( + ov::op::util::VariableInfo{ov::PartialShape::dynamic(), ov::element::dynamic, variable_id[0]}); + auto read_value = std::make_shared(c, variable); + auto add = std::make_shared(in, read_value); + auto assign = std::make_shared(add, variable); + return std::make_shared(ov::OutputVector{assign}, + ov::ParameterVector{in}, + ov::op::util::VariableVector{variable}); +} + +std::shared_ptr CreateFunction_ReadValueAssingAddMultiVariable(const ov::Shape& input_shape, + const ov::element::Type& input_type, + const std::vector& variable_id) { + auto in = std::make_shared(input_type, input_shape); + auto variable1 = std::make_shared( + ov::op::util::VariableInfo{ov::PartialShape::dynamic(), ov::element::dynamic, variable_id[0]}); + auto variable2 = std::make_shared( + ov::op::util::VariableInfo{ov::PartialShape::dynamic(), ov::element::dynamic, variable_id[1]}); + auto read_value1 = std::make_shared(in, variable1); + auto read_value2 = std::make_shared(in, variable2); + auto add1 = std::make_shared(read_value1, read_value2); + auto add2 = std::make_shared(in, add1); + auto assign1 = std::make_shared(add2, variable1); + auto assign2 = std::make_shared(read_value2, variable2); + return std::make_shared(ov::OutputVector{assign1}, + ov::SinkVector{assign2}, + ov::ParameterVector{in}, + ov::op::util::VariableVector{variable1, variable2}); +} + +class ReferenceReadValueAssignAddLayerTest : public ReferenceMemoryTest { +protected: + std::shared_ptr CreateFunction(const ov::Shape& input_shape, + const ov::element::Type& input_type, + const std::vector& variable_id) override { + return CreateFunction_ReadValueAssingAdd(input_shape, input_type, variable_id); + } +}; + +TEST_P(ReferenceReadValueAssignAddLayerTest, MemoryWithHardcodedRefs) { + CommonTestSteps(); +} + +template +std::vector generateParamsForReadValueAssignAdd() { + using T = typename ov::element_type_traits::value_type; + size_t count_runs = 10; + + std::vector first_result_shape1 = {1}; + std::vector first_result_shape22 = {1, 2, 3, 4}; + std::vector first_result_shape123 = {1, 2, 3, 4, 5, 6}; + + std::vector new_result_shape1(1, T(0)); + std::vector new_result_shape22(4, T(0)); + std::vector new_result_shape123(6, T(0)); + + std::vector> result_shape1; + std::vector> result_shape22; + std::vector> result_shape123; + + for (size_t i = 0; i < count_runs; i++) { + std::transform(new_result_shape1.begin(), + new_result_shape1.end(), + first_result_shape1.begin(), + new_result_shape1.begin(), + std::plus()); + std::transform(new_result_shape22.begin(), + new_result_shape22.end(), + first_result_shape22.begin(), + new_result_shape22.begin(), + std::plus()); + std::transform(new_result_shape123.begin(), + new_result_shape123.end(), + first_result_shape123.begin(), + new_result_shape123.begin(), + std::plus()); + result_shape1.push_back(new_result_shape1); + result_shape22.push_back(new_result_shape22); + result_shape123.push_back(new_result_shape123); + } + + std::vector params{MemoryTestParams(ov::Shape{1}, + ov::Shape{1}, + IN_ET, + IN_ET, + std::vector{1}, + result_shape1, + count_runs, + {"v0"}), + MemoryTestParams(ov::Shape{2, 2}, + ov::Shape{2, 2}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4}, + result_shape22, + count_runs, + {"v0"}), + MemoryTestParams(ov::Shape{1, 2, 3}, + ov::Shape{1, 2, 3}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4, 5, 6}, + result_shape123, + count_runs, + {"v0"})}; + return params; +} + +std::vector generateCombinedParamsForReadValueAssignAdd() { + const std::vector> allTypeParams{ + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd(), + generateParamsForReadValueAssignAdd()}; + + std::vector combinedParams; + + for (const auto& params : allTypeParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Memory_With_Hardcoded_Refs, + ReferenceReadValueAssignAddLayerTest, + ::testing::ValuesIn(generateCombinedParamsForReadValueAssignAdd()), + ReferenceReadValueAssignAddLayerTest::getTestCaseName); + +class ReferenceReadValueAssignAddMultiVariableLayerTest : public ReferenceMemoryTest { +protected: + std::shared_ptr CreateFunction(const ov::Shape& input_shape, + const ov::element::Type& input_type, + const std::vector& variable_id) override { + return CreateFunction_ReadValueAssingAddMultiVariable(input_shape, input_type, variable_id); + } +}; + +TEST_P(ReferenceReadValueAssignAddMultiVariableLayerTest, MemoryWithHardcodedRefs) { + CommonTestSteps(); +} + +template +std::vector ReadValueAssignAddMultiVariableLayer() { + using T = typename ov::element_type_traits::value_type; + size_t count_runs = 10; + + std::vector first_result_shape1 = {1}; + std::vector first_result_shape22 = {1, 2, 3, 4}; + std::vector first_result_shape123 = {1, 2, 3, 4, 5, 6}; + + std::vector new_result_shape1(1, T(0)); + std::vector new_result_shape22(4, T(0)); + std::vector new_result_shape123(6, T(0)); + + std::vector> result_shape1; + std::vector> result_shape22; + std::vector> result_shape123; + + for (size_t i = 0; i < count_runs; i++) { + std::transform(new_result_shape1.begin(), + new_result_shape1.end(), + first_result_shape1.begin(), + new_result_shape1.begin(), + std::plus()); + std::transform(new_result_shape22.begin(), + new_result_shape22.end(), + first_result_shape22.begin(), + new_result_shape22.begin(), + std::plus()); + std::transform(new_result_shape123.begin(), + new_result_shape123.end(), + first_result_shape123.begin(), + new_result_shape123.begin(), + std::plus()); + result_shape1.push_back(new_result_shape1); + result_shape22.push_back(new_result_shape22); + result_shape123.push_back(new_result_shape123); + } + + std::vector params{MemoryTestParams(ov::Shape{1}, + ov::Shape{1}, + IN_ET, + IN_ET, + std::vector{1}, + result_shape1, + count_runs, + {"v0", "v1"}), + MemoryTestParams(ov::Shape{2, 2}, + ov::Shape{2, 2}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4}, + result_shape22, + count_runs, + {"v0", "v1"}), + MemoryTestParams(ov::Shape{1, 2, 3}, + ov::Shape{1, 2, 3}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4, 5, 6}, + result_shape123, + count_runs, + {"v0", "v1"})}; + return params; +} + +std::vector generateCombinedParamsForReadValueAssignAddMultiVariableLayer() { + const std::vector> allTypeParams{ + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer(), + ReadValueAssignAddMultiVariableLayer()}; + + std::vector combinedParams; + + for (const auto& params : allTypeParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Memory_With_Hardcoded_Refs, + ReferenceReadValueAssignAddMultiVariableLayerTest, + ::testing::ValuesIn(generateCombinedParamsForReadValueAssignAddMultiVariableLayer()), + ReferenceReadValueAssignAddMultiVariableLayerTest::getTestCaseName); + +class ReferenceReadValueAssignAddResetLayerTest : public ReferenceMemoryTest { +protected: + std::shared_ptr CreateFunction(const ov::Shape& input_shape, + const ov::element::Type& input_type, + const std::vector& variable_id) override { + return CreateFunction_ReadValueAssingAdd(input_shape, input_type, variable_id); + } +}; + +TEST_P(ReferenceReadValueAssignAddResetLayerTest, MemoryResetWithHardcodedRefs) { + auto params = GetParam(); + + auto reset_var = [&](size_t iter, ov::InferRequest& inferRequest) { + if (params.m_reset_on_run == iter) { + auto vars = inferRequest.query_state(); + for (auto& var : vars) { + var.reset(); + } + } + }; + CommonTestSteps(reset_var); +} + +template +std::vector generateParamsForReadValueAssignAddReset() { + using T = typename ov::element_type_traits::value_type; + size_t count_runs = 10; + size_t reset_on_run = 5; + + std::vector first_result_shape1 = {1}; + std::vector first_result_shape22 = {1, 2, 3, 4}; + std::vector first_result_shape123 = {1, 2, 3, 4, 5, 6}; + + std::vector new_result_shape1(1, T(0)); + std::vector new_result_shape22(4, T(0)); + std::vector new_result_shape123(6, T(0)); + + std::vector> result_shape1; + std::vector> result_shape22; + std::vector> result_shape123; + + for (size_t i = 0; i < count_runs - reset_on_run; i++) { + std::transform(new_result_shape1.begin(), + new_result_shape1.end(), + first_result_shape1.begin(), + new_result_shape1.begin(), + std::plus()); + std::transform(new_result_shape22.begin(), + new_result_shape22.end(), + first_result_shape22.begin(), + new_result_shape22.begin(), + std::plus()); + std::transform(new_result_shape123.begin(), + new_result_shape123.end(), + first_result_shape123.begin(), + new_result_shape123.begin(), + std::plus()); + result_shape1.push_back(new_result_shape1); + result_shape22.push_back(new_result_shape22); + result_shape123.push_back(new_result_shape123); + } + + new_result_shape1 = std::vector(1, T(0)); + new_result_shape22 = std::vector(4, T(0)); + new_result_shape123 = std::vector(6, T(0)); + + for (size_t i = count_runs - reset_on_run; i < count_runs; i++) { + std::transform(new_result_shape1.begin(), + new_result_shape1.end(), + first_result_shape1.begin(), + new_result_shape1.begin(), + std::plus()); + std::transform(new_result_shape22.begin(), + new_result_shape22.end(), + first_result_shape22.begin(), + new_result_shape22.begin(), + std::plus()); + std::transform(new_result_shape123.begin(), + new_result_shape123.end(), + first_result_shape123.begin(), + new_result_shape123.begin(), + std::plus()); + result_shape1.push_back(new_result_shape1); + result_shape22.push_back(new_result_shape22); + result_shape123.push_back(new_result_shape123); + } + + std::vector params{MemoryTestParams(ov::Shape{1}, + ov::Shape{1}, + IN_ET, + IN_ET, + std::vector{1}, + result_shape1, + count_runs, + {"v0"}, + reset_on_run), + MemoryTestParams(ov::Shape{2, 2}, + ov::Shape{2, 2}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4}, + result_shape22, + count_runs, + {"v0"}, + reset_on_run), + MemoryTestParams(ov::Shape{1, 2, 3}, + ov::Shape{1, 2, 3}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4, 5, 6}, + result_shape123, + count_runs, + {"v0"}, + reset_on_run)}; + return params; +} + +std::vector generateCombinedParamsForReadValueAssignAddReset() { + const std::vector> allTypeParams{ + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset(), + generateParamsForReadValueAssignAddReset()}; + + std::vector combinedParams; + + for (const auto& params : allTypeParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Memory_With_Hardcoded_Refs, + ReferenceReadValueAssignAddResetLayerTest, + ::testing::ValuesIn(generateCombinedParamsForReadValueAssignAddReset()), + ReferenceReadValueAssignAddResetLayerTest::getTestCaseName); + + +class ReferenceReadValueAssignAddModifyLayerTest : public ReferenceMemoryTest { +protected: + std::shared_ptr CreateFunction(const ov::Shape& input_shape, + const ov::element::Type& input_type, + const std::vector& variable_id) override { + return CreateFunction_ReadValueAssingAdd(input_shape, input_type, variable_id); + } +}; + +TEST_P(ReferenceReadValueAssignAddModifyLayerTest, MemoryResetWithHardcodedRefs) { + auto params = GetParam(); + + auto reset_var = [&](size_t iter, ov::InferRequest& inferRequest) { + if (params.m_reset_on_run == iter) { + auto vars = inferRequest.query_state(); + for (auto& var : vars) { + var.set_state(params.m_input_data); + } + } + }; + CommonTestSteps(reset_var); +} + +template +std::vector generateParamsForReadValueAssignAddModify() { + using T = typename ov::element_type_traits::value_type; + size_t count_runs = 10; + size_t reset_on_run = 5; + + std::vector first_result_shape1 = {1}; + std::vector first_result_shape22 = {1, 2, 3, 4}; + std::vector first_result_shape123 = {1, 2, 3, 4, 5, 6}; + + std::vector new_result_shape1(1, T(0)); + std::vector new_result_shape22(4, T(0)); + std::vector new_result_shape123(6, T(0)); + + std::vector> result_shape1; + std::vector> result_shape22; + std::vector> result_shape123; + + for (size_t i = 0; i < count_runs - reset_on_run; i++) { + std::transform(new_result_shape1.begin(), + new_result_shape1.end(), + first_result_shape1.begin(), + new_result_shape1.begin(), + std::plus()); + std::transform(new_result_shape22.begin(), + new_result_shape22.end(), + first_result_shape22.begin(), + new_result_shape22.begin(), + std::plus()); + std::transform(new_result_shape123.begin(), + new_result_shape123.end(), + first_result_shape123.begin(), + new_result_shape123.begin(), + std::plus()); + result_shape1.push_back(new_result_shape1); + result_shape22.push_back(new_result_shape22); + result_shape123.push_back(new_result_shape123); + } + + new_result_shape1 = std::vector(1, T(0)); + new_result_shape22 = std::vector(4, T(0)); + new_result_shape123 = std::vector(6, T(0)); + + std::transform(new_result_shape1.begin(), + new_result_shape1.end(), + first_result_shape1.begin(), + new_result_shape1.begin(), + std::plus()); + std::transform(new_result_shape22.begin(), + new_result_shape22.end(), + first_result_shape22.begin(), + new_result_shape22.begin(), + std::plus()); + std::transform(new_result_shape123.begin(), + new_result_shape123.end(), + first_result_shape123.begin(), + new_result_shape123.begin(), + std::plus()); + + for (size_t i = count_runs - reset_on_run; i < count_runs; i++) { + std::transform(new_result_shape1.begin(), + new_result_shape1.end(), + first_result_shape1.begin(), + new_result_shape1.begin(), + std::plus()); + std::transform(new_result_shape22.begin(), + new_result_shape22.end(), + first_result_shape22.begin(), + new_result_shape22.begin(), + std::plus()); + std::transform(new_result_shape123.begin(), + new_result_shape123.end(), + first_result_shape123.begin(), + new_result_shape123.begin(), + std::plus()); + result_shape1.push_back(new_result_shape1); + result_shape22.push_back(new_result_shape22); + result_shape123.push_back(new_result_shape123); + } + + std::vector params{MemoryTestParams(ov::Shape{1}, + ov::Shape{1}, + IN_ET, + IN_ET, + std::vector{1}, + result_shape1, + count_runs, + {"v0"}, + reset_on_run), + MemoryTestParams(ov::Shape{2, 2}, + ov::Shape{2, 2}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4}, + result_shape22, + count_runs, + {"v0"}, + reset_on_run), + MemoryTestParams(ov::Shape{1, 2, 3}, + ov::Shape{1, 2, 3}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4, 5, 6}, + result_shape123, + count_runs, + {"v0"}, + reset_on_run)}; + return params; +} + +std::vector generateCombinedParamsForReadValueAssignAddModify() { + const std::vector> allTypeParams{ + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify(), + generateParamsForReadValueAssignAddModify()}; + + std::vector combinedParams; + + for (const auto& params : allTypeParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Memory_With_Hardcoded_Refs, + ReferenceReadValueAssignAddModifyLayerTest, + ::testing::ValuesIn(generateCombinedParamsForReadValueAssignAddModify()), + ReferenceReadValueAssignAddModifyLayerTest::getTestCaseName); + + +class ReferenceReadValueAssignAddMultiVariableModifyLayerTest : public ReferenceMemoryTest { +protected: + std::shared_ptr CreateFunction(const ov::Shape& input_shape, + const ov::element::Type& input_type, + const std::vector& variable_id) override { + return CreateFunction_ReadValueAssingAddMultiVariable(input_shape, input_type, variable_id); + } +}; + +TEST_P(ReferenceReadValueAssignAddMultiVariableModifyLayerTest, MemoryResetWithHardcodedRefs) { + auto params = GetParam(); + + auto reset_var = [&](size_t iter, ov::InferRequest& inferRequest) { + if (params.m_reset_on_run == iter) { + auto vars = inferRequest.query_state(); + vars[1].set_state(params.m_input_data); + } + }; + CommonTestSteps(reset_var); +} + +template +std::vector generateParamsForReadValueAssignAddMultiVariableModify() { + using T = typename ov::element_type_traits::value_type; + size_t count_runs = 10; + size_t reset_on_run = 5; + + std::vector first_result_shape1 = {1}; + std::vector first_result_shape22 = {1, 2, 3, 4}; + std::vector first_result_shape123 = {1, 2, 3, 4, 5, 6}; + + std::vector new_result_shape1(1, T(0)); + std::vector new_result_shape22(4, T(0)); + std::vector new_result_shape123(6, T(0)); + + std::vector> result_shape1; + std::vector> result_shape22; + std::vector> result_shape123; + + for (size_t i = 0; i < count_runs - reset_on_run; i++) { + std::transform(new_result_shape1.begin(), + new_result_shape1.end(), + first_result_shape1.begin(), + new_result_shape1.begin(), + std::plus()); + std::transform(new_result_shape22.begin(), + new_result_shape22.end(), + first_result_shape22.begin(), + new_result_shape22.begin(), + std::plus()); + std::transform(new_result_shape123.begin(), + new_result_shape123.end(), + first_result_shape123.begin(), + new_result_shape123.begin(), + std::plus()); + result_shape1.push_back(new_result_shape1); + result_shape22.push_back(new_result_shape22); + result_shape123.push_back(new_result_shape123); + } + + std::transform(first_result_shape1.begin(), + first_result_shape1.end(), + first_result_shape1.begin(), + first_result_shape1.begin(), + std::plus()); + std::transform(first_result_shape22.begin(), + first_result_shape22.end(), + first_result_shape22.begin(), + first_result_shape22.begin(), + std::plus()); + std::transform(first_result_shape123.begin(), + first_result_shape123.end(), + first_result_shape123.begin(), + first_result_shape123.begin(), + std::plus()); + + for (size_t i = count_runs - reset_on_run; i < count_runs; i++) { + std::transform(new_result_shape1.begin(), + new_result_shape1.end(), + first_result_shape1.begin(), + new_result_shape1.begin(), + std::plus()); + std::transform(new_result_shape22.begin(), + new_result_shape22.end(), + first_result_shape22.begin(), + new_result_shape22.begin(), + std::plus()); + std::transform(new_result_shape123.begin(), + new_result_shape123.end(), + first_result_shape123.begin(), + new_result_shape123.begin(), + std::plus()); + result_shape1.push_back(new_result_shape1); + result_shape22.push_back(new_result_shape22); + result_shape123.push_back(new_result_shape123); + } + + std::vector params{MemoryTestParams(ov::Shape{1}, + ov::Shape{1}, + IN_ET, + IN_ET, + std::vector{1}, + result_shape1, + count_runs, + {"v0", "v1"}, + reset_on_run), + MemoryTestParams(ov::Shape{2, 2}, + ov::Shape{2, 2}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4}, + result_shape22, + count_runs, + {"v0", "v1"}, + reset_on_run), + MemoryTestParams(ov::Shape{1, 2, 3}, + ov::Shape{1, 2, 3}, + IN_ET, + IN_ET, + std::vector{1, 2, 3, 4, 5, 6}, + result_shape123, + count_runs, + {"v0", "v1"}, + reset_on_run)}; + return params; +} + +std::vector generateCombinedParamsForReadValueAssignAddMultiVariableModify() { + const std::vector> allTypeParams{ + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify(), + generateParamsForReadValueAssignAddMultiVariableModify()}; + + std::vector combinedParams; + + for (const auto& params : allTypeParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Memory_With_Hardcoded_Refs, + ReferenceReadValueAssignAddMultiVariableModifyLayerTest, + ::testing::ValuesIn(generateCombinedParamsForReadValueAssignAddMultiVariableModify()), + ReferenceReadValueAssignAddMultiVariableModifyLayerTest::getTestCaseName); +} // namespace