IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Performance counters for nGraph and additional ITT libraries on Linux (#1665)

Browse Source
This commit is contained in:
Vladislav Volkov 2020-08-10 06:58:01 +03:00 committed by GitHub
parent 1c062b6e92
commit 5883a232c3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
84 changed files with 260 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ngraph/src/ngraph/function.cpp
View File

@ -74,6 +74,8 @@ Function::Function(const std::shared_ptr<Node>& result,
void Function::validate_nodes_and_infer_types()
{
OV_ITT_SCOPED_TASK(itt::domains::nGraph, "Function::validate_nodes_and_infer_types");
for (auto& node : get_ordered_ops())
{
node->revalidate_and_infer_types();
@ -92,7 +94,7 @@ void Function::validate_nodes_and_infer_types()
std::vector<shared_ptr<Node>> Function::get_ordered_ops() const
{
OV_ITT_SCOPED_TASK(itt::domains::Ngraph, "Function::get_ordered_ops");
OV_ITT_SCOPED_TASK(itt::domains::nGraph, "Function::get_ordered_ops");
vector<shared_ptr<Node>> nodes;
for (auto& r : get_results())

3
ngraph/src/ngraph/itt.hpp
View File

@ -29,7 +29,8 @@ namespace ngraph
{
namespace domains
{
OV_ITT_DOMAIN(Ngraph);
OV_ITT_DOMAIN(nGraph);
OV_ITT_DOMAIN(nGraphOp, "nGraph::Op");
}
}
}

3
ngraph/src/ngraph/node.cpp
View File

@ -22,6 +22,7 @@
#include "ngraph/descriptor/input.hpp"
#include "ngraph/descriptor/layout/tensor_layout.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/node.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/get_output_element.hpp"
@ -947,6 +948,8 @@ bool Node::evaluate(const HostTensorVector& output_values,
bool Node::constant_fold(OutputVector& output_values, const OutputVector& input_values)
{
OV_ITT_SCOPED_TASK(itt::domains::nGraph, "Node::constant_fold");
// If all the inputs are constants, try to evaluate the outputs
HostTensorVector input_tensors;
for (auto input : input_values)

3
ngraph/src/ngraph/op/abs.cpp
View File

@ -14,6 +14,8 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/itt.hpp"
#include "ngraph/op/abs.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/sign.hpp"
@ -77,5 +79,6 @@ namespace
bool op::Abs::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Abs::evaluate");
return evaluate_abs(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/acos.cpp
View File

@ -14,6 +14,8 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/itt.hpp"
#include "ngraph/op/acos.hpp"
#include "ngraph/axis_set.hpp"
@ -86,5 +88,6 @@ namespace
bool op::Acos::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Acos::evaluate");
return evaluate_acos(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

2
ngraph/src/ngraph/op/acosh.cpp
View File

@ -17,6 +17,7 @@
#include <string>
#include <vector>
#include "ngraph/itt.hpp"
#include "ngraph/op/acosh.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/acosh.hpp"
@ -75,5 +76,6 @@ namespace
bool op::v3::Acosh::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v3::Acosh::evaluate");
return evaluate_acosh(inputs[0], outputs[0]);
}

3
ngraph/src/ngraph/op/add.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/add.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/add.hpp"
@ -106,6 +107,7 @@ namespace
bool op::v0::Add::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Add::evaluate");
return evaluate_add(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -135,5 +137,6 @@ 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 evaluate_add(inputs[0], inputs[1], outputs[0], get_autob());
}

2
ngraph/src/ngraph/op/and.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/and.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/and.hpp"
@ -92,5 +93,6 @@ namespace
bool op::v1::LogicalAnd::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::LogicalAnd::evaluate");
return evaluate_logand(inputs[0], inputs[1], outputs[0], get_autob());
}

3
ngraph/src/ngraph/op/asin.cpp
View File

@ -14,6 +14,8 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/itt.hpp"
#include "ngraph/op/asin.hpp"
#include "ngraph/axis_set.hpp"
@ -87,5 +89,6 @@ namespace
bool op::Asin::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Asin::evaluate");
return evaluate_asin(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

2
ngraph/src/ngraph/op/asinh.cpp
View File

@ -17,6 +17,7 @@
#include <string>
#include <vector>
#include "ngraph/itt.hpp"
#include "ngraph/op/asinh.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/asinh.hpp"
@ -75,5 +76,6 @@ namespace
bool op::v3::Asinh::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v3::Asinh::evaluate");
return evaluate_asinh(inputs[0], outputs[0]);
}

3
ngraph/src/ngraph/op/atan.cpp
View File

@ -14,6 +14,8 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/itt.hpp"
#include "ngraph/op/atan.hpp"
#include "ngraph/axis_set.hpp"
@ -86,5 +88,6 @@ namespace
bool op::Atan::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Atan::evaluate");
return evaluate_atan(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

2
ngraph/src/ngraph/op/atanh.cpp
View File

@ -17,6 +17,7 @@
#include <string>
#include <vector>
#include "ngraph/itt.hpp"
#include "ngraph/op/atanh.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/atanh.hpp"
@ -75,5 +76,6 @@ namespace
bool op::v3::Atanh::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v3::Atanh::evaluate");
return evaluate_atanh(inputs[0], outputs[0]);
}

7
ngraph/src/ngraph/op/broadcast.cpp
View File

@ -14,8 +14,10 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/broadcast.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/op/broadcast.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/sum.hpp"
#include "ngraph/partial_shape.hpp"
@ -189,6 +191,7 @@ bool op::v3::Broadcast::visit_attributes(AttributeVisitor& visitor)
bool op::v3::Broadcast::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v3::Broadcast::evaluate");
if (get_broadcast_spec().m_type == op::BroadcastType::BIDIRECTIONAL)
{
auto arg_shape = inputs[0]->get_shape();
@ -268,6 +271,7 @@ bool op::v1::Broadcast::visit_attributes(AttributeVisitor& visitor)
bool op::v1::Broadcast::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Broadcast::evaluate");
return op::util::BroadcastBase::evaluate(outputs, inputs);
}
@ -411,6 +415,7 @@ namespace
bool op::v0::Broadcast::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Broadcast::evaluate");
return evaluate_broadcast_v0(inputs[0], outputs[0], get_broadcast_axes(), get_output_shape(0));
}

2
ngraph/src/ngraph/op/ceiling.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/ceiling.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/util/eval_copy.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/ceiling.hpp"
@ -93,5 +94,6 @@ namespace
bool op::Ceiling::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Ceiling::evaluate");
return evaluate_ceiling(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/concat.cpp
View File

@ -17,10 +17,12 @@
#include <memory>
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/concat.hpp"
#include "ngraph/op/slice.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/concat.hpp"
using namespace std;
using namespace ngraph;
@ -164,6 +166,7 @@ namespace
bool op::Concat::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Concat::evaluate");
auto concat_axis = get_axis() < 0 ? get_axis() + inputs[0]->get_shape().size() : get_axis();
return evaluate_concat(inputs, outputs[0], concat_axis);
}

2
ngraph/src/ngraph/op/constant.cpp
View File

@ -17,6 +17,7 @@
#include <cmath>
#include <cstdio>
#include "ngraph/itt.hpp"
#include "ngraph/log.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/util/attr_types.hpp"
@ -631,6 +632,7 @@ bool op::v0::Constant::visit_attributes(AttributeVisitor& visitor)
bool op::v0::Constant::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Constant::evaluate");
auto output = outputs[0];
output->write(get_data_ptr(), output->get_size_in_bytes());
return true;

2
ngraph/src/ngraph/op/convert.cpp
View File

@ -16,6 +16,7 @@
#include <memory>
#include "ngraph/itt.hpp"
#include "ngraph/op/convert.hpp"
#include "ngraph/runtime/reference/convert.hpp"
@ -127,5 +128,6 @@ namespace
bool op::v0::Convert::evaluate(const HostTensorVector& output_values,
const HostTensorVector& input_values) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Convert::evaluate");
return evaluate_convert(input_values[0], output_values[0]);
}

3
ngraph/src/ngraph/op/cos.cpp
View File

@ -14,6 +14,8 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/itt.hpp"
#include "ngraph/op/cos.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/negative.hpp"
@ -83,5 +85,6 @@ namespace
bool op::Cos::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Cos::evaluate");
return evaluate_cos(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/cosh.cpp
View File

@ -14,6 +14,8 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/itt.hpp"
#include "ngraph/op/cosh.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/sinh.hpp"
@ -82,5 +84,6 @@ namespace
bool op::Cosh::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Cosh::evaluate");
return evaluate_cosh(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/divide.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/divide.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/negative.hpp"
#include "ngraph/runtime/host_tensor.hpp"
@ -113,6 +114,7 @@ namespace
bool op::v0::Divide::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Divide::evaluate");
return evaluate_divide(inputs[0], inputs[1], outputs[0], get_autob(), is_pythondiv());
}
@ -154,5 +156,6 @@ shared_ptr<Node> op::v1::Divide::clone_with_new_inputs(const OutputVector& new_a
bool op::v1::Divide::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Divide::evaluate");
return evaluate_divide(inputs[0], inputs[1], outputs[0], get_autob(), is_pythondiv());
}

3
ngraph/src/ngraph/op/equal.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/equal.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/equal.hpp"
@ -87,6 +88,7 @@ namespace
bool op::v0::Equal::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Equal::evaluate");
return evaluate_equal(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -110,5 +112,6 @@ shared_ptr<Node> op::v1::Equal::clone_with_new_inputs(const OutputVector& new_ar
bool op::v1::Equal::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Equal::evaluate");
return evaluate_equal(inputs[0], inputs[1], outputs[0], get_autob());
}

2
ngraph/src/ngraph/op/erf.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/erf.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/log.hpp"
#include "ngraph/util.hpp"
@ -82,5 +83,6 @@ namespace
bool op::Erf::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Erf::evaluate");
return evaluate_erf(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/exp.cpp
View File

@ -14,6 +14,8 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/itt.hpp"
#include "ngraph/op/exp.hpp"
#include "ngraph/op/multiply.hpp"
@ -81,5 +83,6 @@ namespace
bool op::Exp::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Exp::evaluate");
return evaluate_exp(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

2
ngraph/src/ngraph/op/floor.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/floor.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/util/eval_copy.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/copy.hpp"
@ -98,5 +99,6 @@ namespace
bool op::Floor::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Floor::evaluate");
return evaluate_floor(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

2
ngraph/src/ngraph/op/fused/clamp.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/fused/clamp.hpp"
#include "ngraph/builder/make_constant.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/maximum.hpp"
#include "ngraph/op/minimum.hpp"
#include "ngraph/runtime/reference/clamp.hpp"
@ -85,6 +86,7 @@ namespace
bool op::v0::Clamp::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Clamp::evaluate");
return evaluate_clamp(
inputs[0], outputs[0], get_min(), get_max(), shape_size(get_input_shape(0)));
}

2
ngraph/src/ngraph/op/fused/matmul.cpp
View File

@ -20,6 +20,7 @@
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/builder/matmul_factory.hpp"
#include "ngraph/builder/reshape.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/reshape.hpp"
#include "ngraph/runtime/reference/matmul.hpp"
@ -228,5 +229,6 @@ namespace
bool op::MatMul::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::MatMul::evaluate");
return evaluate_matmul(inputs[0], inputs[1], outputs[0], get_transpose_a(), get_transpose_b());
}

3
ngraph/src/ngraph/op/fused/prelu.cpp
View File

@ -13,8 +13,10 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/fused/prelu.hpp"
#include <runtime/reference/prelu.hpp>
#include "ngraph/itt.hpp"
#include "ngraph/builder/autobroadcast.hpp"
#include "ngraph/op/add.hpp"
@ -123,5 +125,6 @@ bool evaluate_prelu(const HostTensorPtr& arg, const HostTensorPtr& slope, const
bool op::PRelu::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::PRelu::evaluate");
return evaluate_prelu(inputs[0], inputs[1], outputs[0]);
}

2
ngraph/src/ngraph/op/fused/squeeze.cpp
View File

@ -18,6 +18,7 @@
#include <functional>
#include <set>
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/fused/squeeze.hpp"
#include "ngraph/op/reshape.hpp"
@ -206,5 +207,6 @@ namespace
bool op::v0::Squeeze::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Squeeze::evaluate");
return evaluate_squeeze(inputs[0], inputs[1], outputs[0]);
}

2
ngraph/src/ngraph/op/fused/unsqueeze.cpp
View File

@ -17,6 +17,7 @@
#include <functional>
#include <set>
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/fused/unsqueeze.hpp"
#include "ngraph/op/reshape.hpp"
@ -167,5 +168,6 @@ namespace
bool op::v0::Unsqueeze::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Unsqueeze::evaluate");
return evaluate_unsqueeze(inputs[0], inputs[1], outputs[0]);
}

3
ngraph/src/ngraph/op/gather.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/gather.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/gather.hpp"
@ -286,11 +287,13 @@ namespace
bool op::v0::Gather::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Gather::evaluate");
return evaluate_gather(inputs[0], inputs[1], outputs[0], get_axis());
}
bool op::v1::Gather::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Gather::evaluate");
int64_t axis = 0;
switch (inputs[2]->get_element_type())
{

3
ngraph/src/ngraph/op/greater.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/greater.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/greater.hpp"
@ -88,6 +89,7 @@ namespace
bool op::v0::Greater::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Greater::evaluate");
return evaluate_greater(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -112,5 +114,6 @@ shared_ptr<Node> op::v1::Greater::clone_with_new_inputs(const OutputVector& new_
bool op::v1::Greater::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Greater::evaluate");
return evaluate_greater(inputs[0], inputs[1], outputs[0], get_autob());
}

3
ngraph/src/ngraph/op/greater_eq.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/greater_eq.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/greater_eq.hpp"
@ -88,6 +89,7 @@ namespace
bool op::v0::GreaterEq::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::GreaterEq::evaluate");
return evaluate_greater_equal(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -112,5 +114,6 @@ shared_ptr<Node> op::v1::GreaterEqual::clone_with_new_inputs(const OutputVector&
bool op::v1::GreaterEqual::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::GreaterEqual::evaluate");
return evaluate_greater_equal(inputs[0], inputs[1], outputs[0], get_autob());
}

3
ngraph/src/ngraph/op/less.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/less.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/less.hpp"
@ -87,6 +88,7 @@ namespace
bool op::v0::Less::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Less::evaluate");
return evaluate_less(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -110,5 +112,6 @@ shared_ptr<Node> op::v1::Less::clone_with_new_inputs(const OutputVector& new_arg
bool op::v1::Less::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Less::evaluate");
return evaluate_less(inputs[0], inputs[1], outputs[0], get_autob());
}

3
ngraph/src/ngraph/op/less_eq.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/less_eq.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/less_eq.hpp"
@ -88,6 +89,7 @@ namespace
bool op::v1::LessEqual::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::LessEqual::evaluate");
return evaluate_less_equal(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -111,5 +113,6 @@ shared_ptr<Node> op::v0::LessEq::clone_with_new_inputs(const OutputVector& new_a
bool op::v0::LessEq::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::LessEq::evaluate");
return evaluate_less_equal(inputs[0], inputs[1], outputs[0], get_autob());
}

5
ngraph/src/ngraph/op/log.cpp
View File

@ -14,8 +14,10 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/log.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/divide.hpp"
#include "ngraph/op/log.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/log.hpp"
@ -81,5 +83,6 @@ namespace
bool op::Log::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Log::evaluate");
return evaluate_log(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/max.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/max.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/max.hpp"
#include "ngraph/shape_util.hpp"
@ -121,6 +122,7 @@ namespace
bool op::v0::Max::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Max::evaluate");
return evaluate_max(inputs[0], outputs[0], get_reduction_axes());
}
@ -143,5 +145,6 @@ shared_ptr<Node> op::v1::ReduceMax::clone_with_new_inputs(const OutputVector& ne
bool op::v1::ReduceMax::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::ReduceMax::evaluate");
return evaluate_max(inputs[0], outputs[0], get_reduction_axes());
}

3
ngraph/src/ngraph/op/max_pool.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/max_pool.hpp"
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/add.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/runtime/host_tensor.hpp"
@ -212,6 +213,8 @@ namespace
bool op::v1::MaxPool::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::MaxPool::evaluate");
auto arg_shape = inputs[0]->get_partial_shape();
auto pads_begin_s = get_pads_begin();
auto pads_end_s = get_pads_end();

3
ngraph/src/ngraph/op/maximum.cpp
View File

@ -16,6 +16,7 @@
#include <memory>
#include "ngraph/itt.hpp"
#include "ngraph/op/convert.hpp"
#include "ngraph/op/greater.hpp"
#include "ngraph/op/maximum.hpp"
@ -92,6 +93,7 @@ namespace
bool op::v0::Maximum::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Maximum::evaluate");
return evaluate_maximum(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -116,5 +118,6 @@ shared_ptr<Node> op::v1::Maximum::clone_with_new_inputs(const OutputVector& new_
bool op::v1::Maximum::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Maximum::evaluate");
return evaluate_maximum(inputs[0], inputs[1], outputs[0], get_autob());
}

3
ngraph/src/ngraph/op/min.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/min.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/min.hpp"
#include "ngraph/shape_util.hpp"
@ -121,6 +122,7 @@ namespace
bool op::v0::Min::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Min::evaluate");
return evaluate_min(inputs[0], outputs[0], get_reduction_axes());
}
@ -143,5 +145,6 @@ shared_ptr<Node> op::v1::ReduceMin::clone_with_new_inputs(const OutputVector& ne
bool op::v1::ReduceMin::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::ReduceMin::evaluate");
return evaluate_min(inputs[0], outputs[0], get_reduction_axes());
}

3
ngraph/src/ngraph/op/minimum.cpp
View File

@ -16,6 +16,7 @@
#include <memory>
#include "ngraph/itt.hpp"
#include "ngraph/op/convert.hpp"
#include "ngraph/op/less.hpp"
#include "ngraph/op/minimum.hpp"
@ -92,6 +93,7 @@ namespace
bool op::v0::Minimum::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Minimum::evaluate");
return evaluate_minimum(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -116,5 +118,6 @@ shared_ptr<Node> op::v1::Minimum::clone_with_new_inputs(const OutputVector& new_
bool op::v1::Minimum::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Minimum::evaluate");
return evaluate_minimum(inputs[0], inputs[1], outputs[0], get_autob());
}

5
ngraph/src/ngraph/op/mish.cpp
View File

@ -14,8 +14,10 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/mish.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/op/mish.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/mish.hpp"
@ -77,5 +79,6 @@ namespace
bool op::v4::Mish::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v4::Mish::evaluate");
return evaluate_mish(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/multiply.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/multiply.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/multiply.hpp"
@ -86,6 +87,7 @@ namespace
bool op::v0::Multiply::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Multiply::evaluate");
return evaluate_multiply(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -110,6 +112,7 @@ shared_ptr<Node> op::v1::Multiply::clone_with_new_inputs(const OutputVector& new
bool op::v1::Multiply::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Multiply::evaluate");
return evaluate_multiply(inputs[0], inputs[1], outputs[0], get_autob());
}

3
ngraph/src/ngraph/op/negative.cpp
View File

@ -15,7 +15,7 @@
//*****************************************************************************
#include "ngraph/op/negative.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/negate.hpp"
@ -80,6 +80,7 @@ namespace
bool op::Negative::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Negative::evaluate");
return evaluate_negative(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

2
ngraph/src/ngraph/op/non_zero.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/non_zero.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/op.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/non_zero.hpp"
@ -161,5 +162,6 @@ namespace
bool op::v3::NonZero::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v3::NonZero::evaluate");
return evaluate_nonzero(inputs[0], outputs[0]);
}

4
ngraph/src/ngraph/op/not.cpp
View File

@ -14,6 +14,8 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/itt.hpp"
#include "ngraph/op/not.hpp"
#include "ngraph/op/op.hpp"
#include "ngraph/op/util/elementwise_args.hpp"
@ -94,6 +96,7 @@ namespace
bool op::v1::LogicalNot::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::LogicalNot::evaluate");
return evaluate_not(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}
@ -123,5 +126,6 @@ shared_ptr<Node> op::v0::Not::clone_with_new_inputs(const OutputVector& new_args
bool op::Not::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Not::evaluate");
return evaluate_not(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/not_equal.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/not_equal.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/not_equal.hpp"
@ -88,6 +89,7 @@ namespace
bool op::v0::NotEqual::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::NotEqual::evaluate");
return evaluate_not_equal(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -112,5 +114,6 @@ shared_ptr<Node> op::v1::NotEqual::clone_with_new_inputs(const OutputVector& new
bool op::v1::NotEqual::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::NotEqual::evaluate");
return evaluate_not_equal(inputs[0], inputs[1], outputs[0], get_autob());
}

3
ngraph/src/ngraph/op/or.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/or.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/or.hpp"
@ -86,6 +87,7 @@ namespace
bool op::v1::LogicalOr::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::LogicalOr::evaluate");
return evaluate_logor(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -107,5 +109,6 @@ shared_ptr<Node> op::v0::Or::clone_with_new_inputs(const OutputVector& new_args)
bool op::v0::Or::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Or::evaluate");
return evaluate_logor(inputs[0], inputs[1], outputs[0], get_autob());
}

3
ngraph/src/ngraph/op/power.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/power.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/divide.hpp"
#include "ngraph/op/log.hpp"
#include "ngraph/op/multiply.hpp"
@ -88,6 +89,7 @@ namespace
bool op::v0::Power::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Power::evaluate");
return evaluate_power(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -111,5 +113,6 @@ shared_ptr<Node> op::v1::Power::clone_with_new_inputs(const OutputVector& new_ar
bool op::v1::Power::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Power::evaluate");
return evaluate_power(inputs[0], inputs[1], outputs[0], get_autob());
}

5
ngraph/src/ngraph/op/prior_box.cpp
View File

@ -14,8 +14,10 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/prior_box.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/prior_box.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/prior_box.hpp"
@ -211,5 +213,6 @@ namespace
bool op::v0::PriorBox::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::PriorBox::evaluate");
return evaluate_prior_box(inputs[0], inputs[1], outputs[0], get_attrs());
}

5
ngraph/src/ngraph/op/prior_box_clustered.cpp
View File

@ -14,8 +14,10 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/prior_box_clustered.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/prior_box_clustered.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/prior_box_clustered.hpp"
@ -166,5 +168,6 @@ namespace
bool op::v0::PriorBoxClustered::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::PriorBoxClustered::evaluate");
return evaluate_prior_box(inputs[0], inputs[1], outputs[0], get_attrs());
}

2
ngraph/src/ngraph/op/product.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/product.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/product.hpp"
#include "ngraph/shape_util.hpp"
@ -85,5 +86,6 @@ namespace
bool op::v0::Product::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Product::evaluate");
return evaluate_product(inputs[0], outputs[0], get_reduction_axes());
}

3
ngraph/src/ngraph/op/range.cpp
View File

@ -16,6 +16,7 @@
#include <algorithm>
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/range.hpp"
#include "ngraph/runtime/host_tensor.hpp"
@ -279,6 +280,8 @@ bool try_evaluate_range(const HostTensorPtr& out,
bool op::v0::Range::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Range::evaluate");
HostTensorPtr out = outputs[0];
HostTensorPtr start = inputs[0];
HostTensorPtr stop = inputs[1];

3
ngraph/src/ngraph/op/reduce_logical_and.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/reduce_logical_and.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/log.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/eval_helpers.hpp"
@ -67,6 +68,8 @@ namespace
bool op::v1::ReduceLogicalAnd::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::ReduceLogicalAnd::evaluate");
const auto& data = inputs[0];
const auto& axes = inputs[1];
const auto& out = outputs[0];

3
ngraph/src/ngraph/op/reduce_logical_or.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/reduce_logical_or.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/log.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/eval_helpers.hpp"
@ -67,6 +68,8 @@ namespace
bool op::v1::ReduceLogicalOr::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::ReduceLogicalOr::evaluate");
const auto& data = inputs[0];
const auto& axes = inputs[1];
const auto& out = outputs[0];

2
ngraph/src/ngraph/op/reduce_mean.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/reduce_mean.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/broadcast.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/mean.hpp"
@ -77,5 +78,6 @@ namespace
bool op::v1::ReduceMean::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::ReduceMean::evaluate");
return evaluate_mean(inputs[0], outputs[0], get_reduction_axes());
}

2
ngraph/src/ngraph/op/reduce_prod.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/reduce_prod.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/product.hpp"
#include "ngraph/shape_util.hpp"
@ -81,5 +82,6 @@ namespace
bool op::v1::ReduceProd::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::ReduceProd::evaluate");
return evaluate_product(inputs[0], outputs[0], get_reduction_axes());
}

2
ngraph/src/ngraph/op/reduce_sum.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/reduce_sum.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/broadcast.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/sum.hpp"
@ -82,5 +83,6 @@ namespace
bool op::v1::ReduceSum::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::ReduceSum::evaluate");
return evaluate_sum(inputs[0], outputs[0], get_reduction_axes());
}

5
ngraph/src/ngraph/op/relu.cpp
View File

@ -14,8 +14,10 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/relu.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/relu.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/relu.hpp"
@ -76,5 +78,6 @@ namespace
bool op::Relu::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Relu::evaluate");
return evaluate_relu(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

4
ngraph/src/ngraph/op/reshape.cpp
View File

@ -18,6 +18,7 @@
#include <iostream>
#include "ngraph/function.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/reshape.hpp"
#include "ngraph/runtime/opt_kernel/reshape.hpp"
@ -154,6 +155,7 @@ bool op::Reshape::visit_attributes(AttributeVisitor& visitor)
bool op::v0::Reshape::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Reshape::evaluate");
return evaluate_reshape(inputs[0], outputs[0], get_input_order());
}
@ -330,6 +332,8 @@ shared_ptr<Node> op::v1::Reshape::clone_with_new_inputs(const OutputVector& new_
bool op::v1::Reshape::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Reshape::evaluate");
// infer and set output shape if the output shape contain -1
// and zero value dimension
size_t output_rank = inputs[1]->get_shape()[0];

2
ngraph/src/ngraph/op/result.cpp
View File

@ -18,6 +18,7 @@
#include <typeindex>
#include <typeinfo>
#include "ngraph/itt.hpp"
#include "ngraph/node.hpp"
#include "ngraph/op/result.hpp"
#include "ngraph/runtime/host_tensor.hpp"
@ -57,6 +58,7 @@ shared_ptr<Node> op::Result::clone_with_new_inputs(const OutputVector& new_args)
bool op::Result::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Result::evaluate");
outputs[0]->set_unary(inputs[0]);
void* output = outputs[0]->get_data_ptr();
void* input = inputs[0]->get_data_ptr();

2
ngraph/src/ngraph/op/round.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/round.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/util/eval_copy.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/copy.hpp"
@ -93,5 +94,6 @@ namespace
bool op::Round::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Round::evaluate");
return evaluate_round(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/scatter_elements_update.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/scatter_elements_update.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/util/op_types.hpp"
#include "ngraph/runtime/reference/scatter_elements_update.hpp"
@ -271,6 +272,8 @@ namespace
bool op::v3::ScatterElementsUpdate::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v3::ScatterElementsUpdate::evaluate");
int64_t axis = 0;
switch (inputs[3]->get_element_type())
{

5
ngraph/src/ngraph/op/shape_of.cpp
View File

@ -17,6 +17,7 @@
#include <algorithm>
#include <vector>
#include "ngraph/itt.hpp"
#include "ngraph/op/concat.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/gather.hpp"
@ -158,11 +159,13 @@ namespace
bool op::v3::ShapeOf::evaluate(const HostTensorVector& output_values,
const HostTensorVector& input_values) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v3::ShapeOf::evaluate");
return evaluate_shape_of(output_values[0], input_values[0]);
}
bool op::v3::ShapeOf::constant_fold(OutputVector& output_values, const OutputVector& input_values)
{
OV_ITT_SCOPED_TASK(itt::domains::nGraph, "op::v3::ShapeOf::constant_fold");
return constant_fold_shape_of(this, output_values[0], input_values[0], m_is_foldable);
}
@ -197,10 +200,12 @@ shared_ptr<Node> op::v0::ShapeOf::clone_with_new_inputs(const OutputVector& new_
bool op::v0::ShapeOf::evaluate(const HostTensorVector& output_values,
const HostTensorVector& input_values) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::ShapeOf::evaluate");
return evaluate_shape_of(output_values[0], input_values[0]);
}
bool op::v0::ShapeOf::constant_fold(OutputVector& output_values, const OutputVector& input_values)
{
OV_ITT_SCOPED_TASK(itt::domains::nGraph, "op::v0::ShapeOf::constant_fold");
return constant_fold_shape_of(this, output_values[0], input_values[0], m_is_foldable);
}

3
ngraph/src/ngraph/op/sigmoid.cpp
View File

@ -15,6 +15,8 @@
//*****************************************************************************
#include "ngraph/op/sigmoid.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/log.hpp"
#include "ngraph/util.hpp"
@ -77,5 +79,6 @@ namespace
bool op::Sigmoid::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Sigmoid::evaluate");
return evaluate_sigmoid(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/sign.cpp
View File

@ -14,6 +14,8 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/itt.hpp"
#include "ngraph/op/sign.hpp"
using namespace std;
@ -80,5 +82,6 @@ namespace
bool op::Sign::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Sign::evaluate");
return evaluate_sign(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

5
ngraph/src/ngraph/op/sin.cpp
View File

@ -14,9 +14,11 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/sin.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/cos.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/sin.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/sin.hpp"
@ -82,5 +84,6 @@ namespace
bool op::Sin::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Sin::evaluate");
return evaluate_sin(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

5
ngraph/src/ngraph/op/sinh.cpp
View File

@ -14,9 +14,11 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/sinh.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/cosh.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/sinh.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/sinh.hpp"
@ -82,5 +84,6 @@ namespace
bool op::Sinh::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Sinh::evaluate");
return evaluate_sinh(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

3
ngraph/src/ngraph/op/softmax.cpp
View File

@ -20,6 +20,7 @@
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/builder/autobroadcast.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/reshape.hpp"
@ -153,6 +154,7 @@ namespace
bool op::v0::Softmax::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Softmax::evaluate");
outputs[0]->set_unary(inputs[0]);
return evaluate_softmax(inputs[0], outputs[0], get_axes());
}
@ -197,6 +199,7 @@ shared_ptr<Node> op::v1::Softmax::clone_with_new_inputs(const OutputVector& new_
bool op::v1::Softmax::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Softmax::evaluate");
outputs[0]->set_unary(inputs[0]);
return evaluate_softmax(inputs[0], outputs[0], AxisSet{m_axis});
}

5
ngraph/src/ngraph/op/sqrt.cpp
View File

@ -14,9 +14,11 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/sqrt.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/add.hpp"
#include "ngraph/op/divide.hpp"
#include "ngraph/op/sqrt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/sqrt.hpp"
@ -79,5 +81,6 @@ namespace
bool op::Sqrt::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Sqrt::evaluate");
return evaluate_sqrt(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

2
ngraph/src/ngraph/op/strided_slice.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/strided_slice.hpp"
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/broadcast.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/gather.hpp"
@ -291,6 +292,7 @@ namespace
bool op::v1::StridedSlice::evaluate(const HostTensorVector& output_values,
const HostTensorVector& input_values) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::StridedSlice::evaluate");
return evaluate_strided_slice(input_values[0],
input_values[1],
input_values[2],

3
ngraph/src/ngraph/op/subtract.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/subtract.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/negative.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/subtract.hpp"
@ -92,6 +93,7 @@ namespace
bool op::v0::Subtract::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Subtract::evaluate");
return evaluate_subtract(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -116,5 +118,6 @@ shared_ptr<Node> op::v1::Subtract::clone_with_new_inputs(const OutputVector& new
bool op::v1::Subtract::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Subtract::evaluate");
return evaluate_subtract(inputs[0], inputs[1], outputs[0], get_autob());
}

2
ngraph/src/ngraph/op/sum.cpp
View File

@ -16,6 +16,7 @@
#include "ngraph/op/sum.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/broadcast.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/sum.hpp"
@ -85,5 +86,6 @@ namespace
bool op::v0::Sum::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Sum::evaluate");
return evaluate_sum(inputs[0], outputs[0], get_reduction_axes());
}

5
ngraph/src/ngraph/op/tan.cpp
View File

@ -14,10 +14,12 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/tan.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/cos.hpp"
#include "ngraph/op/divide.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/tan.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/tan.hpp"
@ -83,5 +85,6 @@ namespace
bool op::Tan::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Tan::evaluate");
return evaluate_tan(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

5
ngraph/src/ngraph/op/tanh.cpp
View File

@ -14,9 +14,11 @@
// limitations under the License.
//*****************************************************************************
#include "ngraph/op/tanh.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/subtract.hpp"
#include "ngraph/op/tanh.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/tanh.hpp"
@ -80,5 +82,6 @@ namespace
bool op::Tanh::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::Tanh::evaluate");
return evaluate_tanh(inputs[0], outputs[0], shape_size(get_output_shape(0)));
}

6
ngraph/src/ngraph/op/topk.cpp
View File

@ -18,6 +18,7 @@
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/axis_vector.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/topk.hpp"
#include "ngraph/op/util/op_types.hpp"
@ -379,6 +380,8 @@ Shape op::v0::TopK::compute_output_shape(const Shape input_shape,
bool op::v0::TopK::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::TopK::evaluate");
// check data types for arg, k and output element type
Shape arg_shape = inputs[0]->get_shape();
@ -660,6 +663,8 @@ void op::v1::TopK::set_k(size_t k)
bool op::v1::TopK::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::TopK::evaluate");
Shape arg_shape = inputs[0]->get_shape();
// 1. get axis, mode ( max/min), sort_type
size_t axis = ngraph::normalize_axis(this, m_axis, arg_shape.size());
@ -786,5 +791,6 @@ shared_ptr<Node> op::v3::TopK::clone_with_new_inputs(const OutputVector& new_arg
bool op::v3::TopK::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v3::TopK::evaluate");
return op::v1::TopK::evaluate(outputs, inputs);
}

2
ngraph/src/ngraph/op/transpose.cpp
View File

@ -16,6 +16,7 @@
#include <iostream>
#include "ngraph/itt.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/transpose.hpp"
#include "ngraph/runtime/opt_kernel/reshape.hpp"
@ -145,5 +146,6 @@ namespace
bool op::v1::Transpose::evaluate(const HostTensorVector& output_values,
const HostTensorVector& input_values) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::Transpose::evaluate");
return evaluate_transpose(input_values[0], input_values[1], output_values[0]);
}

4
ngraph/src/ngraph/op/util/broadcast_base.cpp
View File

@ -16,6 +16,7 @@
#include "broadcast_base.hpp"
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/op/concat.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/sum.hpp"
@ -299,6 +300,7 @@ bool op::util::BroadcastBase::evaluate(const HostTensorPtr& arg0,
const HostTensorPtr& out,
const AxisSet& broadcast_axes) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::util::BroadcastBase::evaluate<ET>");
using T = typename element_type_traits<ET>::value_type;
runtime::reference::broadcast<T>((arg0->get_data_ptr<ET>()),
(out->get_data_ptr<ET>()),
@ -462,6 +464,8 @@ Shape op::util::BroadcastBase::get_target_shape(const HostTensorPtr& input1) con
bool op::util::BroadcastBase::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::util::BroadcastBase::evaluate");
Shape target_shape = get_target_shape(inputs[1]);
PartialShape result_shape;

3
ngraph/src/ngraph/op/xor.cpp
View File

@ -15,6 +15,7 @@
//*****************************************************************************
#include "ngraph/op/xor.hpp"
#include "ngraph/itt.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/xor.hpp"
@ -92,6 +93,7 @@ namespace
bool op::v1::LogicalXor::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v1::LogicalXor::evaluate");
return evaluate_logxor(inputs[0], inputs[1], outputs[0], get_autob());
}
@ -113,5 +115,6 @@ shared_ptr<Node> op::v0::Xor::clone_with_new_inputs(const OutputVector& new_args
bool op::v0::Xor::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Xor::evaluate");
return evaluate_logxor(inputs[0], inputs[1], outputs[0], get_autob());
}

3
ngraph/src/ngraph/pass/graph_rewrite.cpp
View File

@ -68,7 +68,7 @@ NGRAPH_RTTI_DEFINITION(ngraph::pass::MatcherPass, "ngraph::pass::MatcherPass", 0
bool pass::GraphRewrite::run_on_function(shared_ptr<Function> f)
{
OV_ITT_SCOPED_TASK(itt::domains::Ngraph, "pass::GraphRewrite::run_on_function");
OV_ITT_SCOPED_TASK(itt::domains::nGraph, "pass::GraphRewrite::run_on_function");
bool rewritten = false;
@ -357,6 +357,7 @@ void ngraph::pass::MatcherPass::register_matcher(const std::shared_ptr<ngraph::p
bool ngraph::pass::MatcherPass::apply(std::shared_ptr<ngraph::Node> node)
{
OV_ITT_SCOPED_TASK(itt::domains::nGraph, "ngraph::pass::MatcherPass::apply");
m_new_nodes.clear();
return m_handler(node);
}

2
ngraph/src/ngraph/pass/manager.cpp
View File

@ -45,7 +45,7 @@ pass::Manager::~Manager()
void pass::Manager::run_passes(shared_ptr<Function> func, bool /* transitive */)
{
OV_ITT_SCOPED_TASK(itt::domains::Ngraph, "pass::Manager::run_passes");
OV_ITT_SCOPED_TASK(itt::domains::nGraph, "pass::Manager::run_passes");
static bool profile_enabled = getenv_bool("NGRAPH_PROFILE_PASS_ENABLE");

2
ngraph/src/ngraph/specialize_function.cpp
View File

@ -31,7 +31,7 @@ std::shared_ptr<Function>
const std::vector<void*>& parameter_values)
{
OV_ITT_SCOPED_TASK(itt::domains::Ngraph, "specialize_function");
OV_ITT_SCOPED_TASK(itt::domains::nGraph, "specialize_function");
NGRAPH_CHECK(f->get_parameters().size() == parameter_shapes.size());
NGRAPH_CHECK(f->get_parameters().size() == parameter_element_types.size());

6
openvino/itt/CMakeLists.txt
View File

@ -31,10 +31,8 @@ add_library(${TARGET_NAME} STATIC ${SOURCES})
add_library(openvino::itt ALIAS ${TARGET_NAME})
if (ENABLE_PROFILING_ITT AND INTEL_ITT_LIBS)
target_include_directories(${TARGET_NAME} SYSTEM PRIVATE $<TARGET_PROPERTY:ittnotify,INTERFACE_INCLUDE_DIRECTORIES>)
target_compile_definitions(${TARGET_NAME} PRIVATE $<TARGET_PROPERTY:ittnotify,INTERFACE_COMPILE_DEFINITIONS>)
target_link_libraries(${TARGET_NAME} PUBLIC ${INTEL_ITT_LIBS})
if(TARGET ittnotify)
target_link_libraries(${TARGET_NAME} PUBLIC ittnotify)
endif()
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")

5
openvino/itt/cmake/FindITT.cmake
View File

@ -47,10 +47,13 @@ find_package_handle_standard_args(ITT
if(ITT_FOUND)
set(INTEL_ITT_FOUND ${ITT_FOUND})
add_library(ittnotify STATIC IMPORTED GLOBAL)
set_target_properties(ittnotify PROPERTIES IMPORTED_LOCATION "${Located_ITT_LIBS}"
INTERFACE_INCLUDE_DIRECTORIES ${Located_ITT_INCLUDE_DIRS}
INTERFACE_COMPILE_DEFINITIONS ENABLE_PROFILING_ITT)
set(INTEL_ITT_LIBS ittnotify)
if(UNIX)
set_target_properties(ittnotify PROPERTIES INTERFACE_LINK_LIBRARIES "${CMAKE_DL_LIBS};Threads::Threads")
endif()
endif()

22
openvino/itt/include/openvino/itt.hpp
View File

@ -135,21 +135,39 @@ namespace openvino
* @ingroup ie_dev_profiling
* @brief Declare domain with a given name.
* @param domainName [in] Known at compile time name of module or library (the domain name).
* @param domainDisplayName [in] Domain name used as the ITT counter name and displayed in Intel VTune. Parameter is optional.
*/
#define OV_ITT_DOMAIN(domainName) \
#define OV_ITT_DOMAIN(...) OV_ITT_MACRO_OVERLOAD(OV_ITT_DOMAIN, __VA_ARGS__)
/**
* @cond
*/
#define OV_ITT_DOMAIN_1(domainName) \
inline openvino::itt::domain_t domainName() noexcept \
{ \
static auto d = openvino::itt::internal::domain(#domainName); \
return d; \
}
#define OV_ITT_DOMAIN_2(domainName, domainDisplayName) \
inline openvino::itt::domain_t domainName() noexcept \
{ \
static auto d = openvino::itt::internal::domain(domainDisplayName); \
return d; \
}
/**
* @endcond
*/
/**
* @def OV_ITT_SCOPED_TASK(domain, handleOrTaskName)
* @ingroup ie_dev_profiling
* @brief Annotate section of code till scope exit to be profiled using known @p handle or @p taskName as section id.
* @details In case if handle or taskName absent, the current function name is used.
* @param domainName [in] Known at compile time name of module or library (the domain name).
* @param handleOrTaskName [in] The annotation name or handle for section of code.
* @param handleOrTaskName [in] The annotation name or handle for section of code. Parameter is optional.
*/
#define OV_ITT_SCOPED_TASK(...) OV_ITT_MACRO_OVERLOAD(OV_ITT_SCOPED_TASK, __VA_ARGS__)