Organized source by using macro

src/frontends/onnx/frontend/CMakeLists.txt

@@ -6,10 +6,12 @@ if(NOT BUILD_SHARED_LIBS)
     file(GLOB_RECURSE op_list "src/op/*.cpp")
     set(static_reg_file "src/static_reg.hpp")
     file(WRITE ${static_reg_file} "// Copyright (C) 2018-2024 Intel Corporation\n// SPDX-License-Identifier: Apache-2.0\n// Auto generated file, DO NOT EDIT INLINE\n\n")
+    file(APPEND ${static_reg_file} "#include \"core/operator_set.hpp\"\n\n")
+    file(APPEND ${static_reg_file} "#define ONNX_DECL_OP(op) extern ov::OutputVector op(const Node&)\n\n")
     file(APPEND ${static_reg_file} "namespace ov {\nnamespace frontend {\nnamespace onnx {\n")
     foreach(src ${op_list})
         file(READ ${src} source_code)
-        string(REGEX MATCHALL "register_translator([^;]+);" matches "${source_code}")
+        string(REGEX MATCHALL "ONNX_OP([^;]+);" matches "${source_code}")
         foreach(match ${matches})
             if(${match} MATCHES "([a-z0-9_]+)::([a-z0-9_]+)::([a-z0-9_]+)")
                 list(APPEND declarations ${CMAKE_MATCH_0})
@@ -46,7 +48,7 @@ if(NOT BUILD_SHARED_LIBS)
         if(NOT op_name STREQUAL CMAKE_MATCH_3)
             set(op_name ${CMAKE_MATCH_3})
             if(NOT op_name STREQUAL "register_multiple_translators")
-                file(APPEND ${static_reg_file} "extern ov::OutputVector ${CMAKE_MATCH_3}(const Node&);\n")
+                file(APPEND ${static_reg_file} "ONNX_DECL_OP(${CMAKE_MATCH_3});\n")
             else()
                 file(APPEND ${static_reg_file} "extern bool ${CMAKE_MATCH_3}(void);\n")
             endif()
@@ -60,10 +62,11 @@ if(NOT BUILD_SHARED_LIBS)
     endif()
     file(APPEND ${static_reg_file} "\nvoid static_lib_registration(void) {\n")
     foreach(reg ${registrations})
+        string(REPLACE "ONNX_OP(" "ONNX_OP_M(" reg ${reg})
         file(APPEND ${static_reg_file} "    ${reg};\n")
     endforeach()
     file(APPEND ${static_reg_file} "}\n")
-    file(APPEND ${static_reg_file} "}  // namespace onnx\n}  // namespace frontend\n}  // namespace ov\n")
+    file(APPEND ${static_reg_file} "}  // namespace onnx\n}  // namespace frontend\n}  // namespace ov\n#undef ONNX_DECL_OP\n")
 endif()
 
 ov_add_frontend(NAME onnx

src/frontends/onnx/frontend/src/core/operator_set.hpp

@@ -36,6 +36,15 @@ extern bool register_translator(const std::string name,
                                 const Operator fn,
                                 const std::string domain = "");
 
+#define OPSET_RANGE(_in, _until) \
+    VersionRange {               \
+        _in, _until              \
+    }
+#define OPSET_SINCE(_since)             VersionRange::since(_since)
+#define OPSET_IN(_in)                   VersionRange::in(_in)
+#define ONNX_OP_M(name, range, fn, ...) register_translator(name, range, fn, __VA_ARGS__)
+#define ONNX_OP(name, range, fn, ...)   static bool onnx_op_reg = ONNX_OP_M(name, range, fn, __VA_ARGS__)
+
 }  // namespace onnx
 }  // namespace frontend
 }  // namespace ov

src/frontends/onnx/frontend/src/op/abs.cpp

@@ -18,15 +18,15 @@ ov::OutputVector abs(const ov::frontend::onnx::Node& node) {
                      "consumed_inputs legacy attribute of Abs op is not supported");
     return {std::make_shared<ov::op::v0::Abs>(node.get_ov_inputs().at(0))};
 }
-static bool registered = register_translator("Abs", {1, 5}, ai_onnx::opset_1::abs);
+ONNX_OP("Abs", OPSET_RANGE(1, 5), ai_onnx::opset_1::abs);
 }  // namespace opset_1
 
 namespace opset_6 {
-static bool registered = register_translator("Abs", {6, 12}, ai_onnx::opset_1::abs);
+ONNX_OP("Abs", OPSET_RANGE(6, 12), ai_onnx::opset_1::abs);
 }  // namespace opset_6
 
 namespace opset_13 {
-static bool registered = register_translator("Abs", VersionRange::since(13), ai_onnx::opset_1::abs);
+ONNX_OP("Abs", OPSET_SINCE(13), ai_onnx::opset_1::abs);
 }  // namespace opset_13
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/acos.cpp

@@ -14,8 +14,7 @@ namespace opset_7 {
 ov::OutputVector acos(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<ov::op::v0::Acos>(node.get_ov_inputs().at(0))};
 }
-static bool registered =
-    register_translator("Acos", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_7::acos);
+ONNX_OP("Acos", OPSET_SINCE(1), ai_onnx::opset_7::acos);
 }  // namespace opset_7
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/acosh.cpp

@@ -14,8 +14,7 @@ namespace opset_9 {
 ov::OutputVector acosh(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<ov::op::v3::Acosh>(node.get_ov_inputs().at(0))};
 }
-static bool registered =
-    register_translator("Acosh", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_9::acosh);
+ONNX_OP("Acosh", OPSET_SINCE(1), ai_onnx::opset_9::acosh);
 }  // namespace opset_9
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/adaptive_avg_pooling2d.cpp

@@ -21,10 +21,7 @@ ov::OutputVector adaptive_avg_pooling2d(const ov::frontend::onnx::Node& node) {
 
     return {std::make_shared<v8::AdaptiveAvgPool>(inputs[0], inputs[1])};
 }
-static bool registered = register_translator("adaptive_avg_pool2d",
-                                             VersionRange::single_version_for_all_opsets(),
-                                             ai_onnx::opset_1::adaptive_avg_pooling2d,
-                                             PYTORCH_ATEN_DOMAIN);
+ONNX_OP("adaptive_avg_pool2d", OPSET_SINCE(1), ai_onnx::opset_1::adaptive_avg_pooling2d, PYTORCH_ATEN_DOMAIN);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/add.cpp

@@ -21,29 +21,29 @@ ov::OutputVector add(const ov::frontend::onnx::Node& node) {
                      "consumed_inputs legacy attribute of Add op is not supported");
     return common::handle_opset6_binary_op<v1::Add>(node);
 }
-static bool registered = register_translator("Add", {1, 5}, ai_onnx::opset_1::add);
+ONNX_OP("Add", OPSET_RANGE(1, 5), ai_onnx::opset_1::add);
 }  // namespace opset_1
 
 namespace opset_6 {
 ov::OutputVector add(const ov::frontend::onnx::Node& node) {
     return common::handle_opset6_binary_op<v1::Add>(node);
 }
-static bool registered = register_translator("Add", VersionRange::in(6), ai_onnx::opset_6::add);
+ONNX_OP("Add", OPSET_IN(6), ai_onnx::opset_6::add);
 }  // namespace opset_6
 
 namespace opset_7 {
 ov::OutputVector add(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<v1::Add>(node.get_ov_inputs().at(0), node.get_ov_inputs().at(1))};
 }
-static bool registered = register_translator("Add", {7, 12}, ai_onnx::opset_7::add);
+ONNX_OP("Add", OPSET_RANGE(7, 12), ai_onnx::opset_7::add);
 }  // namespace opset_7
 
 namespace opset_13 {
-static bool registered = register_translator("Add", VersionRange::in(13), ai_onnx::opset_7::add);
+ONNX_OP("Add", OPSET_IN(13), ai_onnx::opset_7::add);
 }  // namespace opset_13
 
 namespace opset_14 {
-static bool registered = register_translator("Add", VersionRange::since(14), ai_onnx::opset_7::add);
+ONNX_OP("Add", OPSET_SINCE(14), ai_onnx::opset_7::add);
 }  // namespace opset_14
 
 }  // namespace ai_onnx

src/frontends/onnx/frontend/src/op/affine.cpp

@@ -31,8 +31,7 @@ ov::OutputVector affine(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<v1::Add>(std::make_shared<v1::Multiply>(data, alpha_const), beta_const)};
 }
 
-static bool registered =
-    register_translator("Affine", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::affine);
+ONNX_OP("Affine", OPSET_SINCE(1), ai_onnx::opset_1::affine);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/and.cpp

@@ -14,14 +14,14 @@ namespace opset_1 {
 ov::OutputVector logical_and(const ov::frontend::onnx::Node& node) {
     return common::handle_opset6_binary_op<ov::op::v1::LogicalAnd>(node);
 }
-static bool registered = register_translator("And", {1, 6}, ai_onnx::opset_1::logical_and);
+ONNX_OP("And", OPSET_RANGE(1, 6), ai_onnx::opset_1::logical_and);
 }  // namespace opset_1
 
 namespace opset_7 {
 ov::OutputVector logical_and(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<ov::op::v1::LogicalAnd>(node.get_ov_inputs().at(0), node.get_ov_inputs().at(1))};
 }
-static bool registered = register_translator("And", VersionRange::since(7), ai_onnx::opset_7::logical_and);
+ONNX_OP("And", OPSET_SINCE(7), ai_onnx::opset_7::logical_and);
 }  // namespace opset_7
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/argmax.cpp

@@ -15,7 +15,7 @@ ov::OutputVector argmax(const ov::frontend::onnx::Node& node) {
     return {arg_factory.make_arg_max()};
 }
 
-static bool registered = register_translator("ArgMax", {1, 11}, ai_onnx::opset_1::argmax);
+ONNX_OP("ArgMax", OPSET_RANGE(1, 11), ai_onnx::opset_1::argmax);
 }  // namespace opset_1
 
 namespace opset_12 {
@@ -24,7 +24,7 @@ ov::OutputVector argmax(const ov::frontend::onnx::Node& node) {
     return {arg_factory.make_arg_max()};
 }
 
-static bool registered = register_translator("ArgMax", VersionRange::since(12), ai_onnx::opset_12::argmax);
+ONNX_OP("ArgMax", OPSET_SINCE(12), ai_onnx::opset_12::argmax);
 }  // namespace opset_12
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/argmin.cpp

@@ -15,7 +15,7 @@ ov::OutputVector argmin(const ov::frontend::onnx::Node& node) {
     return {arg_factory.make_arg_min()};
 }
 
-static bool registered = register_translator("ArgMin", {1, 11}, ai_onnx::opset_1::argmin);
+ONNX_OP("ArgMin", {1, 11}, ai_onnx::opset_1::argmin);
 }  // namespace opset_1
 
 namespace opset_12 {
@@ -24,7 +24,7 @@ ov::OutputVector argmin(const ov::frontend::onnx::Node& node) {
     return {arg_factory.make_arg_min()};
 }
 
-static bool registered = register_translator("ArgMin", VersionRange::since(12), ai_onnx::opset_12::argmin);
+ONNX_OP("ArgMin", OPSET_SINCE(12), ai_onnx::opset_12::argmin);
 }  // namespace opset_12
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/asin.cpp

@@ -14,8 +14,7 @@ namespace opset_1 {
 ov::OutputVector asin(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<ov::op::v0::Asin>(node.get_ov_inputs().at(0))};
 }
-static bool registered =
-    register_translator("Asin", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::asin);
+ONNX_OP("Asin", OPSET_SINCE(1), ai_onnx::opset_1::asin);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/asinh.cpp

@@ -14,8 +14,7 @@ namespace opset_1 {
 ov::OutputVector asinh(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<ov::op::v3::Asinh>(node.get_ov_inputs().at(0))};
 }
-static bool registered =
-    register_translator("Asinh", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::asinh);
+ONNX_OP("Asinh", OPSET_SINCE(1), ai_onnx::opset_1::asinh);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/atan.cpp

@@ -14,8 +14,7 @@ namespace opset_1 {
 ov::OutputVector atan(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<ov::op::v0::Atan>(node.get_ov_inputs().at(0))};
 }
-static bool registered =
-    register_translator("Atan", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::atan);
+ONNX_OP("Atan", OPSET_SINCE(1), ai_onnx::opset_1::atan);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/atanh.cpp

@@ -14,8 +14,7 @@ namespace opset_1 {
 ov::OutputVector atanh(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<ov::op::v3::Atanh>(node.get_ov_inputs().at(0))};
 }
-static bool registered =
-    register_translator("Atanh", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::atanh);
+ONNX_OP("Atanh", OPSET_SINCE(1), ai_onnx::opset_1::atanh);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/aten.cpp

@@ -94,8 +94,7 @@ ov::OutputVector aten(const ov::frontend::onnx::Node& node) {
     return ov::OutputVector(node.get_outputs_size(), embedding_bag);
 }
 
-static bool registered =
-    register_translator("ATen", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::aten);
+ONNX_OP("ATen", OPSET_SINCE(1), ai_onnx::opset_1::aten);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/average_pool.cpp

@@ -13,8 +13,7 @@ ov::OutputVector average_pool(const ov::frontend::onnx::Node& node) {
     return pooling::PoolingFactory(node).make_avg_pool();
 }
 
-static bool registered =
-    register_translator("AveragePool", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::average_pool);
+ONNX_OP("AveragePool", OPSET_SINCE(1), ai_onnx::opset_1::average_pool);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/batch_norm.cpp

@@ -50,7 +50,7 @@ ov::OutputVector batch_norm(const ov::frontend::onnx::Node& node) {
 
     OPENVINO_THROW("Cannot create OpenVINO batch norm with unsupported number of inputs");
 }
-static bool registered = register_translator("BatchNormalization", {1, 6}, ai_onnx::opset_1::batch_norm);
+ONNX_OP("BatchNormalization", OPSET_RANGE(1, 6), ai_onnx::opset_1::batch_norm);
 }  // namespace opset_1
 /*
      Opset 6 is skipped because there are no significant difference between opset1 and opset6.
@@ -77,7 +77,7 @@ ov::OutputVector batch_norm(const ov::frontend::onnx::Node& node) {
 
     return {std::make_shared<v5::BatchNormInference>(x, scale, bias, mean, var, epsilon)};
 }
-static bool registered = register_translator("BatchNormalization", {7, 13}, ai_onnx::opset_7::batch_norm);
+ONNX_OP("BatchNormalization", OPSET_RANGE(7, 13), ai_onnx::opset_7::batch_norm);
 }  // namespace opset_7
 /*
     Opset 9 is skipped because there are no significant difference between opset7 and opset9.
@@ -106,8 +106,7 @@ ov::OutputVector batch_norm(const ov::frontend::onnx::Node& node) {
                      "Training mode of BatchNormalization is not supported.");
     return {std::make_shared<v5::BatchNormInference>(x, scale, bias, mean, var, epsilon)};
 }
-static bool registered =
-    register_translator("BatchNormalization", VersionRange::since(14), ai_onnx::opset_14::batch_norm);
+ONNX_OP("BatchNormalization", OPSET_SINCE(14), ai_onnx::opset_14::batch_norm);
 }  // namespace opset_14
 /*
      Opset 15 is skipped because there are no significant difference between opset14 and opset15.

src/frontends/onnx/frontend/src/op/bitshift.cpp

@@ -39,8 +39,7 @@ ov::OutputVector bitshift(const ov::frontend::onnx::Node& node) {
     }
 }
 
-static bool registered =
-    register_translator("BitShift", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::bitshift);
+ONNX_OP("BitShift", OPSET_SINCE(1), ai_onnx::opset_1::bitshift);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/bitwise_and.cpp

@@ -17,8 +17,7 @@ ov::OutputVector bitwise_and(const ov::frontend::onnx::Node& node) {
     OPENVINO_ASSERT(inputs.size() == 2);
     return {std::make_shared<v13::BitwiseAnd>(inputs[0], inputs[1])};
 }
-static bool registered =
-    register_translator("BitwiseAnd", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::bitwise_and);
+ONNX_OP("BitwiseAnd", OPSET_SINCE(1), ai_onnx::opset_1::bitwise_and);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/bitwise_not.cpp

@@ -17,8 +17,7 @@ ov::OutputVector bitwise_not(const ov::frontend::onnx::Node& node) {
     OPENVINO_ASSERT(inputs.size() == 1);
     return {std::make_shared<v13::BitwiseNot>(inputs[0])};
 }
-static bool registered =
-    register_translator("BitwiseNot", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::bitwise_not);
+ONNX_OP("BitwiseNot", OPSET_SINCE(1), ai_onnx::opset_1::bitwise_not);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/bitwise_or.cpp

@@ -17,8 +17,7 @@ ov::OutputVector bitwise_or(const ov::frontend::onnx::Node& node) {
     OPENVINO_ASSERT(inputs.size() == 2);
     return {std::make_shared<v13::BitwiseOr>(inputs[0], inputs[1])};
 }
-static bool registered =
-    register_translator("BitwiseOr", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::bitwise_or);
+ONNX_OP("BitwiseOr", OPSET_SINCE(1), ai_onnx::opset_1::bitwise_or);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/bitwise_xor.cpp

@@ -17,8 +17,7 @@ ov::OutputVector bitwise_xor(const ov::frontend::onnx::Node& node) {
     OPENVINO_ASSERT(inputs.size() == 2);
     return {std::make_shared<v13::BitwiseXor>(inputs[0], inputs[1])};
 }
-static bool registered =
-    register_translator("BitwiseXor", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::bitwise_xor);
+ONNX_OP("BitwiseXor", OPSET_SINCE(1), ai_onnx::opset_1::bitwise_xor);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/blackmanwindow.cpp

@@ -74,9 +74,7 @@ ov::OutputVector blackmanwindow(const ov::frontend::onnx::Node& node) {
         return {std::make_shared<v0::Convert>(y_values, output_datatype)};
     }
 }
-static bool registered = register_translator("BlackmanWindow",
-                                             VersionRange::single_version_for_all_opsets(),
-                                             ai_onnx::opset_1::blackmanwindow);
+ONNX_OP("BlackmanWindow", OPSET_SINCE(1), ai_onnx::opset_1::blackmanwindow);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/cast.cpp

@@ -21,8 +21,7 @@ ov::OutputVector cast(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<v0::Convert>(data, elem_type)};
 }
 
-static bool registered =
-    register_translator("Cast", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::cast);
+ONNX_OP("Cast", OPSET_SINCE(1), ai_onnx::opset_1::cast);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/cast_like.cpp

@@ -17,8 +17,7 @@ ov::OutputVector cast_like(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<v1::ConvertLike>(inputs.at(0), inputs.at(1))};
 }
 
-static bool registered =
-    register_translator("CastLike", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::cast_like);
+ONNX_OP("CastLike", OPSET_SINCE(1), ai_onnx::opset_1::cast_like);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/ceil.cpp

@@ -14,8 +14,7 @@ ov::OutputVector ceil(const ov::frontend::onnx::Node& node) {
     return {std::make_shared<ov::op::v0::Ceiling>(node.get_ov_inputs().at(0))};
 }
 
-static bool registered =
-    register_translator("Ceil", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::ceil);
+ONNX_OP("Ceil", OPSET_SINCE(1), ai_onnx::opset_1::ceil);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx

src/frontends/onnx/frontend/src/op/celu.cpp

@@ -26,8 +26,7 @@ ov::OutputVector celu(const ov::frontend::onnx::Node& node) {
 
     return {std::make_shared<v1::Multiply>(alpha_node, elu_node)};
 }
-static bool registered =
-    register_translator("Celu", VersionRange::single_version_for_all_opsets(), ai_onnx::opset_1::celu);
+ONNX_OP("Celu", OPSET_SINCE(1), ai_onnx::opset_1::celu);
 }  // namespace opset_1
 }  // namespace ai_onnx
 }  // namespace onnx