[core] Tensor::data member preserve constness of tensor

src/core/include/openvino/runtime/tensor.hpp

@@ -197,23 +197,33 @@ class OPENVINO_API Tensor {
     Strides get_strides() const;
 
     /**
-     * @brief Provides an access to the underlaying host memory
+     * @brief Provides an access to the underlying host memory
      * @param type Optional type parameter.
      * @note If type parameter is specified, the method throws an exception
      * if specified type's fundamental type does not match with tensor element type's fundamental type
      * @return A host pointer to tensor memory
+     * @{
      */
-    void* data(const element::Type& type = {}) const;
+    const void* data(const element::Type& type = {}) const;
+    void* data(const element::Type& type = {});
+    /// @}
 
     /**
-     * @brief Provides an access to the underlaying host memory casted to type `T`
+     * @brief Provides an access to the underlying host memory casted to type `T`
      * @return A host pointer to tensor memory casted to specified type `T`.
      * @note Throws exception if specified type does not match with tensor element type
+     * @{
      */
-    template <typename T, typename datatype = typename std::decay<T>::type>
-    T* data() const {
+    template <typename T, typename datatype = std::decay_t<T>>
+    const T* data() const {
+        return static_cast<const T*>(data(element::from<datatype>()));
+    }
+
+    template <typename T, typename datatype = std::decay_t<T>>
+    T* data() {
         return static_cast<T*>(data(element::from<datatype>()));
     }
+    /// @}
 
     /**
      * @brief Checks if current Tensor object is not initialized
@@ -234,7 +244,7 @@ class OPENVINO_API Tensor {
      * @return true if this object can be dynamically cast to the type const T*. Otherwise, false
      */
     template <typename T>
-    typename std::enable_if<std::is_base_of<Tensor, T>::value, bool>::type is() const noexcept {
+    std::enable_if_t<std::is_base_of_v<Tensor, T>, bool> is() const noexcept {
         try {
             T::type_check(*this);
         } catch (...) {
@@ -250,7 +260,7 @@ class OPENVINO_API Tensor {
      * @return T object
      */
     template <typename T>
-    const typename std::enable_if<std::is_base_of<Tensor, T>::value, T>::type as() const {
+    const std::enable_if_t<std::is_base_of_v<Tensor, T>, T> as() const {
         T::type_check(*this);
         return *static_cast<const T*>(this);
     }

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

@@ -803,7 +803,7 @@ void interpolate(const T* input_data,
 }
 
 template <typename T>
-void interpolate(T* input_data,
+void interpolate(const T* input_data,
                  const PartialShape& input_data_shape,
                  T* out,
                  const Shape& out_shape,
@@ -817,7 +817,7 @@ void interpolate(T* input_data,
     size_t bytes_in_padded_input = shape_size(padded_input_shape) * sizeof(T);
     std::vector<uint8_t> padded_input_data(bytes_in_padded_input, 0);
     uint8_t* padded_data_ptr = padded_input_data.data();
-    pad_input_data(reinterpret_cast<uint8_t*>(input_data),
+    pad_input_data(reinterpret_cast<const uint8_t*>(input_data),
                    padded_data_ptr,
                    sizeof(T),
                    input_data_shape.to_shape(),

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

@@ -89,7 +89,7 @@ void mvn_6(const T* arg,
 
 template <typename T>
 AxisSet mvn_6_reduction_axes(const ov::Tensor& axes_input, size_t rank) {
-    T* a = axes_input.data<T>();
+    const T* a = axes_input.data<T>();
     auto v = std::vector<T>(a, a + axes_input.get_shape()[0]);
     std::vector<size_t> axes(v.size(), 0);
     for (size_t i = 0; i < v.size(); i++) {

src/core/reference/src/op/loop.cpp

@@ -113,7 +113,7 @@ void loop(const std::shared_ptr<Model>& func,
                     pointers_to_data[slice_desc->m_stride > 0 ? j : (pointers_to_data.size() - j - 1)] =
                         static_cast<char*>(sliced_values[slice_in_idx][j].data());
                 }
-                reference::split(static_cast<char*>(args[slice_desc->m_input_index].data()),
+                reference::split(static_cast<const char*>(args[slice_desc->m_input_index].data()),
                                  args[slice_desc->m_input_index].get_shape(),
                                  el_size,
                                  slice_desc->m_axis,
@@ -211,7 +211,7 @@ void loop(const std::shared_ptr<Model>& func,
             std::vector<const char*> pointers_on_values;
             pointers_on_values.reserve(values_to_concat[i].size());
             for (const auto& vec : values_to_concat[i]) {
-                pointers_on_values.push_back(static_cast<char*>(vec.data()));
+                pointers_on_values.push_back(static_cast<const char*>(vec.data()));
             }
             reference::concat(pointers_on_values,
                               static_cast<char*>(out[concat_desc->m_output_index].data()),

src/core/reference/src/op/tensor_iterator.cpp

@@ -64,7 +64,7 @@ void tensor_iterator(uint64_t num_iterations,
                 pointers_to_data[slice_desc->m_stride > 0 ? j : (pointers_to_data.size() - j - 1)] =
                     static_cast<char*>(sliced_values[slice_in_idx][j].data());
             }
-            reference::split(static_cast<char*>(args[slice_desc->m_input_index].data()),
+            reference::split(static_cast<const char*>(args[slice_desc->m_input_index].data()),
                              args[slice_desc->m_input_index].get_shape(),
                              el_size,
                              slice_desc->m_axis,

src/core/src/bound_evaluate.cpp

@@ -453,7 +453,7 @@ bool ov::interval_bound_evaluator(const Node* node,
                node->evaluate(lower_output_values, *input_variants.begin());
 
     auto zero = op::v0::Constant::create(element::i64, {1}, {0});
-    const auto zero_t = ov::Tensor(element::i64, Shape{});
+    auto zero_t = ov::Tensor(element::i64, Shape{});
     *zero_t.data<int64_t>() = 0;
 
     std::vector<TensorVector> unsqueezed_output_variants;
@@ -529,8 +529,8 @@ bool ov::interval_bound_evaluator(const Node* node,
             fully_defined = false;
         } else {
             // Can not set to make_tensor_of_min_value(lower_output_values[i]->get_element_type()) yet
-            const auto then = Tensor{lower_out[0].get_element_type(), Shape{}};
-            const auto then_data = static_cast<char*>(then.data());
+            auto then = Tensor{lower_out[0].get_element_type(), Shape{}};
+            auto then_data = static_cast<char*>(then.data());
             std::memset(then_data, 0, then.get_byte_size());
             op::v1::Select().evaluate(lower_out, {final_input_dyn_mask, then, lower_out[0]});
             node->get_output_tensor(i).set_lower_value(lower_out[0]);

src/core/src/op/constant.cpp

@@ -207,8 +207,10 @@ Constant::Constant(const Tensor& tensor)
     : m_element_type{tensor.get_element_type()},
       m_shape{tensor.get_shape()},
       m_byte_strides{m_element_type.bitwidth() >= 8 ? tensor.get_strides() : Strides{}},
-      m_data{
-          std::make_shared<SharedBuffer<Tensor>>(static_cast<char*>(tensor.data()), tensor.get_byte_size(), tensor)} {
+      // cast is for internal use only to store tensor data in shared buffer (not for modification)
+      m_data{std::make_shared<SharedBuffer<Tensor>>(const_cast<char*>(static_cast<const char*>(tensor.data())),
+                                                    tensor.get_byte_size(),
+                                                    tensor)} {
     constructor_validate_and_infer_types();
 }
 

src/core/src/op/convert.cpp

@@ -57,7 +57,7 @@ struct Evaluate : public element::NoAction<bool> {
                           CONVERT_ET_LIST,
                           EvalByOutputType,
                           out.get_element_type(),
-                          iterator<ET_IN>(reinterpret_cast<const TI*>(arg.data())),
+                          iterator<ET_IN>(arg.data()),
                           out,
                           count);
     }

src/core/src/op/depth_to_space.cpp

@@ -51,7 +51,7 @@ bool DepthToSpace::evaluate(TensorVector& outputs, const TensorVector& inputs) c
     OPENVINO_ASSERT(outputs.size() == 1);
 
     const auto& in = inputs[0];
-    const auto& out = outputs[0];
+    auto& out = outputs[0];
     reference::depth_to_space(static_cast<const char*>(in.data()),
                               in.get_shape(),
                               static_cast<char*>(out.data()),

src/core/src/op/divide.cpp

@@ -94,7 +94,7 @@ bool evaluate_bound(const Node* node, TensorVector& output_values, bool is_upper
         return false;
 
     const auto zeros_const = Constant::create(input2.get_element_type(), {}, {0});
-    const auto zero_t = Tensor(input2.get_element_type(), Shape{});
+    auto zero_t = Tensor(input2.get_element_type(), Shape{});
     memcpy(zero_t.data(), zeros_const->get_data_ptr(), zero_t.get_byte_size());
 
     const auto max_value = ov::util::make_tensor_of_max_value(input2.get_element_type());
@@ -172,7 +172,7 @@ bool evaluate_bound(const Node* node, TensorVector& output_values, bool is_upper
 
         // replace zeros by 1 values to get result of divide for other values of arguments
         const auto ones = Constant::create(input2.get_element_type(), input2.get_shape(), {1});
-        const auto ones_t = Tensor(ones->get_element_type(), ones->get_shape());
+        auto ones_t = Tensor(ones->get_element_type(), ones->get_shape());
         memcpy(ones_t.data(), ones->get_data_ptr(), ones_t.get_byte_size());
 
         status = Select().evaluate(value2_outs, {input2_zeros_mask, ones_t, value2});

src/core/src/op/roi_align.cpp

@@ -162,7 +162,7 @@ template <element::Type_t ET>
 bool evaluate(const Tensor& feature_maps,
               const Tensor& rois,
               const std::vector<int64_t>& batch_indices_vec_scaled_up,
-              const Tensor& out,
+              Tensor& out,
               const int pooled_height,
               const int pooled_width,
               const int sampling_ratio,
@@ -189,7 +189,7 @@ bool evaluate(const Tensor& feature_maps,
 }
 
 bool evaluate(const TensorVector& args,
-              const Tensor& out,
+              Tensor& out,
               const int pooled_height,
               const int pooled_width,
               const int sampling_ratio,

src/core/src/op/space_to_batch.cpp

@@ -74,7 +74,7 @@ namespace space_to_batch {
 namespace {
 bool evaluate(TensorVector& outputs, const TensorVector& inputs) {
     const auto& data = inputs[0];
-    const auto& out = outputs[0];
+    auto& out = outputs[0];
     const auto elem_size = data.get_element_type().size();
 
     auto data_shape = data.get_shape();

src/core/src/op/space_to_depth.cpp

@@ -55,7 +55,7 @@ bool SpaceToDepth::evaluate(TensorVector& outputs, const TensorVector& inputs) c
     OPENVINO_ASSERT(outputs.size() == 1);
 
     const auto& in = inputs[0];
-    const auto& out = outputs[0];
+    auto& out = outputs[0];
     reference::space_to_depth(static_cast<const char*>(in.data()),
                               in.get_shape(),
                               static_cast<char*>(out.data()),

src/core/src/op/split.cpp

@@ -91,7 +91,7 @@ bool Split::evaluate(TensorVector& outputs, const TensorVector& inputs) const {
         auto axis = get_tensor_data_as<int64_t>(axis_tensor).front();
         axis = ov::util::normalize(axis, data_tensor.get_shape().size());
 
-        ov::reference::split(static_cast<char*>(data_tensor.data()),
+        ov::reference::split(static_cast<const char*>(data_tensor.data()),
                              data_tensor.get_shape(),
                              data_tensor.get_element_type().size(),
                              axis,

src/core/src/op/transpose.cpp

@@ -96,7 +96,8 @@ bool Transpose::evaluate(TensorVector& outputs, const TensorVector& inputs) cons
         };
 
         auto out_ptr = int4_iterator(static_cast<uint8_t*>(out.data()));
-        auto in_ptr = int4_iterator(static_cast<uint8_t*>(arg.data()));
+        // The int4_iterator not supports const pointer but these data are not modified
+        auto in_ptr = int4_iterator(static_cast<uint8_t*>(const_cast<void*>(arg.data())));
         if ((arg_type == ov::element::i4 || arg_type == ov::element::u4) && arg.get_shape().size() == 2) {
             for (size_t i = 0; i < out_shape[0]; i++) {
                 size_t off = i;

src/core/src/op/util/pad_base.cpp

@@ -106,7 +106,7 @@ bool op::util::PadBase::evaluate_pad(TensorVector& outputs, const TensorVector&
     const char* pad_value = nullptr;
     const std::vector<char> pad_zero_value(elem_size, 0);
     if (get_input_size() == 4) {
-        pad_value = static_cast<char*>(inputs[3].data());
+        pad_value = static_cast<const char*>(inputs[3].data());
     } else {
         pad_value = pad_zero_value.data();
     }
@@ -127,7 +127,7 @@ bool op::util::PadBase::evaluate_pad(TensorVector& outputs, const TensorVector&
     }
     outputs[0].set_shape(padded_shape);
 
-    ov::reference::pad(static_cast<char*>(inputs[0].data()),
+    ov::reference::pad(static_cast<const char*>(inputs[0].data()),
                        pad_value,
                        static_cast<char*>(outputs[0].data()),
                        elem_size,

src/core/src/runtime/tensor.cpp

@@ -96,7 +96,11 @@ size_t Tensor::get_byte_size() const {
     OV_TENSOR_STATEMENT(return _impl->get_byte_size(););
 }
 
-void* Tensor::data(const element::Type& element_type) const {
+void* Tensor::data(const element::Type& element_type) {
+    OV_TENSOR_STATEMENT(return _impl->data(element_type));
+}
+
+const void* Tensor::data(const element::Type& element_type) const {
     OV_TENSOR_STATEMENT(return _impl->data(element_type));
 }
 

src/core/tests/ov_tensor_test.cpp

@@ -903,8 +903,8 @@ void compare_data(const ov::Tensor& src, const ov::Tensor& dst) {
 template <ov::element::Type_t ET,
           typename T = typename ov::element_type_traits<ET>::value_type,
           typename std::enable_if<ET != ov::element::Type_t::string, bool>::type = true>
-void init_tensor(const ov::Tensor& tensor, bool input) {
-    const auto origPtr = tensor.data<T>();
+void init_tensor(ov::Tensor& tensor, bool input) {
+    auto origPtr = tensor.data<T>();
     ASSERT_NE(nullptr, origPtr);
     for (size_t i = 0; i < tensor.get_size(); ++i) {
         origPtr[i] = static_cast<T>(input ? i : -1);
@@ -914,15 +914,15 @@ void init_tensor(const ov::Tensor& tensor, bool input) {
 template <ov::element::Type_t ET,
           typename T = typename ov::element_type_traits<ET>::value_type,
           typename std::enable_if<ET == ov::element::Type_t::string, bool>::type = true>
-void init_tensor(const ov::Tensor& tensor, bool input) {
+void init_tensor(ov::Tensor& tensor, bool input) {
     const auto origPtr = tensor.data<T>();
     ASSERT_NE(nullptr, origPtr);
     for (size_t i = 0; i < tensor.get_size(); ++i) {
         origPtr[i] = std::to_string(i);
     }
 }
 
-void init_tensor(const ov::Tensor& tensor, bool input) {
+void init_tensor(ov::Tensor& tensor, bool input) {
     switch (tensor.get_element_type()) {
     case ov::element::bf16:
         init_tensor<ov::element::bf16>(tensor, input);

src/core/tests/utils/eval_utils.hpp

@@ -11,7 +11,7 @@
 
 namespace {
 template <typename T>
-void copy_data(const ov::Tensor& tv, const std::vector<T>& data) {
+void copy_data(ov::Tensor& tv, const std::vector<T>& data) {
     size_t data_size = data.size() * sizeof(T);
     if (data_size > 0) {
         OPENVINO_ASSERT(tv.get_byte_size() >= data_size);
@@ -21,13 +21,13 @@ void copy_data(const ov::Tensor& tv, const std::vector<T>& data) {
 }
 
 template <>
-inline void copy_data<bool>(const ov::Tensor& tv, const std::vector<bool>& data) {
+inline void copy_data<bool>(ov::Tensor& tv, const std::vector<bool>& data) {
     std::vector<char> data_char(data.begin(), data.end());
     copy_data(tv, data_char);
 }
 
 template <typename T>
-void init_int_tv(const ov::Tensor& tv, std::default_random_engine& engine, T min, T max) {
+void init_int_tv(ov::Tensor& tv, std::default_random_engine& engine, T min, T max) {
     size_t size = tv.get_size();
     std::uniform_int_distribution<T> dist(min, max);
     std::vector<T> vec(size);
@@ -40,7 +40,7 @@ void init_int_tv(const ov::Tensor& tv, std::default_random_engine& engine, T min
 }
 
 template <>
-inline void init_int_tv<char>(const ov::Tensor& tv, std::default_random_engine& engine, char min, char max) {
+inline void init_int_tv<char>(ov::Tensor& tv, std::default_random_engine& engine, char min, char max) {
     size_t size = tv.get_size();
     std::uniform_int_distribution<int16_t> dist(static_cast<short>(min), static_cast<short>(max));
     std::vector<char> vec(size);
@@ -53,7 +53,7 @@ inline void init_int_tv<char>(const ov::Tensor& tv, std::default_random_engine&
 }
 
 template <>
-inline void init_int_tv<int8_t>(const ov::Tensor& tv, std::default_random_engine& engine, int8_t min, int8_t max) {
+inline void init_int_tv<int8_t>(ov::Tensor& tv, std::default_random_engine& engine, int8_t min, int8_t max) {
     size_t size = tv.get_size();
     std::uniform_int_distribution<int16_t> dist(static_cast<short>(min), static_cast<short>(max));
     std::vector<int8_t> vec(size);
@@ -66,7 +66,7 @@ inline void init_int_tv<int8_t>(const ov::Tensor& tv, std::default_random_engine
 }
 
 template <>
-inline void init_int_tv<uint8_t>(const ov::Tensor& tv, std::default_random_engine& engine, uint8_t min, uint8_t max) {
+inline void init_int_tv<uint8_t>(ov::Tensor& tv, std::default_random_engine& engine, uint8_t min, uint8_t max) {
     size_t size = tv.get_size();
     std::uniform_int_distribution<int16_t> dist(static_cast<short>(min), static_cast<short>(max));
     std::vector<uint8_t> vec(size);
@@ -79,7 +79,7 @@ inline void init_int_tv<uint8_t>(const ov::Tensor& tv, std::default_random_engin
 }
 
 template <typename T>
-void init_real_tv(const ov::Tensor& tv, std::default_random_engine& engine, T min, T max) {
+void init_real_tv(ov::Tensor& tv, std::default_random_engine& engine, T min, T max) {
     size_t size = tv.get_size();
     std::uniform_real_distribution<T> dist(min, max);
     std::vector<T> vec(size);
@@ -91,7 +91,7 @@ void init_real_tv(const ov::Tensor& tv, std::default_random_engine& engine, T mi
     memcpy(tv.data(), vec.data(), data_size);
 }
 
-inline void random_init(const ov::Tensor& tv, std::default_random_engine& engine) {
+inline void random_init(ov::Tensor& tv, std::default_random_engine& engine) {
     ov::element::Type et = tv.get_element_type();
     if (et == ov::element::boolean) {
         init_int_tv<char>(tv, engine, 0, 1);

src/inference/src/dev/compilation_context.cpp

@@ -109,7 +109,7 @@ std::string ModelCache::compute_hash(const std::string& modelStr,
     if (tensor) {
         seed = hash_combine(seed, tensor.get_size());
 
-        auto ptr = static_cast<size_t*>(tensor.data());
+        auto ptr = static_cast<const size_t*>(tensor.data());
         size_t size = tensor.get_size() / sizeof(size_t);
 
         // 10MB block size in size_t
@@ -141,7 +141,7 @@ std::string ModelCache::compute_hash(const std::string& modelStr,
         }
 
         auto size_done = size * sizeof(size_t);
-        auto ptr_left = static_cast<uint8_t*>(tensor.data()) + size_done;
+        auto ptr_left = static_cast<const uint8_t*>(tensor.data()) + size_done;
         size_t size_left = tensor.get_size() - size_done;
         for (size_t i = 0; i < size_left; i++)
             seed = hash_combine(seed, ptr_left[i]);

src/inference/src/model_reader.cpp

@@ -175,7 +175,7 @@ std::shared_ptr<ov::Model> read_model(const std::string& model,
     ov::AnyVector params{&modelStream};
     if (weights) {
         std::shared_ptr<ov::AlignedBuffer> weights_buffer =
-            std::make_shared<ov::SharedBuffer<ov::Tensor>>(reinterpret_cast<char*>(weights.data()),
+            std::make_shared<ov::SharedBuffer<ov::Tensor>>(reinterpret_cast<char*>(const_cast<void*>(weights.data())),
                                                            weights.get_byte_size(),
                                                            weights);
         params.emplace_back(weights_buffer);