[ONNX] Change translator registration approach (#25166)

### Details:
 - Moved to VersionRange usage
 - Moved a translators registration near a translator code
 - Simplified file structure
 - Implemented support of *.lib build
- Implemented a supported op customization by removing op-files from the
build

### Tickets:
 - N/A

Author: gkrivor

src/frontends/onnx/frontend/CMakeLists.txt

@@ -2,6 +2,73 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
+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 "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})
+            endif()
+            list(APPEND registrations ${match})
+        endforeach()
+    endforeach()
+    list(APPEND declarations "com_microsoft::opset_1::register_multiple_translators")
+    list(APPEND registrations "com_microsoft::opset_1::register_multiple_translators()")
+    list(SORT declarations)
+    set(domain "")
+    set(opset "")
+    set(op_name, "")
+    foreach(decl ${declarations})
+        string(REGEX MATCH "([a-z0-9_]+)::([a-z0-9_]+)::([a-z0-9_]+)" matches ${decl})
+        if(NOT domain STREQUAL CMAKE_MATCH_1)
+            if(NOT opset STREQUAL "")
+                file(APPEND ${static_reg_file} "}  // namespace ${opset}\n")
+            endif()
+            if(NOT domain STREQUAL "")
+                file(APPEND ${static_reg_file} "}  // namespace ${domain}\n")
+            endif()
+            set(domain ${CMAKE_MATCH_1})
+            set(opset "")
+            file(APPEND ${static_reg_file} "namespace ${domain} {\n")
+        endif()
+        if(NOT opset STREQUAL CMAKE_MATCH_2)
+            if(NOT opset STREQUAL "")
+                file(APPEND ${static_reg_file} "}  // namespace ${opset}\n")
+            endif()
+            set(opset ${CMAKE_MATCH_2})
+            file(APPEND ${static_reg_file} "namespace ${opset} {\n")
+        endif()
+        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} "ONNX_DECL_OP(${CMAKE_MATCH_3});\n")
+            else()
+                file(APPEND ${static_reg_file} "extern bool ${CMAKE_MATCH_3}(void);\n")
+            endif()
+        endif()
+    endforeach()
+    if(NOT opset STREQUAL "")
+        file(APPEND ${static_reg_file} "}  // namespace ${opset}\n")
+    endif()
+    if(NOT domain STREQUAL "")
+        file(APPEND ${static_reg_file} "}  // namespace ${domain}\n")
+    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#undef ONNX_DECL_OP\n")
+endif()
+
 ov_add_frontend(NAME onnx
                 LINKABLE_FRONTEND
                 PROTOBUF_REQUIRED
@@ -13,6 +80,10 @@ ov_add_frontend(NAME onnx
 set(ONNX_OPSET_VERSION 20 CACHE INTERNAL "Supported version of ONNX operator set")
 target_compile_definitions(${TARGET_NAME} PRIVATE ONNX_OPSET_VERSION=${ONNX_OPSET_VERSION})
 
+if(BUILD_SHARED_LIBS)
+    target_compile_definitions(${TARGET_NAME} PRIVATE ONNX_BUILD_SHARED=1)
+endif()
+
 ov_ncc_naming_style(FOR_TARGET ${TARGET_NAME}
                     SOURCE_DIRECTORIES "${${TARGET_NAME}_INCLUDE_DIR}"
                     DEFINITIONS

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

@@ -5,21 +5,44 @@
 #pragma once
 
 #include <functional>
+#include <map>
 #include <string>
 #include <unordered_map>
 
 #include "core/node.hpp"
+#include "version_range.hpp"
 
 namespace ov {
 namespace frontend {
 namespace onnx {
-/// \brief      Function which transforms single ONNX operator to OV sub-graph.
 
+/// \brief      Function which transforms single ONNX operator to OV sub-graph.
 using Operator = std::function<OutputVector(const Node&)>;
 
 /// \brief      Map which contains ONNX operators accessible by std::string value as a key.
 using OperatorSet = std::unordered_map<std::string, Operator>;
 
+/// \brief      Map with map of versioned operators, accessible like map["Operation"][Version]
+using DomainOpset = std::unordered_map<std::string, std::map<std::int64_t, Operator>>;
+
+extern const char* OPENVINO_ONNX_DOMAIN;
+extern const char* MICROSOFT_DOMAIN;
+extern const char* PYTORCH_ATEN_DOMAIN;
+extern const char* MMDEPLOY_DOMAIN;
+
+/// \brief Registering a versions range of translator in global map of translators (preferred to use)
+extern bool register_translator(const std::string name,
+                                const VersionRange range,
+                                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, ...) register_translator(name, range, __VA_ARGS__)
+#define ONNX_OP(name, range, ...)   static bool onnx_op_reg = ONNX_OP_M(name, range, __VA_ARGS__)
+
 }  // namespace onnx
 }  // namespace frontend
 }  // namespace ov

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

@@ -2,33 +2,33 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#pragma once
+#include "openvino/op/abs.hpp"
 
-#include "core/node.hpp"
+#include "core/operator_set.hpp"
 #include "exceptions.hpp"
-#include "openvino/op/abs.hpp"
 
 namespace ov {
 namespace frontend {
 namespace onnx {
-namespace op {
-namespace set_1 {
-inline ov::OutputVector abs(const ov::frontend::onnx::Node& node) {
+namespace ai_onnx {
+namespace opset_1 {
+ov::OutputVector abs(const ov::frontend::onnx::Node& node) {
     CHECK_VALID_NODE(node,
                      !node.has_attribute("consumed_inputs"),
                      "consumed_inputs legacy attribute of Abs op is not supported");
     return {std::make_shared<ov::op::v0::Abs>(node.get_ov_inputs().at(0))};
 }
-}  // namespace set_1
+ONNX_OP("Abs", OPSET_RANGE(1, 5), ai_onnx::opset_1::abs);
+}  // namespace opset_1
 
-namespace set_6 {
-using set_1::abs;
-}  // namespace set_6
+namespace opset_6 {
+ONNX_OP("Abs", OPSET_RANGE(6, 12), ai_onnx::opset_1::abs);
+}  // namespace opset_6
 
-namespace set_13 {
-using set_6::abs;
-}  // namespace set_13
-}  // namespace op
+namespace opset_13 {
+ONNX_OP("Abs", OPSET_SINCE(13), ai_onnx::opset_1::abs);
+}  // namespace opset_13
+}  // namespace ai_onnx
 }  // namespace onnx
 }  // namespace frontend
 }  // namespace ov

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

@@ -2,21 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#pragma once
-
-#include "core/node.hpp"
 #include "openvino/op/acos.hpp"
 
+#include "core/operator_set.hpp"
+
 namespace ov {
 namespace frontend {
 namespace onnx {
-namespace op {
-namespace set_7 {
-inline ov::OutputVector acos(const ov::frontend::onnx::Node& node) {
+namespace ai_onnx {
+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))};
 }
-}  // namespace set_7
-}  // namespace op
+ONNX_OP("Acos", OPSET_SINCE(1), ai_onnx::opset_7::acos);
+}  // namespace opset_7
+}  // namespace ai_onnx
 }  // namespace onnx
 }  // namespace frontend
 }  // namespace ov

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

@@ -2,21 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#pragma once
-
-#include "core/node.hpp"
 #include "openvino/op/acosh.hpp"
 
+#include "core/operator_set.hpp"
+
 namespace ov {
 namespace frontend {
 namespace onnx {
-namespace op {
-namespace set_9 {
-inline ov::OutputVector acosh(const ov::frontend::onnx::Node& node) {
+namespace ai_onnx {
+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))};
 }
-}  // namespace set_9
-}  // namespace op
+ONNX_OP("Acosh", OPSET_SINCE(1), ai_onnx::opset_9::acosh);
+}  // namespace opset_9
+}  // namespace ai_onnx
 }  // namespace onnx
 }  // namespace frontend
 }  // namespace ov

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

@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "op/adaptive_avg_pooling2d.hpp"
-
+#include "core/operator_set.hpp"
 #include "exceptions.hpp"
 #include "openvino/op/adaptive_avg_pool.hpp"
 
@@ -12,8 +11,8 @@ using namespace ov::op;
 namespace ov {
 namespace frontend {
 namespace onnx {
-namespace op {
-namespace set_1 {
+namespace ai_onnx {
+namespace opset_1 {
 ov::OutputVector adaptive_avg_pooling2d(const ov::frontend::onnx::Node& node) {
     const auto inputs = node.get_ov_inputs();
     const auto num_inputs = inputs.size();
@@ -22,9 +21,9 @@ ov::OutputVector adaptive_avg_pooling2d(const ov::frontend::onnx::Node& node) {
 
     return {std::make_shared<v8::AdaptiveAvgPool>(inputs[0], inputs[1])};
 }
-
-}  // namespace set_1
-}  // namespace op
+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
 }  // namespace frontend
 }  // namespace ov

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

@@ -2,39 +2,51 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "op/add.hpp"
+#include "openvino/op/add.hpp"
 
+#include "core/operator_set.hpp"
 #include "exceptions.hpp"
-#include "openvino/op/add.hpp"
 #include "utils/common.hpp"
 
 using namespace ov::op;
 
 namespace ov {
 namespace frontend {
 namespace onnx {
-namespace op {
-namespace set_1 {
+namespace ai_onnx {
+namespace opset_1 {
 ov::OutputVector add(const ov::frontend::onnx::Node& node) {
     CHECK_VALID_NODE(node,
                      !node.has_attribute("consumed_inputs"),
                      "consumed_inputs legacy attribute of Add op is not supported");
     return common::handle_opset6_binary_op<v1::Add>(node);
 }
-}  // namespace set_1
+ONNX_OP("Add", OPSET_RANGE(1, 5), ai_onnx::opset_1::add);
+}  // namespace opset_1
 
-namespace set_6 {
+namespace opset_6 {
 ov::OutputVector add(const ov::frontend::onnx::Node& node) {
     return common::handle_opset6_binary_op<v1::Add>(node);
 }
-}  // namespace set_6
+ONNX_OP("Add", OPSET_IN(6), ai_onnx::opset_6::add);
+}  // namespace opset_6
 
-namespace set_7 {
+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))};
 }
-}  // namespace set_7
-}  // namespace op
+ONNX_OP("Add", OPSET_RANGE(7, 12), ai_onnx::opset_7::add);
+}  // namespace opset_7
+
+namespace opset_13 {
+ONNX_OP("Add", OPSET_IN(13), ai_onnx::opset_7::add);
+}  // namespace opset_13
+
+namespace opset_14 {
+ONNX_OP("Add", OPSET_SINCE(14), ai_onnx::opset_7::add);
+}  // namespace opset_14
+
+}  // namespace ai_onnx
 }  // namespace onnx
 }  // namespace frontend
 }  // namespace ov