[Ref_Impl] Change namespace from nG to OV (#19363)

* Use quotes for openvino includes

* Drop runtime from openvino::reference

* Drop runtime::reference

* Replace ngraph::reference with ov::reference - defs

* Replace ngraph::reference with ov::reference - uses

* Drop redundant nesting

* Fix non arch64 builds

* Move coordinate*pp files under openvino

* Move Coordinate... helpers under ov:: namespace

* Revert not needed changes

* Fix missing namespace scope

* Fix compilation

* Fix code style

* Use ov suppress deprecated macro instead of ngraph

---------

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

src/common/offline_transformations/src/pruning/init_const_mask.cpp

@@ -5,10 +5,10 @@
 #include <memory>
 
 #include "mask_attribute.hpp"
-#include "ngraph/coordinate_transform.hpp"
 #include "openvino/op/log.hpp"
 #include "openvino/opsets/opset6.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 #include "pruning.hpp"
 
 ov::pass::InitConstMask::InitConstMask(const ov::AxisSet& dims,
@@ -43,7 +43,7 @@ ov::pass::InitConstMask::InitConstMask(const ov::AxisSet& dims,
 
                 bool skip_dim_value = false;
                 OPENVINO_SUPPRESS_DEPRECATED_START
-                ngraph::CoordinateTransform iter(shape, begin, end);
+                ov::CoordinateTransform iter(shape, begin, end);
                 for (const Coordinate& coord : iter) {
                     if (!condition(values.at(iter.index(coord)))) {
                         skip_dim_value = true;

src/common/offline_transformations/src/pruning/propagate_masks.cpp

@@ -7,7 +7,6 @@
 #include <memory>
 
 #include "mask_attribute.hpp"
-#include "ngraph/coordinate_transform.hpp"
 #include "openvino/core/rt_info.hpp"
 #include "openvino/core/validation_util.hpp"
 #include "openvino/op/gelu.hpp"
@@ -17,6 +16,7 @@
 #include "openvino/op/util/pad_base.hpp"
 #include "openvino/opsets/opset10.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 #include "openvino/util/log.hpp"
 #include "pruning.hpp"
 
@@ -1015,14 +1015,14 @@ struct ChannelsMap {
  *  on unsquized_shape_dim dimension according to unsquized_shape shape.
  */
 OPENVINO_SUPPRESS_DEPRECATED_START
-static ngraph::CoordinateTransform get_channel_iter(const ov::Shape unsquized_shape,
+static ov::CoordinateTransform get_channel_iter(const ov::Shape unsquized_shape,
-                                                    const size_t unsquized_shape_dim,
+                                                const size_t unsquized_shape_dim,
-                                                    const size_t channel) {
+                                                const size_t channel) {
     auto begin = ov::Coordinate(unsquized_shape.size(), 0);
     auto end = ov::Coordinate(unsquized_shape);
     begin[unsquized_shape_dim] = channel;
     end[unsquized_shape_dim] = channel + 1;
-    ngraph::CoordinateTransform iter(unsquized_shape, begin, end);
+    ov::CoordinateTransform iter(unsquized_shape, begin, end);
     return iter;
 }
 OPENVINO_SUPPRESS_DEPRECATED_END

src/common/snippets/src/pass/fq_decomposition.cpp

@@ -6,13 +6,13 @@
 
 #include <numeric>
 
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "openvino/core/rt_info.hpp"
 #include "openvino/opsets/opset1.hpp"
 #include "openvino/pass/constant_folding.hpp"
 #include "openvino/pass/manager.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/validate.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 #include "openvino/reference/broadcast.hpp"
 #include "snippets/itt.hpp"
 #include "snippets/op/convert_saturation.hpp"
@@ -208,9 +208,10 @@ bool ov::snippets::pass::FakeQuantizeDecomposition::getScalesAndShifts(
     auto broadcast_type = fq_node->get_auto_broadcast();
 
     // We have two ways for computations of scales and shifts to avoid model compilation time growth
-    // because common function "ov::runtime::reference::autobroadcast_binop()" is expensive:
+    // because common function "ov::reference::autobroadcast_binop()" is expensive:
     //  - A usual case (weights with the same shapes or scalars) - optimal calculations without large broadcasting
-    //  - A rare case ("general broadcasting") - common computations using autobroadcast_binop() call with broadcasting support
+    //  - A rare case ("general broadcasting") - common computations using autobroadcast_binop() call with broadcasting
+    //  support
 
     // Calculations of input scales and shift:
     //   - isc := (levels-1) / (ih - il)
@@ -235,23 +236,35 @@ bool ov::snippets::pass::FakeQuantizeDecomposition::getScalesAndShifts(
         const auto input_size = ov::shape_size(scale_shape);
         isc.resize(input_size, 0);
         ish.resize(input_size, 0);
-        ngraph::runtime::reference::autobroadcast_binop(input_high.data(), input_low.data(), isc.data(),
+        ov::reference::autobroadcast_binop(input_high.data(),
-                                                        input_high_shape, input_low_shape, broadcast_type,
+                                           input_low.data(),
-                                                        [levels](float x, float y) -> float { return (levels - 1) / (x - y); });
+                                           isc.data(),
-        ngraph::runtime::reference::autobroadcast_binop(input_low.data(), isc.data(), ish.data(),
+                                           input_high_shape,
-                                                        input_low_shape, scale_shape, broadcast_type,
+                                           input_low_shape,
-                                                        [](float x, float y) -> float { return -x * y; });
+                                           broadcast_type,
+                                           [levels](float x, float y) -> float {
+                                               return (levels - 1) / (x - y);
+                                           });
+        ov::reference::autobroadcast_binop(input_low.data(),
+                                           isc.data(),
+                                           ish.data(),
+                                           input_low_shape,
+                                           scale_shape,
+                                           broadcast_type,
+                                           [](float x, float y) -> float {
+                                               return -x * y;
+                                           });
         auto broadcast = [](const std::vector<float>& original_data, std::vector<float>& out_data,
                             const ov::Shape& original_shape, const ov::Shape& out_shape, size_t size) -> void {
             out_data.resize(size, 0);
             std::vector<size_t> broadcast_axes(out_shape.size() - original_shape.size());
             std::iota(broadcast_axes.begin(), broadcast_axes.end(), 0);
-            ngraph::runtime::reference::broadcast(reinterpret_cast<const char*>(original_data.data()),
+            ov::reference::broadcast(reinterpret_cast<const char*>(original_data.data()),
-                                                  reinterpret_cast<char*>(out_data.data()),
+                                     reinterpret_cast<char*>(out_data.data()),
-                                                  original_shape,
+                                     original_shape,
-                                                  out_shape,
+                                     out_shape,
-                                                  broadcast_axes,
+                                     broadcast_axes,
-                                                  sizeof(float));
+                                     sizeof(float));
         };
         broadcast(input_low, cl, input_low_shape, scale_shape, input_size);
         broadcast(input_high, ch, input_high_shape, scale_shape, input_size);
@@ -276,9 +289,15 @@ bool ov::snippets::pass::FakeQuantizeDecomposition::getScalesAndShifts(
         PartialShape::broadcast_merge_into(scale_pshape, output_high_constant->get_output_partial_shape(0), broadcast_type);
         const auto output_size = ov::shape_size(scale_pshape.get_shape());
         osc.resize(output_size, 0);
-        ngraph::runtime::reference::autobroadcast_binop(output_high.data(), output_low.data(), osc.data(),
+        ov::reference::autobroadcast_binop(output_high.data(),
-                                                        output_high_shape, output_low_shape, broadcast_type,
+                                           output_low.data(),
-                                                        [levels](float x, float y) -> float { return (x - y) / (levels - 1); });
+                                           osc.data(),
+                                           output_high_shape,
+                                           output_low_shape,
+                                           broadcast_type,
+                                           [levels](float x, float y) -> float {
+                                               return (x - y) / (levels - 1);
+                                           });
         osh = output_low;
     }
 

src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp

@@ -96,7 +96,7 @@ ov::pass::CompressFloatConstantsImpl::CompressFloatConstantsImpl(bool postponed)
             if (size == 0)
                 return false;
             auto num_out_of_range =
-                ngraph::runtime::reference::count_out_of_f16_range(const_node->get_data_ptr<ov::element::f32>(), size);
+                ov::reference::count_out_of_f16_range(const_node->get_data_ptr<ov::element::f32>(), size);
 
             // if more than 75% of a FP32 constant do not fit into FP16 keep in FP32
             const float keep_threshold = 0.75f;
@@ -113,7 +113,7 @@ ov::pass::CompressFloatConstantsImpl::CompressFloatConstantsImpl(bool postponed)
                 auto* dst_data =
                     const_cast<ov::float16*>(reinterpret_cast<const ov::float16*>(compressed_const->get_data_ptr()));
                 OPENVINO_ASSERT(dst_data);
-                ngraph::runtime::reference::convert_from_f32_to_f16_with_clamp(src_data, dst_data, size);
+                ov::reference::convert_from_f32_to_f16_with_clamp(src_data, dst_data, size);
                 new_const = compressed_const;
             }
         } else if (c_type == ov::element::f64) {

src/common/transformations/src/transformations/convert_precision.cpp

@@ -907,7 +907,7 @@ std::shared_ptr<Node> change_constant_precision<ov::element::Type_t::f32, ov::el
     if (dst_data == nullptr)
         OPENVINO_THROW("Can't get destination data pointer");
 
-    ngraph::runtime::reference::convert_from_f32_to_f16_with_clamp(src_data, dst_data, size);
+    ov::reference::convert_from_f32_to_f16_with_clamp(src_data, dst_data, size);
 
     return new_constant;
 }
@@ -927,7 +927,7 @@ std::shared_ptr<Node> change_constant_precision<ov::element::Type_t::f16, ov::el
     if (dst_data == nullptr)
         OPENVINO_THROW("Can't get destination data pointer");
 
-    ngraph::runtime::reference::convert<src_type, dst_type>(src_data, dst_data, size);
+    ov::reference::convert<src_type, dst_type>(src_data, dst_data, size);
 
     return new_constant;
 }

src/common/transformations/tests/offline_transformations/pruning_test.cpp

@@ -13,7 +13,6 @@
 #include "common_test_utils/ov_test_utils.hpp"
 #include "inference_engine.hpp"
 #include "mask_attribute.hpp"
-#include "ngraph/coordinate_transform.hpp"
 #include "openvino/core/model.hpp"
 #include "openvino/op/util/attr_types.hpp"
 #include "openvino/op/util/pad_base.hpp"
@@ -22,6 +21,7 @@
 #include "openvino/pass/manager.hpp"
 #include "openvino/pass/serialize.hpp"
 #include "openvino/pass/visualize_tree.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 #include "openvino/util/env_util.hpp"
 #include "transformations/init_node_info.hpp"
 
@@ -52,7 +52,7 @@ Output<Node> create_constant_with_zeros(const Shape& shape, const Mask& mask) {
             coord_end[dim] = dim_value + 1;
 
             OPENVINO_SUPPRESS_DEPRECATED_START
-            ngraph::CoordinateTransform iter(shape, coord_begin, coord_end);
+            ov::CoordinateTransform iter(shape, coord_begin, coord_end);
             for (const Coordinate& coord : iter) {
                 values[iter.index(coord)] = 0;
             }
@@ -138,7 +138,7 @@ TEST(TransformationTests, InitMasksOutputChannel) {
     Shape weights_shape{6, 3, 3, 3};
     std::vector<double> values(shape_size(weights_shape), 1);
     OPENVINO_SUPPRESS_DEPRECATED_START
-    ngraph::CoordinateTransform iter(weights_shape, {0, 1, 0, 0}, {6, 2, 3, 3});
+    ov::CoordinateTransform iter(weights_shape, {0, 1, 0, 0}, {6, 2, 3, 3});
     for (const Coordinate& coord : iter) {
         values[iter.index(coord)] = 0;
     }

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

@@ -7,8 +7,7 @@
 #include <cstddef>
 #include <type_traits>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename std::enable_if<std::is_unsigned<T>::value, bool>::type = true>
 void abs(const T* arg, T* out, size_t count) {
@@ -23,5 +22,4 @@ void abs(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -11,8 +11,7 @@
 #include "ngraph/axis_vector.hpp"
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace adaptive_pool {
 inline size_t window_start(size_t idx, size_t arg_shape, size_t out_shape) {
@@ -130,5 +129,4 @@ void adaptive_avg_pool(const T* arg, T* out, const Shape& arg_shape, const Shape
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -11,8 +11,7 @@
 #include "ngraph/axis_vector.hpp"
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename IT>
 void adaptive_max_pool_1d(const T* arg, T* out, IT* indices, size_t h_in, size_t h_out) {
@@ -126,5 +125,4 @@ void adaptive_max_pool(const T* arg, T* out, IT* selected_indices, const Shape&
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,11 +6,10 @@
 
 #include <cstddef>
 
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape_util.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void add(const T* arg0, const T* arg1, T* out, size_t count) {
@@ -31,5 +30,4 @@ void add(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cstddef>
 
 #include "ngraph/op/util/attr_types.hpp"
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void logical_and(const T* arg0, const T* arg1, T* out, size_t count) {
@@ -32,5 +31,4 @@ void logical_and(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename X, typename Y, typename Z>
 void atan2(const X* py, const Y* px, Z* pout, size_t count) {
@@ -17,5 +16,4 @@ void atan2(const X* py, const Y* px, Z* pout, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,9 +8,9 @@
 #include <numeric>
 #include <utility>
 
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/op/util/attr_types.hpp"
 #include "ngraph/shape_util.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
 namespace ov {
 namespace reference {
@@ -44,7 +44,6 @@ inline void numpy_autobroadcast_binop(const T* arg0,
                                       const size_t axis,
                                       const size_t stride,
                                       Functor elementwise_functor) {
-    using ngraph::CoordinateIterator;
     for (CoordinateIterator it(output_shape), ite = CoordinateIterator::end();;) {
         for (size_t i = 0; i < stride; ++i)
             *out++ = elementwise_functor(arg0[i * A0], arg1[i * A1]);
@@ -264,9 +263,9 @@ void autobroadcast_binop(const T* arg0,
             }
 
             NGRAPH_SUPPRESS_DEPRECATED_START
-            ngraph::CoordinateTransform arg0_transform(arg0_shape);
+            CoordinateTransform arg0_transform(arg0_shape);
-            ngraph::CoordinateTransform arg1_transform(arg1_squeezed_shape);
+            CoordinateTransform arg1_transform(arg1_squeezed_shape);
-            ngraph::CoordinateTransform output_transform(arg0_shape);
+            CoordinateTransform output_transform(arg0_shape);
 
             for (const Coordinate& output_coord : output_transform) {
                 Coordinate arg1_coord = ngraph::reduce(output_coord, arg1_squeezed_axes, false);
@@ -309,8 +308,6 @@ void autobroadcast_select(const U* arg0,
                           const Shape& arg2_shape,
                           const op::AutoBroadcastSpec& broadcast_spec,
                           Functor elementwise_functor) {
-    using ngraph::CoordinateTransformBasic;
-
     switch (broadcast_spec.m_type) {
     case op::AutoBroadcastType::NONE:
         for (size_t i = 0; i < shape_size(arg0_shape); i++) {

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

@@ -11,11 +11,10 @@
 #include <vector>
 
 #include "ngraph/axis_vector.hpp"
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void avg_pool_backprop(const T* delta,
@@ -231,5 +230,4 @@ void avg_pool(const T* arg,
     NGRAPH_SUPPRESS_DEPRECATED_END
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cmath>
 #include <vector>
 
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 static inline T norm(T val, T mean, T var, T eps) {
@@ -46,5 +45,4 @@ void batch_norm_inference(float eps,
     NGRAPH_SUPPRESS_DEPRECATED_END
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include "ngraph/shape.hpp"
 #include "openvino/reference/convolution.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace details {
 inline uint8_t extract_bit(uint8_t val, uint8_t bit) {
@@ -143,5 +142,4 @@ void binary_convolution(const T_IN* in,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include "ngraph/axis_set.hpp"
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void broadcast(const char* arg,
                char* out,
@@ -17,5 +16,4 @@ void broadcast(const char* arg,
                const AxisSet& broadcast_axes,
                size_t elem_size);
 }
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,8 +8,7 @@
 
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename B, typename P>
 void bucketize(const T* data,
@@ -40,7 +39,4 @@ void bucketize(const T* data,
 }
 
 }  // namespace reference
-
+}  // namespace ov
-}  // namespace runtime
-
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void ceiling(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void ceiling(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void clamp(const T* arg, T* out, T min, T max, size_t count) {
@@ -23,5 +22,4 @@ void clamp(const T* arg, T* out, T min, T max, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,8 +8,7 @@
 
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void concat(const std::vector<const char*>& args,
             char* out,
@@ -18,5 +17,4 @@ void concat(const std::vector<const char*>& args,
             int64_t concatenation_axis,
             size_t elem_size);
 }
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,8 +6,7 @@
 
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void constant(const T* arg0, T* out, size_t count) {
@@ -16,5 +15,4 @@ void constant(const T* arg0, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -9,8 +9,7 @@
 #include "ngraph/type/element_type.hpp"
 #include "ngraph/type/float16.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace detail {
 inline void set_u1(uint8_t* buf, size_t idx, uint8_t val) {
@@ -130,5 +129,4 @@ typename std::enable_if<std::is_same<TO, char>::value>::type convert(const TI* a
 }
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -10,8 +10,7 @@
 #include "openvino/op/util/convert_color_i420_base.hpp"
 #include "openvino/op/util/convert_color_nv12_base.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 
 template <typename T>
@@ -206,5 +205,4 @@ inline bool color_convert_i420(const std::shared_ptr<Node>& op,
 
 OPENVINO_SUPPRESS_DEPRECATED_END
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,8 +8,7 @@
 
 #include "ngraph/util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace {
 
@@ -407,8 +406,7 @@ void convolution(const T* in,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph
 
 // can't be removed currently due to arm-plugin dependency
 #include "openvino/reference/convolution_backprop_data.hpp"

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

@@ -14,8 +14,7 @@
 #include "openvino/reference/convolution.hpp"
 #include "openvino/reference/reverse.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace {
 constexpr size_t filter_input_ch_axis = 0;
@@ -395,5 +394,4 @@ void convolution_backprop_in(const T* delta_in,
                               output_padding);
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,8 +6,7 @@
 
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void copy(const T* arg, T* out, size_t count) {
@@ -16,5 +15,4 @@ void copy(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,9 +8,9 @@
 #include <limits>
 #include <vector>
 
-#include "ngraph/coordinate_transform.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
-namespace ngraph {
+
-namespace runtime {
+namespace ov {
 namespace reference {
 template <typename T>
 void ctc_greedy_decoder(const T* data,
@@ -20,7 +20,7 @@ void ctc_greedy_decoder(const T* data,
                         const Shape& sequence_masks_shape,
                         const Shape& out_shape,
                         const bool ctc_merge_repeated) {
-    NGRAPH_SUPPRESS_DEPRECATED_START
+    OPENVINO_SUPPRESS_DEPRECATED_START
     const auto max_seq_len = data_shape[0];
     const auto batch_size = data_shape[1];
     const auto class_count = data_shape[2];
@@ -59,8 +59,7 @@ void ctc_greedy_decoder(const T* data,
         }
     }
     std::copy(tmp_out.begin(), tmp_out.end(), out);
-    NGRAPH_SUPPRESS_DEPRECATED_END
+    OPENVINO_SUPPRESS_DEPRECATED_END
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,9 +8,8 @@
 #include <limits>
 #include <vector>
 
-#include "ngraph/coordinate_transform.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename TF, typename TI, typename TCI, typename TSL>
 void ctc_greedy_decoder_seq_len(const TF* data,
@@ -44,5 +43,4 @@ void ctc_greedy_decoder_seq_len(const TF* data,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,8 +8,7 @@
 
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename U>
 void CTCLoss(const T* logits,
@@ -162,5 +161,4 @@ void CTCLoss(const T* logits,
     }  // for (size_t b = 0; b < batchNum; b++)
 }  // CTCLoss
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,8 +6,7 @@
 
 #include <cmath>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 
 template <typename T, typename P>
@@ -42,5 +41,4 @@ void cumsum(const T* arg,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,8 +6,7 @@
 
 #include "openvino/reference/convolution.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace def_conv_impl {
 inline void validate_deformable_convolution_params(const Shape& in_shape,
@@ -316,5 +315,4 @@ void deformable_convolution(const T* in,
                            bilinear_interpolation_pad);
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -16,8 +16,7 @@
 #include "clamp.hpp"
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void deformable_psroi_pooling(const T* data_input,
@@ -172,5 +171,4 @@ void deformable_psroi_pooling(const T* data_input,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,16 +7,14 @@
 #include "ngraph/op/depth_to_space.hpp"
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void depth_to_space(const char* const in,
                     const Shape& in_shape,
                     char* const out,
                     const Shape& out_shape,
                     const size_t block_size,
-                    const op::DepthToSpace::DepthToSpaceMode mode,
+                    const op::v0::DepthToSpace::DepthToSpaceMode mode,
                     const size_t elem_size);
 }
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -13,8 +13,7 @@
 #include "ngraph/op/util/detection_output_base.hpp"
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 enum { idxLocation, idxConfidence, idxPriors, idxArmConfidence, idxArmLocation, numInputs };
 
@@ -588,5 +587,4 @@ public:
     }
 };
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -9,13 +9,12 @@
 #include <type_traits>
 
 #include "ngraph/op/util/attr_types.hpp"
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape.hpp"
 #include "ngraph/type/bfloat16.hpp"
 #include "ngraph/type/float16.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 // NOTE: Execution throws `std::domain_error` if either a non-integral value or an
 // out-of-bounds value is detected in the input tensor.
@@ -110,5 +109,4 @@ divide(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -9,10 +9,8 @@
 
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void einsum(const HostTensorVector& outputs, const HostTensorVector& inputs, const std::string& equation);
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void elu(const T* arg, T* out, size_t count, double alpha) {
@@ -17,5 +16,4 @@ void elu(const T* arg, T* out, size_t count, double alpha) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,8 +6,7 @@
 
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename U>
 void embeddingBagOffsetsSum(const T* emb_table,
@@ -93,5 +92,4 @@ void embeddingBagOffsetsSum(const T* emb_table,
 }  // embeddingBagOffsetsSum
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,8 +6,7 @@
 
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename U>
 void embeddingBagPackedSum(const T* emb_table,
@@ -47,5 +46,4 @@ void embeddingBagPackedSum(const T* emb_table,
 }  // embeddingBagPackedSum
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,8 +6,7 @@
 
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename U>
 void embeddingSegmentsSum(const T* embTable,
@@ -72,5 +71,4 @@ void embeddingSegmentsSum(const T* embTable,
 }  // embeddingSegmentsSum
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -12,11 +12,10 @@
 #include <cstddef>
 
 #include "ngraph/op/util/attr_types.hpp"
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void equal(const T* arg0,
@@ -41,8 +40,7 @@ void equal(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph
 
 #if defined(__GNUC__)
 #    pragma GCC diagnostic pop

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

@@ -11,8 +11,7 @@
 #include "ngraph/type/bfloat16.hpp"
 #include "ngraph/type/float16.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename std::enable_if<!std::is_integral<T>::value, bool>::type = true>
 void erf(const T* arg, T* out, size_t count) {
@@ -28,5 +27,4 @@ void erf(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void exp(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void exp(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -27,8 +27,7 @@
 #include "ngraph/ops.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void experimental_detectron_detection_output(const float* input_rois,
                                              const float* input_deltas,
@@ -50,5 +49,4 @@ void experimental_detectron_detection_output_postprocessing(void* pboxes,
                                                             const Shape& output_classes_shape,
                                                             const Shape& output_scores_shape);
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -26,8 +26,7 @@
 #include "ngraph/ops.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void experimental_detectron_prior_grid_generator(const T* priors,
@@ -58,5 +57,4 @@ void experimental_detectron_prior_grid_generator(const T* priors,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -15,8 +15,7 @@
 #include "ngraph/ops.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void experimental_detectron_proposals_single_image(
     const float* im_info,
@@ -39,5 +38,4 @@ void experimental_detectron_proposals_single_image_postprocessing(void* prois,
                                                                   const Shape& output_rois_shape,
                                                                   const Shape& output_scores_shape);
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -14,8 +14,7 @@
 #include "ngraph/ops.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void experimental_detectron_roi_feature_extractor(
     const std::vector<std::vector<float>>& inputs,
@@ -32,5 +31,4 @@ void experimental_detectron_roi_feature_extractor_postprocessing(void* prois_fea
                                                                  const Shape& output_roi_features_shape,
                                                                  const Shape& output_rois_shape);
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -15,8 +15,7 @@
 #include "ngraph/ops.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void experimental_detectron_topk_rois(const T* input_rois,
@@ -43,5 +42,4 @@ void experimental_detectron_topk_rois(const T* input_rois,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,11 +6,10 @@
 
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
-void extract_image_patches(const std::shared_ptr<op::ExtractImagePatches> extImgPatches,
+void extract_image_patches(const std::shared_ptr<op::v3::ExtractImagePatches> extImgPatches,
                            const T* input,
                            T* out,
                            const Shape& inShape,
@@ -115,5 +114,4 @@ void extract_image_patches(const std::shared_ptr<op::ExtractImagePatches> extImg
 }  // extractImagePatches
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -9,8 +9,7 @@
 #include "ngraph/shape.hpp"
 #include "utils/span.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void eye(T* data, const Shape& out_shape, const int64_t diagonal_index) {
@@ -37,5 +36,4 @@ void eye(T* data, const Shape& out_shape, const int64_t diagonal_index) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -12,13 +12,12 @@
 #include <vector>
 
 #include "ngraph/check.hpp"
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/op/util/attr_types.hpp"
 #include "ngraph/shape.hpp"
 #include "ngraph/shape_util.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace fake_quantize_details {
 template <typename T>
@@ -158,11 +157,11 @@ void fake_quantize(const T* const arg,
 
         for (const Coordinate& output_coord : output_transform) {
             OPENVINO_SUPPRESS_DEPRECATED_START
-            const Coordinate arg0_coord = reduce(output_coord, arg0_squeezed_axes, false);
+            const Coordinate arg0_coord = ngraph::reduce(output_coord, arg0_squeezed_axes, false);
-            const Coordinate arg1_coord = reduce(output_coord, arg1_squeezed_axes, false);
+            const Coordinate arg1_coord = ngraph::reduce(output_coord, arg1_squeezed_axes, false);
-            const Coordinate arg2_coord = reduce(output_coord, arg2_squeezed_axes, false);
+            const Coordinate arg2_coord = ngraph::reduce(output_coord, arg2_squeezed_axes, false);
-            const Coordinate arg3_coord = reduce(output_coord, arg3_squeezed_axes, false);
+            const Coordinate arg3_coord = ngraph::reduce(output_coord, arg3_squeezed_axes, false);
-            const Coordinate arg4_coord = reduce(output_coord, arg4_squeezed_axes, false);
+            const Coordinate arg4_coord = ngraph::reduce(output_coord, arg4_squeezed_axes, false);
             OPENVINO_SUPPRESS_DEPRECATED_END
 
             const size_t arg0_idx =
@@ -187,5 +186,4 @@ void fake_quantize(const T* const arg,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -31,8 +31,7 @@
 #include "ngraph/ops.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 enum class FFTKind { Forward, Inverse };
 
@@ -52,5 +51,4 @@ std::vector<int64_t> canonicalize_axes(const int64_t* axes_data,
                                        const Shape& axes_data_shape,
                                        int64_t complex_data_rank);
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void floor(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void floor(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cmath>
 #include <cstddef>
 
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape_util.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void floor_mod(const T* arg0,
@@ -28,5 +27,4 @@ void floor_mod(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,12 +8,10 @@
 #include <cstddef>
 #include <vector>
 
-#include "ngraph/function.hpp"
+#include "openvino/core/model.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
-void function(const std::shared_ptr<Function>& function, const HostTensorVector& inputs, HostTensorVector& outputs);
+void function(const std::shared_ptr<Model>& function, const HostTensorVector& inputs, HostTensorVector& outputs);
 }
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -9,8 +9,7 @@
 #include "ngraph/shape.hpp"
 #include "utils/span.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename U>
 void gather(const T* const data,
@@ -57,5 +56,4 @@ void gather(const T* const data,
 }
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -4,11 +4,9 @@
 
 #pragma once
 
-#include "ngraph/coordinate_index.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
-#include "ngraph/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename U>
 void gather_elements(const T* data,
@@ -109,5 +107,4 @@ void gather_elements(const T* data,
             }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,11 +8,10 @@
 #include <cassert>
 #include <numeric>
 
-#include "ngraph/coordinate_transform.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 #include "utils/span.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace details {
 template <typename Iterator>
@@ -106,5 +105,4 @@ void gather_nd(const T* const params,
 }
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include "ngraph/shape.hpp"
 #include "ngraph/type/element_type.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void gather_tree(const char* step_ids,
                  const char* parent_ids,
@@ -21,5 +20,4 @@ void gather_tree(const char* step_ids,
                  const Shape& end_token_shape,
                  const element::Type& type);
 }
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,8 +8,7 @@
 #include <cstddef>
 #include <ngraph/op/gelu.hpp>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void gelu(const T* arg, T* out, op::GeluApproximationMode mode, size_t count) {
@@ -27,5 +26,4 @@ void gelu(const T* arg, T* out, op::GeluApproximationMode mode, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -15,8 +15,7 @@
 #include "ngraph/ops.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void generate_proposals(const std::vector<float>& im_info,
                         const std::vector<float>& anchors,
@@ -43,5 +42,4 @@ void generate_proposals_postprocessing(void* prois,
                                        const Shape& output_scores_shape);
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cstddef>
 
 #include "ngraph/op/util/attr_types.hpp"
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void greater(const T* arg0,
@@ -36,5 +35,4 @@ void greater(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cstddef>
 
 #include "ngraph/op/util/attr_types.hpp"
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void greater_eq(const T* arg0,
@@ -36,5 +35,4 @@ void greater_eq(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -13,8 +13,7 @@
 #include "ngraph/shape.hpp"
 #include "openvino/op/grid_sample.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace {
 
@@ -295,5 +294,4 @@ void grid_sample(DATA_ET* output,
     std::fesetround(prev_rounding_mode);
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,13 +6,11 @@
 
 #include "openvino/reference/normalize_l2.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void grn(const T* data, T* out, float bias, const Shape& data_shape) {
     normalize_l2(data, out, data_shape, {1}, bias, op::EpsMode::ADD);
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -16,8 +16,7 @@ constexpr size_t out_batch_axis = 0;
 constexpr size_t out_channel_axis = 1;
 }  // namespace
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void validate_group_convolution_parameters(const Shape& in_shape,
                                            const Shape& f_shape,
@@ -72,16 +71,16 @@ void group_convolution(const INPUT* in,
     for (size_t batch_idx = 0; batch_idx < in_shape[in_batch_axis]; ++batch_idx) {
         group_filter = f;
         for (size_t group_idx = 0; group_idx < group_count; ++group_idx) {
-            runtime::reference::convolution(group_batch,
+            reference::convolution(group_batch,
-                                            group_filter,
+                                   group_filter,
-                                            group_out,
+                                   group_out,
-                                            group_batch_shape,
+                                   group_batch_shape,
-                                            group_filter_shape,
+                                   group_filter_shape,
-                                            group_out_shape,
+                                   group_out_shape,
-                                            strides,
+                                   strides,
-                                            dilation,
+                                   dilation,
-                                            pads_begin,
+                                   pads_begin,
-                                            pads_end);
+                                   pads_end);
             group_batch += group_batch_size;
             group_filter += group_filter_size;
             group_out += group_out_size;
@@ -89,5 +88,4 @@ void group_convolution(const INPUT* in,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include "ngraph/util.hpp"
 #include "openvino/reference/group_convolution.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 
 void infer_backward_conv_output_shape(const Shape& in_spatial_shape,
@@ -80,18 +79,18 @@ void group_convolution_backprop_data(const T* in,
     for (size_t batch_idx = 0; batch_idx < in_shape[in_batch_axis]; ++batch_idx) {
         group_filter = f;
         for (size_t group_idx = 0; group_idx < group_count; ++group_idx) {
-            runtime::reference::convolution_backprop_in(group_batch,
+            reference::convolution_backprop_in(group_batch,
-                                                        group_filter,
+                                               group_filter,
-                                                        group_out,
+                                               group_out,
-                                                        group_batch_shape,
+                                               group_batch_shape,
-                                                        group_filter_shape,
+                                               group_filter_shape,
-                                                        group_out_shape,
+                                               group_out_shape,
-                                                        in_dilation,
+                                               in_dilation,
-                                                        dilation,
+                                               dilation,
-                                                        pads_begin,
+                                               pads_begin,
-                                                        pads_end,
+                                               pads_end,
-                                                        strides,
+                                               strides,
-                                                        output_padding);
+                                               output_padding);
             group_batch += group_batch_size;
             group_filter += group_filter_size;
             group_out += group_out_size;
@@ -129,5 +128,4 @@ void group_convolution_backprop_data(const INPUT* in,
 }
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -23,7 +23,6 @@ void group_normalization(const T* const data,
                          const size_t num_groups,
                          const double epsilon) {
     using namespace std;
-    using namespace ngraph::runtime::reference;
 
     const auto num_batches = data_shape[0];
     const auto num_channels = data_shape[1];

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

@@ -16,8 +16,7 @@
 #include "openvino/reference/subtract.hpp"
 #include "openvino/reference/tanh.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void gru_cell(const T* X,
@@ -216,5 +215,4 @@ void gru_cell(const T* X,
     reference::add(mul1.data(), mul2.data(), dst_data, gate_shape, gate_shape, op::AutoBroadcastType::NUMPY);
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void hard_sigmoid(const T* arg, const T alpha, const T beta, T* out, size_t count) {
@@ -17,5 +16,4 @@ void hard_sigmoid(const T* arg, const T alpha, const T beta, T* out, size_t coun
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -4,8 +4,7 @@
 
 #pragma once
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 struct widen {
@@ -22,5 +21,4 @@ struct widen<double> {
     using type = long double;
 };
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void hsigmoid(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void hsigmoid(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void hswish(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void hswish(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,16 +6,14 @@
 
 #include <cmath>
 
-#include "ngraph/op/util/multi_subgraph_base.hpp"
+#include "openvino/op/util/multi_subgraph_base.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
-void if_reference(const std::vector<std::shared_ptr<Function>>& body,
+void if_reference(const std::vector<std::shared_ptr<Model>>& body,
-                  const std::vector<op::util::MultiSubgraphOutputDescriptionVector>& out_descs,
+                  const std::vector<op::util::MultiSubGraphOp::MultiSubgraphOutputDescriptionVector>& out_descs,
-                  const std::vector<op::util::MultiSubgraphInputDescriptionVector>& input_descs,
+                  const std::vector<op::util::MultiSubGraphOp::MultiSubgraphInputDescriptionVector>& input_descs,
                   const HostTensorVector& out,
                   const HostTensorVector& args);
 }
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -13,13 +13,12 @@
 #include <map>
 
 #include "interpolate_pil.hpp"
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/op/interpolate.hpp"
 #include "ngraph/shape_util.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 #include "transpose.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 using Nearest_mode = ngraph::op::v4::Interpolate::NearestMode;
 using Transform_mode = ngraph::op::v4::Interpolate::CoordinateTransformMode;
@@ -831,5 +830,4 @@ void interpolate(T* input_data,
     evaluator(reinterpret_cast<T*>(padded_data_ptr), padded_input_shape, scales, axes, out, out_shape);
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -44,8 +44,7 @@
 #include "ngraph/op/interpolate.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace interpolate_pil {
 
@@ -316,5 +315,4 @@ void imaging_resample_inner(const T* im_in,
 
 }  // namespace interpolate_pil
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,8 +8,7 @@
 
 #include "ngraph/shape.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void irdft(const std::vector<float>& input_data,
            const Shape& input_data_shape,
@@ -19,5 +18,4 @@ void irdft(const std::vector<float>& input_data,
            const Shape& irdft_output_shape,
            const int64_t last_signal_size);
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename U>
 typename std::enable_if<std::is_floating_point<T>::value, void>::type is_finite(const T* input,
@@ -28,5 +27,4 @@ typename std::enable_if<std::is_class<T>::value, void>::type is_finite(const T*
 }
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename U>
 typename std::enable_if<std::is_floating_point<T>::value, void>::type
@@ -54,5 +53,4 @@ typename std::enable_if<std::is_class<T>::value, void>::type is_inf(const T* inp
 }
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T, typename U>
 typename std::enable_if<std::is_floating_point<T>::value, void>::type is_nan(const T* input, U* output, size_t count) {
@@ -25,5 +24,4 @@ typename std::enable_if<std::is_class<T>::value, void>::type is_nan(const T* inp
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cstddef>
 
 #include "ngraph/op/util/attr_types.hpp"
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void less(const T* arg0,
@@ -36,5 +35,4 @@ void less(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cstddef>
 
 #include "ngraph/op/util/attr_types.hpp"
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void less_eq(const T* arg0,
@@ -36,5 +35,4 @@ void less_eq(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void log(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void log(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -6,18 +6,17 @@
 
 #include <cmath>
 
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/shape_util.hpp"
 #include "openvino/reference/max.hpp"
 #include "openvino/reference/sum.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void log_softmax(const T* arg, T* out, const Shape& shape, const AxisSet& axes) {
     NGRAPH_SUPPRESS_DEPRECATED_START
-    auto temp_shape = reduce(shape, axes, true);
+    auto temp_shape = ngraph::reduce(shape, axes, true);
     auto temp_elements = shape_size(temp_shape);
     auto temp_max = std::vector<T>(temp_elements, 0);
     auto temp_sum = std::vector<T>(temp_elements, 0);
@@ -27,7 +26,7 @@ void log_softmax(const T* arg, T* out, const Shape& shape, const AxisSet& axes)
     CoordinateTransform transform(shape);
     CoordinateTransform temp_transform(temp_shape);
     for (const Coordinate& coord : transform) {
-        Coordinate temp_coord = reduce(coord, axes, true);
+        Coordinate temp_coord = ngraph::reduce(coord, axes, true);
         out[transform.index(coord)] =
             static_cast<T>(std::exp(arg[transform.index(coord)] - temp_max[temp_transform.index(temp_coord)]));
     }
@@ -35,7 +34,7 @@ void log_softmax(const T* arg, T* out, const Shape& shape, const AxisSet& axes)
     sum(out, temp_sum.data(), shape, axes);
 
     for (const Coordinate& coord : transform) {
-        Coordinate temp_coord = reduce(coord, axes, true);
+        Coordinate temp_coord = ngraph::reduce(coord, axes, true);
         out[transform.index(coord)] =
             static_cast<T>((arg[transform.index(coord)] - temp_max[temp_transform.index(temp_coord)]) -
                            std::log(temp_sum[temp_transform.index(temp_coord)]));
@@ -43,5 +42,4 @@ void log_softmax(const T* arg, T* out, const Shape& shape, const AxisSet& axes)
     NGRAPH_SUPPRESS_DEPRECATED_END
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cmath>
 #include <numeric>
 
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/shape_util.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 OPENVINO_SUPPRESS_DEPRECATED_START
 static inline void reduce_logical_and(const char* arg,
@@ -19,7 +18,7 @@ static inline void reduce_logical_and(const char* arg,
                                       const Shape& in_shape,
                                       const AxisSet& reduction_axes) {
     constexpr bool dont_keep_dims_in_output = false;
-    const auto out_shape = reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
+    const auto out_shape = ngraph::reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
     std::fill(out, out + shape_size(out_shape), 1);
 
     const auto in_strides = row_major_strides(in_shape);
@@ -27,7 +26,7 @@ static inline void reduce_logical_and(const char* arg,
 
     CoordinateTransformBasic input_transform(in_shape);
     for (const Coordinate& input_coord : input_transform) {
-        const Coordinate output_coord = reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
+        const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
 
         const size_t in_idx =
             std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -39,7 +38,7 @@ static inline void reduce_logical_and(const char* arg,
 }
 
 static inline void reduce_logical_or(const char* arg, char* out, const Shape& in_shape, const AxisSet& reduction_axes) {
-    const auto out_shape = reduce(in_shape, reduction_axes, false);
+    const auto out_shape = ngraph::reduce(in_shape, reduction_axes, false);
     std::fill(out, out + shape_size(out_shape), 0);
 
     const auto in_strides = row_major_strides(in_shape);
@@ -47,7 +46,7 @@ static inline void reduce_logical_or(const char* arg, char* out, const Shape& in
 
     CoordinateTransformBasic input_transform(in_shape);
     for (const Coordinate& input_coord : input_transform) {
-        const Coordinate output_coord = reduce(input_coord, reduction_axes, false);
+        const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, false);
 
         const size_t in_idx =
             std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -59,5 +58,4 @@ static inline void reduce_logical_or(const char* arg, char* out, const Shape& in
 }
 OPENVINO_SUPPRESS_DEPRECATED_END
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -5,17 +5,17 @@
 #pragma once
 
 #include <cmath>
-#include <ngraph/opsets/opset5.hpp>
 
-namespace ngraph {
+#include "openvino/op/loop.hpp"
-namespace runtime {
+#include "openvino/op/util/sub_graph_base.hpp"
+
+namespace ov {
 namespace reference {
-void loop(const std::shared_ptr<Function>& body,
+void loop(const std::shared_ptr<Model>& body,
           const op::util::OutputDescriptionVector& out_descs,
           const op::util::InputDescriptionVector& input_descs,
-          const opset5::Loop::SpecialBodyPorts& special_ports,
+          const op::v5::Loop::SpecialBodyPorts& special_ports,
           const HostTensorVector& out,
           const HostTensorVector& args);
 }
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,11 +8,10 @@
 #include <cmath>
 #include <numeric>
 
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/util.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 static size_t point_to_flat_idx(const Shape& shape, const std::vector<size_t>& point) {
     size_t idx = point[0];
@@ -97,5 +96,4 @@ void lrn(const T* arg,
     NGRAPH_SUPPRESS_DEPRECATED_END
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -16,8 +16,7 @@
 #include "openvino/reference/subtract.hpp"
 #include "openvino/reference/tanh.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void lstm_cell(const T* X,
@@ -365,5 +364,4 @@ void lstm_cell_v1(const T* X,
     reference::multiply(XHBPo.data(), Ct.data(), out_Ht, gate_shape, gate_shape, op::AutoBroadcastType::NUMPY);
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -13,8 +13,7 @@
 #include "ngraph/shape_util.hpp"
 #include "openvino/reference/broadcast.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 namespace details {
 template <typename T>
@@ -102,12 +101,12 @@ void matmul(const T* arg0,
         std::vector<T> tmp(shape_size(arg0_shape));
         auto axis_vector = details::get_transpose_order(arg0_shape);
         std::swap(arg0_shape_tmp[arg0_rank - 1], arg0_shape_tmp[arg0_rank - 2]);
-        opt_kernel::reshape(reinterpret_cast<const char*>(arg0_data),
+        ngraph::runtime::opt_kernel::reshape(reinterpret_cast<const char*>(arg0_data),
-                            reinterpret_cast<char*>(tmp.data()),
+                                             reinterpret_cast<char*>(tmp.data()),
-                            arg0_shape,
+                                             arg0_shape,
-                            axis_vector,
+                                             axis_vector,
-                            arg0_shape_tmp,
+                                             arg0_shape_tmp,
-                            sizeof(T));
+                                             sizeof(T));
         arg0_new_data.swap(tmp);
         arg0_data = arg0_new_data.data();
     }
@@ -116,12 +115,12 @@ void matmul(const T* arg0,
         std::vector<T> tmp(shape_size(arg1_shape));
         auto axis_vector = details::get_transpose_order(arg1_shape);
         std::swap(arg1_shape_tmp[arg1_rank - 1], arg1_shape_tmp[arg1_rank - 2]);
-        opt_kernel::reshape(reinterpret_cast<const char*>(arg1_data),
+        ngraph::runtime::opt_kernel::reshape(reinterpret_cast<const char*>(arg1_data),
-                            reinterpret_cast<char*>(tmp.data()),
+                                             reinterpret_cast<char*>(tmp.data()),
-                            arg1_shape,
+                                             arg1_shape,
-                            axis_vector,
+                                             axis_vector,
-                            arg1_shape_tmp,
+                                             arg1_shape_tmp,
-                            sizeof(T));
+                                             sizeof(T));
         arg1_new_data.swap(tmp);
         arg1_data = arg1_new_data.data();
     }
@@ -218,5 +217,4 @@ void matmul(const T* arg0,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -19,8 +19,7 @@
 #include "ngraph/op/util/op_types.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 void matrix_nms(const float* boxes_data,
                 const Shape& boxes_data_shape,
@@ -34,5 +33,4 @@ void matrix_nms(const float* boxes_data,
                 int64_t* valid_outputs);
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,11 +8,10 @@
 #include <limits>
 #include <numeric>
 
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/shape_util.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void max(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_axes) {
@@ -20,7 +19,7 @@ void max(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
 
     constexpr bool dont_keep_dims_in_output = false;
     OPENVINO_SUPPRESS_DEPRECATED_START
-    const auto out_shape = reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
+    const auto out_shape = ngraph::reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
     std::fill(out, out + shape_size(out_shape), minval);
 
     const auto in_strides = row_major_strides(in_shape);
@@ -28,7 +27,7 @@ void max(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
 
     CoordinateTransformBasic input_transform(in_shape);
     for (const Coordinate& input_coord : input_transform) {
-        const Coordinate output_coord = reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
+        const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
 
         const size_t in_idx =
             std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -44,5 +43,4 @@ void max(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
     OPENVINO_SUPPRESS_DEPRECATED_END
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,10 +7,9 @@
 #include <cmath>
 #include <numeric>
 
-#include "ngraph/coordinate_transform.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void max_pool(const T* arg,
@@ -411,5 +410,4 @@ void max_pool(const Values_t* data,
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cstddef>
 
 #include "ngraph/op/util/attr_types.hpp"
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void maximum(const T* arg0, const T* arg1, T* out, size_t count) {
@@ -32,5 +31,4 @@ void maximum(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -9,20 +9,19 @@
 #include <numeric>
 #include <vector>
 
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/shape_util.hpp"
 #include "ngraph/type/bfloat16.hpp"
 #include "ngraph/type/float16.hpp"
 #include "openvino/reference/sum.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void mean(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_axes) {
     constexpr bool dont_keep_dims_in_output = false;
     OPENVINO_SUPPRESS_DEPRECATED_START
-    const auto out_shape = reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
+    const auto out_shape = ngraph::reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
     std::vector<T> cs(shape_size(out_shape), 0);
     std::fill(out, out + shape_size(out_shape), T(0));
 
@@ -33,7 +32,7 @@ void mean(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_
     std::map<size_t, int> index_to_count_map;
 
     for (const Coordinate& input_coord : input_transform) {
-        const Coordinate output_coord = reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
+        const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
 
         const size_t in_idx =
             std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -56,5 +55,4 @@ void mean(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -8,15 +8,14 @@
 #include <limits>
 #include <numeric>
 
-#include "ngraph/coordinate_transform.hpp"
 #include "ngraph/shape_util.hpp"
+#include "openvino/reference/utils/coordinate_transform.hpp"
 
 #ifdef _WIN32
 #    undef min
 #endif
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void min(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_axes) {
@@ -25,7 +24,7 @@ void min(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
 
     constexpr bool dont_keep_dims_in_output = false;
     OPENVINO_SUPPRESS_DEPRECATED_START
-    const auto out_shape = reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
+    const auto out_shape = ngraph::reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
     std::fill(out, out + shape_size(out_shape), minval);
 
     const auto in_strides = row_major_strides(in_shape);
@@ -33,7 +32,7 @@ void min(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
 
     CoordinateTransformBasic input_transform(in_shape);
     for (const Coordinate& input_coord : input_transform) {
-        const Coordinate output_coord = reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
+        const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
 
         const size_t in_idx =
             std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -49,5 +48,4 @@ void min(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
     OPENVINO_SUPPRESS_DEPRECATED_END
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,11 +7,10 @@
 #include <cstddef>
 
 #include "ngraph/op/util/attr_types.hpp"
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void minimum(const T* arg0, const T* arg1, T* out, size_t count) {
@@ -32,5 +31,4 @@ void minimum(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,8 +7,7 @@
 #include <cmath>
 #include <cstddef>
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void mish(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void mish(const T* arg, T* out, size_t count) {
     }
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -7,10 +7,9 @@
 #include <cmath>
 #include <cstddef>
 
-#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
+#include "openvino/reference/autobroadcast_binop.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 template <typename T>
 void mod(const T* arg0,
@@ -24,5 +23,4 @@ void mod(const T* arg0,
     });
 }
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph

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

@@ -19,8 +19,7 @@
 #include "ngraph/op/util/op_types.hpp"
 #include "ngraph/shape_util.hpp"
 
-namespace ngraph {
+namespace ov {
-namespace runtime {
 namespace reference {
 
 void multiclass_nms(const float* boxes_data,
@@ -37,5 +36,4 @@ void multiclass_nms(const float* boxes_data,
                     int64_t* valid_outputs);
 
 }  // namespace reference
-}  // namespace runtime
+}  // namespace ov
-}  // namespace ngraph