Enable Conditional Compilation for nGraph evaluate methods

ngraph/core/CMakeLists.txt

@@ -58,7 +58,7 @@ set_target_properties(ngraph PROPERTIES
                       C_VISIBILITY_PRESET hidden
                       VISIBILITY_INLINES_HIDDEN ON)
 
-target_link_libraries(ngraph PRIVATE openvino::itt ngraph::builder ngraph::reference)
+target_link_libraries(ngraph PRIVATE openvino::conditional_compilation openvino::itt ngraph::builder ngraph::reference)
 
 find_package(Graphviz QUIET)
 if (GRAPHVIZ_FOUND)

ngraph/core/include/ngraph/op/broadcast.hpp

@@ -82,6 +82,10 @@ namespace ngraph
                 std::pair<bool, AxisSet> get_broadcast_axes() const override;
                 bool evaluate(const HostTensorVector& outputs,
                               const HostTensorVector& inputs) const override;
+
+            private:
+                bool broadcast_evaluate(const HostTensorVector& outputs,
+                                        const HostTensorVector& inputs) const;
             };
         } // namespace v3
 

ngraph/core/include/ngraph/op/depth_to_space.hpp

@@ -79,6 +79,10 @@ namespace ngraph
                 std::size_t m_blocksize;
                 DepthToSpaceMode m_mode;
                 DepthToSpaceMode mode_from_string(const std::string& mode) const;
+
+            private:
+                bool evaluate_depth_to_space(const HostTensorVector& outputs,
+                                             const HostTensorVector& inputs) const;
             };
         }
         using v0::DepthToSpace;

ngraph/core/include/ngraph/op/gather.hpp

@@ -57,6 +57,9 @@ namespace ngraph
                 static const int PARAMS;
                 static const int INDICES;
                 static const int AXIS;
+
+                bool evaluate_gather(const HostTensorVector& outputs,
+                                     const HostTensorVector& inputs) const;
             };
         } // namespace v1
     }     // namespace op

ngraph/core/include/ngraph/op/interpolate.hpp

@@ -234,6 +234,8 @@ namespace ngraph
                 std::vector<int64_t> get_axes() const;
 
             private:
+                bool evaluate_interpolate(const HostTensorVector& outputs,
+                                          const HostTensorVector& inputs) const;
                 InterpolateAttrs m_attrs;
 
                 /// \brief Corrects pads_begin and pads_end attributes.

ngraph/core/include/ngraph/op/max_pool.hpp

@@ -98,6 +98,8 @@ namespace ngraph
                 bool update_auto_padding(const PartialShape& in_shape,
                                          Shape& new_pads_end,
                                          Shape& new_pads_begin) const;
+                bool evaluate_maxpool(const HostTensorVector& outputs,
+                                      const HostTensorVector& inputs) const;
             };
         } // namespace v1
     }     // namespace op

ngraph/core/include/ngraph/op/pad.hpp

@@ -89,6 +89,8 @@ namespace ngraph
 
             private:
                 PadMode m_pad_mode;
+                bool evaluate_pad(const HostTensorVector& outputs,
+                                  const HostTensorVector& inputs) const;
             };
         }
     }

ngraph/core/include/ngraph/op/reshape.hpp

@@ -71,6 +71,8 @@ namespace ngraph
 
             protected:
                 bool m_special_zero;
+                bool evaluate_reshape(const HostTensorVector& outputs,
+                                      const HostTensorVector& inputs) const;
             };
         }
     }

ngraph/core/include/ngraph/op/reverse.hpp

@@ -73,6 +73,10 @@ namespace ngraph
                 /// Alternatively it can contain a boolean mask that indicates which axes should be
                 /// reversed.
                 Mode m_mode;
+
+            private:
+                bool evaluate_reverse(const HostTensorVector& outputs,
+                                      const HostTensorVector& inputs) const;
             };
         }
     }

ngraph/core/include/ngraph/op/scatter_elements_update.hpp

@@ -52,6 +52,10 @@ namespace ngraph
                     clone_with_new_inputs(const OutputVector& inputs) const override;
                 bool evaluate(const HostTensorVector& outputs,
                               const HostTensorVector& inputs) const override;
+
+            private:
+                bool evaluate_scatter_element_update(const HostTensorVector& outputs,
+                                                     const HostTensorVector& inputs) const;
             };
         }
         using v3::ScatterElementsUpdate;

ngraph/core/include/ngraph/op/scatter_update.hpp

@@ -53,6 +53,10 @@ namespace ngraph
 
                 bool evaluate(const HostTensorVector& outputs,
                               const HostTensorVector& inputs) const override;
+
+            private:
+                bool evaluate_scatter_update(const HostTensorVector& outputs,
+                                             const HostTensorVector& inputs) const;
             };
         }
     }

ngraph/core/include/ngraph/op/shuffle_channels.hpp

@@ -69,6 +69,8 @@ namespace ngraph
                 /// \param data_shape - Shape of the original input data tensor
                 /// \return A 4D tensor to be used to reshape the input data before shuffling it
                 Shape get_pre_shuffle_shape(const Shape& data_shape) const;
+                bool evaluate_shuffle_channels(const HostTensorVector& outputs,
+                                               const HostTensorVector& inputs) const;
 
                 int64_t m_axis;
                 int64_t m_group;

ngraph/core/include/ngraph/op/space_to_batch.hpp

@@ -63,6 +63,10 @@ namespace ngraph
 
                 bool evaluate(const HostTensorVector& outputs,
                               const HostTensorVector& inputs) const override;
+
+            private:
+                bool evaluate_space_to_batch(const HostTensorVector& outputs,
+                                             const HostTensorVector& inputs) const;
             };
         }
         using v1::SpaceToBatch;

ngraph/core/include/ngraph/op/space_to_depth.hpp

@@ -76,6 +76,10 @@ namespace ngraph
             protected:
                 std::size_t m_blocksize;
                 SpaceToDepthMode m_mode;
+
+            private:
+                bool evaluate_space_to_depth(const HostTensorVector& outputs,
+                                             const HostTensorVector& inputs) const;
             };
         }
         using v0::SpaceToDepth;

ngraph/core/include/ngraph/op/tile.hpp

@@ -47,6 +47,10 @@ namespace ngraph
 
                 bool evaluate(const HostTensorVector& outputs,
                               const HostTensorVector& inputs) const override;
+
+            private:
+                bool evaluate_tile(const HostTensorVector& outputs,
+                                   const HostTensorVector& inputs) const;
             };
         }
     }

ngraph/core/include/ngraph/op/topk.hpp

@@ -115,6 +115,10 @@ namespace ngraph
                                            const PartialShape input_partial_shape,
                                            const int64_t k) const;
                 void set_axis(const Rank input_rank, const int64_t axis);
+
+            private:
+                bool evaluate_topk(const HostTensorVector& outputs,
+                                   const HostTensorVector& inputs) const;
             };
         } // namespace v1
 

ngraph/core/include/ngraph/op/variadic_split.hpp

@@ -56,6 +56,10 @@ namespace ngraph
                 size_t get_default_output_index() const override { return no_default_index(); }
                 bool evaluate(const HostTensorVector& outputs,
                               const HostTensorVector& inputs) const override;
+
+            private:
+                bool evaluate_variadic_split(const HostTensorVector& outputs,
+                                             const HostTensorVector& inputs) const;
             };
         } // namespace v1
 

ngraph/core/src/itt.hpp

@@ -21,6 +21,8 @@
 
 #pragma once
 
+#include <openvino/cc/factory.h>
+#include <openvino/cc/selective_build.h>
 #include <openvino/itt.hpp>
 
 namespace ngraph
@@ -31,7 +33,33 @@ namespace ngraph
         {
             OV_ITT_DOMAIN(nGraph);
             OV_ITT_DOMAIN(nGraphPass_LT);
-            OV_ITT_DOMAIN(nGraphOp, "nGraph::Op");
+            OV_ITT_DOMAIN(ngraph_op, "nGraph::Op");
         }
     }
+    OV_CC_DOMAINS(ngraph_op);
 }
+
+#if defined(SELECTIVE_BUILD) || defined(SELECTIVE_BUILD_ANALYZER)
+#define NGRAPH_OP_SCOPE(region, ...) OV_SCOPE(ngraph_op, region, __VA_ARGS__)
+#else
+#define NGRAPH_OP_SCOPE(region, ...)                                                               \
+    OV_ITT_SCOPED_TASK(itt::domains::ngraph_op, #region);                                          \
+    __VA_ARGS__
+#endif
+
+#define NGRAPH_TYPE_CASE(region, a, ...)                                                           \
+    case element::Type_t::a:                                                                       \
+    {                                                                                              \
+        OV_SCOPE(                                                                                  \
+            ngraph_op, OV_CC_CAT3(region, _, a), rc = evaluate<element::Type_t::a>(__VA_ARGS__));  \
+    }                                                                                              \
+    break;
+
+#define NGRAPH_COPY_TENSOR(region, a, ...)                                                         \
+    case element::Type_t::a:                                                                       \
+    {                                                                                              \
+        OV_SCOPE(ngraph_op,                                                                        \
+                 OV_CC_CAT3(region, _, a),                                                         \
+                 rc = copy_tensor<element::Type_t::a>(__VA_ARGS__));                               \
+    }                                                                                              \
+    break;

ngraph/core/src/op/abs.cpp

@@ -57,22 +57,14 @@ namespace absop
 
         switch (arg0->get_element_type())
         {
-            TYPE_CASE(boolean)(arg0, out, count);
-            break;
-            TYPE_CASE(i32)(arg0, out, count);
-            break;
-            TYPE_CASE(i64)(arg0, out, count);
-            break;
-            TYPE_CASE(u32)(arg0, out, count);
-            break;
-            TYPE_CASE(u64)(arg0, out, count);
-            break;
-            TYPE_CASE(f16)(arg0, out, count);
-            break;
-            TYPE_CASE(f32)(arg0, out, count);
-            break;
-            TYPE_CASE(bf16)(arg0, out, count);
-            break;
+            NGRAPH_TYPE_CASE(evaluate_abs, boolean, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_abs, i32, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_abs, i64, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_abs, u32, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_abs, u64, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_abs, f16, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_abs, f32, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_abs, bf16, arg0, out, count);
         default: rc = false; break;
         }
         return rc;
@@ -81,6 +73,9 @@ namespace absop
 
 bool op::Abs::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
 {
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Abs::evaluate");
-    return absop::evaluate_abs(inputs[0], outputs[0], shape_size(get_output_shape(0)));
+    bool rc = false;
+    NGRAPH_OP_SCOPE(
+        v0_Abs_evaluate,
+        rc = absop::evaluate_abs(inputs[0], outputs[0], shape_size(get_output_shape(0))));
+    return rc;
 }

ngraph/core/src/op/acos.cpp

@@ -66,20 +66,13 @@ namespace acosop
 
         switch (arg0->get_element_type())
         {
-            TYPE_CASE(boolean)(arg0, out, count);
-            break;
-            TYPE_CASE(i32)(arg0, out, count);
-            break;
-            TYPE_CASE(i64)(arg0, out, count);
-            break;
-            TYPE_CASE(u32)(arg0, out, count);
-            break;
-            TYPE_CASE(u64)(arg0, out, count);
-            break;
-            TYPE_CASE(f16)(arg0, out, count);
-            break;
-            TYPE_CASE(f32)(arg0, out, count);
-            break;
+            NGRAPH_TYPE_CASE(evaluate_acos, boolean, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_acos, i32, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_acos, i64, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_acos, u32, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_acos, u64, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_acos, f16, arg0, out, count);
+            NGRAPH_TYPE_CASE(evaluate_acos, f32, arg0, out, count);
         default: rc = false; break;
         }
         return rc;
@@ -88,6 +81,9 @@ namespace acosop
 
 bool op::Acos::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
 {
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Acos::evaluate");
-    return acosop::evaluate_acos(inputs[0], outputs[0], shape_size(get_output_shape(0)));
+    bool rc = false;
+    NGRAPH_OP_SCOPE(
+        v0_Acos_evaluate,
+        rc = acosop::evaluate_acos(inputs[0], outputs[0], shape_size(get_output_shape(0))));
+    return rc;
 }

ngraph/core/src/op/acosh.cpp

@@ -56,18 +56,12 @@ namespace acoshop
         out->set_unary(arg0);
         switch (arg0->get_element_type())
         {
-            TYPE_CASE(i32)(arg0, out);
-            break;
-            TYPE_CASE(i64)(arg0, out);
-            break;
-            TYPE_CASE(u32)(arg0, out);
-            break;
-            TYPE_CASE(u64)(arg0, out);
-            break;
-            TYPE_CASE(f16)(arg0, out);
-            break;
-            TYPE_CASE(f32)(arg0, out);
-            break;
+            NGRAPH_TYPE_CASE(evaluate_acosh, i32, arg0, out);
+            NGRAPH_TYPE_CASE(evaluate_acosh, i64, arg0, out);
+            NGRAPH_TYPE_CASE(evaluate_acosh, u32, arg0, out);
+            NGRAPH_TYPE_CASE(evaluate_acosh, u64, arg0, out);
+            NGRAPH_TYPE_CASE(evaluate_acosh, f16, arg0, out);
+            NGRAPH_TYPE_CASE(evaluate_acosh, f32, arg0, out);
         default: rc = false; break;
         }
         return rc;
@@ -76,6 +70,7 @@ namespace acoshop
 
 bool op::v3::Acosh::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
 {
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v3::Acosh::evaluate");
-    return acoshop::evaluate_acosh(inputs[0], outputs[0]);
+    bool rc = false;
+    NGRAPH_OP_SCOPE(v3_Acosh_evaluate, rc = acoshop::evaluate_acosh(inputs[0], outputs[0]));
+    return rc;
 }

ngraph/core/src/op/add.cpp

@@ -50,28 +50,17 @@ namespace add
         out->set_broadcast(broadcast_spec, arg0, arg1);
         switch (arg0->get_element_type())
         {
-            TYPE_CASE(i8)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(i16)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(i32)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(i64)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(u8)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(u16)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(u32)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(u64)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(bf16)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(f16)(arg0, arg1, out, broadcast_spec);
-            break;
-            TYPE_CASE(f32)(arg0, arg1, out, broadcast_spec);
-            break;
+            NGRAPH_TYPE_CASE(evaluate_add, i8, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, i16, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, i32, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, i64, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, u8, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, u16, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, u32, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, u64, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, bf16, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, f16, arg0, arg1, out, broadcast_spec);
+            NGRAPH_TYPE_CASE(evaluate_add, f32, arg0, arg1, out, broadcast_spec);
         default: rc = false; break;
         }
         return rc;
@@ -104,6 +93,8 @@ shared_ptr<Node> op::v1::Add::clone_with_new_inputs(const OutputVector& new_args
 
 bool op::v1::Add::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
 {
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Add::evaluate");
-    return add::evaluate_add(inputs[0], inputs[1], outputs[0], get_autob());
-}
+    bool rc = false;
+    NGRAPH_OP_SCOPE(v1_Add_evaluate,
+                    rc = add::evaluate_add(inputs[0], inputs[1], outputs[0], get_autob()));
+    return rc;
+}