diff --git a/src/core/include/openvino/op/greater.hpp b/src/core/include/openvino/op/greater.hpp index de889a0acae..daf38ed8c9d 100644 --- a/src/core/include/openvino/op/greater.hpp +++ b/src/core/include/openvino/op/greater.hpp @@ -26,9 +26,7 @@ public: const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY)); 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 v1 diff --git a/src/core/include/openvino/op/less.hpp b/src/core/include/openvino/op/less.hpp index 3d87ab9b6ff..f57ebbc07bf 100644 --- a/src/core/include/openvino/op/less.hpp +++ b/src/core/include/openvino/op/less.hpp @@ -26,9 +26,7 @@ public: const AutoBroadcastSpec& auto_broadcast = AutoBroadcastSpec(AutoBroadcastType::NUMPY)); 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 v1 diff --git a/src/core/reference/include/openvino/reference/greater.hpp b/src/core/reference/include/openvino/reference/greater.hpp index 2dff5e6c489..98f1ecfff51 100644 --- a/src/core/reference/include/openvino/reference/greater.hpp +++ b/src/core/reference/include/openvino/reference/greater.hpp @@ -4,25 +4,26 @@ #pragma once -#include - -#include "openvino/core/shape.hpp" -#include "openvino/op/util/attr_types.hpp" -#include "openvino/reference/autobroadcast_binop.hpp" +#include "openvino/reference/less.hpp" namespace ov { namespace reference { + template -void greater(const T* arg0, - const T* arg1, - char* out, - size_t count) // TODO: using char for bool, is this right? -{ - for (size_t i = 0; i < count; i++) { - out[i] = arg0[i] > arg1[i]; - } +void greater(const T* arg0, const T* arg1, char* out, size_t count) { + less(arg1, arg0, out, count); } +/** + * @brief Reference implementation of binary elementwise Greater operator. + * + * @param arg0 Pointer to input 0 data. + * @param arg1 Pointer to input 1 data. + * @param out Pointer to output data. + * @param arg0_shape Input 0 shape. + * @param arg1_shape Input 1 shape. + * @param broadcast_spec Broadcast specification mode. + */ template void greater(const T* arg0, const T* arg1, @@ -30,9 +31,7 @@ void greater(const T* arg0, const Shape& arg0_shape, const Shape& arg1_shape, const op::AutoBroadcastSpec& broadcast_spec) { - autobroadcast_binop(arg0, arg1, out, arg0_shape, arg1_shape, broadcast_spec, [](T x, T y) -> U { - return static_cast(x > y); - }); + less(arg1, arg0, out, arg1_shape, arg0_shape, broadcast_spec); } } // namespace reference } // namespace ov diff --git a/src/core/reference/include/openvino/reference/less.hpp b/src/core/reference/include/openvino/reference/less.hpp index 21d2321f566..6ab5f41f6d0 100644 --- a/src/core/reference/include/openvino/reference/less.hpp +++ b/src/core/reference/include/openvino/reference/less.hpp @@ -4,7 +4,7 @@ #pragma once -#include +#include #include "openvino/core/shape.hpp" #include "openvino/op/util/attr_types.hpp" @@ -12,17 +12,30 @@ namespace ov { namespace reference { +namespace func { +// Use custom implementation as function instead std::less functor, gives smaller binary size. +// If removed or replace check impact on library binary size. +template +constexpr bool less(const T lhs, const T rhs) { + return lhs < rhs; +} +} // namespace func + template -void less(const T* arg0, - const T* arg1, - char* out, - size_t count) // TODO: using char for bool, is this right? -{ - for (size_t i = 0; i < count; i++) { - out[i] = arg0[i] < arg1[i]; - } +void less(const T* arg0, const T* arg1, char* out, const size_t count) { + std::transform(arg0, std::next(arg0, count), arg1, out, func::less); } +/** + * @brief Reference implementation of binary elementwise Less operator. + * + * @param arg0 Pointer to input 0 data. + * @param arg1 Pointer to input 1 data. + * @param out Pointer to output data. + * @param arg0_shape Input 0 shape. + * @param arg1_shape Input 1 shape. + * @param broadcast_spec Broadcast specification mode. + */ template void less(const T* arg0, const T* arg1, @@ -30,9 +43,7 @@ void less(const T* arg0, const Shape& arg0_shape, const Shape& arg1_shape, const op::AutoBroadcastSpec& broadcast_spec) { - autobroadcast_binop(arg0, arg1, out, arg0_shape, arg1_shape, broadcast_spec, [](T x, T y) -> U { - return static_cast(x < y); - }); + autobroadcast_binop(arg0, arg1, out, arg0_shape, arg1_shape, broadcast_spec, func::less); } } // namespace reference } // namespace ov diff --git a/src/core/src/op/greater.cpp b/src/core/src/op/greater.cpp index dfc838c2f9c..76715745a5f 100644 --- a/src/core/src/op/greater.cpp +++ b/src/core/src/op/greater.cpp @@ -2,86 +2,81 @@ // SPDX-License-Identifier: Apache-2.0 // -#include "ngraph/op/greater.hpp" +#include "openvino/op/greater.hpp" +#include "element_visitor.hpp" #include "itt.hpp" -#include "ngraph/runtime/host_tensor.hpp" #include "openvino/reference/greater.hpp" +#include "utils.hpp" -using namespace std; -using namespace ngraph; +namespace ov { +namespace op { +namespace greater { -OPENVINO_SUPPRESS_DEPRECATED_START -namespace greaterop { -namespace { -template -bool evaluate(const HostTensorPtr& arg0, - const HostTensorPtr& arg1, - const HostTensorPtr& out, - const op::AutoBroadcastSpec& broadcast_spec) { - ov::reference::greater(arg0->get_data_ptr(), - arg1->get_data_ptr(), - out->get_data_ptr(), - arg0->get_shape(), - arg1->get_shape(), +struct Evaluate : element::NoAction { + using element::NoAction::visit; + + template > + static result_type visit(const Tensor& in0, + const Tensor& in1, + Tensor& out, + const Shape& shape0, + const Shape& shape1, + const AutoBroadcastSpec& broadcast_spec) { + reference::greater(in0.data(), + in1.data(), + out.data>(), + shape0, + shape1, broadcast_spec); - return true; -} - -bool evaluate_greater(const HostTensorPtr& arg0, - const HostTensorPtr& arg1, - const HostTensorPtr& out, - const op::AutoBroadcastSpec& broadcast_spec) { - bool rc = true; - out->set_broadcast(broadcast_spec, arg0, arg1, element::boolean); - switch (arg0->get_element_type()) { - OPENVINO_TYPE_CASE(evaluate_greater, boolean, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_greater, i32, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_greater, i64, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_greater, u32, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_greater, u64, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_greater, f16, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_greater, f32, arg0, arg1, out, broadcast_spec); - default: - rc = false; - break; + return true; } - return rc; -} -} // namespace -} // namespace greaterop +}; +} // namespace greater //-------------------------------------- v1 ------------------------------------ - -op::v1::Greater::Greater(const Output& arg0, const Output& arg1, const AutoBroadcastSpec& auto_broadcast) +namespace v1 { +Greater::Greater(const Output& arg0, const Output& arg1, const AutoBroadcastSpec& auto_broadcast) : BinaryElementwiseComparison(arg0, arg1, auto_broadcast) { constructor_validate_and_infer_types(); } -shared_ptr op::v1::Greater::clone_with_new_inputs(const OutputVector& new_args) const { +std::shared_ptr Greater::clone_with_new_inputs(const OutputVector& new_args) const { OV_OP_SCOPE(v1_Greater_clone_with_new_inputs); check_new_args_count(this, new_args); - return make_shared(new_args.at(0), new_args.at(1), this->get_autob()); + return std::make_shared(new_args.at(0), new_args.at(1), get_autob()); } -bool op::v1::Greater::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const { +bool Greater::evaluate(TensorVector& outputs, const TensorVector& inputs) const { OV_OP_SCOPE(v1_Greater_evaluate); - return greaterop::evaluate_greater(inputs[0], inputs[1], outputs[0], get_autob()); + OPENVINO_ASSERT(outputs.size() == 1); + + outputs[0].set_shape(infer_broadcast_shape(this, inputs)); + using namespace ov::element; + return IfTypeOf::apply(inputs[0].get_element_type(), + inputs[0], + inputs[1], + outputs[0], + inputs[0].get_shape(), + inputs[1].get_shape(), + get_autob()); } -bool op::v1::Greater::has_evaluate() const { +bool Greater::has_evaluate() const { OV_OP_SCOPE(v1_Greater_has_evaluate); switch (get_input_element_type(0)) { - case ngraph::element::boolean: - 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 element::boolean: + case element::f16: + case element::f32: + case element::i32: + case element::i64: + case element::u32: + case element::u64: return true; default: - break; + return false; } - return false; } +} // namespace v1 +} // namespace op +} // namespace ov diff --git a/src/core/src/op/less.cpp b/src/core/src/op/less.cpp index aada1ff872d..910876c3a58 100644 --- a/src/core/src/op/less.cpp +++ b/src/core/src/op/less.cpp @@ -2,85 +2,80 @@ // SPDX-License-Identifier: Apache-2.0 // -#include "ngraph/op/less.hpp" +#include "openvino/op/less.hpp" #include "itt.hpp" -#include "ngraph/runtime/host_tensor.hpp" #include "openvino/reference/less.hpp" +#include "utils.hpp" -using namespace std; -using namespace ngraph; +namespace ov { +namespace op { +namespace less { -OPENVINO_SUPPRESS_DEPRECATED_START -namespace lessop { -namespace { -template -bool evaluate(const HostTensorPtr& arg0, - const HostTensorPtr& arg1, - const HostTensorPtr& out, - const op::AutoBroadcastSpec& broadcast_spec) { - ov::reference::less(arg0->get_data_ptr(), - arg1->get_data_ptr(), - out->get_data_ptr(), - arg0->get_shape(), - arg1->get_shape(), +struct Evaluate : element::NoAction { + using element::NoAction::visit; + + template > + static result_type visit(const Tensor& in0, + const Tensor& in1, + Tensor& out, + const Shape& shape0, + const Shape& shape1, + const AutoBroadcastSpec& broadcast_spec) { + reference::less(in0.data(), + in1.data(), + out.data>(), + shape0, + shape1, broadcast_spec); - return true; -} - -bool evaluate_less(const HostTensorPtr& arg0, - const HostTensorPtr& arg1, - const HostTensorPtr& out, - const op::AutoBroadcastSpec& broadcast_spec) { - bool rc = true; - out->set_broadcast(broadcast_spec, arg0, arg1, element::boolean); - switch (arg0->get_element_type()) { - OPENVINO_TYPE_CASE(evaluate_less, boolean, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_less, i32, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_less, i64, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_less, u32, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_less, u64, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_less, f16, arg0, arg1, out, broadcast_spec); - OPENVINO_TYPE_CASE(evaluate_less, f32, arg0, arg1, out, broadcast_spec); - default: - rc = false; - break; + return true; } - return rc; -} -} // namespace -} // namespace lessop +}; +} // namespace less // ----------------------------- v1 -------------------------------------------- -op::v1::Less::Less(const Output& arg0, const Output& arg1, const AutoBroadcastSpec& auto_broadcast) +namespace v1 { +Less::Less(const Output& arg0, const Output& arg1, const AutoBroadcastSpec& auto_broadcast) : BinaryElementwiseComparison(arg0, arg1, auto_broadcast) { constructor_validate_and_infer_types(); } -shared_ptr op::v1::Less::clone_with_new_inputs(const OutputVector& new_args) const { +std::shared_ptr Less::clone_with_new_inputs(const OutputVector& new_args) const { OV_OP_SCOPE(v1_Less_clone_with_new_inputs); check_new_args_count(this, new_args); - return make_shared(new_args.at(0), new_args.at(1), this->get_autob()); + return std::make_shared(new_args.at(0), new_args.at(1), get_autob()); } -bool op::v1::Less::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const { +bool Less::evaluate(TensorVector& outputs, const TensorVector& inputs) const { OV_OP_SCOPE(v1_Less_evaluate); - return lessop::evaluate_less(inputs[0], inputs[1], outputs[0], get_autob()); + OPENVINO_ASSERT(outputs.size() == 1); + + outputs[0].set_shape(infer_broadcast_shape(this, inputs)); + using namespace ov::element; + return IfTypeOf::apply(inputs[0].get_element_type(), + inputs[0], + inputs[1], + outputs[0], + inputs[0].get_shape(), + inputs[1].get_shape(), + get_autob()); } -bool op::v1::Less::has_evaluate() const { +bool Less::has_evaluate() const { OV_OP_SCOPE(v1_Less_has_evaluate); switch (get_input_element_type(0)) { - case ngraph::element::boolean: - 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 element::boolean: + case element::f16: + case element::f32: + case element::i32: + case element::i64: + case element::u32: + case element::u64: return true; default: - break; + return false; } - return false; } +} // namespace v1 +} // namespace op +} // namespace ov