Re-name some methods and add a new one get_user_state()

Signed-off-by: Bogdan Pereanu <[email protected]>

Author: pereanub

src/plugins/intel_npu/src/backend/include/zero_variable_state.hpp

@@ -32,6 +32,11 @@ class ZeroVariableState final : public ov::IVariableState {
 
     ov::SoPtr<ov::ITensor> get_state() const override;
 
+    /**
+     * @brief Get user state to not change the state of the tensor through get_state()
+     */
+    ov::SoPtr<ov::ITensor> get_user_state() const;
+
     std::shared_ptr<ZeroTensor> get_zero_state() const;
 
     /**
@@ -46,25 +51,25 @@ class ZeroVariableState final : public ov::IVariableState {
     size_t get_related_tensor_index() const;
 
     /**
-     * @brief Get acknowledgment if the tensor was updated
+     * @brief Get acknowledgment if state was updated
      */
-    bool tensor_was_updated() const;
+    bool state_update_pending() const;
 
     /**
-     * @brief Reset tensor updated flag
+     * @brief Reset state updated flag
      */
-    void reset_tensor_updated_flag();
+    void clear_state_update_pending();
 
     /**
-     * @brief Get acknowledgment if the zero tensor was updated
-     * @details In case the memory was allocated in the same level zero context update the zero tensor
+     * @brief Get acknowledgment if the zero state was updated
+     * @details In case the memory was allocated in the same level zero context update the zero state
      */
-    bool zero_tensor_should_be_updated() const;
+    bool zero_state_update_pending() const;
 
     /**
-     * @brief Reset zero tensor updated flag
+     * @brief Reset zero state updated flag
      */
-    void reset_zero_tensor_updated_flag();
+    void clear_zero_state_update_pending();
 
     ~ZeroVariableState() override = default;
 
@@ -75,8 +80,8 @@ class ZeroVariableState final : public ov::IVariableState {
 
     std::shared_ptr<ZeroTensor> _zero_state;
 
-    bool _tensor_updated = false;
-    bool _zero_tensor_updated = false;
+    bool _is_state_updated = false;
+    bool _is_zero_state_update_needed = false;
 
     const Config _config;
     Logger _logger;

src/plugins/intel_npu/src/backend/src/zero_infer_request.cpp

@@ -241,19 +241,19 @@ void ZeroInferRequest::create_pipeline() {
         auto zeroState = std::dynamic_pointer_cast<ZeroVariableState>(variableState._ptr);
         OPENVINO_ASSERT(zeroState != nullptr, "State is not compatible with NPU plugin");
 
-        if (zeroState->tensor_was_updated()) {
+        if (zeroState->state_update_pending()) {
             _logger.debug("ZeroInferRequest::create_pipeline - user state tensor should be updated");
 
-            get_user_input(zeroState->get_tensor_index()) = zeroState->get_state();
-            _userOutputTensors.at(zeroState->get_related_tensor_index()) = zeroState->get_state();
-            zeroState->reset_tensor_updated_flag();
+            get_user_input(zeroState->get_tensor_index()) = zeroState->get_user_state();
+            _userOutputTensors.at(zeroState->get_related_tensor_index()) = zeroState->get_user_state();
+            zeroState->clear_state_update_pending();
 
-            if (zeroState->zero_tensor_should_be_updated()) {
+            if (zeroState->zero_state_update_pending()) {
                 _logger.debug("ZeroInferRequest::create_pipeline - level zero state tensor should be updated");
 
                 get_level_zero_input(zeroState->get_tensor_index()) = zeroState->get_zero_state();
                 _levelZeroOutputTensors.at(zeroState->get_related_tensor_index()) = zeroState->get_zero_state();
-                zeroState->reset_zero_tensor_updated_flag();
+                zeroState->clear_zero_state_update_pending();
             }
         }
     }
@@ -639,15 +639,15 @@ void ZeroInferRequest::update_states_if_memory_changed() {
         auto zeroState = std::dynamic_pointer_cast<ZeroVariableState>(variableState._ptr);
         OPENVINO_ASSERT(zeroState != nullptr, "State is not compatible with NPU plugin");
 
-        if (zeroState->tensor_was_updated()) {
-            get_user_input(zeroState->get_tensor_index()) = zeroState->get_state();
-            _userOutputTensors.at(zeroState->get_related_tensor_index()) = zeroState->get_state();
-            zeroState->reset_tensor_updated_flag();
+        if (zeroState->state_update_pending()) {
+            get_user_input(zeroState->get_tensor_index()) = zeroState->get_user_state();
+            _userOutputTensors.at(zeroState->get_related_tensor_index()) = zeroState->get_user_state();
+            zeroState->clear_state_update_pending();
 
-            if (zeroState->zero_tensor_should_be_updated()) {
+            if (zeroState->zero_state_update_pending()) {
                 get_level_zero_input(zeroState->get_tensor_index()) = zeroState->get_zero_state();
                 _levelZeroOutputTensors.at(zeroState->get_related_tensor_index()) = zeroState->get_zero_state();
-                zeroState->reset_zero_tensor_updated_flag();
+                zeroState->clear_zero_state_update_pending();
 
                 _pipeline->update_graph_arguments(_graphInputDescriptors.at(zeroState->get_tensor_index()).idx,
                                                   get_level_zero_input(zeroState->get_tensor_index())->data(),

src/plugins/intel_npu/src/backend/src/zero_variable_state.cpp

@@ -29,16 +29,22 @@ ZeroVariableState::ZeroVariableState(const std::shared_ptr<ZeroInitStructsHolder
 }
 
 void ZeroVariableState::set_state(const ov::SoPtr<ov::ITensor>& new_state) {
+    if (m_state._ptr == new_state._ptr) {
+        // set_tensor called with the same tensor object; no action needed
+        _logger.debug("ZeroVariableState::set_state - got the same state, do nothing");
+        return;
+    }
+
     m_state = new_state;
-    _tensor_updated = true;
+    _is_state_updated = true;
 
     if (_init_structs->getMutableCommandListExtVersion() >= ZE_MAKE_VERSION(1, 0)) {
         try {
             _logger.debug("ZeroVariableState::set_state - create zero tensor");
             // Try to use the user tensor directly if its underlying data is already allocated in the same Level Zero
             // context.
             _zero_state = std::make_shared<ZeroTensor>(_init_structs, m_state, _config);
-            _zero_tensor_updated = true;
+            _is_zero_state_update_needed = true;
         } catch (const ZeroTensorException&) {
             // Check if the current Level Zero tensor was previously shared with the user. If so, it cannot be reused;
             // allocate a new tensor to back up the user tensor (which cannot be imported or used directly).
@@ -49,7 +55,10 @@ void ZeroVariableState::set_state(const ov::SoPtr<ov::ITensor>& new_state) {
                                                            m_state->get_element_type(),
                                                            m_state->get_shape(),
                                                            false);
-                _zero_tensor_updated = true;
+                _is_zero_state_update_needed = true;
+            } else {
+                _logger.debug("ZeroVariableState::set_state - reusing the level zero tensor since it is not shared "
+                              "with the user");
             }
         }
         // If command list updates are not supported, fallback to copying tensors every time.
@@ -65,6 +74,10 @@ ov::SoPtr<ov::ITensor> ZeroVariableState::get_state() const {
     return m_state;
 }
 
+ov::SoPtr<ov::ITensor> ZeroVariableState::get_user_state() const {
+    return m_state;
+}
+
 std::shared_ptr<ZeroTensor> ZeroVariableState::get_zero_state() const {
     return _zero_state;
 }
@@ -84,20 +97,20 @@ size_t ZeroVariableState::get_related_tensor_index() const {
     return _related_tensor_index;
 }
 
-bool ZeroVariableState::tensor_was_updated() const {
-    return _tensor_updated;
+bool ZeroVariableState::state_update_pending() const {
+    return _is_state_updated;
 }
 
-void ZeroVariableState::reset_tensor_updated_flag() {
-    _tensor_updated = false;
+void ZeroVariableState::clear_state_update_pending() {
+    _is_state_updated = false;
 }
 
-bool ZeroVariableState::zero_tensor_should_be_updated() const {
-    return _zero_tensor_updated;
+bool ZeroVariableState::zero_state_update_pending() const {
+    return _is_zero_state_update_needed;
 }
 
-void ZeroVariableState::reset_zero_tensor_updated_flag() {
-    _zero_tensor_updated = false;
+void ZeroVariableState::clear_zero_state_update_pending() {
+    _is_zero_state_update_needed = false;
 }
 
 }  // namespace intel_npu

src/plugins/intel_npu/tests/functional/internal/backend/zero_tensor_tests.cpp

@@ -13,7 +13,7 @@ using namespace ov::test::behavior;
 
 const std::vector<ov::AnyMap> configsInferRequestRunTests = {{}};
 
-INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTest,
+INSTANTIATE_TEST_SUITE_P(compatibility_smoke_BehaviorTest,
                          ZeroTensorTests,
                          ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_NPU),
                                             ::testing::ValuesIn(configsInferRequestRunTests)),

src/plugins/intel_npu/tests/functional/internal/backend/zero_tensor_tests.hpp

@@ -125,13 +125,17 @@ TEST_P(ZeroTensorTests, CheckSetSmallerShape) {
     auto new_shape = Shape{1, 10, 10, 10};
     auto new_shape_size = ov::shape_size(new_shape);
     // Reallocation is not required.
-    zero_tensor->set_shape(new_shape);
-    EXPECT_EQ(new_shape, zero_tensor->get_shape());
-    EXPECT_EQ(new_shape_size, zero_tensor->get_size());
-    EXPECT_EQ(new_shape_size * sizeof(ov::element::f32), zero_tensor->get_byte_size());
-    EXPECT_EQ(data, zero_tensor->data());
-    ASSERT_TRUE(::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
-                                                                                    zero_tensor->data()));
+    if (init_struct->getMutableCommandListExtVersion() >= ZE_MAKE_VERSION(1, 0)) {
+        zero_tensor->set_shape(new_shape);
+        EXPECT_EQ(new_shape, zero_tensor->get_shape());
+        EXPECT_EQ(new_shape_size, zero_tensor->get_size());
+        EXPECT_EQ(new_shape_size * sizeof(ov::element::f32), zero_tensor->get_byte_size());
+        EXPECT_EQ(data, zero_tensor->data());
+        ASSERT_TRUE(::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
+                                                                                        zero_tensor->data()));
+    } else {
+        ASSERT_THROW(zero_tensor->set_shape(new_shape), ov::Exception);
+    }
 }
 
 TEST_P(ZeroTensorTests, CheckSetBiggerShape) {

src/plugins/intel_npu/tests/functional/internal/backend/zero_variable_state_tests.cpp

@@ -13,7 +13,7 @@ using namespace ov::test::behavior;
 
 const std::vector<ov::AnyMap> configsInferRequestRunTests = {{}};
 
-INSTANTIATE_TEST_SUITE_P(smoke_BehaviorTest,
+INSTANTIATE_TEST_SUITE_P(compatibility_smoke_BehaviorTest,
                          ZeroVariableStateTests,
                          ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_NPU),
                                             ::testing::ValuesIn(configsInferRequestRunTests)),

src/plugins/intel_npu/tests/functional/internal/backend/zero_variable_state_tests.hpp

@@ -132,8 +132,8 @@ TEST_P(ZeroVariableStateTests, CreateZeroStateAndUseSetStateWithZeroTensor) {
     ASSERT_TRUE(::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
                                                                                     zero_state->get_state()->data()));
 
-    ASSERT_TRUE(zero_state->tensor_was_updated());
-    ASSERT_TRUE(zero_state->zero_tensor_should_be_updated());
+    ASSERT_TRUE(zero_state->state_update_pending());
+    ASSERT_TRUE(zero_state->zero_state_update_pending());
 
     EXPECT_NE(zero_state->get_state()->data(), zero_tensor0->data());
 
@@ -159,6 +159,9 @@ TEST_P(ZeroVariableStateTests, CreateZeroStateAndUseSetStateWithNormalTensor) {
     auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element::f32, shape, true);
     auto zero_state =
         std::make_shared<::intel_npu::ZeroVariableState>(init_struct, "state", zero_tensor, 1, 1, npu_config);
+    ASSERT_TRUE(
+        ::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
+                                                                            zero_state->get_user_state()->data()));
 
     // shape size is unaligned to standard page size, expect to fail
     auto data = static_cast<float*>(::operator new(ov::shape_size(shape) * sizeof(ov::element::f32)));
@@ -170,8 +173,8 @@ TEST_P(ZeroVariableStateTests, CreateZeroStateAndUseSetStateWithNormalTensor) {
         ::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
                                                                             zero_state->get_zero_state()->data()));
 
-    ASSERT_TRUE(zero_state->tensor_was_updated());
-    ASSERT_FALSE(zero_state->zero_tensor_should_be_updated());
+    ASSERT_TRUE(zero_state->state_update_pending());
+    ASSERT_FALSE(zero_state->zero_state_update_pending());
 
     EXPECT_NE(zero_state->get_state()->data(), zero_tensor->data());
     EXPECT_EQ(zero_state->get_zero_state()->data(), zero_tensor->data());
@@ -211,8 +214,8 @@ TEST_P(ZeroVariableStateTests, CreateZeroStateAndUseSetStateWithNormalTensorAfte
         ::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
                                                                             zero_state->get_zero_state()->data()));
 
-    ASSERT_TRUE(zero_state->tensor_was_updated());
-    ASSERT_TRUE(zero_state->zero_tensor_should_be_updated());
+    ASSERT_TRUE(zero_state->state_update_pending());
+    ASSERT_TRUE(zero_state->zero_state_update_pending());
 
     EXPECT_NE(zero_state->get_state()->data(), zero_tensor->data());
     EXPECT_NE(zero_state->get_zero_state()->data(), zero_tensor->data());
@@ -253,8 +256,8 @@ TEST_P(ZeroVariableStateTests, CreateZeroStateAndUseSetStateWithHostTensor) {
         ::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
                                                                             zero_state->get_zero_state()->data()));
 
-    ASSERT_TRUE(zero_state->tensor_was_updated());
-    ASSERT_TRUE(zero_state->zero_tensor_should_be_updated());
+    ASSERT_TRUE(zero_state->state_update_pending());
+    ASSERT_TRUE(zero_state->zero_state_update_pending());
 
     EXPECT_NE(zero_state->get_state()->data(), zero_tensor->data());
     EXPECT_NE(zero_state->get_zero_state()->data(), zero_tensor->data());
@@ -298,8 +301,8 @@ TEST_P(ZeroVariableStateTests, CreateZeroStateAndUseSetStateWithRemoteTensor) {
         ::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
                                                                             zero_state->get_zero_state()->data()));
 
-    ASSERT_TRUE(zero_state->tensor_was_updated());
-    ASSERT_TRUE(zero_state->zero_tensor_should_be_updated());
+    ASSERT_TRUE(zero_state->state_update_pending());
+    ASSERT_TRUE(zero_state->zero_state_update_pending());
 
     EXPECT_NE(zero_remote_tensor->get_original_memory(), zero_tensor->data());
     EXPECT_NE(zero_state->get_zero_state()->data(), zero_tensor->data());