diff --git a/src/core/include/openvino/op/sqrt.hpp b/src/core/include/openvino/op/sqrt.hpp index 9fad4ba2a76..d09521e95cb 100644 --- a/src/core/include/openvino/op/sqrt.hpp +++ b/src/core/include/openvino/op/sqrt.hpp @@ -35,11 +35,8 @@ public: Sqrt(const Output& arg); Sqrt() = default; - bool visit_attributes(AttributeVisitor& visitor) override; std::shared_ptr clone_with_new_inputs(const OutputVector& new_args) const override; - OPENVINO_SUPPRESS_DEPRECATED_START - bool evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const override; - OPENVINO_SUPPRESS_DEPRECATED_END + bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override; bool has_evaluate() const override; }; } // namespace v0 diff --git a/src/core/reference/include/openvino/reference/sqrt.hpp b/src/core/reference/include/openvino/reference/sqrt.hpp index e0d4d4f1ba0..1562b7cca23 100644 --- a/src/core/reference/include/openvino/reference/sqrt.hpp +++ b/src/core/reference/include/openvino/reference/sqrt.hpp @@ -6,21 +6,33 @@ #include #include -#include + +#include "openvino/reference/utils/type_util.hpp" namespace ov { namespace reference { -template -typename std::enable_if::value>::type sqrt(const T* arg, T* out, size_t count) { - for (size_t i = 0; i < count; i++) { - out[i] = std::sqrt(arg[i]); - } +namespace func { +template ()>::type* = nullptr> +T sqrt(const T in) { + return std::sqrt(in); } -template -typename std::enable_if::value>::type sqrt(const T* arg, T* out, size_t count) { - for (size_t i = 0; i < count; i++) { - out[i] = static_cast(std::round(std::sqrt(arg[i]))); - } + +template ::value>::type* = nullptr> +T sqrt(const T in) { + return static_cast(std::round(std::sqrt(in))); +} +} // namespace func + +/** + * @brief Reference implementation of Sqrt operator. + * + * @param arg Pointer to input data. + * @param out Pointer to output data. + * @param count Number of elements in input buffer. + */ +template +void sqrt(const T* arg, T* out, const size_t count) { + std::transform(arg, arg + count, out, func::sqrt); } } // namespace reference } // namespace ov diff --git a/src/core/src/op/sqrt.cpp b/src/core/src/op/sqrt.cpp index fe9c3830e9c..0c05c6833bf 100644 --- a/src/core/src/op/sqrt.cpp +++ b/src/core/src/op/sqrt.cpp @@ -2,80 +2,66 @@ // SPDX-License-Identifier: Apache-2.0 // -#include "ngraph/op/sqrt.hpp" +#include "openvino/op/sqrt.hpp" +#include "element_visitor.hpp" #include "itt.hpp" -#include "ngraph/op/add.hpp" -#include "ngraph/op/divide.hpp" -#include "ngraph/runtime/host_tensor.hpp" #include "openvino/reference/sqrt.hpp" -using namespace std; -using namespace ngraph; +namespace ov { +namespace op { +namespace sqrt { +struct Evaluate : element::NoAction { + using element::NoAction::visit; -op::Sqrt::Sqrt(const Output& arg) : UnaryElementwiseArithmetic(arg) { + template > + static result_type visit(const Tensor& arg0, Tensor& out, const size_t count) { + reference::sqrt(arg0.data(), out.data(), count); + return true; + } +}; +} // namespace sqrt + +namespace v0 { +Sqrt::Sqrt(const Output& arg) : UnaryElementwiseArithmetic(arg) { constructor_validate_and_infer_types(); } -bool ngraph::op::v0::Sqrt::visit_attributes(AttributeVisitor& visitor) { - OV_OP_SCOPE(v0_Sqrt_visit_attrinutes); - return true; -} - -shared_ptr op::Sqrt::clone_with_new_inputs(const OutputVector& new_args) const { +std::shared_ptr Sqrt::clone_with_new_inputs(const OutputVector& new_args) const { OV_OP_SCOPE(v0_Sqrt_clone_with_new_inputs); check_new_args_count(this, new_args); - return make_shared(new_args.at(0)); + return std::make_shared(new_args.at(0)); } -OPENVINO_SUPPRESS_DEPRECATED_START -namespace sqrtop { -namespace { -template -inline bool evaluate(const HostTensorPtr& arg0, const HostTensorPtr& out, const size_t count) { - using T = typename element_type_traits::value_type; - ov::reference::sqrt(arg0->get_data_ptr(), out->get_data_ptr(), count); - return true; -} - -bool evaluate_sqrt(const HostTensorPtr& arg0, const HostTensorPtr& out, const size_t count) { - bool rc = true; - out->set_unary(arg0); - switch (arg0->get_element_type()) { - OPENVINO_TYPE_CASE(evaluate_sqrt, i32, arg0, out, count); - OPENVINO_TYPE_CASE(evaluate_sqrt, i64, arg0, out, count); - OPENVINO_TYPE_CASE(evaluate_sqrt, u32, arg0, out, count); - OPENVINO_TYPE_CASE(evaluate_sqrt, u64, arg0, out, count); - OPENVINO_TYPE_CASE(evaluate_sqrt, f16, arg0, out, count); - OPENVINO_TYPE_CASE(evaluate_sqrt, f32, arg0, out, count); - OPENVINO_TYPE_CASE(evaluate_sqrt, f64, arg0, out, count); - default: - rc = false; - break; - } - return rc; -} -} // namespace -} // namespace sqrtop - -bool op::Sqrt::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const { +bool Sqrt::evaluate(TensorVector& outputs, const TensorVector& inputs) const { OV_OP_SCOPE(v0_Sqrt_evaluate); - return sqrtop::evaluate_sqrt(inputs[0], outputs[0], shape_size(inputs[0]->get_shape())); + OPENVINO_ASSERT(outputs.size() == 1); + OPENVINO_ASSERT(inputs.size() == 1); + + const auto& in_shape = inputs[0].get_shape(); + outputs[0].set_shape(in_shape); + using namespace ov::element; + return IfTypeOf::apply(inputs[0].get_element_type(), + inputs[0], + outputs[0], + shape_size(in_shape)); } -bool op::Sqrt::has_evaluate() const { +bool Sqrt::has_evaluate() const { OV_OP_SCOPE(v0_Sqrt_has_evaluate); switch (get_input_element_type(0)) { - case ngraph::element::i32: - case ngraph::element::i64: - case ngraph::element::u32: - case ngraph::element::u64: - case ngraph::element::f16: - case ngraph::element::f32: - case ngraph::element::f64: + case element::f16: + case element::f32: + case element::f64: + case element::i32: + case element::i64: + case element::u32: + case element::u64: return true; default: - break; + return false; } - return false; } +} // namespace v0 +} // namespace op +} // namespace ov