Introduced new RTTI macros for nGraph (#7515)
* Introduced new RTTI macros for nGraph * Added new tests * Fixed comment * Fixed Windows ieFuncTests * Fixed code style
This commit is contained in:
Ilya Churaev
GitHub
parent
850c526e3b
commit
88b874ec8b
27
ngraph/core/include/ngraph/compatibility.hpp
Normal file
27
ngraph/core/include/ngraph/compatibility.hpp
Normal file
@ -0,0 +1,27 @@
|
||||
// Copyright (C) 2018-2021 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <utility>
|
||||
|
||||
#include "ngraph/deprecated.hpp"
|
||||
|
||||
namespace ngraph {
|
||||
|
||||
// If operation has type_info, use it to add operation to opset
|
||||
template <class T>
|
||||
class HasTypeInfoMember {
|
||||
template <typename U>
|
||||
static std::false_type check(...);
|
||||
NGRAPH_SUPPRESS_DEPRECATED_START
|
||||
template <typename U>
|
||||
static auto check(int) -> decltype(std::declval<U>().type_info, std::true_type{});
|
||||
using type = decltype(check<T>(0));
|
||||
NGRAPH_SUPPRESS_DEPRECATED_END
|
||||
public:
|
||||
static constexpr bool value = type::value;
|
||||
};
|
||||
|
||||
} // namespace ngraph
|
||||
@ -8,6 +8,8 @@
|
||||
#include <mutex>
|
||||
#include <unordered_map>
|
||||
|
||||
#include "ngraph/compatibility.hpp"
|
||||
#include "ngraph/deprecated.hpp"
|
||||
#include "ngraph/ngraph_visibility.hpp"
|
||||
|
||||
namespace ngraph {
|
||||
@ -35,9 +37,17 @@ public:
|
||||
}
|
||||
|
||||
/// \brief Register a custom factory for DERIVED_TYPE
|
||||
template <typename DERIVED_TYPE>
|
||||
template <typename DERIVED_TYPE,
|
||||
typename std::enable_if<!HasTypeInfoMember<DERIVED_TYPE>::value, bool>::type = true>
|
||||
void register_factory(Factory factory) {
|
||||
register_factory(DERIVED_TYPE::get_type_info_static(), factory);
|
||||
}
|
||||
|
||||
template <typename DERIVED_TYPE, typename std::enable_if<HasTypeInfoMember<DERIVED_TYPE>::value, bool>::type = true>
|
||||
void register_factory(Factory factory) {
|
||||
NGRAPH_SUPPRESS_DEPRECATED_START
|
||||
register_factory(DERIVED_TYPE::type_info, factory);
|
||||
NGRAPH_SUPPRESS_DEPRECATED_END
|
||||
}
|
||||
|
||||
/// \brief Register the defualt constructor factory for DERIVED_TYPE
|
||||
@ -53,9 +63,17 @@ public:
|
||||
}
|
||||
|
||||
/// \brief Check to see if DERIVED_TYPE has a registered factory
|
||||
template <typename DERIVED_TYPE>
|
||||
template <typename DERIVED_TYPE,
|
||||
typename std::enable_if<!HasTypeInfoMember<DERIVED_TYPE>::value, bool>::type = true>
|
||||
bool has_factory() {
|
||||
return has_factory(DERIVED_TYPE::get_type_info_static());
|
||||
}
|
||||
|
||||
template <typename DERIVED_TYPE, typename std::enable_if<HasTypeInfoMember<DERIVED_TYPE>::value, bool>::type = true>
|
||||
bool has_factory() {
|
||||
NGRAPH_SUPPRESS_DEPRECATED_START
|
||||
return has_factory(DERIVED_TYPE::type_info);
|
||||
NGRAPH_SUPPRESS_DEPRECATED_END
|
||||
}
|
||||
|
||||
/// \brief Create an instance for type_info
|
||||
@ -66,9 +84,17 @@ public:
|
||||
}
|
||||
|
||||
/// \brief Create an instance using factory for DERIVED_TYPE
|
||||
template <typename DERIVED_TYPE>
|
||||
template <typename DERIVED_TYPE,
|
||||
typename std::enable_if<!HasTypeInfoMember<DERIVED_TYPE>::value, bool>::type = true>
|
||||
BASE_TYPE* create() const {
|
||||
return create(DERIVED_TYPE::get_type_info_static());
|
||||
}
|
||||
|
||||
template <typename DERIVED_TYPE, typename std::enable_if<HasTypeInfoMember<DERIVED_TYPE>::value, bool>::type = true>
|
||||
BASE_TYPE* create() const {
|
||||
NGRAPH_SUPPRESS_DEPRECATED_START
|
||||
return create(DERIVED_TYPE::type_info);
|
||||
NGRAPH_SUPPRESS_DEPRECATED_END
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
@ -34,11 +34,16 @@ public:
|
||||
}
|
||||
|
||||
/// \brief Insert OP_TYPE into the opset with the default name and factory
|
||||
template <typename OP_TYPE>
|
||||
template <typename OP_TYPE, typename std::enable_if<ngraph::HasTypeInfoMember<OP_TYPE>::value, bool>::type = true>
|
||||
void insert() {
|
||||
ov::OpSet::insert<OP_TYPE>(OP_TYPE::type_info.name);
|
||||
}
|
||||
|
||||
template <typename OP_TYPE, typename std::enable_if<!ngraph::HasTypeInfoMember<OP_TYPE>::value, bool>::type = true>
|
||||
void insert() {
|
||||
ov::OpSet::insert<OP_TYPE>(OP_TYPE::get_type_info_static().name);
|
||||
}
|
||||
|
||||
ngraph::FactoryRegistry<ngraph::Node>& get_factory_registry() {
|
||||
return m_factory_registry;
|
||||
}
|
||||
|
||||
@ -38,6 +38,6 @@
|
||||
# define NGRAPH_OP(x, y)
|
||||
#endif
|
||||
|
||||
#define OPENVINO_OP NGRAPH_OP
|
||||
#define _OPENVINO_OP_REG NGRAPH_OP
|
||||
#include "openvino/opsets/opset1_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
|
||||
@ -7,6 +7,6 @@
|
||||
# define NGRAPH_OP(x, y)
|
||||
#endif
|
||||
|
||||
#define OPENVINO_OP NGRAPH_OP
|
||||
#define _OPENVINO_OP_REG NGRAPH_OP
|
||||
#include "openvino/opsets/opset2_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
|
||||
@ -7,6 +7,6 @@
|
||||
# define NGRAPH_OP(x, y)
|
||||
#endif
|
||||
|
||||
#define OPENVINO_OP NGRAPH_OP
|
||||
#define _OPENVINO_OP_REG NGRAPH_OP
|
||||
#include "openvino/opsets/opset3_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
|
||||
@ -7,6 +7,6 @@
|
||||
# define NGRAPH_OP(x, y)
|
||||
#endif
|
||||
|
||||
#define OPENVINO_OP NGRAPH_OP
|
||||
#define _OPENVINO_OP_REG NGRAPH_OP
|
||||
#include "openvino/opsets/opset4_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
|
||||
@ -7,6 +7,6 @@
|
||||
# define NGRAPH_OP(x, y)
|
||||
#endif
|
||||
|
||||
#define OPENVINO_OP NGRAPH_OP
|
||||
#define _OPENVINO_OP_REG NGRAPH_OP
|
||||
#include "openvino/opsets/opset5_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
|
||||
@ -7,6 +7,6 @@
|
||||
# define NGRAPH_OP(x, y)
|
||||
#endif
|
||||
|
||||
#define OPENVINO_OP NGRAPH_OP
|
||||
#define _OPENVINO_OP_REG NGRAPH_OP
|
||||
#include "openvino/opsets/opset6_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
|
||||
@ -7,6 +7,6 @@
|
||||
# define NGRAPH_OP(x, y)
|
||||
#endif
|
||||
|
||||
#define OPENVINO_OP NGRAPH_OP
|
||||
#define _OPENVINO_OP_REG NGRAPH_OP
|
||||
#include "openvino/opsets/opset7_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
|
||||
@ -7,6 +7,6 @@
|
||||
# define NGRAPH_OP(x, y)
|
||||
#endif
|
||||
|
||||
#define OPENVINO_OP NGRAPH_OP
|
||||
#define _OPENVINO_OP_REG NGRAPH_OP
|
||||
#include "openvino/opsets/opset8_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
|
||||
@ -29,6 +29,7 @@
|
||||
#include "openvino/core/node_input.hpp"
|
||||
#include "openvino/core/node_output.hpp"
|
||||
#include "openvino/core/node_vector.hpp"
|
||||
#include "openvino/core/rtti.hpp"
|
||||
#include "openvino/core/strides.hpp"
|
||||
#include "openvino/core/type.hpp"
|
||||
#include "openvino/core/variant.hpp"
|
||||
@ -519,8 +520,6 @@ using NodeTypeInfo = Node::type_info_t;
|
||||
OPENVINO_API std::ostream& operator<<(std::ostream&, const Node&);
|
||||
OPENVINO_API std::ostream& operator<<(std::ostream&, const Node*);
|
||||
|
||||
#define _OPENVINO_RTTI_EXPAND(X) X
|
||||
|
||||
/// Helper macro that puts necessary declarations of RTTI block inside a class definition.
|
||||
/// Should be used in the scope of class that requires type identification besides one provided by
|
||||
/// C++ RTTI.
|
||||
@ -584,8 +583,6 @@ OPENVINO_API std::ostream& operator<<(std::ostream&, const Node*);
|
||||
} \
|
||||
_OPENVINO_RTTI_DEFINITION_COMMON(CLASS)
|
||||
|
||||
#define _OPENVINO_RTTI_DEFINITION_SELECTOR(_1, _2, _3, _4, NAME, ...) NAME
|
||||
|
||||
/// Complementary to OPENVINO_RTTI_DECLARATION, this helper macro _defines_ items _declared_ by
|
||||
/// OPENVINO_RTTI_DECLARATION.
|
||||
/// Should be used outside the class definition scope in place where ODR is ensured.
|
||||
@ -685,10 +682,8 @@ public:
|
||||
AttributeAdapter(std::shared_ptr<ov::Node>& value);
|
||||
|
||||
bool visit_attributes(AttributeVisitor& visitor) override;
|
||||
static constexpr DiscreteTypeInfo type_info{"AttributeAdapter<std::shared_ptr<Node>>", 0};
|
||||
const DiscreteTypeInfo& get_type_info() const override {
|
||||
return type_info;
|
||||
}
|
||||
OPENVINO_RTTI("AttributeAdapter<std::shared_ptr<Node>>");
|
||||
BWDCMP_RTTI_DECLARATION;
|
||||
|
||||
protected:
|
||||
std::shared_ptr<ov::Node>& m_ref;
|
||||
@ -701,10 +696,8 @@ public:
|
||||
|
||||
bool visit_attributes(AttributeVisitor& visitor) override;
|
||||
|
||||
static constexpr DiscreteTypeInfo type_info{"AttributeAdapter<NodeVector>", 0};
|
||||
const DiscreteTypeInfo& get_type_info() const override {
|
||||
return type_info;
|
||||
}
|
||||
OPENVINO_RTTI("AttributeAdapter<NodeVector>");
|
||||
BWDCMP_RTTI_DECLARATION;
|
||||
|
||||
protected:
|
||||
ov::NodeVector& m_ref;
|
||||
|
||||
105
ngraph/core/include/openvino/core/rtti.hpp
Normal file
105
ngraph/core/include/openvino/core/rtti.hpp
Normal file
@ -0,0 +1,105 @@
|
||||
// Copyright (C) 2018-2021 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "openvino/core/type.hpp"
|
||||
|
||||
#define _OPENVINO_RTTI_EXPAND(X) X
|
||||
#define _OPENVINO_RTTI_DEFINITION_SELECTOR(_1, _2, _3, _4, NAME, ...) NAME
|
||||
|
||||
#define _OPENVINO_RTTI_WITH_TYPE(TYPE_NAME) _OPENVINO_RTTI_WITH_TYPE_VERSION(TYPE_NAME, "util")
|
||||
|
||||
#define _OPENVINO_RTTI_WITH_TYPE_VERSION(TYPE_NAME, VERSION_NAME) \
|
||||
static const ::ov::DiscreteTypeInfo& get_type_info_static() { \
|
||||
static const ::ov::DiscreteTypeInfo type_info{TYPE_NAME, 0, VERSION_NAME}; \
|
||||
return type_info; \
|
||||
} \
|
||||
const ::ov::DiscreteTypeInfo& get_type_info() const override { \
|
||||
return get_type_info_static(); \
|
||||
}
|
||||
|
||||
#define _OPENVINO_RTTI_WITH_TYPE_VERSION_PARENT(TYPE_NAME, VERSION_NAME, PARENT_CLASS) \
|
||||
_OPENVINO_RTTI_WITH_TYPE_VERSIONS_PARENT(TYPE_NAME, VERSION_NAME, PARENT_CLASS, 0)
|
||||
|
||||
#define _OPENVINO_RTTI_WITH_TYPE_VERSIONS_PARENT(TYPE_NAME, VERSION_NAME, PARENT_CLASS, OLD_VERSION) \
|
||||
static const ::ov::DiscreteTypeInfo& get_type_info_static() { \
|
||||
static const ::ov::DiscreteTypeInfo type_info{TYPE_NAME, \
|
||||
OLD_VERSION, \
|
||||
VERSION_NAME, \
|
||||
&PARENT_CLASS::get_type_info_static()}; \
|
||||
return type_info; \
|
||||
} \
|
||||
const ::ov::DiscreteTypeInfo& get_type_info() const override { \
|
||||
return get_type_info_static(); \
|
||||
}
|
||||
/// Helper macro that puts necessary declarations of RTTI block inside a class definition.
|
||||
/// Should be used in the scope of class that requires type identification besides one provided by
|
||||
/// C++ RTTI.
|
||||
/// Recommended to be used for all classes that are inherited from class ov::Node to enable
|
||||
/// pattern
|
||||
/// matching for them. Accepts necessary type identification details like type of the operation,
|
||||
/// version and optional parent class.
|
||||
///
|
||||
/// Applying this macro within a class definition provides declaration of type_info static
|
||||
/// constant for backward compatibility with old RTTI definition for Node,
|
||||
/// static function get_type_info_static which returns a reference to an object that is equal to
|
||||
/// type_info but not necessary to the same object, and get_type_info virtual function that
|
||||
/// overrides Node::get_type_info and returns a reference to the same object that
|
||||
/// get_type_info_static gives.
|
||||
///
|
||||
/// Use this macro as a public part of the class definition:
|
||||
///
|
||||
/// class MyClass
|
||||
/// {
|
||||
/// public:
|
||||
/// OPENVINO_RTTI("MyClass", "my_version");
|
||||
///
|
||||
/// ...
|
||||
/// };
|
||||
///
|
||||
/// class MyClass2: public MyClass
|
||||
/// {
|
||||
/// public:
|
||||
/// OPENVINO_RTTI("MyClass2", "my_version2", MyClass);
|
||||
///
|
||||
/// ...
|
||||
/// };
|
||||
///
|
||||
/// \param TYPE_NAME a string literal of type const char* that names your class in type
|
||||
/// identification namespace;
|
||||
/// It is your choice how to name it, but it should be unique among all
|
||||
/// OPENVINO_RTTI_DECLARATION-enabled classes that can be
|
||||
/// used in conjunction with each other in one transformation flow.
|
||||
/// \param VERSION_NAME is an name of operation version to distinguish different versions of
|
||||
/// operations that shares the same TYPE_NAME
|
||||
/// \param PARENT_CLASS is an optional direct or indirect parent class for this class; define
|
||||
/// it only in case if there is a need to capture any operation from some group of operations
|
||||
/// that all derived from some common base class. Don't use Node as a parent, it is a base
|
||||
/// class
|
||||
/// for all operations and doesn't provide ability to define some perfect subset of
|
||||
/// operations. PARENT_CLASS should define RTTI with OPENVINO_RTTI_{DECLARATION/DEFINITION}
|
||||
/// macros.
|
||||
/// \param _VERSION_INDEX is an unsigned integer index to distinguish different versions of
|
||||
/// operations that shares the same TYPE_NAME (for backward compatibility)
|
||||
///
|
||||
/// OPENVINO_RTTI(name)
|
||||
/// OPENVINO_RTTI(name, version_id)
|
||||
/// OPENVINO_RTTI(name, version_id, parent)
|
||||
/// OPENVINO_RTTI(name, version_id, parent, old_version)
|
||||
#define OPENVINO_RTTI(...) \
|
||||
_OPENVINO_RTTI_EXPAND(_OPENVINO_RTTI_DEFINITION_SELECTOR(__VA_ARGS__, \
|
||||
_OPENVINO_RTTI_WITH_TYPE_VERSIONS_PARENT, \
|
||||
_OPENVINO_RTTI_WITH_TYPE_VERSION_PARENT, \
|
||||
_OPENVINO_RTTI_WITH_TYPE_VERSION, \
|
||||
_OPENVINO_RTTI_WITH_TYPE)(__VA_ARGS__))
|
||||
|
||||
/// Note: Please don't use this macros for new operations
|
||||
#define BWDCMP_RTTI_DECLARATION \
|
||||
OPENVINO_DEPRECATED("This member was deprecate. Please use ::get_type_info_static() instead.") \
|
||||
static const ov::DiscreteTypeInfo type_info
|
||||
#define BWDCMP_RTTI_DEFINITION(CLASS) \
|
||||
OPENVINO_SUPPRESS_DEPRECATED_START \
|
||||
const ov::DiscreteTypeInfo CLASS::type_info = CLASS::get_type_info_static(); \
|
||||
OPENVINO_SUPPRESS_DEPRECATED_END
|
||||
@ -8,13 +8,16 @@
|
||||
#include <cstring>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <ostream>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "ngraph/compatibility.hpp"
|
||||
#include "openvino/core/core_visibility.hpp"
|
||||
|
||||
namespace ov {
|
||||
|
||||
/// Supports three functions, ov::is_type<Type>, ov::as_type<Type>, and ov::as_type_ptr<Type> for type-safe
|
||||
/// dynamic conversions via static_cast/static_ptr_cast without using C++ RTTI.
|
||||
/// Type must have a static type_info member and a virtual get_type_info() member that
|
||||
@ -25,6 +28,7 @@ namespace ov {
|
||||
struct OPENVINO_API DiscreteTypeInfo {
|
||||
const char* name;
|
||||
uint64_t version;
|
||||
const char* version_id;
|
||||
// A pointer to a parent type info; used for casting and inheritance traversal, not for
|
||||
// exact type identification
|
||||
const DiscreteTypeInfo* parent;
|
||||
@ -34,6 +38,16 @@ struct OPENVINO_API DiscreteTypeInfo {
|
||||
constexpr DiscreteTypeInfo(const char* _name, uint64_t _version, const DiscreteTypeInfo* _parent = nullptr)
|
||||
: name(_name),
|
||||
version(_version),
|
||||
version_id(nullptr),
|
||||
parent(_parent) {}
|
||||
|
||||
constexpr DiscreteTypeInfo(const char* _name,
|
||||
uint64_t _version,
|
||||
const char* _version_id,
|
||||
const DiscreteTypeInfo* _parent = nullptr)
|
||||
: name(_name),
|
||||
version(_version),
|
||||
version_id(_version_id),
|
||||
parent(_parent) {}
|
||||
|
||||
bool is_castable(const DiscreteTypeInfo& target_type) const {
|
||||
@ -41,35 +55,39 @@ struct OPENVINO_API DiscreteTypeInfo {
|
||||
}
|
||||
|
||||
// For use as a key
|
||||
bool operator<(const DiscreteTypeInfo& b) const {
|
||||
return version < b.version || (version == b.version && strcmp(name, b.name) < 0);
|
||||
}
|
||||
bool operator<=(const DiscreteTypeInfo& b) const {
|
||||
return version < b.version || (version == b.version && strcmp(name, b.name) <= 0);
|
||||
}
|
||||
bool operator>(const DiscreteTypeInfo& b) const {
|
||||
return version < b.version || (version == b.version && strcmp(name, b.name) > 0);
|
||||
}
|
||||
bool operator>=(const DiscreteTypeInfo& b) const {
|
||||
return version < b.version || (version == b.version && strcmp(name, b.name) >= 0);
|
||||
}
|
||||
bool operator==(const DiscreteTypeInfo& b) const {
|
||||
return version == b.version && strcmp(name, b.name) == 0;
|
||||
}
|
||||
bool operator!=(const DiscreteTypeInfo& b) const {
|
||||
return version != b.version || strcmp(name, b.name) != 0;
|
||||
}
|
||||
bool operator<(const DiscreteTypeInfo& b) const;
|
||||
bool operator<=(const DiscreteTypeInfo& b) const;
|
||||
bool operator>(const DiscreteTypeInfo& b) const;
|
||||
bool operator>=(const DiscreteTypeInfo& b) const;
|
||||
bool operator==(const DiscreteTypeInfo& b) const;
|
||||
bool operator!=(const DiscreteTypeInfo& b) const;
|
||||
};
|
||||
|
||||
OPENVINO_API
|
||||
std::ostream& operator<<(std::ostream& s, const DiscreteTypeInfo& info);
|
||||
|
||||
/// \brief Tests if value is a pointer/shared_ptr that can be statically cast to a
|
||||
/// Type*/shared_ptr<Type>
|
||||
OPENVINO_SUPPRESS_DEPRECATED_START
|
||||
template <typename Type, typename Value>
|
||||
typename std::enable_if<
|
||||
std::is_convertible<decltype(std::declval<Value>()->get_type_info().is_castable(Type::type_info)), bool>::value,
|
||||
ngraph::HasTypeInfoMember<Type>::value &&
|
||||
std::is_convertible<decltype(std::declval<Value>()->get_type_info().is_castable(Type::type_info)), bool>::value,
|
||||
bool>::type
|
||||
is_type(Value value) {
|
||||
return value->get_type_info().is_castable(Type::type_info);
|
||||
}
|
||||
OPENVINO_SUPPRESS_DEPRECATED_END
|
||||
|
||||
template <typename Type, typename Value>
|
||||
typename std::enable_if<
|
||||
!ngraph::HasTypeInfoMember<Type>::value &&
|
||||
std::is_convertible<decltype(std::declval<Value>()->get_type_info().is_castable(Type::get_type_info_static())),
|
||||
bool>::value,
|
||||
bool>::type
|
||||
is_type(Value value) {
|
||||
return value->get_type_info().is_castable(Type::get_type_info_static());
|
||||
}
|
||||
|
||||
/// Casts a Value* to a Type* if it is of type Type, nullptr otherwise
|
||||
template <typename Type, typename Value>
|
||||
|
||||
@ -7,6 +7,19 @@
|
||||
#include <string>
|
||||
|
||||
#include "openvino/core/node.hpp"
|
||||
#include "openvino/core/rtti.hpp"
|
||||
|
||||
#define _OPENVINO_RTTI_OP_WITH_TYPE(TYPE_NAME) _OPENVINO_RTTI_OP_WITH_TYPE_VERSION(TYPE_NAME, "extension")
|
||||
|
||||
#define _OPENVINO_RTTI_OP_WITH_TYPE_VERSION(TYPE_NAME, VERSION_NAME) \
|
||||
_OPENVINO_RTTI_WITH_TYPE_VERSION_PARENT(TYPE_NAME, VERSION_NAME, ::ov::op::Op)
|
||||
|
||||
#define OPENVINO_OP(...) \
|
||||
_OPENVINO_RTTI_EXPAND(_OPENVINO_RTTI_DEFINITION_SELECTOR(__VA_ARGS__, \
|
||||
_OPENVINO_RTTI_WITH_TYPE_VERSIONS_PARENT, \
|
||||
_OPENVINO_RTTI_WITH_TYPE_VERSION_PARENT, \
|
||||
_OPENVINO_RTTI_OP_WITH_TYPE_VERSION, \
|
||||
_OPENVINO_RTTI_OP_WITH_TYPE)(__VA_ARGS__))
|
||||
|
||||
namespace ov {
|
||||
namespace op {
|
||||
@ -15,6 +28,15 @@ class OPENVINO_API Op : public Node {
|
||||
protected:
|
||||
Op() : Node() {}
|
||||
Op(const OutputVector& arguments);
|
||||
|
||||
public:
|
||||
static const ::ov::Node::type_info_t& get_type_info_static() {
|
||||
static const ::ov::Node::type_info_t info{"Op", 0, "util"};
|
||||
return info;
|
||||
}
|
||||
const ::ov::Node::type_info_t& get_type_info() const override {
|
||||
return get_type_info_static();
|
||||
}
|
||||
};
|
||||
} // namespace op
|
||||
} // namespace ov
|
||||
|
||||
@ -10,7 +10,9 @@
|
||||
#include <set>
|
||||
#include <utility>
|
||||
|
||||
#include "ngraph/compatibility.hpp"
|
||||
#include "ngraph/factory.hpp"
|
||||
#include "openvino/core/deprecated.hpp"
|
||||
#include "openvino/core/node.hpp"
|
||||
|
||||
namespace ov {
|
||||
@ -27,15 +29,27 @@ public:
|
||||
}
|
||||
|
||||
/// \brief Insert OP_TYPE into the opset with a special name and the default factory
|
||||
template <typename OP_TYPE>
|
||||
template <typename OP_TYPE, typename std::enable_if<!ngraph::HasTypeInfoMember<OP_TYPE>::value, bool>::type = true>
|
||||
void insert(const std::string& name) {
|
||||
insert(name, OP_TYPE::get_type_info_static(), ngraph::FactoryRegistry<Node>::get_default_factory<OP_TYPE>());
|
||||
}
|
||||
template <typename OP_TYPE, typename std::enable_if<ngraph::HasTypeInfoMember<OP_TYPE>::value, bool>::type = true>
|
||||
void insert(const std::string& name) {
|
||||
OPENVINO_SUPPRESS_DEPRECATED_START
|
||||
insert(name, OP_TYPE::type_info, ngraph::FactoryRegistry<Node>::get_default_factory<OP_TYPE>());
|
||||
OPENVINO_SUPPRESS_DEPRECATED_END
|
||||
}
|
||||
|
||||
/// \brief Insert OP_TYPE into the opset with the default name and factory
|
||||
template <typename OP_TYPE>
|
||||
template <typename OP_TYPE, typename std::enable_if<!ngraph::HasTypeInfoMember<OP_TYPE>::value, bool>::type = true>
|
||||
void insert() {
|
||||
insert<OP_TYPE>(OP_TYPE::get_type_info_static().name);
|
||||
}
|
||||
template <typename OP_TYPE, typename std::enable_if<ngraph::HasTypeInfoMember<OP_TYPE>::value, bool>::type = true>
|
||||
void insert() {
|
||||
OPENVINO_SUPPRESS_DEPRECATED_START
|
||||
insert<OP_TYPE>(OP_TYPE::type_info.name);
|
||||
OPENVINO_SUPPRESS_DEPRECATED_END
|
||||
}
|
||||
|
||||
const std::set<NodeTypeInfo>& get_types_info() const {
|
||||
@ -54,9 +68,15 @@ public:
|
||||
}
|
||||
|
||||
/// \brief Return true if OP_TYPE is in the opset
|
||||
template <typename OP_TYPE>
|
||||
template <typename OP_TYPE, typename std::enable_if<!ngraph::HasTypeInfoMember<OP_TYPE>::value, bool>::type = true>
|
||||
bool contains_type() const {
|
||||
return contains_type(OP_TYPE::get_type_info_static());
|
||||
}
|
||||
template <typename OP_TYPE, typename std::enable_if<ngraph::HasTypeInfoMember<OP_TYPE>::value, bool>::type = true>
|
||||
bool contains_type() const {
|
||||
OPENVINO_SUPPRESS_DEPRECATED_START
|
||||
return contains_type(OP_TYPE::type_info);
|
||||
OPENVINO_SUPPRESS_DEPRECATED_END
|
||||
}
|
||||
|
||||
/// \brief Return true if name is in the opset
|
||||
|
||||
@ -8,8 +8,8 @@
|
||||
|
||||
namespace ov {
|
||||
namespace opset1 {
|
||||
#define OPENVINO_OP(a, b) using b::a;
|
||||
#define _OPENVINO_OP_REG(a, b) using b::a;
|
||||
#include "openvino/opsets/opset1_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
} // namespace opset1
|
||||
} // namespace ov
|
||||
|
||||
@ -5,26 +5,26 @@
|
||||
// This collection contains one entry for each op. If an op is added it must be
|
||||
// added to this list.
|
||||
//
|
||||
// In order to use this list you want to define a macro named exactly OPENVINO_OP
|
||||
// In order to use this list you want to define a macro named exactly _OPENVINO_OP_REG
|
||||
// When you are done you should undef the macro
|
||||
// As an example if you wanted to make a list of all op names as strings you could do this:
|
||||
//
|
||||
// #define OPENVINO_OP(a,b) #a,
|
||||
// #define _OPENVINO_OP_REG(a,b) #a,
|
||||
// std::vector<std::string> op_names{
|
||||
// #include "this include file name"
|
||||
// };
|
||||
// #undef OPENVINO_OP
|
||||
// #undef _OPENVINO_OP_REG
|
||||
//
|
||||
// This sample expands to a list like this:
|
||||
// "Abs",
|
||||
// "Acos",
|
||||
// ...
|
||||
//
|
||||
// #define OPENVINO_OP(a,b) b::a,
|
||||
// #define _OPENVINO_OP_REG(a,b) b::a,
|
||||
// std::vector<std::string> op_names{
|
||||
// #include "this include file name"
|
||||
// };
|
||||
// #undef OPENVINO_OP
|
||||
// #undef _OPENVINO_OP_REG
|
||||
//
|
||||
// This sample expands to a list like this:
|
||||
// ov::op::Abs,
|
||||
@ -33,118 +33,118 @@
|
||||
//
|
||||
// It's that easy. You can use this for fun and profit.
|
||||
|
||||
#ifndef OPENVINO_OP
|
||||
# warning "OPENVINO_OP not defined"
|
||||
# define OPENVINO_OP(x, y)
|
||||
#ifndef _OPENVINO_OP_REG
|
||||
# warning "_OPENVINO_OP_REG not defined"
|
||||
# define _OPENVINO_OP_REG(x, y)
|
||||
#endif
|
||||
|
||||
OPENVINO_OP(Abs, ov::op::v0)
|
||||
OPENVINO_OP(Acos, ov::op::v0)
|
||||
OPENVINO_OP(Add, ov::op::v1)
|
||||
OPENVINO_OP(Asin, ov::op::v0)
|
||||
OPENVINO_OP(Atan, ov::op::v0)
|
||||
OPENVINO_OP(AvgPool, ov::op::v1)
|
||||
OPENVINO_OP(BatchNormInference, ov::op::v0)
|
||||
OPENVINO_OP(BinaryConvolution, ov::op::v1)
|
||||
OPENVINO_OP(Broadcast, ov::op::v1)
|
||||
OPENVINO_OP(CTCGreedyDecoder, ov::op::v0)
|
||||
OPENVINO_OP(Ceiling, ov::op::v0)
|
||||
OPENVINO_OP(Clamp, ov::op::v0)
|
||||
OPENVINO_OP(Concat, ov::op::v0)
|
||||
OPENVINO_OP(Constant, ov::op::v0)
|
||||
OPENVINO_OP(Convert, ov::op::v0)
|
||||
OPENVINO_OP(ConvertLike, ov::op::v1)
|
||||
OPENVINO_OP(Convolution, ov::op::v1)
|
||||
OPENVINO_OP(ConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(Cos, ov::op::v0)
|
||||
OPENVINO_OP(Cosh, ov::op::v0)
|
||||
OPENVINO_OP(DeformableConvolution, ov::op::v1)
|
||||
OPENVINO_OP(DeformablePSROIPooling, ov::op::v1)
|
||||
OPENVINO_OP(DepthToSpace, ov::op::v0)
|
||||
OPENVINO_OP(DetectionOutput, ov::op::v0)
|
||||
OPENVINO_OP(Divide, ov::op::v1)
|
||||
OPENVINO_OP(Elu, ov::op::v0)
|
||||
OPENVINO_OP(Erf, ov::op::v0)
|
||||
OPENVINO_OP(Equal, ov::op::v1)
|
||||
OPENVINO_OP(Exp, ov::op::v0)
|
||||
OPENVINO_OP(FakeQuantize, ov::op::v0)
|
||||
OPENVINO_OP(Floor, ov::op::v0)
|
||||
OPENVINO_OP(FloorMod, ov::op::v1)
|
||||
OPENVINO_OP(Gather, ov::op::v1)
|
||||
OPENVINO_OP(GatherTree, ov::op::v1)
|
||||
OPENVINO_OP(Greater, ov::op::v1)
|
||||
OPENVINO_OP(GreaterEqual, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolution, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(GRN, ov::op::v0)
|
||||
OPENVINO_OP(HardSigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Interpolate, ov::op::v0)
|
||||
OPENVINO_OP(Less, ov::op::v1)
|
||||
OPENVINO_OP(LessEqual, ov::op::v1)
|
||||
OPENVINO_OP(Log, ov::op::v0)
|
||||
OPENVINO_OP(LogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(LogicalNot, ov::op::v1)
|
||||
OPENVINO_OP(LogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(LogicalXor, ov::op::v1)
|
||||
OPENVINO_OP(LRN, ov::op::v0)
|
||||
OPENVINO_OP(LSTMCell, ov::op::v0)
|
||||
OPENVINO_OP(LSTMSequence, ov::op::v0)
|
||||
OPENVINO_OP(MatMul, ov::op::v0)
|
||||
OPENVINO_OP(MaxPool, ov::op::v1)
|
||||
OPENVINO_OP(Maximum, ov::op::v1)
|
||||
OPENVINO_OP(Minimum, ov::op::v1)
|
||||
OPENVINO_OP(Mod, ov::op::v1)
|
||||
OPENVINO_OP(Multiply, ov::op::v1)
|
||||
OPENVINO_OP(Negative, ov::op::v0)
|
||||
OPENVINO_OP(NonMaxSuppression, ov::op::v1)
|
||||
OPENVINO_OP(NormalizeL2, ov::op::v0)
|
||||
OPENVINO_OP(NotEqual, ov::op::v1)
|
||||
OPENVINO_OP(OneHot, ov::op::v1)
|
||||
OPENVINO_OP(PRelu, ov::op::v0)
|
||||
OPENVINO_OP(PSROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(Pad, ov::op::v1)
|
||||
OPENVINO_OP(Parameter, ov::op::v0)
|
||||
OPENVINO_OP(Power, ov::op::v1)
|
||||
OPENVINO_OP(PriorBox, ov::op::v0)
|
||||
OPENVINO_OP(PriorBoxClustered, ov::op::v0)
|
||||
OPENVINO_OP(Proposal, ov::op::v0)
|
||||
OPENVINO_OP(Range, ov::op::v0)
|
||||
OPENVINO_OP(Relu, ov::op::v0)
|
||||
OPENVINO_OP(ReduceMax, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMean, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMin, ov::op::v1)
|
||||
OPENVINO_OP(ReduceProd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceSum, ov::op::v1)
|
||||
OPENVINO_OP(RegionYolo, ov::op::v0)
|
||||
OPENVINO_OP(Reshape, ov::op::v1)
|
||||
OPENVINO_OP(Result, ov::op::v0)
|
||||
OPENVINO_OP(Reverse, ov::op::v1)
|
||||
OPENVINO_OP(ReverseSequence, ov::op::v0)
|
||||
OPENVINO_OP(RNNCell, ov::op::v0)
|
||||
OPENVINO_OP(Select, ov::op::v1)
|
||||
OPENVINO_OP(Selu, ov::op::v0)
|
||||
OPENVINO_OP(ShapeOf, ov::op::v0)
|
||||
OPENVINO_OP(ShuffleChannels, ov::op::v0)
|
||||
OPENVINO_OP(Sign, ov::op::v0)
|
||||
OPENVINO_OP(Sigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Sin, ov::op::v0)
|
||||
OPENVINO_OP(Sinh, ov::op::v0)
|
||||
OPENVINO_OP(Softmax, ov::op::v1)
|
||||
OPENVINO_OP(Sqrt, ov::op::v0)
|
||||
OPENVINO_OP(SpaceToDepth, ov::op::v0)
|
||||
OPENVINO_OP(Split, ov::op::v1)
|
||||
OPENVINO_OP(SquaredDifference, ov::op::v0)
|
||||
OPENVINO_OP(Squeeze, ov::op::v0)
|
||||
OPENVINO_OP(StridedSlice, ov::op::v1)
|
||||
OPENVINO_OP(Subtract, ov::op::v1)
|
||||
OPENVINO_OP(Tan, ov::op::v0)
|
||||
OPENVINO_OP(Tanh, ov::op::v0)
|
||||
OPENVINO_OP(TensorIterator, ov::op::v0)
|
||||
OPENVINO_OP(Tile, ov::op::v0)
|
||||
OPENVINO_OP(TopK, ov::op::v1)
|
||||
OPENVINO_OP(Transpose, ov::op::v1)
|
||||
OPENVINO_OP(Unsqueeze, ov::op::v0)
|
||||
OPENVINO_OP(VariadicSplit, ov::op::v1)
|
||||
OPENVINO_OP(Xor, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Abs, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Acos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Add, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Asin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Atan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(AvgPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchNormInference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(BinaryConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Broadcast, ov::op::v1)
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoder, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Ceiling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Clamp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Concat, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Constant, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Convert, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ConvertLike, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Convolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Cos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Cosh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DeformableConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DeformablePSROIPooling, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DepthToSpace, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DetectionOutput, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Divide, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Elu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Erf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Equal, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Exp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FakeQuantize, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Floor, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FloorMod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gather, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GatherTree, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Greater, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GreaterEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(HardSigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Interpolate, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Less, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LessEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Log, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalNot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalXor, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MatMul, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MaxPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Maximum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Minimum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Mod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Multiply, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Negative, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NonMaxSuppression, ov::op::v1)
|
||||
_OPENVINO_OP_REG(NormalizeL2, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NotEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(OneHot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PRelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PSROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Pad, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Parameter, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Power, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PriorBox, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PriorBoxClustered, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Proposal, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Range, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Relu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReduceMax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMean, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMin, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceProd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceSum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(RegionYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Reshape, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Result, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Reverse, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReverseSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(RNNCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Select, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Selu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ShapeOf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ShuffleChannels, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sign, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sinh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Softmax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sqrt, ov::op::v0)
|
||||
_OPENVINO_OP_REG(SpaceToDepth, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Split, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SquaredDifference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Squeeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(StridedSlice, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Subtract, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Tan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tanh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TensorIterator, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tile, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TopK, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Transpose, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Unsqueeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(VariadicSplit, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Xor, ov::op::v0)
|
||||
|
||||
@ -8,8 +8,8 @@
|
||||
|
||||
namespace ov {
|
||||
namespace opset2 {
|
||||
#define OPENVINO_OP(a, b) using b::a;
|
||||
#define _OPENVINO_OP_REG(a, b) using b::a;
|
||||
#include "openvino/opsets/opset2_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
} // namespace opset2
|
||||
} // namespace ov
|
||||
|
||||
@ -2,142 +2,142 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#ifndef OPENVINO_OP
|
||||
# warning "OPENVINO_OP not defined"
|
||||
# define OPENVINO_OP(x, y)
|
||||
#ifndef _OPENVINO_OP_REG
|
||||
# warning "_OPENVINO_OP_REG not defined"
|
||||
# define _OPENVINO_OP_REG(x, y)
|
||||
#endif
|
||||
|
||||
OPENVINO_OP(Abs, ov::op::v0)
|
||||
OPENVINO_OP(Acos, ov::op::v0)
|
||||
OPENVINO_OP(Add, ov::op::v1)
|
||||
OPENVINO_OP(Asin, ov::op::v0)
|
||||
OPENVINO_OP(Atan, ov::op::v0)
|
||||
OPENVINO_OP(AvgPool, ov::op::v1)
|
||||
OPENVINO_OP(BatchNormInference, ov::op::v0)
|
||||
OPENVINO_OP(BinaryConvolution, ov::op::v1)
|
||||
OPENVINO_OP(Broadcast, ov::op::v1)
|
||||
OPENVINO_OP(CTCGreedyDecoder, ov::op::v0)
|
||||
OPENVINO_OP(Ceiling, ov::op::v0)
|
||||
OPENVINO_OP(Clamp, ov::op::v0)
|
||||
OPENVINO_OP(Concat, ov::op::v0)
|
||||
OPENVINO_OP(Constant, ov::op::v0)
|
||||
OPENVINO_OP(Convert, ov::op::v0)
|
||||
OPENVINO_OP(ConvertLike, ov::op::v1)
|
||||
OPENVINO_OP(Convolution, ov::op::v1)
|
||||
OPENVINO_OP(ConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(Cos, ov::op::v0)
|
||||
OPENVINO_OP(Cosh, ov::op::v0)
|
||||
OPENVINO_OP(DeformableConvolution, ov::op::v1)
|
||||
OPENVINO_OP(DeformablePSROIPooling, ov::op::v1)
|
||||
OPENVINO_OP(DepthToSpace, ov::op::v0)
|
||||
OPENVINO_OP(DetectionOutput, ov::op::v0)
|
||||
OPENVINO_OP(Divide, ov::op::v1)
|
||||
OPENVINO_OP(Elu, ov::op::v0)
|
||||
OPENVINO_OP(Erf, ov::op::v0)
|
||||
OPENVINO_OP(Equal, ov::op::v1)
|
||||
OPENVINO_OP(Exp, ov::op::v0)
|
||||
OPENVINO_OP(FakeQuantize, ov::op::v0)
|
||||
OPENVINO_OP(Floor, ov::op::v0)
|
||||
OPENVINO_OP(FloorMod, ov::op::v1)
|
||||
OPENVINO_OP(Gather, ov::op::v1)
|
||||
OPENVINO_OP(GatherTree, ov::op::v1)
|
||||
OPENVINO_OP(Greater, ov::op::v1)
|
||||
OPENVINO_OP(GreaterEqual, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolution, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(GRN, ov::op::v0)
|
||||
OPENVINO_OP(HardSigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Interpolate, ov::op::v0)
|
||||
OPENVINO_OP(Less, ov::op::v1)
|
||||
OPENVINO_OP(LessEqual, ov::op::v1)
|
||||
OPENVINO_OP(Log, ov::op::v0)
|
||||
OPENVINO_OP(LogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(LogicalNot, ov::op::v1)
|
||||
OPENVINO_OP(LogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(LogicalXor, ov::op::v1)
|
||||
OPENVINO_OP(LRN, ov::op::v0)
|
||||
OPENVINO_OP(LSTMCell, ov::op::v0)
|
||||
OPENVINO_OP(LSTMSequence, ov::op::v0)
|
||||
OPENVINO_OP(MatMul, ov::op::v0)
|
||||
OPENVINO_OP(MaxPool, ov::op::v1)
|
||||
OPENVINO_OP(Maximum, ov::op::v1)
|
||||
OPENVINO_OP(Minimum, ov::op::v1)
|
||||
OPENVINO_OP(Mod, ov::op::v1)
|
||||
OPENVINO_OP(Multiply, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Abs, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Acos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Add, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Asin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Atan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(AvgPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchNormInference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(BinaryConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Broadcast, ov::op::v1)
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoder, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Ceiling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Clamp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Concat, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Constant, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Convert, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ConvertLike, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Convolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Cos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Cosh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DeformableConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DeformablePSROIPooling, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DepthToSpace, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DetectionOutput, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Divide, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Elu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Erf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Equal, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Exp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FakeQuantize, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Floor, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FloorMod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gather, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GatherTree, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Greater, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GreaterEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(HardSigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Interpolate, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Less, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LessEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Log, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalNot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalXor, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MatMul, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MaxPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Maximum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Minimum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Mod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Multiply, ov::op::v1)
|
||||
|
||||
OPENVINO_OP(MVN, ov::op::v0) // Missing in opset1
|
||||
_OPENVINO_OP_REG(MVN, ov::op::v0) // Missing in opset1
|
||||
|
||||
OPENVINO_OP(Negative, ov::op::v0)
|
||||
OPENVINO_OP(NonMaxSuppression, ov::op::v1)
|
||||
OPENVINO_OP(NormalizeL2, ov::op::v0)
|
||||
OPENVINO_OP(NotEqual, ov::op::v1)
|
||||
OPENVINO_OP(OneHot, ov::op::v1)
|
||||
OPENVINO_OP(PRelu, ov::op::v0)
|
||||
OPENVINO_OP(PSROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(Pad, ov::op::v1)
|
||||
OPENVINO_OP(Parameter, ov::op::v0)
|
||||
OPENVINO_OP(Power, ov::op::v1)
|
||||
OPENVINO_OP(PriorBox, ov::op::v0)
|
||||
OPENVINO_OP(PriorBoxClustered, ov::op::v0)
|
||||
OPENVINO_OP(Proposal, ov::op::v0)
|
||||
OPENVINO_OP(Range, ov::op::v0)
|
||||
OPENVINO_OP(Relu, ov::op::v0)
|
||||
OPENVINO_OP(ReduceMax, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMean, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMin, ov::op::v1)
|
||||
OPENVINO_OP(ReduceProd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceSum, ov::op::v1)
|
||||
OPENVINO_OP(RegionYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Negative, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NonMaxSuppression, ov::op::v1)
|
||||
_OPENVINO_OP_REG(NormalizeL2, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NotEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(OneHot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PRelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PSROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Pad, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Parameter, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Power, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PriorBox, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PriorBoxClustered, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Proposal, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Range, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Relu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReduceMax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMean, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMin, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceProd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceSum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(RegionYolo, ov::op::v0)
|
||||
|
||||
OPENVINO_OP(ReorgYolo, ov::op::v0) // Missing in opset1
|
||||
_OPENVINO_OP_REG(ReorgYolo, ov::op::v0) // Missing in opset1
|
||||
|
||||
OPENVINO_OP(Reshape, ov::op::v1)
|
||||
OPENVINO_OP(Result, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Reshape, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Result, ov::op::v0)
|
||||
|
||||
// Moved out of opset2, it was added to opset1 by mistake
|
||||
// OPENVINO_OP(Reverse, ov::op::v1)
|
||||
// _OPENVINO_OP_REG(Reverse, ov::op::v1)
|
||||
|
||||
OPENVINO_OP(ReverseSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReverseSequence, ov::op::v0)
|
||||
|
||||
// Moved out of opset2, it was added to opset1 by mistake
|
||||
// OPENVINO_OP(RNNCell, ov::op::v0)
|
||||
// _OPENVINO_OP_REG(RNNCell, ov::op::v0)
|
||||
|
||||
OPENVINO_OP(ROIPooling, ov::op::v0) // Missing in opset1
|
||||
_OPENVINO_OP_REG(ROIPooling, ov::op::v0) // Missing in opset1
|
||||
|
||||
OPENVINO_OP(Select, ov::op::v1)
|
||||
OPENVINO_OP(Selu, ov::op::v0)
|
||||
OPENVINO_OP(ShapeOf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Select, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Selu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ShapeOf, ov::op::v0)
|
||||
|
||||
// Moved out of opset2, it was added to opset1 by mistake
|
||||
// OPENVINO_OP(ShuffleChannels, ov::op::v0)
|
||||
// _OPENVINO_OP_REG(ShuffleChannels, ov::op::v0)
|
||||
|
||||
OPENVINO_OP(Sign, ov::op::v0)
|
||||
OPENVINO_OP(Sigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Sin, ov::op::v0)
|
||||
OPENVINO_OP(Sinh, ov::op::v0)
|
||||
OPENVINO_OP(Softmax, ov::op::v1)
|
||||
OPENVINO_OP(Sqrt, ov::op::v0)
|
||||
OPENVINO_OP(SpaceToDepth, ov::op::v0)
|
||||
OPENVINO_OP(Split, ov::op::v1)
|
||||
OPENVINO_OP(SquaredDifference, ov::op::v0)
|
||||
OPENVINO_OP(Squeeze, ov::op::v0)
|
||||
OPENVINO_OP(StridedSlice, ov::op::v1)
|
||||
OPENVINO_OP(Subtract, ov::op::v1)
|
||||
OPENVINO_OP(Tan, ov::op::v0)
|
||||
OPENVINO_OP(Tanh, ov::op::v0)
|
||||
OPENVINO_OP(TensorIterator, ov::op::v0)
|
||||
OPENVINO_OP(Tile, ov::op::v0)
|
||||
OPENVINO_OP(TopK, ov::op::v1)
|
||||
OPENVINO_OP(Transpose, ov::op::v1)
|
||||
OPENVINO_OP(Unsqueeze, ov::op::v0)
|
||||
OPENVINO_OP(VariadicSplit, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sign, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sinh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Softmax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sqrt, ov::op::v0)
|
||||
_OPENVINO_OP_REG(SpaceToDepth, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Split, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SquaredDifference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Squeeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(StridedSlice, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Subtract, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Tan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tanh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TensorIterator, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tile, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TopK, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Transpose, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Unsqueeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(VariadicSplit, ov::op::v1)
|
||||
|
||||
// Moved out of opset2, it was added to opset1 by mistake
|
||||
// OPENVINO_OP(Xor, ov::op::v0)
|
||||
// _OPENVINO_OP_REG(Xor, ov::op::v0)
|
||||
|
||||
// New operations added in opset2
|
||||
OPENVINO_OP(Gelu, ov::op::v0)
|
||||
OPENVINO_OP(BatchToSpace, ov::op::v1)
|
||||
OPENVINO_OP(SpaceToBatch, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(BatchToSpace, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SpaceToBatch, ov::op::v1)
|
||||
|
||||
@ -8,8 +8,8 @@
|
||||
|
||||
namespace ov {
|
||||
namespace opset3 {
|
||||
#define OPENVINO_OP(a, b) using b::a;
|
||||
#define _OPENVINO_OP_REG(a, b) using b::a;
|
||||
#include "openvino/opsets/opset3_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
} // namespace opset3
|
||||
} // namespace ov
|
||||
|
||||
@ -2,158 +2,158 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#ifndef OPENVINO_OP
|
||||
# warning "OPENVINO_OP not defined"
|
||||
# define OPENVINO_OP(x, y)
|
||||
#ifndef _OPENVINO_OP_REG
|
||||
# warning "_OPENVINO_OP_REG not defined"
|
||||
# define _OPENVINO_OP_REG(x, y)
|
||||
#endif
|
||||
|
||||
OPENVINO_OP(Abs, ov::op::v0)
|
||||
OPENVINO_OP(Acos, ov::op::v0)
|
||||
OPENVINO_OP(Add, ov::op::v1)
|
||||
OPENVINO_OP(Asin, ov::op::v0)
|
||||
OPENVINO_OP(Atan, ov::op::v0)
|
||||
OPENVINO_OP(AvgPool, ov::op::v1)
|
||||
OPENVINO_OP(BatchNormInference, ov::op::v0)
|
||||
OPENVINO_OP(BinaryConvolution, ov::op::v1)
|
||||
OPENVINO_OP(Broadcast, ov::op::v3)
|
||||
OPENVINO_OP(Bucketize, ov::op::v3)
|
||||
OPENVINO_OP(CTCGreedyDecoder, ov::op::v0)
|
||||
OPENVINO_OP(Ceiling, ov::op::v0)
|
||||
OPENVINO_OP(Clamp, ov::op::v0)
|
||||
OPENVINO_OP(Concat, ov::op::v0)
|
||||
OPENVINO_OP(Constant, ov::op::v0)
|
||||
OPENVINO_OP(Convert, ov::op::v0)
|
||||
OPENVINO_OP(ConvertLike, ov::op::v1)
|
||||
OPENVINO_OP(Convolution, ov::op::v1)
|
||||
OPENVINO_OP(ConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(Cos, ov::op::v0)
|
||||
OPENVINO_OP(Cosh, ov::op::v0)
|
||||
OPENVINO_OP(CumSum, ov::op::v0)
|
||||
OPENVINO_OP(DeformableConvolution, ov::op::v1)
|
||||
OPENVINO_OP(DeformablePSROIPooling, ov::op::v1)
|
||||
OPENVINO_OP(DepthToSpace, ov::op::v0)
|
||||
OPENVINO_OP(DetectionOutput, ov::op::v0)
|
||||
OPENVINO_OP(Divide, ov::op::v1)
|
||||
OPENVINO_OP(Elu, ov::op::v0)
|
||||
OPENVINO_OP(Erf, ov::op::v0)
|
||||
OPENVINO_OP(Equal, ov::op::v1)
|
||||
OPENVINO_OP(Exp, ov::op::v0)
|
||||
OPENVINO_OP(ExtractImagePatches, ov::op::v3)
|
||||
OPENVINO_OP(FakeQuantize, ov::op::v0)
|
||||
OPENVINO_OP(Floor, ov::op::v0)
|
||||
OPENVINO_OP(FloorMod, ov::op::v1)
|
||||
OPENVINO_OP(Gather, ov::op::v1)
|
||||
OPENVINO_OP(GatherTree, ov::op::v1)
|
||||
OPENVINO_OP(Greater, ov::op::v1)
|
||||
OPENVINO_OP(GreaterEqual, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolution, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(GRN, ov::op::v0)
|
||||
OPENVINO_OP(HardSigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Interpolate, ov::op::v0)
|
||||
OPENVINO_OP(Less, ov::op::v1)
|
||||
OPENVINO_OP(LessEqual, ov::op::v1)
|
||||
OPENVINO_OP(Log, ov::op::v0)
|
||||
OPENVINO_OP(LogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(LogicalNot, ov::op::v1)
|
||||
OPENVINO_OP(LogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(LogicalXor, ov::op::v1)
|
||||
OPENVINO_OP(LRN, ov::op::v0)
|
||||
OPENVINO_OP(LSTMCell, ov::op::v0)
|
||||
OPENVINO_OP(LSTMSequence, ov::op::v0)
|
||||
OPENVINO_OP(MatMul, ov::op::v0)
|
||||
OPENVINO_OP(MaxPool, ov::op::v1)
|
||||
OPENVINO_OP(Maximum, ov::op::v1)
|
||||
OPENVINO_OP(Minimum, ov::op::v1)
|
||||
OPENVINO_OP(Mod, ov::op::v1)
|
||||
OPENVINO_OP(Multiply, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Abs, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Acos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Add, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Asin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Atan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(AvgPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchNormInference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(BinaryConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Broadcast, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Bucketize, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoder, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Ceiling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Clamp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Concat, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Constant, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Convert, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ConvertLike, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Convolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Cos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Cosh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(CumSum, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DeformableConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DeformablePSROIPooling, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DepthToSpace, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DetectionOutput, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Divide, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Elu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Erf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Equal, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Exp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ExtractImagePatches, ov::op::v3)
|
||||
_OPENVINO_OP_REG(FakeQuantize, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Floor, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FloorMod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gather, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GatherTree, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Greater, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GreaterEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(HardSigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Interpolate, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Less, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LessEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Log, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalNot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalXor, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MatMul, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MaxPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Maximum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Minimum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Mod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Multiply, ov::op::v1)
|
||||
|
||||
OPENVINO_OP(MVN, ov::op::v0) // Missing in opset1
|
||||
_OPENVINO_OP_REG(MVN, ov::op::v0) // Missing in opset1
|
||||
|
||||
OPENVINO_OP(Negative, ov::op::v0)
|
||||
OPENVINO_OP(NonMaxSuppression, ov::op::v3)
|
||||
OPENVINO_OP(NormalizeL2, ov::op::v0)
|
||||
OPENVINO_OP(NotEqual, ov::op::v1)
|
||||
OPENVINO_OP(OneHot, ov::op::v1)
|
||||
OPENVINO_OP(PRelu, ov::op::v0)
|
||||
OPENVINO_OP(PSROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(Pad, ov::op::v1)
|
||||
OPENVINO_OP(Parameter, ov::op::v0)
|
||||
OPENVINO_OP(Power, ov::op::v1)
|
||||
OPENVINO_OP(PriorBox, ov::op::v0)
|
||||
OPENVINO_OP(PriorBoxClustered, ov::op::v0)
|
||||
OPENVINO_OP(Proposal, ov::op::v0)
|
||||
OPENVINO_OP(Range, ov::op::v0)
|
||||
OPENVINO_OP(Relu, ov::op::v0)
|
||||
OPENVINO_OP(ReduceMax, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMean, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMin, ov::op::v1)
|
||||
OPENVINO_OP(ReduceProd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceSum, ov::op::v1)
|
||||
OPENVINO_OP(RegionYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Negative, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NonMaxSuppression, ov::op::v3)
|
||||
_OPENVINO_OP_REG(NormalizeL2, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NotEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(OneHot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PRelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PSROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Pad, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Parameter, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Power, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PriorBox, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PriorBoxClustered, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Proposal, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Range, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Relu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReduceMax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMean, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMin, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceProd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceSum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(RegionYolo, ov::op::v0)
|
||||
|
||||
OPENVINO_OP(ReorgYolo, ov::op::v0) // Missing in opset1
|
||||
_OPENVINO_OP_REG(ReorgYolo, ov::op::v0) // Missing in opset1
|
||||
|
||||
OPENVINO_OP(Reshape, ov::op::v1)
|
||||
OPENVINO_OP(Result, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Reshape, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Result, ov::op::v0)
|
||||
|
||||
// Moved out of opset2, it was added to opset1 by mistake
|
||||
// OPENVINO_OP(Reverse, ov::op::v1)
|
||||
// _OPENVINO_OP_REG(Reverse, ov::op::v1)
|
||||
|
||||
OPENVINO_OP(ReverseSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReverseSequence, ov::op::v0)
|
||||
|
||||
// Moved out of opset2, it was added to opset1 by mistake
|
||||
// OPENVINO_OP(RNNCell, ov::op::v0)
|
||||
// _OPENVINO_OP_REG(RNNCell, ov::op::v0)
|
||||
|
||||
OPENVINO_OP(ROIPooling, ov::op::v0) // Missing in opset1
|
||||
_OPENVINO_OP_REG(ROIPooling, ov::op::v0) // Missing in opset1
|
||||
|
||||
OPENVINO_OP(Select, ov::op::v1)
|
||||
OPENVINO_OP(Selu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Select, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Selu, ov::op::v0)
|
||||
// Superseded
|
||||
// OPENVINO_OP(ShapeOf, ov::op::v0)
|
||||
// _OPENVINO_OP_REG(ShapeOf, ov::op::v0)
|
||||
|
||||
OPENVINO_OP(Sign, ov::op::v0)
|
||||
OPENVINO_OP(Sigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Sin, ov::op::v0)
|
||||
OPENVINO_OP(Sinh, ov::op::v0)
|
||||
OPENVINO_OP(Softmax, ov::op::v1)
|
||||
OPENVINO_OP(Sqrt, ov::op::v0)
|
||||
OPENVINO_OP(SpaceToDepth, ov::op::v0)
|
||||
OPENVINO_OP(Split, ov::op::v1)
|
||||
OPENVINO_OP(SquaredDifference, ov::op::v0)
|
||||
OPENVINO_OP(Squeeze, ov::op::v0)
|
||||
OPENVINO_OP(StridedSlice, ov::op::v1)
|
||||
OPENVINO_OP(Subtract, ov::op::v1)
|
||||
OPENVINO_OP(Tan, ov::op::v0)
|
||||
OPENVINO_OP(Tanh, ov::op::v0)
|
||||
OPENVINO_OP(TensorIterator, ov::op::v0)
|
||||
OPENVINO_OP(Tile, ov::op::v0)
|
||||
OPENVINO_OP(Transpose, ov::op::v1)
|
||||
OPENVINO_OP(Unsqueeze, ov::op::v0)
|
||||
OPENVINO_OP(VariadicSplit, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sign, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sinh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Softmax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sqrt, ov::op::v0)
|
||||
_OPENVINO_OP_REG(SpaceToDepth, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Split, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SquaredDifference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Squeeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(StridedSlice, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Subtract, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Tan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tanh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TensorIterator, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tile, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Transpose, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Unsqueeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(VariadicSplit, ov::op::v1)
|
||||
|
||||
// Moved out of opset2, it was added to opset1 by mistake
|
||||
// OPENVINO_OP(Xor, ov::op::v0)
|
||||
// _OPENVINO_OP_REG(Xor, ov::op::v0)
|
||||
|
||||
// New operations added in opset2
|
||||
OPENVINO_OP(Gelu, ov::op::v0)
|
||||
OPENVINO_OP(BatchToSpace, ov::op::v1)
|
||||
OPENVINO_OP(SpaceToBatch, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(BatchToSpace, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SpaceToBatch, ov::op::v1)
|
||||
|
||||
// New operations added in opset3
|
||||
OPENVINO_OP(EmbeddingBagPackedSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingSegmentsSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
OPENVINO_OP(GRUCell, ov::op::v3)
|
||||
OPENVINO_OP(NonZero, ov::op::v3)
|
||||
OPENVINO_OP(RNNCell, ov::op::v0)
|
||||
OPENVINO_OP(ROIAlign, ov::op::v3)
|
||||
OPENVINO_OP(ScatterElementsUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ScatterUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ShuffleChannels, ov::op::v0)
|
||||
OPENVINO_OP(ShapeOf, ov::op::v3)
|
||||
OPENVINO_OP(Assign, ov::op::v3)
|
||||
OPENVINO_OP(ReadValue, ov::op::v3)
|
||||
OPENVINO_OP(TopK, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagPackedSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingSegmentsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(GRUCell, ov::op::v3)
|
||||
_OPENVINO_OP_REG(NonZero, ov::op::v3)
|
||||
_OPENVINO_OP_REG(RNNCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIAlign, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterElementsUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ShuffleChannels, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ShapeOf, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Assign, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ReadValue, ov::op::v3)
|
||||
_OPENVINO_OP_REG(TopK, ov::op::v3)
|
||||
|
||||
@ -8,8 +8,8 @@
|
||||
|
||||
namespace ov {
|
||||
namespace opset4 {
|
||||
#define OPENVINO_OP(a, b) using b::a;
|
||||
#define _OPENVINO_OP_REG(a, b) using b::a;
|
||||
#include "openvino/opsets/opset4_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
} // namespace opset4
|
||||
} // namespace ov
|
||||
|
||||
@ -2,151 +2,151 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#ifndef OPENVINO_OP
|
||||
# warning "OPENVINO_OP not defined"
|
||||
# define OPENVINO_OP(x, y)
|
||||
#ifndef _OPENVINO_OP_REG
|
||||
# warning "_OPENVINO_OP_REG not defined"
|
||||
# define _OPENVINO_OP_REG(x, y)
|
||||
#endif
|
||||
|
||||
OPENVINO_OP(Abs, ov::op::v0)
|
||||
OPENVINO_OP(Acos, ov::op::v0)
|
||||
OPENVINO_OP(Add, ov::op::v1)
|
||||
OPENVINO_OP(Asin, ov::op::v0)
|
||||
OPENVINO_OP(Atan, ov::op::v0)
|
||||
OPENVINO_OP(AvgPool, ov::op::v1)
|
||||
OPENVINO_OP(BatchNormInference, ov::op::v0)
|
||||
OPENVINO_OP(BinaryConvolution, ov::op::v1)
|
||||
OPENVINO_OP(Broadcast, ov::op::v3)
|
||||
OPENVINO_OP(Bucketize, ov::op::v3)
|
||||
OPENVINO_OP(CTCGreedyDecoder, ov::op::v0)
|
||||
OPENVINO_OP(Ceiling, ov::op::v0)
|
||||
OPENVINO_OP(Clamp, ov::op::v0)
|
||||
OPENVINO_OP(Concat, ov::op::v0)
|
||||
OPENVINO_OP(Constant, ov::op::v0)
|
||||
OPENVINO_OP(Convert, ov::op::v0)
|
||||
OPENVINO_OP(ConvertLike, ov::op::v1)
|
||||
OPENVINO_OP(Convolution, ov::op::v1)
|
||||
OPENVINO_OP(ConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(Cos, ov::op::v0)
|
||||
OPENVINO_OP(Cosh, ov::op::v0)
|
||||
OPENVINO_OP(CumSum, ov::op::v0)
|
||||
OPENVINO_OP(DeformableConvolution, ov::op::v1)
|
||||
OPENVINO_OP(DeformablePSROIPooling, ov::op::v1)
|
||||
OPENVINO_OP(DepthToSpace, ov::op::v0)
|
||||
OPENVINO_OP(DetectionOutput, ov::op::v0)
|
||||
OPENVINO_OP(Divide, ov::op::v1)
|
||||
OPENVINO_OP(Elu, ov::op::v0)
|
||||
OPENVINO_OP(Erf, ov::op::v0)
|
||||
OPENVINO_OP(Equal, ov::op::v1)
|
||||
OPENVINO_OP(Exp, ov::op::v0)
|
||||
OPENVINO_OP(ExtractImagePatches, ov::op::v3)
|
||||
OPENVINO_OP(FakeQuantize, ov::op::v0)
|
||||
OPENVINO_OP(Floor, ov::op::v0)
|
||||
OPENVINO_OP(FloorMod, ov::op::v1)
|
||||
OPENVINO_OP(Gather, ov::op::v1)
|
||||
OPENVINO_OP(GatherTree, ov::op::v1)
|
||||
OPENVINO_OP(Greater, ov::op::v1)
|
||||
OPENVINO_OP(GreaterEqual, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolution, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(GRN, ov::op::v0)
|
||||
OPENVINO_OP(HardSigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Less, ov::op::v1)
|
||||
OPENVINO_OP(LessEqual, ov::op::v1)
|
||||
OPENVINO_OP(Log, ov::op::v0)
|
||||
OPENVINO_OP(LogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(LogicalNot, ov::op::v1)
|
||||
OPENVINO_OP(LogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(LogicalXor, ov::op::v1)
|
||||
OPENVINO_OP(LRN, ov::op::v0)
|
||||
OPENVINO_OP(LSTMCell, ov::op::v4)
|
||||
OPENVINO_OP(MatMul, ov::op::v0)
|
||||
OPENVINO_OP(MaxPool, ov::op::v1)
|
||||
OPENVINO_OP(Maximum, ov::op::v1)
|
||||
OPENVINO_OP(Minimum, ov::op::v1)
|
||||
OPENVINO_OP(Mod, ov::op::v1)
|
||||
OPENVINO_OP(Multiply, ov::op::v1)
|
||||
OPENVINO_OP(MVN, ov::op::v0)
|
||||
OPENVINO_OP(Negative, ov::op::v0)
|
||||
OPENVINO_OP(NormalizeL2, ov::op::v0)
|
||||
OPENVINO_OP(NotEqual, ov::op::v1)
|
||||
OPENVINO_OP(OneHot, ov::op::v1)
|
||||
OPENVINO_OP(PRelu, ov::op::v0)
|
||||
OPENVINO_OP(PSROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(Pad, ov::op::v1)
|
||||
OPENVINO_OP(Parameter, ov::op::v0)
|
||||
OPENVINO_OP(Power, ov::op::v1)
|
||||
OPENVINO_OP(PriorBox, ov::op::v0)
|
||||
OPENVINO_OP(PriorBoxClustered, ov::op::v0)
|
||||
OPENVINO_OP(Proposal, ov::op::v4)
|
||||
OPENVINO_OP(Range, ov::op::v4)
|
||||
OPENVINO_OP(Relu, ov::op::v0)
|
||||
OPENVINO_OP(ReduceMax, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMean, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMin, ov::op::v1)
|
||||
OPENVINO_OP(ReduceProd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceSum, ov::op::v1)
|
||||
OPENVINO_OP(RegionYolo, ov::op::v0)
|
||||
OPENVINO_OP(ReorgYolo, ov::op::v0)
|
||||
OPENVINO_OP(Reshape, ov::op::v1)
|
||||
OPENVINO_OP(Result, ov::op::v0)
|
||||
OPENVINO_OP(ReverseSequence, ov::op::v0)
|
||||
OPENVINO_OP(ROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(ScatterNDUpdate, ov::op::v3)
|
||||
OPENVINO_OP(Select, ov::op::v1)
|
||||
OPENVINO_OP(Selu, ov::op::v0)
|
||||
OPENVINO_OP(Sign, ov::op::v0)
|
||||
OPENVINO_OP(Sigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Sin, ov::op::v0)
|
||||
OPENVINO_OP(Sinh, ov::op::v0)
|
||||
OPENVINO_OP(Softmax, ov::op::v1)
|
||||
OPENVINO_OP(Sqrt, ov::op::v0)
|
||||
OPENVINO_OP(SpaceToDepth, ov::op::v0)
|
||||
OPENVINO_OP(Split, ov::op::v1)
|
||||
OPENVINO_OP(SquaredDifference, ov::op::v0)
|
||||
OPENVINO_OP(Squeeze, ov::op::v0)
|
||||
OPENVINO_OP(StridedSlice, ov::op::v1)
|
||||
OPENVINO_OP(Subtract, ov::op::v1)
|
||||
OPENVINO_OP(Tan, ov::op::v0)
|
||||
OPENVINO_OP(Tanh, ov::op::v0)
|
||||
OPENVINO_OP(TensorIterator, ov::op::v0)
|
||||
OPENVINO_OP(Tile, ov::op::v0)
|
||||
OPENVINO_OP(Transpose, ov::op::v1)
|
||||
OPENVINO_OP(Unsqueeze, ov::op::v0)
|
||||
OPENVINO_OP(VariadicSplit, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Abs, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Acos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Add, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Asin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Atan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(AvgPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchNormInference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(BinaryConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Broadcast, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Bucketize, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoder, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Ceiling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Clamp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Concat, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Constant, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Convert, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ConvertLike, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Convolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Cos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Cosh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(CumSum, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DeformableConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DeformablePSROIPooling, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DepthToSpace, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DetectionOutput, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Divide, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Elu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Erf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Equal, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Exp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ExtractImagePatches, ov::op::v3)
|
||||
_OPENVINO_OP_REG(FakeQuantize, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Floor, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FloorMod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gather, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GatherTree, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Greater, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GreaterEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(HardSigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Less, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LessEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Log, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalNot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalXor, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMCell, ov::op::v4)
|
||||
_OPENVINO_OP_REG(MatMul, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MaxPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Maximum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Minimum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Mod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Multiply, ov::op::v1)
|
||||
_OPENVINO_OP_REG(MVN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Negative, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NormalizeL2, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NotEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(OneHot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PRelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PSROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Pad, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Parameter, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Power, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PriorBox, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PriorBoxClustered, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Proposal, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Range, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Relu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReduceMax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMean, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMin, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceProd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceSum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(RegionYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReorgYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Reshape, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Result, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReverseSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ScatterNDUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Select, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Selu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sign, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sinh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Softmax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sqrt, ov::op::v0)
|
||||
_OPENVINO_OP_REG(SpaceToDepth, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Split, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SquaredDifference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Squeeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(StridedSlice, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Subtract, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Tan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tanh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TensorIterator, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tile, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Transpose, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Unsqueeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(VariadicSplit, ov::op::v1)
|
||||
|
||||
// New operations added in opset2
|
||||
OPENVINO_OP(Gelu, ov::op::v0)
|
||||
OPENVINO_OP(BatchToSpace, ov::op::v1)
|
||||
OPENVINO_OP(SpaceToBatch, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(BatchToSpace, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SpaceToBatch, ov::op::v1)
|
||||
|
||||
// New operations added in opset3
|
||||
OPENVINO_OP(EmbeddingBagPackedSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingSegmentsSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
OPENVINO_OP(GRUCell, ov::op::v3)
|
||||
OPENVINO_OP(NonZero, ov::op::v3)
|
||||
OPENVINO_OP(RNNCell, ov::op::v0)
|
||||
OPENVINO_OP(ROIAlign, ov::op::v3)
|
||||
OPENVINO_OP(ScatterElementsUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ScatterUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ShuffleChannels, ov::op::v0)
|
||||
OPENVINO_OP(ShapeOf, ov::op::v3)
|
||||
OPENVINO_OP(Assign, ov::op::v3)
|
||||
OPENVINO_OP(ReadValue, ov::op::v3)
|
||||
OPENVINO_OP(TopK, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagPackedSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingSegmentsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(GRUCell, ov::op::v3)
|
||||
_OPENVINO_OP_REG(NonZero, ov::op::v3)
|
||||
_OPENVINO_OP_REG(RNNCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIAlign, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterElementsUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ShuffleChannels, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ShapeOf, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Assign, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ReadValue, ov::op::v3)
|
||||
_OPENVINO_OP_REG(TopK, ov::op::v3)
|
||||
|
||||
// New operations added in opset4
|
||||
OPENVINO_OP(Acosh, ov::op::v3)
|
||||
OPENVINO_OP(Asinh, ov::op::v3)
|
||||
OPENVINO_OP(Atanh, ov::op::v3)
|
||||
OPENVINO_OP(CTCLoss, ov::op::v4)
|
||||
OPENVINO_OP(HSwish, ov::op::v4)
|
||||
OPENVINO_OP(Interpolate, ov::op::v4)
|
||||
OPENVINO_OP(Mish, ov::op::v4)
|
||||
OPENVINO_OP(NonMaxSuppression, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL1, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL2, ov::op::v4)
|
||||
OPENVINO_OP(SoftPlus, ov::op::v4)
|
||||
OPENVINO_OP(Swish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Acosh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Asinh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Atanh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCLoss, ov::op::v4)
|
||||
_OPENVINO_OP_REG(HSwish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Interpolate, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Mish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(NonMaxSuppression, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL1, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL2, ov::op::v4)
|
||||
_OPENVINO_OP_REG(SoftPlus, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Swish, ov::op::v4)
|
||||
|
||||
@ -8,8 +8,8 @@
|
||||
|
||||
namespace ov {
|
||||
namespace opset5 {
|
||||
#define OPENVINO_OP(a, b) using b::a;
|
||||
#define _OPENVINO_OP_REG(a, b) using b::a;
|
||||
#include "openvino/opsets/opset5_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
} // namespace opset5
|
||||
} // namespace ov
|
||||
|
||||
@ -2,161 +2,161 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#ifndef OPENVINO_OP
|
||||
# warning "OPENVINO_OP not defined"
|
||||
# define OPENVINO_OP(x, y)
|
||||
#ifndef _OPENVINO_OP_REG
|
||||
# warning "_OPENVINO_OP_REG not defined"
|
||||
# define _OPENVINO_OP_REG(x, y)
|
||||
#endif
|
||||
|
||||
OPENVINO_OP(Abs, ov::op::v0)
|
||||
OPENVINO_OP(Acos, ov::op::v0)
|
||||
OPENVINO_OP(Add, ov::op::v1)
|
||||
OPENVINO_OP(Asin, ov::op::v0)
|
||||
OPENVINO_OP(Atan, ov::op::v0)
|
||||
OPENVINO_OP(AvgPool, ov::op::v1)
|
||||
OPENVINO_OP(BatchNormInference, ov::op::v5)
|
||||
OPENVINO_OP(BinaryConvolution, ov::op::v1)
|
||||
OPENVINO_OP(Broadcast, ov::op::v3)
|
||||
OPENVINO_OP(Bucketize, ov::op::v3)
|
||||
OPENVINO_OP(CTCGreedyDecoder, ov::op::v0)
|
||||
OPENVINO_OP(Ceiling, ov::op::v0)
|
||||
OPENVINO_OP(Clamp, ov::op::v0)
|
||||
OPENVINO_OP(Concat, ov::op::v0)
|
||||
OPENVINO_OP(Constant, ov::op::v0)
|
||||
OPENVINO_OP(Convert, ov::op::v0)
|
||||
OPENVINO_OP(ConvertLike, ov::op::v1)
|
||||
OPENVINO_OP(Convolution, ov::op::v1)
|
||||
OPENVINO_OP(ConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(Cos, ov::op::v0)
|
||||
OPENVINO_OP(Cosh, ov::op::v0)
|
||||
OPENVINO_OP(CumSum, ov::op::v0)
|
||||
OPENVINO_OP(DeformableConvolution, ov::op::v1)
|
||||
OPENVINO_OP(DeformablePSROIPooling, ov::op::v1)
|
||||
OPENVINO_OP(DepthToSpace, ov::op::v0)
|
||||
OPENVINO_OP(DetectionOutput, ov::op::v0)
|
||||
OPENVINO_OP(Divide, ov::op::v1)
|
||||
OPENVINO_OP(Elu, ov::op::v0)
|
||||
OPENVINO_OP(Erf, ov::op::v0)
|
||||
OPENVINO_OP(Equal, ov::op::v1)
|
||||
OPENVINO_OP(Exp, ov::op::v0)
|
||||
OPENVINO_OP(ExtractImagePatches, ov::op::v3)
|
||||
OPENVINO_OP(FakeQuantize, ov::op::v0)
|
||||
OPENVINO_OP(Floor, ov::op::v0)
|
||||
OPENVINO_OP(FloorMod, ov::op::v1)
|
||||
OPENVINO_OP(Gather, ov::op::v1)
|
||||
OPENVINO_OP(GatherTree, ov::op::v1)
|
||||
OPENVINO_OP(Greater, ov::op::v1)
|
||||
OPENVINO_OP(GreaterEqual, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolution, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(GRN, ov::op::v0)
|
||||
OPENVINO_OP(HardSigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Less, ov::op::v1)
|
||||
OPENVINO_OP(LessEqual, ov::op::v1)
|
||||
OPENVINO_OP(Log, ov::op::v0)
|
||||
OPENVINO_OP(LogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(LogicalNot, ov::op::v1)
|
||||
OPENVINO_OP(LogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(LogicalXor, ov::op::v1)
|
||||
OPENVINO_OP(LRN, ov::op::v0)
|
||||
OPENVINO_OP(LSTMCell, ov::op::v4)
|
||||
OPENVINO_OP(MatMul, ov::op::v0)
|
||||
OPENVINO_OP(MaxPool, ov::op::v1)
|
||||
OPENVINO_OP(Maximum, ov::op::v1)
|
||||
OPENVINO_OP(Minimum, ov::op::v1)
|
||||
OPENVINO_OP(Mod, ov::op::v1)
|
||||
OPENVINO_OP(Multiply, ov::op::v1)
|
||||
OPENVINO_OP(MVN, ov::op::v0)
|
||||
OPENVINO_OP(Negative, ov::op::v0)
|
||||
OPENVINO_OP(NormalizeL2, ov::op::v0)
|
||||
OPENVINO_OP(NotEqual, ov::op::v1)
|
||||
OPENVINO_OP(OneHot, ov::op::v1)
|
||||
OPENVINO_OP(PRelu, ov::op::v0)
|
||||
OPENVINO_OP(PSROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(Pad, ov::op::v1)
|
||||
OPENVINO_OP(Parameter, ov::op::v0)
|
||||
OPENVINO_OP(Power, ov::op::v1)
|
||||
OPENVINO_OP(PriorBox, ov::op::v0)
|
||||
OPENVINO_OP(PriorBoxClustered, ov::op::v0)
|
||||
OPENVINO_OP(Proposal, ov::op::v4)
|
||||
OPENVINO_OP(Range, ov::op::v4)
|
||||
OPENVINO_OP(Relu, ov::op::v0)
|
||||
OPENVINO_OP(ReduceMax, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMean, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMin, ov::op::v1)
|
||||
OPENVINO_OP(ReduceProd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceSum, ov::op::v1)
|
||||
OPENVINO_OP(RegionYolo, ov::op::v0)
|
||||
OPENVINO_OP(ReorgYolo, ov::op::v0)
|
||||
OPENVINO_OP(Reshape, ov::op::v1)
|
||||
OPENVINO_OP(Result, ov::op::v0)
|
||||
OPENVINO_OP(ReverseSequence, ov::op::v0)
|
||||
OPENVINO_OP(ROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(ScatterNDUpdate, ov::op::v3)
|
||||
OPENVINO_OP(Select, ov::op::v1)
|
||||
OPENVINO_OP(Selu, ov::op::v0)
|
||||
OPENVINO_OP(Sign, ov::op::v0)
|
||||
OPENVINO_OP(Sigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Sin, ov::op::v0)
|
||||
OPENVINO_OP(Sinh, ov::op::v0)
|
||||
OPENVINO_OP(Softmax, ov::op::v1)
|
||||
OPENVINO_OP(Sqrt, ov::op::v0)
|
||||
OPENVINO_OP(SpaceToDepth, ov::op::v0)
|
||||
OPENVINO_OP(Split, ov::op::v1)
|
||||
OPENVINO_OP(SquaredDifference, ov::op::v0)
|
||||
OPENVINO_OP(Squeeze, ov::op::v0)
|
||||
OPENVINO_OP(StridedSlice, ov::op::v1)
|
||||
OPENVINO_OP(Subtract, ov::op::v1)
|
||||
OPENVINO_OP(Tan, ov::op::v0)
|
||||
OPENVINO_OP(Tanh, ov::op::v0)
|
||||
OPENVINO_OP(TensorIterator, ov::op::v0)
|
||||
OPENVINO_OP(Tile, ov::op::v0)
|
||||
OPENVINO_OP(Transpose, ov::op::v1)
|
||||
OPENVINO_OP(Unsqueeze, ov::op::v0)
|
||||
OPENVINO_OP(VariadicSplit, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Abs, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Acos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Add, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Asin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Atan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(AvgPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchNormInference, ov::op::v5)
|
||||
_OPENVINO_OP_REG(BinaryConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Broadcast, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Bucketize, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoder, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Ceiling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Clamp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Concat, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Constant, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Convert, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ConvertLike, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Convolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Cos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Cosh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(CumSum, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DeformableConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DeformablePSROIPooling, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DepthToSpace, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DetectionOutput, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Divide, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Elu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Erf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Equal, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Exp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ExtractImagePatches, ov::op::v3)
|
||||
_OPENVINO_OP_REG(FakeQuantize, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Floor, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FloorMod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gather, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GatherTree, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Greater, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GreaterEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(HardSigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Less, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LessEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Log, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalNot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalXor, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMCell, ov::op::v4)
|
||||
_OPENVINO_OP_REG(MatMul, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MaxPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Maximum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Minimum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Mod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Multiply, ov::op::v1)
|
||||
_OPENVINO_OP_REG(MVN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Negative, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NormalizeL2, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NotEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(OneHot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PRelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PSROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Pad, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Parameter, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Power, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PriorBox, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PriorBoxClustered, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Proposal, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Range, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Relu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReduceMax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMean, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMin, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceProd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceSum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(RegionYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReorgYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Reshape, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Result, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReverseSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ScatterNDUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Select, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Selu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sign, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sinh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Softmax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sqrt, ov::op::v0)
|
||||
_OPENVINO_OP_REG(SpaceToDepth, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Split, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SquaredDifference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Squeeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(StridedSlice, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Subtract, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Tan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tanh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TensorIterator, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tile, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Transpose, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Unsqueeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(VariadicSplit, ov::op::v1)
|
||||
|
||||
// New operations added in opset2
|
||||
OPENVINO_OP(Gelu, ov::op::v0)
|
||||
OPENVINO_OP(BatchToSpace, ov::op::v1)
|
||||
OPENVINO_OP(SpaceToBatch, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(BatchToSpace, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SpaceToBatch, ov::op::v1)
|
||||
|
||||
// New operations added in opset3
|
||||
OPENVINO_OP(EmbeddingBagPackedSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingSegmentsSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
OPENVINO_OP(GRUCell, ov::op::v3)
|
||||
OPENVINO_OP(NonZero, ov::op::v3)
|
||||
OPENVINO_OP(RNNCell, ov::op::v0)
|
||||
OPENVINO_OP(ROIAlign, ov::op::v3)
|
||||
OPENVINO_OP(ScatterElementsUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ScatterUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ShuffleChannels, ov::op::v0)
|
||||
OPENVINO_OP(ShapeOf, ov::op::v3)
|
||||
OPENVINO_OP(Assign, ov::op::v3)
|
||||
OPENVINO_OP(ReadValue, ov::op::v3)
|
||||
OPENVINO_OP(TopK, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagPackedSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingSegmentsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(GRUCell, ov::op::v3)
|
||||
_OPENVINO_OP_REG(NonZero, ov::op::v3)
|
||||
_OPENVINO_OP_REG(RNNCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIAlign, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterElementsUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ShuffleChannels, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ShapeOf, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Assign, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ReadValue, ov::op::v3)
|
||||
_OPENVINO_OP_REG(TopK, ov::op::v3)
|
||||
|
||||
// New operations added in opset4
|
||||
OPENVINO_OP(Acosh, ov::op::v3)
|
||||
OPENVINO_OP(Asinh, ov::op::v3)
|
||||
OPENVINO_OP(Atanh, ov::op::v3)
|
||||
OPENVINO_OP(CTCLoss, ov::op::v4)
|
||||
OPENVINO_OP(HSwish, ov::op::v4)
|
||||
OPENVINO_OP(Interpolate, ov::op::v4)
|
||||
OPENVINO_OP(Mish, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL1, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL2, ov::op::v4)
|
||||
OPENVINO_OP(SoftPlus, ov::op::v4)
|
||||
OPENVINO_OP(Swish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Acosh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Asinh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Atanh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCLoss, ov::op::v4)
|
||||
_OPENVINO_OP_REG(HSwish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Interpolate, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Mish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL1, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL2, ov::op::v4)
|
||||
_OPENVINO_OP_REG(SoftPlus, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Swish, ov::op::v4)
|
||||
|
||||
// New operations added in opset5
|
||||
OPENVINO_OP(GatherND, ov::op::v5)
|
||||
OPENVINO_OP(GRUSequence, ov::op::v5)
|
||||
OPENVINO_OP(HSigmoid, ov::op::v5)
|
||||
OPENVINO_OP(LogSoftmax, ov::op::v5)
|
||||
OPENVINO_OP(Loop, ov::op::v5)
|
||||
OPENVINO_OP(LSTMSequence, ov::op::v5)
|
||||
OPENVINO_OP(NonMaxSuppression, ov::op::v5)
|
||||
OPENVINO_OP(RNNSequence, ov::op::v5)
|
||||
OPENVINO_OP(Round, ov::op::v5)
|
||||
_OPENVINO_OP_REG(GatherND, ov::op::v5)
|
||||
_OPENVINO_OP_REG(GRUSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(HSigmoid, ov::op::v5)
|
||||
_OPENVINO_OP_REG(LogSoftmax, ov::op::v5)
|
||||
_OPENVINO_OP_REG(Loop, ov::op::v5)
|
||||
_OPENVINO_OP_REG(LSTMSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(NonMaxSuppression, ov::op::v5)
|
||||
_OPENVINO_OP_REG(RNNSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(Round, ov::op::v5)
|
||||
|
||||
@ -8,8 +8,8 @@
|
||||
|
||||
namespace ov {
|
||||
namespace opset6 {
|
||||
#define OPENVINO_OP(a, b) using b::a;
|
||||
#define _OPENVINO_OP_REG(a, b) using b::a;
|
||||
#include "openvino/opsets/opset6_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
} // namespace opset6
|
||||
} // namespace ov
|
||||
|
||||
@ -2,170 +2,170 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#ifndef OPENVINO_OP
|
||||
# warning "OPENVINO_OP not defined"
|
||||
# define OPENVINO_OP(x, y)
|
||||
#ifndef _OPENVINO_OP_REG
|
||||
# warning "_OPENVINO_OP_REG not defined"
|
||||
# define _OPENVINO_OP_REG(x, y)
|
||||
#endif
|
||||
|
||||
OPENVINO_OP(Abs, ov::op::v0)
|
||||
OPENVINO_OP(Acos, ov::op::v0)
|
||||
OPENVINO_OP(Add, ov::op::v1)
|
||||
OPENVINO_OP(Asin, ov::op::v0)
|
||||
OPENVINO_OP(Atan, ov::op::v0)
|
||||
OPENVINO_OP(AvgPool, ov::op::v1)
|
||||
OPENVINO_OP(BatchNormInference, ov::op::v5)
|
||||
OPENVINO_OP(BinaryConvolution, ov::op::v1)
|
||||
OPENVINO_OP(Broadcast, ov::op::v3)
|
||||
OPENVINO_OP(Bucketize, ov::op::v3)
|
||||
OPENVINO_OP(CTCGreedyDecoder, ov::op::v0)
|
||||
OPENVINO_OP(Ceiling, ov::op::v0)
|
||||
OPENVINO_OP(Clamp, ov::op::v0)
|
||||
OPENVINO_OP(Concat, ov::op::v0)
|
||||
OPENVINO_OP(Constant, ov::op::v0)
|
||||
OPENVINO_OP(Convert, ov::op::v0)
|
||||
OPENVINO_OP(ConvertLike, ov::op::v1)
|
||||
OPENVINO_OP(Convolution, ov::op::v1)
|
||||
OPENVINO_OP(ConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(Cos, ov::op::v0)
|
||||
OPENVINO_OP(Cosh, ov::op::v0)
|
||||
OPENVINO_OP(CumSum, ov::op::v0)
|
||||
OPENVINO_OP(DeformableConvolution, ov::op::v1)
|
||||
OPENVINO_OP(DeformablePSROIPooling, ov::op::v1)
|
||||
OPENVINO_OP(DepthToSpace, ov::op::v0)
|
||||
OPENVINO_OP(DetectionOutput, ov::op::v0)
|
||||
OPENVINO_OP(Divide, ov::op::v1)
|
||||
OPENVINO_OP(Elu, ov::op::v0)
|
||||
OPENVINO_OP(Erf, ov::op::v0)
|
||||
OPENVINO_OP(Equal, ov::op::v1)
|
||||
OPENVINO_OP(Exp, ov::op::v0)
|
||||
OPENVINO_OP(ExtractImagePatches, ov::op::v3)
|
||||
OPENVINO_OP(FakeQuantize, ov::op::v0)
|
||||
OPENVINO_OP(Floor, ov::op::v0)
|
||||
OPENVINO_OP(FloorMod, ov::op::v1)
|
||||
OPENVINO_OP(Gather, ov::op::v1)
|
||||
OPENVINO_OP(GatherTree, ov::op::v1)
|
||||
OPENVINO_OP(Greater, ov::op::v1)
|
||||
OPENVINO_OP(GreaterEqual, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolution, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(GRN, ov::op::v0)
|
||||
OPENVINO_OP(HardSigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Less, ov::op::v1)
|
||||
OPENVINO_OP(LessEqual, ov::op::v1)
|
||||
OPENVINO_OP(Log, ov::op::v0)
|
||||
OPENVINO_OP(LogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(LogicalNot, ov::op::v1)
|
||||
OPENVINO_OP(LogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(LogicalXor, ov::op::v1)
|
||||
OPENVINO_OP(LRN, ov::op::v0)
|
||||
OPENVINO_OP(LSTMCell, ov::op::v4)
|
||||
OPENVINO_OP(MatMul, ov::op::v0)
|
||||
OPENVINO_OP(MaxPool, ov::op::v1)
|
||||
OPENVINO_OP(Maximum, ov::op::v1)
|
||||
OPENVINO_OP(Minimum, ov::op::v1)
|
||||
OPENVINO_OP(Mod, ov::op::v1)
|
||||
OPENVINO_OP(Multiply, ov::op::v1)
|
||||
OPENVINO_OP(Negative, ov::op::v0)
|
||||
OPENVINO_OP(NormalizeL2, ov::op::v0)
|
||||
OPENVINO_OP(NotEqual, ov::op::v1)
|
||||
OPENVINO_OP(OneHot, ov::op::v1)
|
||||
OPENVINO_OP(PRelu, ov::op::v0)
|
||||
OPENVINO_OP(PSROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(Pad, ov::op::v1)
|
||||
OPENVINO_OP(Parameter, ov::op::v0)
|
||||
OPENVINO_OP(Power, ov::op::v1)
|
||||
OPENVINO_OP(PriorBox, ov::op::v0)
|
||||
OPENVINO_OP(PriorBoxClustered, ov::op::v0)
|
||||
OPENVINO_OP(Proposal, ov::op::v4)
|
||||
OPENVINO_OP(Range, ov::op::v4)
|
||||
OPENVINO_OP(Relu, ov::op::v0)
|
||||
OPENVINO_OP(ReduceMax, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMean, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMin, ov::op::v1)
|
||||
OPENVINO_OP(ReduceProd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceSum, ov::op::v1)
|
||||
OPENVINO_OP(RegionYolo, ov::op::v0)
|
||||
OPENVINO_OP(ReorgYolo, ov::op::v0)
|
||||
OPENVINO_OP(Reshape, ov::op::v1)
|
||||
OPENVINO_OP(Result, ov::op::v0)
|
||||
OPENVINO_OP(ReverseSequence, ov::op::v0)
|
||||
OPENVINO_OP(ROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(ScatterNDUpdate, ov::op::v3)
|
||||
OPENVINO_OP(Select, ov::op::v1)
|
||||
OPENVINO_OP(Selu, ov::op::v0)
|
||||
OPENVINO_OP(Sign, ov::op::v0)
|
||||
OPENVINO_OP(Sigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Sin, ov::op::v0)
|
||||
OPENVINO_OP(Sinh, ov::op::v0)
|
||||
OPENVINO_OP(Softmax, ov::op::v1)
|
||||
OPENVINO_OP(Sqrt, ov::op::v0)
|
||||
OPENVINO_OP(SpaceToDepth, ov::op::v0)
|
||||
OPENVINO_OP(Split, ov::op::v1)
|
||||
OPENVINO_OP(SquaredDifference, ov::op::v0)
|
||||
OPENVINO_OP(Squeeze, ov::op::v0)
|
||||
OPENVINO_OP(StridedSlice, ov::op::v1)
|
||||
OPENVINO_OP(Subtract, ov::op::v1)
|
||||
OPENVINO_OP(Tan, ov::op::v0)
|
||||
OPENVINO_OP(Tanh, ov::op::v0)
|
||||
OPENVINO_OP(TensorIterator, ov::op::v0)
|
||||
OPENVINO_OP(Tile, ov::op::v0)
|
||||
OPENVINO_OP(Transpose, ov::op::v1)
|
||||
OPENVINO_OP(Unsqueeze, ov::op::v0)
|
||||
OPENVINO_OP(VariadicSplit, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Abs, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Acos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Add, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Asin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Atan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(AvgPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchNormInference, ov::op::v5)
|
||||
_OPENVINO_OP_REG(BinaryConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Broadcast, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Bucketize, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoder, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Ceiling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Clamp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Concat, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Constant, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Convert, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ConvertLike, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Convolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Cos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Cosh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(CumSum, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DeformableConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DeformablePSROIPooling, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DepthToSpace, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DetectionOutput, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Divide, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Elu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Erf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Equal, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Exp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ExtractImagePatches, ov::op::v3)
|
||||
_OPENVINO_OP_REG(FakeQuantize, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Floor, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FloorMod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gather, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GatherTree, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Greater, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GreaterEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(HardSigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Less, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LessEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Log, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalNot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalXor, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMCell, ov::op::v4)
|
||||
_OPENVINO_OP_REG(MatMul, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MaxPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Maximum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Minimum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Mod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Multiply, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Negative, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NormalizeL2, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NotEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(OneHot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PRelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PSROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Pad, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Parameter, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Power, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PriorBox, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PriorBoxClustered, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Proposal, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Range, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Relu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReduceMax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMean, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMin, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceProd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceSum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(RegionYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReorgYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Reshape, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Result, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReverseSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ScatterNDUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Select, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Selu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sign, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sinh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Softmax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sqrt, ov::op::v0)
|
||||
_OPENVINO_OP_REG(SpaceToDepth, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Split, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SquaredDifference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Squeeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(StridedSlice, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Subtract, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Tan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tanh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TensorIterator, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tile, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Transpose, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Unsqueeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(VariadicSplit, ov::op::v1)
|
||||
|
||||
// New operations added in opset2
|
||||
OPENVINO_OP(Gelu, ov::op::v0)
|
||||
OPENVINO_OP(BatchToSpace, ov::op::v1)
|
||||
OPENVINO_OP(SpaceToBatch, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(BatchToSpace, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SpaceToBatch, ov::op::v1)
|
||||
|
||||
// New operations added in opset3
|
||||
OPENVINO_OP(EmbeddingBagPackedSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingSegmentsSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
OPENVINO_OP(GRUCell, ov::op::v3)
|
||||
OPENVINO_OP(NonZero, ov::op::v3)
|
||||
OPENVINO_OP(RNNCell, ov::op::v0)
|
||||
OPENVINO_OP(ROIAlign, ov::op::v3)
|
||||
OPENVINO_OP(ScatterElementsUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ScatterUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ShuffleChannels, ov::op::v0)
|
||||
OPENVINO_OP(ShapeOf, ov::op::v3)
|
||||
OPENVINO_OP(TopK, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagPackedSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingSegmentsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(GRUCell, ov::op::v3)
|
||||
_OPENVINO_OP_REG(NonZero, ov::op::v3)
|
||||
_OPENVINO_OP_REG(RNNCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIAlign, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterElementsUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ShuffleChannels, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ShapeOf, ov::op::v3)
|
||||
_OPENVINO_OP_REG(TopK, ov::op::v3)
|
||||
|
||||
// New operations added in opset4
|
||||
OPENVINO_OP(Acosh, ov::op::v3)
|
||||
OPENVINO_OP(Asinh, ov::op::v3)
|
||||
OPENVINO_OP(Atanh, ov::op::v3)
|
||||
OPENVINO_OP(CTCLoss, ov::op::v4)
|
||||
OPENVINO_OP(HSwish, ov::op::v4)
|
||||
OPENVINO_OP(Interpolate, ov::op::v4)
|
||||
OPENVINO_OP(Mish, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL1, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL2, ov::op::v4)
|
||||
OPENVINO_OP(SoftPlus, ov::op::v4)
|
||||
OPENVINO_OP(Swish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Acosh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Asinh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Atanh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCLoss, ov::op::v4)
|
||||
_OPENVINO_OP_REG(HSwish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Interpolate, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Mish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL1, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL2, ov::op::v4)
|
||||
_OPENVINO_OP_REG(SoftPlus, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Swish, ov::op::v4)
|
||||
|
||||
// New operations added in opset5
|
||||
OPENVINO_OP(GatherND, ov::op::v5)
|
||||
OPENVINO_OP(GRUSequence, ov::op::v5)
|
||||
OPENVINO_OP(HSigmoid, ov::op::v5)
|
||||
OPENVINO_OP(LogSoftmax, ov::op::v5)
|
||||
OPENVINO_OP(Loop, ov::op::v5)
|
||||
OPENVINO_OP(LSTMSequence, ov::op::v5)
|
||||
OPENVINO_OP(NonMaxSuppression, ov::op::v5)
|
||||
OPENVINO_OP(RNNSequence, ov::op::v5)
|
||||
OPENVINO_OP(Round, ov::op::v5)
|
||||
_OPENVINO_OP_REG(GatherND, ov::op::v5)
|
||||
_OPENVINO_OP_REG(GRUSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(HSigmoid, ov::op::v5)
|
||||
_OPENVINO_OP_REG(LogSoftmax, ov::op::v5)
|
||||
_OPENVINO_OP_REG(Loop, ov::op::v5)
|
||||
_OPENVINO_OP_REG(LSTMSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(NonMaxSuppression, ov::op::v5)
|
||||
_OPENVINO_OP_REG(RNNSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(Round, ov::op::v5)
|
||||
|
||||
// New operations added in opset6
|
||||
OPENVINO_OP(CTCGreedyDecoderSeqLen, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronDetectionOutput, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronGenerateProposalsSingleImage, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronPriorGridGenerator, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronROIFeatureExtractor, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronTopKROIs, ov::op::v6)
|
||||
OPENVINO_OP(GatherElements, ov::op::v6)
|
||||
OPENVINO_OP(MVN, ov::op::v6)
|
||||
OPENVINO_OP(Assign, ov::op::v6) // new version
|
||||
OPENVINO_OP(ReadValue, ov::op::v6) // new version
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoderSeqLen, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronDetectionOutput, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronGenerateProposalsSingleImage, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronPriorGridGenerator, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronROIFeatureExtractor, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronTopKROIs, ov::op::v6)
|
||||
_OPENVINO_OP_REG(GatherElements, ov::op::v6)
|
||||
_OPENVINO_OP_REG(MVN, ov::op::v6)
|
||||
_OPENVINO_OP_REG(Assign, ov::op::v6) // new version
|
||||
_OPENVINO_OP_REG(ReadValue, ov::op::v6) // new version
|
||||
|
||||
@ -8,8 +8,8 @@
|
||||
|
||||
namespace ov {
|
||||
namespace opset7 {
|
||||
#define OPENVINO_OP(a, b) using b::a;
|
||||
#define _OPENVINO_OP_REG(a, b) using b::a;
|
||||
#include "openvino/opsets/opset7_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
} // namespace opset7
|
||||
} // namespace ov
|
||||
|
||||
@ -2,176 +2,176 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#ifndef OPENVINO_OP
|
||||
# warning "OPENVINO_OP not defined"
|
||||
# define OPENVINO_OP(x, y)
|
||||
#ifndef _OPENVINO_OP_REG
|
||||
# warning "_OPENVINO_OP_REG not defined"
|
||||
# define _OPENVINO_OP_REG(x, y)
|
||||
#endif
|
||||
|
||||
OPENVINO_OP(Abs, ov::op::v0)
|
||||
OPENVINO_OP(Acos, ov::op::v0)
|
||||
OPENVINO_OP(Add, ov::op::v1)
|
||||
OPENVINO_OP(Asin, ov::op::v0)
|
||||
OPENVINO_OP(Atan, ov::op::v0)
|
||||
OPENVINO_OP(AvgPool, ov::op::v1)
|
||||
OPENVINO_OP(BatchNormInference, ov::op::v5)
|
||||
OPENVINO_OP(BinaryConvolution, ov::op::v1)
|
||||
OPENVINO_OP(Broadcast, ov::op::v3)
|
||||
OPENVINO_OP(Bucketize, ov::op::v3)
|
||||
OPENVINO_OP(CTCGreedyDecoder, ov::op::v0)
|
||||
OPENVINO_OP(Ceiling, ov::op::v0)
|
||||
OPENVINO_OP(Clamp, ov::op::v0)
|
||||
OPENVINO_OP(Concat, ov::op::v0)
|
||||
OPENVINO_OP(Constant, ov::op::v0)
|
||||
OPENVINO_OP(Convert, ov::op::v0)
|
||||
OPENVINO_OP(ConvertLike, ov::op::v1)
|
||||
OPENVINO_OP(Convolution, ov::op::v1)
|
||||
OPENVINO_OP(ConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(Cos, ov::op::v0)
|
||||
OPENVINO_OP(Cosh, ov::op::v0)
|
||||
OPENVINO_OP(CumSum, ov::op::v0)
|
||||
OPENVINO_OP(DeformableConvolution, ov::op::v1)
|
||||
OPENVINO_OP(DeformablePSROIPooling, ov::op::v1)
|
||||
OPENVINO_OP(DepthToSpace, ov::op::v0)
|
||||
OPENVINO_OP(DetectionOutput, ov::op::v0)
|
||||
OPENVINO_OP(Divide, ov::op::v1)
|
||||
OPENVINO_OP(Elu, ov::op::v0)
|
||||
OPENVINO_OP(Erf, ov::op::v0)
|
||||
OPENVINO_OP(Equal, ov::op::v1)
|
||||
OPENVINO_OP(Exp, ov::op::v0)
|
||||
OPENVINO_OP(ExtractImagePatches, ov::op::v3)
|
||||
OPENVINO_OP(FakeQuantize, ov::op::v0)
|
||||
OPENVINO_OP(Floor, ov::op::v0)
|
||||
OPENVINO_OP(FloorMod, ov::op::v1)
|
||||
OPENVINO_OP(Gather, ov::op::v7)
|
||||
OPENVINO_OP(GatherTree, ov::op::v1)
|
||||
OPENVINO_OP(Greater, ov::op::v1)
|
||||
OPENVINO_OP(GreaterEqual, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolution, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(GRN, ov::op::v0)
|
||||
OPENVINO_OP(HardSigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Less, ov::op::v1)
|
||||
OPENVINO_OP(LessEqual, ov::op::v1)
|
||||
OPENVINO_OP(Log, ov::op::v0)
|
||||
OPENVINO_OP(LogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(LogicalNot, ov::op::v1)
|
||||
OPENVINO_OP(LogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(LogicalXor, ov::op::v1)
|
||||
OPENVINO_OP(LRN, ov::op::v0)
|
||||
OPENVINO_OP(LSTMCell, ov::op::v4)
|
||||
OPENVINO_OP(MatMul, ov::op::v0)
|
||||
OPENVINO_OP(MaxPool, ov::op::v1)
|
||||
OPENVINO_OP(Maximum, ov::op::v1)
|
||||
OPENVINO_OP(Minimum, ov::op::v1)
|
||||
OPENVINO_OP(Mod, ov::op::v1)
|
||||
OPENVINO_OP(Multiply, ov::op::v1)
|
||||
OPENVINO_OP(Negative, ov::op::v0)
|
||||
OPENVINO_OP(NormalizeL2, ov::op::v0)
|
||||
OPENVINO_OP(NotEqual, ov::op::v1)
|
||||
OPENVINO_OP(OneHot, ov::op::v1)
|
||||
OPENVINO_OP(PRelu, ov::op::v0)
|
||||
OPENVINO_OP(PSROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(Pad, ov::op::v1)
|
||||
OPENVINO_OP(Parameter, ov::op::v0)
|
||||
OPENVINO_OP(Power, ov::op::v1)
|
||||
OPENVINO_OP(PriorBox, ov::op::v0)
|
||||
OPENVINO_OP(PriorBoxClustered, ov::op::v0)
|
||||
OPENVINO_OP(Proposal, ov::op::v4)
|
||||
OPENVINO_OP(Range, ov::op::v4)
|
||||
OPENVINO_OP(Relu, ov::op::v0)
|
||||
OPENVINO_OP(ReduceMax, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMean, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMin, ov::op::v1)
|
||||
OPENVINO_OP(ReduceProd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceSum, ov::op::v1)
|
||||
OPENVINO_OP(RegionYolo, ov::op::v0)
|
||||
OPENVINO_OP(ReorgYolo, ov::op::v0)
|
||||
OPENVINO_OP(Reshape, ov::op::v1)
|
||||
OPENVINO_OP(Result, ov::op::v0)
|
||||
OPENVINO_OP(ReverseSequence, ov::op::v0)
|
||||
OPENVINO_OP(ROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(ScatterNDUpdate, ov::op::v3)
|
||||
OPENVINO_OP(Select, ov::op::v1)
|
||||
OPENVINO_OP(Selu, ov::op::v0)
|
||||
OPENVINO_OP(Sign, ov::op::v0)
|
||||
OPENVINO_OP(Sigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Sin, ov::op::v0)
|
||||
OPENVINO_OP(Sinh, ov::op::v0)
|
||||
OPENVINO_OP(Softmax, ov::op::v1)
|
||||
OPENVINO_OP(Sqrt, ov::op::v0)
|
||||
OPENVINO_OP(SpaceToDepth, ov::op::v0)
|
||||
OPENVINO_OP(Split, ov::op::v1)
|
||||
OPENVINO_OP(SquaredDifference, ov::op::v0)
|
||||
OPENVINO_OP(Squeeze, ov::op::v0)
|
||||
OPENVINO_OP(StridedSlice, ov::op::v1)
|
||||
OPENVINO_OP(Subtract, ov::op::v1)
|
||||
OPENVINO_OP(Tan, ov::op::v0)
|
||||
OPENVINO_OP(Tanh, ov::op::v0)
|
||||
OPENVINO_OP(TensorIterator, ov::op::v0)
|
||||
OPENVINO_OP(Tile, ov::op::v0)
|
||||
OPENVINO_OP(Transpose, ov::op::v1)
|
||||
OPENVINO_OP(Unsqueeze, ov::op::v0)
|
||||
OPENVINO_OP(VariadicSplit, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Abs, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Acos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Add, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Asin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Atan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(AvgPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchNormInference, ov::op::v5)
|
||||
_OPENVINO_OP_REG(BinaryConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Broadcast, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Bucketize, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoder, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Ceiling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Clamp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Concat, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Constant, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Convert, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ConvertLike, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Convolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Cos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Cosh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(CumSum, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DeformableConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DeformablePSROIPooling, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DepthToSpace, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DetectionOutput, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Divide, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Elu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Erf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Equal, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Exp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ExtractImagePatches, ov::op::v3)
|
||||
_OPENVINO_OP_REG(FakeQuantize, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Floor, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FloorMod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Gather, ov::op::v7)
|
||||
_OPENVINO_OP_REG(GatherTree, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Greater, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GreaterEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(HardSigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Less, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LessEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Log, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalNot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalXor, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMCell, ov::op::v4)
|
||||
_OPENVINO_OP_REG(MatMul, ov::op::v0)
|
||||
_OPENVINO_OP_REG(MaxPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Maximum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Minimum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Mod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Multiply, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Negative, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NormalizeL2, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NotEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(OneHot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PRelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PSROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Pad, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Parameter, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Power, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PriorBox, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PriorBoxClustered, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Proposal, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Range, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Relu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReduceMax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMean, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMin, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceProd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceSum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(RegionYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReorgYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Reshape, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Result, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReverseSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ScatterNDUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Select, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Selu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sign, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sinh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Softmax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sqrt, ov::op::v0)
|
||||
_OPENVINO_OP_REG(SpaceToDepth, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Split, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SquaredDifference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Squeeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(StridedSlice, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Subtract, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Tan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tanh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TensorIterator, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tile, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Transpose, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Unsqueeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(VariadicSplit, ov::op::v1)
|
||||
|
||||
// New operations added in opset2
|
||||
OPENVINO_OP(BatchToSpace, ov::op::v1)
|
||||
OPENVINO_OP(SpaceToBatch, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchToSpace, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SpaceToBatch, ov::op::v1)
|
||||
|
||||
// New operations added in opset3
|
||||
OPENVINO_OP(EmbeddingBagPackedSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingSegmentsSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
OPENVINO_OP(GRUCell, ov::op::v3)
|
||||
OPENVINO_OP(NonZero, ov::op::v3)
|
||||
OPENVINO_OP(RNNCell, ov::op::v0)
|
||||
OPENVINO_OP(ROIAlign, ov::op::v3)
|
||||
OPENVINO_OP(ScatterElementsUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ScatterUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ShuffleChannels, ov::op::v0)
|
||||
OPENVINO_OP(ShapeOf, ov::op::v3)
|
||||
OPENVINO_OP(TopK, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagPackedSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingSegmentsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(GRUCell, ov::op::v3)
|
||||
_OPENVINO_OP_REG(NonZero, ov::op::v3)
|
||||
_OPENVINO_OP_REG(RNNCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIAlign, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterElementsUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ShuffleChannels, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ShapeOf, ov::op::v3)
|
||||
_OPENVINO_OP_REG(TopK, ov::op::v3)
|
||||
|
||||
// New operations added in opset4
|
||||
OPENVINO_OP(Acosh, ov::op::v3)
|
||||
OPENVINO_OP(Asinh, ov::op::v3)
|
||||
OPENVINO_OP(Atanh, ov::op::v3)
|
||||
OPENVINO_OP(CTCLoss, ov::op::v4)
|
||||
OPENVINO_OP(HSwish, ov::op::v4)
|
||||
OPENVINO_OP(Interpolate, ov::op::v4)
|
||||
OPENVINO_OP(Mish, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL1, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL2, ov::op::v4)
|
||||
OPENVINO_OP(SoftPlus, ov::op::v4)
|
||||
OPENVINO_OP(Swish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Acosh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Asinh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Atanh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCLoss, ov::op::v4)
|
||||
_OPENVINO_OP_REG(HSwish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Interpolate, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Mish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL1, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL2, ov::op::v4)
|
||||
_OPENVINO_OP_REG(SoftPlus, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Swish, ov::op::v4)
|
||||
|
||||
// New operations added in opset5
|
||||
OPENVINO_OP(GatherND, ov::op::v5)
|
||||
OPENVINO_OP(GRUSequence, ov::op::v5)
|
||||
OPENVINO_OP(HSigmoid, ov::op::v5)
|
||||
OPENVINO_OP(LogSoftmax, ov::op::v5)
|
||||
OPENVINO_OP(Loop, ov::op::v5)
|
||||
OPENVINO_OP(LSTMSequence, ov::op::v5)
|
||||
OPENVINO_OP(NonMaxSuppression, ov::op::v5)
|
||||
OPENVINO_OP(RNNSequence, ov::op::v5)
|
||||
OPENVINO_OP(Round, ov::op::v5)
|
||||
_OPENVINO_OP_REG(GatherND, ov::op::v5)
|
||||
_OPENVINO_OP_REG(GRUSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(HSigmoid, ov::op::v5)
|
||||
_OPENVINO_OP_REG(LogSoftmax, ov::op::v5)
|
||||
_OPENVINO_OP_REG(Loop, ov::op::v5)
|
||||
_OPENVINO_OP_REG(LSTMSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(NonMaxSuppression, ov::op::v5)
|
||||
_OPENVINO_OP_REG(RNNSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(Round, ov::op::v5)
|
||||
|
||||
// New operations added in opset6
|
||||
OPENVINO_OP(CTCGreedyDecoderSeqLen, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronDetectionOutput, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronGenerateProposalsSingleImage, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronPriorGridGenerator, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronROIFeatureExtractor, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronTopKROIs, ov::op::v6)
|
||||
OPENVINO_OP(GatherElements, ov::op::v6)
|
||||
OPENVINO_OP(MVN, ov::op::v6)
|
||||
OPENVINO_OP(Assign, ov::op::v6) // new version
|
||||
OPENVINO_OP(ReadValue, ov::op::v6) // new version
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoderSeqLen, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronDetectionOutput, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronGenerateProposalsSingleImage, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronPriorGridGenerator, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronROIFeatureExtractor, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronTopKROIs, ov::op::v6)
|
||||
_OPENVINO_OP_REG(GatherElements, ov::op::v6)
|
||||
_OPENVINO_OP_REG(MVN, ov::op::v6)
|
||||
_OPENVINO_OP_REG(Assign, ov::op::v6) // new version
|
||||
_OPENVINO_OP_REG(ReadValue, ov::op::v6) // new version
|
||||
|
||||
// New operations added in opset7
|
||||
OPENVINO_OP(DFT, ov::op::v7)
|
||||
OPENVINO_OP(Einsum, ov::op::v7)
|
||||
OPENVINO_OP(Gelu, ov::op::v7)
|
||||
OPENVINO_OP(IDFT, ov::op::v7)
|
||||
OPENVINO_OP(Roll, ov::op::v7)
|
||||
_OPENVINO_OP_REG(DFT, ov::op::v7)
|
||||
_OPENVINO_OP_REG(Einsum, ov::op::v7)
|
||||
_OPENVINO_OP_REG(Gelu, ov::op::v7)
|
||||
_OPENVINO_OP_REG(IDFT, ov::op::v7)
|
||||
_OPENVINO_OP_REG(Roll, ov::op::v7)
|
||||
|
||||
@ -8,8 +8,8 @@
|
||||
|
||||
namespace ov {
|
||||
namespace opset8 {
|
||||
#define OPENVINO_OP(a, b) using b::a;
|
||||
#define _OPENVINO_OP_REG(a, b) using b::a;
|
||||
#include "openvino/opsets/opset8_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
} // namespace opset8
|
||||
} // namespace ov
|
||||
|
||||
@ -2,185 +2,185 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#ifndef OPENVINO_OP
|
||||
# warning "OPENVINO_OP not defined"
|
||||
# define OPENVINO_OP(x, y)
|
||||
#ifndef _OPENVINO_OP_REG
|
||||
# warning "_OPENVINO_OP_REG not defined"
|
||||
# define _OPENVINO_OP_REG(x, y)
|
||||
#endif
|
||||
|
||||
OPENVINO_OP(Abs, ov::op::v0)
|
||||
OPENVINO_OP(Acos, ov::op::v0)
|
||||
OPENVINO_OP(Add, ov::op::v1)
|
||||
OPENVINO_OP(Asin, ov::op::v0)
|
||||
OPENVINO_OP(Atan, ov::op::v0)
|
||||
OPENVINO_OP(AvgPool, ov::op::v1)
|
||||
OPENVINO_OP(BatchNormInference, ov::op::v5)
|
||||
OPENVINO_OP(BinaryConvolution, ov::op::v1)
|
||||
OPENVINO_OP(Broadcast, ov::op::v3)
|
||||
OPENVINO_OP(Bucketize, ov::op::v3)
|
||||
OPENVINO_OP(CTCGreedyDecoder, ov::op::v0)
|
||||
OPENVINO_OP(Ceiling, ov::op::v0)
|
||||
OPENVINO_OP(Clamp, ov::op::v0)
|
||||
OPENVINO_OP(Concat, ov::op::v0)
|
||||
OPENVINO_OP(Constant, ov::op::v0)
|
||||
OPENVINO_OP(Convert, ov::op::v0)
|
||||
OPENVINO_OP(ConvertLike, ov::op::v1)
|
||||
OPENVINO_OP(Convolution, ov::op::v1)
|
||||
OPENVINO_OP(ConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(Cos, ov::op::v0)
|
||||
OPENVINO_OP(Cosh, ov::op::v0)
|
||||
OPENVINO_OP(CumSum, ov::op::v0)
|
||||
OPENVINO_OP(DeformablePSROIPooling, ov::op::v1)
|
||||
OPENVINO_OP(DepthToSpace, ov::op::v0)
|
||||
OPENVINO_OP(DetectionOutput, ov::op::v0)
|
||||
OPENVINO_OP(Divide, ov::op::v1)
|
||||
OPENVINO_OP(Elu, ov::op::v0)
|
||||
OPENVINO_OP(Erf, ov::op::v0)
|
||||
OPENVINO_OP(Equal, ov::op::v1)
|
||||
OPENVINO_OP(Exp, ov::op::v0)
|
||||
OPENVINO_OP(ExtractImagePatches, ov::op::v3)
|
||||
OPENVINO_OP(FakeQuantize, ov::op::v0)
|
||||
OPENVINO_OP(Floor, ov::op::v0)
|
||||
OPENVINO_OP(FloorMod, ov::op::v1)
|
||||
OPENVINO_OP(GatherTree, ov::op::v1)
|
||||
OPENVINO_OP(Greater, ov::op::v1)
|
||||
OPENVINO_OP(GreaterEqual, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolution, ov::op::v1)
|
||||
OPENVINO_OP(GroupConvolutionBackpropData, ov::op::v1)
|
||||
OPENVINO_OP(GRN, ov::op::v0)
|
||||
OPENVINO_OP(HardSigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Less, ov::op::v1)
|
||||
OPENVINO_OP(LessEqual, ov::op::v1)
|
||||
OPENVINO_OP(Log, ov::op::v0)
|
||||
OPENVINO_OP(LogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(LogicalNot, ov::op::v1)
|
||||
OPENVINO_OP(LogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(LogicalXor, ov::op::v1)
|
||||
OPENVINO_OP(LRN, ov::op::v0)
|
||||
OPENVINO_OP(LSTMCell, ov::op::v4)
|
||||
OPENVINO_OP(MatMul, ov::op::v0)
|
||||
OPENVINO_OP(Maximum, ov::op::v1)
|
||||
OPENVINO_OP(Minimum, ov::op::v1)
|
||||
OPENVINO_OP(Mod, ov::op::v1)
|
||||
OPENVINO_OP(Multiply, ov::op::v1)
|
||||
OPENVINO_OP(Negative, ov::op::v0)
|
||||
OPENVINO_OP(NormalizeL2, ov::op::v0)
|
||||
OPENVINO_OP(NotEqual, ov::op::v1)
|
||||
OPENVINO_OP(OneHot, ov::op::v1)
|
||||
OPENVINO_OP(PRelu, ov::op::v0)
|
||||
OPENVINO_OP(PSROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(Pad, ov::op::v1)
|
||||
OPENVINO_OP(Parameter, ov::op::v0)
|
||||
OPENVINO_OP(Power, ov::op::v1)
|
||||
OPENVINO_OP(PriorBox, ov::op::v0)
|
||||
OPENVINO_OP(PriorBoxClustered, ov::op::v0)
|
||||
OPENVINO_OP(Proposal, ov::op::v4)
|
||||
OPENVINO_OP(Range, ov::op::v4)
|
||||
OPENVINO_OP(Relu, ov::op::v0)
|
||||
OPENVINO_OP(ReduceMax, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalAnd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceLogicalOr, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMean, ov::op::v1)
|
||||
OPENVINO_OP(ReduceMin, ov::op::v1)
|
||||
OPENVINO_OP(ReduceProd, ov::op::v1)
|
||||
OPENVINO_OP(ReduceSum, ov::op::v1)
|
||||
OPENVINO_OP(RegionYolo, ov::op::v0)
|
||||
OPENVINO_OP(ReorgYolo, ov::op::v0)
|
||||
OPENVINO_OP(Reshape, ov::op::v1)
|
||||
OPENVINO_OP(Result, ov::op::v0)
|
||||
OPENVINO_OP(ReverseSequence, ov::op::v0)
|
||||
OPENVINO_OP(ROIPooling, ov::op::v0)
|
||||
OPENVINO_OP(ScatterNDUpdate, ov::op::v3)
|
||||
OPENVINO_OP(Select, ov::op::v1)
|
||||
OPENVINO_OP(Selu, ov::op::v0)
|
||||
OPENVINO_OP(Sign, ov::op::v0)
|
||||
OPENVINO_OP(Sigmoid, ov::op::v0)
|
||||
OPENVINO_OP(Sin, ov::op::v0)
|
||||
OPENVINO_OP(Sinh, ov::op::v0)
|
||||
OPENVINO_OP(Softmax, ov::op::v1)
|
||||
OPENVINO_OP(Sqrt, ov::op::v0)
|
||||
OPENVINO_OP(SpaceToDepth, ov::op::v0)
|
||||
OPENVINO_OP(Split, ov::op::v1)
|
||||
OPENVINO_OP(SquaredDifference, ov::op::v0)
|
||||
OPENVINO_OP(Squeeze, ov::op::v0)
|
||||
OPENVINO_OP(StridedSlice, ov::op::v1)
|
||||
OPENVINO_OP(Subtract, ov::op::v1)
|
||||
OPENVINO_OP(Tan, ov::op::v0)
|
||||
OPENVINO_OP(Tanh, ov::op::v0)
|
||||
OPENVINO_OP(TensorIterator, ov::op::v0)
|
||||
OPENVINO_OP(Tile, ov::op::v0)
|
||||
OPENVINO_OP(Transpose, ov::op::v1)
|
||||
OPENVINO_OP(Unsqueeze, ov::op::v0)
|
||||
OPENVINO_OP(VariadicSplit, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Abs, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Acos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Add, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Asin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Atan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(AvgPool, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchNormInference, ov::op::v5)
|
||||
_OPENVINO_OP_REG(BinaryConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Broadcast, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Bucketize, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoder, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Ceiling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Clamp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Concat, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Constant, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Convert, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ConvertLike, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Convolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Cos, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Cosh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(CumSum, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DeformablePSROIPooling, ov::op::v1)
|
||||
_OPENVINO_OP_REG(DepthToSpace, ov::op::v0)
|
||||
_OPENVINO_OP_REG(DetectionOutput, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Divide, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Elu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Erf, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Equal, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Exp, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ExtractImagePatches, ov::op::v3)
|
||||
_OPENVINO_OP_REG(FakeQuantize, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Floor, ov::op::v0)
|
||||
_OPENVINO_OP_REG(FloorMod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GatherTree, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Greater, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GreaterEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolution, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GroupConvolutionBackpropData, ov::op::v1)
|
||||
_OPENVINO_OP_REG(GRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(HardSigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Less, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LessEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Log, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalNot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LogicalXor, ov::op::v1)
|
||||
_OPENVINO_OP_REG(LRN, ov::op::v0)
|
||||
_OPENVINO_OP_REG(LSTMCell, ov::op::v4)
|
||||
_OPENVINO_OP_REG(MatMul, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Maximum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Minimum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Mod, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Multiply, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Negative, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NormalizeL2, ov::op::v0)
|
||||
_OPENVINO_OP_REG(NotEqual, ov::op::v1)
|
||||
_OPENVINO_OP_REG(OneHot, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PRelu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PSROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Pad, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Parameter, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Power, ov::op::v1)
|
||||
_OPENVINO_OP_REG(PriorBox, ov::op::v0)
|
||||
_OPENVINO_OP_REG(PriorBoxClustered, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Proposal, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Range, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Relu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReduceMax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalAnd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceLogicalOr, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMean, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceMin, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceProd, ov::op::v1)
|
||||
_OPENVINO_OP_REG(ReduceSum, ov::op::v1)
|
||||
_OPENVINO_OP_REG(RegionYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReorgYolo, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Reshape, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Result, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ReverseSequence, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIPooling, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ScatterNDUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Select, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Selu, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sign, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sigmoid, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sin, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Sinh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Softmax, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Sqrt, ov::op::v0)
|
||||
_OPENVINO_OP_REG(SpaceToDepth, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Split, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SquaredDifference, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Squeeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(StridedSlice, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Subtract, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Tan, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tanh, ov::op::v0)
|
||||
_OPENVINO_OP_REG(TensorIterator, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Tile, ov::op::v0)
|
||||
_OPENVINO_OP_REG(Transpose, ov::op::v1)
|
||||
_OPENVINO_OP_REG(Unsqueeze, ov::op::v0)
|
||||
_OPENVINO_OP_REG(VariadicSplit, ov::op::v1)
|
||||
|
||||
// New operations added in opset2
|
||||
OPENVINO_OP(BatchToSpace, ov::op::v1)
|
||||
OPENVINO_OP(SpaceToBatch, ov::op::v1)
|
||||
_OPENVINO_OP_REG(BatchToSpace, ov::op::v1)
|
||||
_OPENVINO_OP_REG(SpaceToBatch, ov::op::v1)
|
||||
|
||||
// New operations added in opset3
|
||||
OPENVINO_OP(EmbeddingBagPackedSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingSegmentsSum, ov::op::v3)
|
||||
OPENVINO_OP(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
OPENVINO_OP(GRUCell, ov::op::v3)
|
||||
OPENVINO_OP(NonZero, ov::op::v3)
|
||||
OPENVINO_OP(RNNCell, ov::op::v0)
|
||||
OPENVINO_OP(ROIAlign, ov::op::v3)
|
||||
OPENVINO_OP(ScatterElementsUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ScatterUpdate, ov::op::v3)
|
||||
OPENVINO_OP(ShuffleChannels, ov::op::v0)
|
||||
OPENVINO_OP(ShapeOf, ov::op::v3)
|
||||
OPENVINO_OP(TopK, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagPackedSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingSegmentsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(EmbeddingBagOffsetsSum, ov::op::v3)
|
||||
_OPENVINO_OP_REG(GRUCell, ov::op::v3)
|
||||
_OPENVINO_OP_REG(NonZero, ov::op::v3)
|
||||
_OPENVINO_OP_REG(RNNCell, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ROIAlign, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterElementsUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ScatterUpdate, ov::op::v3)
|
||||
_OPENVINO_OP_REG(ShuffleChannels, ov::op::v0)
|
||||
_OPENVINO_OP_REG(ShapeOf, ov::op::v3)
|
||||
_OPENVINO_OP_REG(TopK, ov::op::v3)
|
||||
|
||||
// New operations added in opset4
|
||||
OPENVINO_OP(Acosh, ov::op::v3)
|
||||
OPENVINO_OP(Asinh, ov::op::v3)
|
||||
OPENVINO_OP(Atanh, ov::op::v3)
|
||||
OPENVINO_OP(CTCLoss, ov::op::v4)
|
||||
OPENVINO_OP(HSwish, ov::op::v4)
|
||||
OPENVINO_OP(Interpolate, ov::op::v4)
|
||||
OPENVINO_OP(Mish, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL1, ov::op::v4)
|
||||
OPENVINO_OP(ReduceL2, ov::op::v4)
|
||||
OPENVINO_OP(SoftPlus, ov::op::v4)
|
||||
OPENVINO_OP(Swish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Acosh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Asinh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(Atanh, ov::op::v3)
|
||||
_OPENVINO_OP_REG(CTCLoss, ov::op::v4)
|
||||
_OPENVINO_OP_REG(HSwish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Interpolate, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Mish, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL1, ov::op::v4)
|
||||
_OPENVINO_OP_REG(ReduceL2, ov::op::v4)
|
||||
_OPENVINO_OP_REG(SoftPlus, ov::op::v4)
|
||||
_OPENVINO_OP_REG(Swish, ov::op::v4)
|
||||
|
||||
// New operations added in opset5
|
||||
OPENVINO_OP(GatherND, ov::op::v5)
|
||||
OPENVINO_OP(GRUSequence, ov::op::v5)
|
||||
OPENVINO_OP(HSigmoid, ov::op::v5)
|
||||
OPENVINO_OP(LogSoftmax, ov::op::v5)
|
||||
OPENVINO_OP(Loop, ov::op::v5)
|
||||
OPENVINO_OP(LSTMSequence, ov::op::v5)
|
||||
OPENVINO_OP(NonMaxSuppression, ov::op::v5)
|
||||
OPENVINO_OP(RNNSequence, ov::op::v5)
|
||||
OPENVINO_OP(Round, ov::op::v5)
|
||||
_OPENVINO_OP_REG(GatherND, ov::op::v5)
|
||||
_OPENVINO_OP_REG(GRUSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(HSigmoid, ov::op::v5)
|
||||
_OPENVINO_OP_REG(LogSoftmax, ov::op::v5)
|
||||
_OPENVINO_OP_REG(Loop, ov::op::v5)
|
||||
_OPENVINO_OP_REG(LSTMSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(NonMaxSuppression, ov::op::v5)
|
||||
_OPENVINO_OP_REG(RNNSequence, ov::op::v5)
|
||||
_OPENVINO_OP_REG(Round, ov::op::v5)
|
||||
|
||||
// New operations added in opset6
|
||||
OPENVINO_OP(CTCGreedyDecoderSeqLen, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronDetectionOutput, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronGenerateProposalsSingleImage, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronPriorGridGenerator, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronROIFeatureExtractor, ov::op::v6)
|
||||
OPENVINO_OP(ExperimentalDetectronTopKROIs, ov::op::v6)
|
||||
OPENVINO_OP(GatherElements, ov::op::v6)
|
||||
OPENVINO_OP(MVN, ov::op::v6)
|
||||
OPENVINO_OP(Assign, ov::op::v6) // new version
|
||||
OPENVINO_OP(ReadValue, ov::op::v6) // new version
|
||||
_OPENVINO_OP_REG(CTCGreedyDecoderSeqLen, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronDetectionOutput, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronGenerateProposalsSingleImage, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronPriorGridGenerator, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronROIFeatureExtractor, ov::op::v6)
|
||||
_OPENVINO_OP_REG(ExperimentalDetectronTopKROIs, ov::op::v6)
|
||||
_OPENVINO_OP_REG(GatherElements, ov::op::v6)
|
||||
_OPENVINO_OP_REG(MVN, ov::op::v6)
|
||||
_OPENVINO_OP_REG(Assign, ov::op::v6) // new version
|
||||
_OPENVINO_OP_REG(ReadValue, ov::op::v6) // new version
|
||||
|
||||
// New operations added in opset7
|
||||
OPENVINO_OP(DFT, ov::op::v7)
|
||||
OPENVINO_OP(Einsum, ov::op::v7)
|
||||
OPENVINO_OP(Gelu, ov::op::v7)
|
||||
OPENVINO_OP(IDFT, ov::op::v7)
|
||||
OPENVINO_OP(Roll, ov::op::v7)
|
||||
_OPENVINO_OP_REG(DFT, ov::op::v7)
|
||||
_OPENVINO_OP_REG(Einsum, ov::op::v7)
|
||||
_OPENVINO_OP_REG(Gelu, ov::op::v7)
|
||||
_OPENVINO_OP_REG(IDFT, ov::op::v7)
|
||||
_OPENVINO_OP_REG(Roll, ov::op::v7)
|
||||
|
||||
// New operations added in opset8
|
||||
OPENVINO_OP(Gather, ov::op::v8)
|
||||
OPENVINO_OP(AdaptiveAvgPool, ov::op::v8)
|
||||
OPENVINO_OP(AdaptiveMaxPool, ov::op::v8)
|
||||
OPENVINO_OP(DeformableConvolution, ov::op::v8)
|
||||
OPENVINO_OP(MatrixNms, ov::op::v8)
|
||||
OPENVINO_OP(MaxPool, ov::op::v8)
|
||||
OPENVINO_OP(MulticlassNms, ov::op::v8)
|
||||
OPENVINO_OP(RandomUniform, ov::op::v8)
|
||||
OPENVINO_OP(Slice, ov::op::v8)
|
||||
OPENVINO_OP(If, ov::op::v8)
|
||||
_OPENVINO_OP_REG(Gather, ov::op::v8)
|
||||
_OPENVINO_OP_REG(AdaptiveAvgPool, ov::op::v8)
|
||||
_OPENVINO_OP_REG(AdaptiveMaxPool, ov::op::v8)
|
||||
_OPENVINO_OP_REG(DeformableConvolution, ov::op::v8)
|
||||
_OPENVINO_OP_REG(MatrixNms, ov::op::v8)
|
||||
_OPENVINO_OP_REG(MaxPool, ov::op::v8)
|
||||
_OPENVINO_OP_REG(MulticlassNms, ov::op::v8)
|
||||
_OPENVINO_OP_REG(RandomUniform, ov::op::v8)
|
||||
_OPENVINO_OP_REG(Slice, ov::op::v8)
|
||||
_OPENVINO_OP_REG(If, ov::op::v8)
|
||||
|
||||
@ -835,7 +835,7 @@ bool ov::Node::constant_fold(OutputVector& output_values, const OutputVector& in
|
||||
}
|
||||
|
||||
namespace ov {
|
||||
constexpr DiscreteTypeInfo AttributeAdapter<shared_ptr<Node>>::type_info;
|
||||
BWDCMP_RTTI_DEFINITION(AttributeAdapter<shared_ptr<Node>>);
|
||||
|
||||
AttributeAdapter<std::shared_ptr<Node>>::AttributeAdapter(std::shared_ptr<Node>& value) : m_ref(value) {}
|
||||
|
||||
@ -849,7 +849,7 @@ bool AttributeAdapter<std::shared_ptr<Node>>::visit_attributes(AttributeVisitor&
|
||||
return true;
|
||||
}
|
||||
|
||||
constexpr DiscreteTypeInfo AttributeAdapter<NodeVector>::type_info;
|
||||
BWDCMP_RTTI_DEFINITION(AttributeAdapter<NodeVector>);
|
||||
|
||||
AttributeAdapter<NodeVector>::AttributeAdapter(NodeVector& ref) : m_ref(ref) {}
|
||||
|
||||
|
||||
@ -11,7 +11,6 @@
|
||||
#include "ngraph/node.hpp"
|
||||
#include "ngraph/type/element_type.hpp"
|
||||
|
||||
using namespace ngraph;
|
||||
using namespace std;
|
||||
|
||||
op::Op::Op(const OutputVector& args) : Node(args) {}
|
||||
ov::op::Op::Op(const ov::OutputVector& args) : Node(args) {}
|
||||
|
||||
@ -33,9 +33,9 @@ const ov::OpSet& ov::get_opset1() {
|
||||
static OpSet opset;
|
||||
static std::once_flag flag;
|
||||
std::call_once(flag, [&]() {
|
||||
#define OPENVINO_OP(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#define _OPENVINO_OP_REG(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#include "openvino/opsets/opset1_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
});
|
||||
return opset;
|
||||
}
|
||||
@ -44,9 +44,9 @@ const ov::OpSet& ov::get_opset2() {
|
||||
static OpSet opset;
|
||||
static std::once_flag flag;
|
||||
std::call_once(flag, [&]() {
|
||||
#define OPENVINO_OP(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#define _OPENVINO_OP_REG(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#include "openvino/opsets/opset2_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
});
|
||||
return opset;
|
||||
}
|
||||
@ -55,9 +55,9 @@ const ov::OpSet& ov::get_opset3() {
|
||||
static OpSet opset;
|
||||
static std::once_flag flag;
|
||||
std::call_once(flag, [&]() {
|
||||
#define OPENVINO_OP(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#define _OPENVINO_OP_REG(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#include "openvino/opsets/opset3_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
});
|
||||
return opset;
|
||||
}
|
||||
@ -66,9 +66,9 @@ const ov::OpSet& ov::get_opset4() {
|
||||
static OpSet opset;
|
||||
static std::once_flag flag;
|
||||
std::call_once(flag, [&]() {
|
||||
#define OPENVINO_OP(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#define _OPENVINO_OP_REG(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#include "openvino/opsets/opset4_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
});
|
||||
return opset;
|
||||
}
|
||||
@ -77,9 +77,9 @@ const ov::OpSet& ov::get_opset5() {
|
||||
static OpSet opset;
|
||||
static std::once_flag flag;
|
||||
std::call_once(flag, [&]() {
|
||||
#define OPENVINO_OP(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#define _OPENVINO_OP_REG(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#include "openvino/opsets/opset5_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
});
|
||||
return opset;
|
||||
}
|
||||
@ -88,9 +88,9 @@ const ov::OpSet& ov::get_opset6() {
|
||||
static OpSet opset;
|
||||
static std::once_flag flag;
|
||||
std::call_once(flag, [&]() {
|
||||
#define OPENVINO_OP(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#define _OPENVINO_OP_REG(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#include "openvino/opsets/opset6_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
});
|
||||
return opset;
|
||||
}
|
||||
@ -99,9 +99,9 @@ const ov::OpSet& ov::get_opset7() {
|
||||
static OpSet opset;
|
||||
static std::once_flag flag;
|
||||
std::call_once(flag, [&]() {
|
||||
#define OPENVINO_OP(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#define _OPENVINO_OP_REG(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#include "openvino/opsets/opset7_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
});
|
||||
return opset;
|
||||
}
|
||||
@ -110,9 +110,9 @@ const ov::OpSet& ov::get_opset8() {
|
||||
static OpSet opset;
|
||||
static std::once_flag flag;
|
||||
std::call_once(flag, [&]() {
|
||||
#define OPENVINO_OP(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#define _OPENVINO_OP_REG(NAME, NAMESPACE) opset.insert<NAMESPACE::NAME>();
|
||||
#include "openvino/opsets/opset8_tbl.hpp"
|
||||
#undef OPENVINO_OP
|
||||
#undef _OPENVINO_OP_REG
|
||||
});
|
||||
return opset;
|
||||
}
|
||||
|
||||
@ -16,3 +16,50 @@ size_t std::hash<ngraph::DiscreteTypeInfo>::operator()(const ngraph::DiscreteTyp
|
||||
NGRAPH_SUPPRESS_DEPRECATED_END
|
||||
}
|
||||
} // namespace std
|
||||
|
||||
namespace ov {
|
||||
std::ostream& operator<<(std::ostream& s, const DiscreteTypeInfo& info) {
|
||||
std::string version_id = info.version_id ? info.version_id : "(empty)";
|
||||
s << "DiscreteTypeInfo{name: " << info.name << ", version_id: " << version_id << ", old_version: " << info.version
|
||||
<< ", parent: ";
|
||||
if (!info.parent)
|
||||
s << info.parent;
|
||||
else
|
||||
s << *info.parent;
|
||||
|
||||
s << "}";
|
||||
return s;
|
||||
}
|
||||
|
||||
// parent is commented to fix type relaxed operations
|
||||
bool DiscreteTypeInfo::operator<(const DiscreteTypeInfo& b) const {
|
||||
if (version_id == nullptr || b.version_id == nullptr)
|
||||
return version < b.version ||
|
||||
(version == b.version && strcmp(name, b.name) < 0); // ||
|
||||
// (version == b.version && strcmp(name, b.name) ==
|
||||
// 0 && parent && b.parent && *parent < *b.parent);
|
||||
else
|
||||
return strcmp(version_id, b.version_id) < 0 ||
|
||||
(strcmp(version_id, b.version_id) == 0 && strcmp(name, b.name) < 0); // ||
|
||||
// (strcmp(version_id, b.version_id) == 0 && strcmp(name, b.name) == 0 && parent && b.parent &&
|
||||
// *parent < *b.parent);
|
||||
}
|
||||
bool DiscreteTypeInfo::operator==(const DiscreteTypeInfo& b) const {
|
||||
if (version_id == nullptr || b.version_id == nullptr)
|
||||
return version == b.version && strcmp(name, b.name) == 0; // && parent == b.parent;
|
||||
else
|
||||
return strcmp(version_id, b.version_id) == 0 && strcmp(name, b.name) == 0; // && parent == b.parent;
|
||||
}
|
||||
bool DiscreteTypeInfo::operator<=(const DiscreteTypeInfo& b) const {
|
||||
return *this == b || *this < b;
|
||||
}
|
||||
bool DiscreteTypeInfo::operator>(const DiscreteTypeInfo& b) const {
|
||||
return !(*this <= b);
|
||||
}
|
||||
bool DiscreteTypeInfo::operator>=(const DiscreteTypeInfo& b) const {
|
||||
return !(*this < b);
|
||||
}
|
||||
bool DiscreteTypeInfo::operator!=(const DiscreteTypeInfo& b) const {
|
||||
return !(*this == b);
|
||||
}
|
||||
} // namespace ov
|
||||
|
||||
@ -49,6 +49,7 @@ set(SRC
|
||||
matcher_pass.cpp
|
||||
misc.cpp
|
||||
node_input_output.cpp
|
||||
rtti.cpp
|
||||
op.cpp
|
||||
opset.cpp
|
||||
op_eval/binary_convolution.cpp
|
||||
@ -86,6 +87,7 @@ set(SRC
|
||||
span.cpp
|
||||
specialize_function.cpp
|
||||
tensor.cpp
|
||||
type_info.cpp
|
||||
type_prop/abs.cpp
|
||||
type_prop/acos.cpp
|
||||
type_prop/adaptive_avg_pool.cpp
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "openvino/op/op.hpp"
|
||||
#include "openvino/opsets/opset1.hpp"
|
||||
#include "openvino/opsets/opset2.hpp"
|
||||
#include "openvino/opsets/opset3.hpp"
|
||||
@ -142,3 +143,64 @@ TEST(opset, opset8_dump) {
|
||||
std::cout << std::endl;
|
||||
ASSERT_EQ(163, opset.get_types_info().size());
|
||||
}
|
||||
|
||||
class MyOpOld : public ov::op::Op {
|
||||
public:
|
||||
static constexpr ov::DiscreteTypeInfo type_info{"MyOpOld", 0};
|
||||
const ov::DiscreteTypeInfo& get_type_info() const override {
|
||||
return type_info;
|
||||
}
|
||||
MyOpOld() = default;
|
||||
|
||||
std::shared_ptr<Node> clone_with_new_inputs(const ov::OutputVector& inputs) const override {
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
constexpr ov::DiscreteTypeInfo MyOpOld::type_info;
|
||||
|
||||
class MyOpNewFromOld : public MyOpOld {
|
||||
public:
|
||||
OPENVINO_OP("MyOpNewFromOld", "custom_opset", MyOpOld);
|
||||
BWDCMP_RTTI_DECLARATION;
|
||||
MyOpNewFromOld() = default;
|
||||
|
||||
std::shared_ptr<Node> clone_with_new_inputs(const ov::OutputVector& inputs) const override {
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
BWDCMP_RTTI_DEFINITION(MyOpNewFromOld);
|
||||
|
||||
class MyOpIncorrect : public MyOpOld {
|
||||
public:
|
||||
OPENVINO_OP("MyOpIncorrect", "custom_opset", MyOpOld);
|
||||
MyOpIncorrect() = default;
|
||||
|
||||
std::shared_ptr<Node> clone_with_new_inputs(const ov::OutputVector& inputs) const override {
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
class MyOpNew : public ov::op::Op {
|
||||
public:
|
||||
OPENVINO_OP("MyOpNew", "custom_opset", MyOpOld);
|
||||
MyOpNew() = default;
|
||||
|
||||
std::shared_ptr<Node> clone_with_new_inputs(const ov::OutputVector& inputs) const override {
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
TEST(opset, custom_opset) {
|
||||
ov::OpSet opset;
|
||||
opset.insert<MyOpOld>();
|
||||
opset.insert<MyOpNewFromOld>();
|
||||
opset.insert<MyOpIncorrect>();
|
||||
opset.insert<MyOpNew>();
|
||||
ASSERT_EQ(opset.get_types_info().size(), 3);
|
||||
ASSERT_TRUE(opset.contains_type("MyOpNew"));
|
||||
ASSERT_TRUE(opset.contains_type("MyOpOld"));
|
||||
ASSERT_TRUE(opset.contains_type("MyOpNewFromOld"));
|
||||
ASSERT_FALSE(opset.contains_type("MyOpIncorrect"));
|
||||
}
|
||||
|
||||
95
ngraph/test/rtti.cpp
Normal file
95
ngraph/test/rtti.cpp
Normal file
@ -0,0 +1,95 @@
|
||||
// Copyright (C) 2018-2021 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
#include "ngraph/node.hpp"
|
||||
#include "util/all_close_f.hpp"
|
||||
#include "util/test_tools.hpp"
|
||||
|
||||
using namespace ngraph;
|
||||
using namespace std;
|
||||
|
||||
class OpType : public ngraph::op::Op {
|
||||
public:
|
||||
OPENVINO_OP("OpType");
|
||||
OpType() = default;
|
||||
|
||||
std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& inputs) const override {
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
class OpTypeVersion : public ngraph::op::Op {
|
||||
public:
|
||||
OPENVINO_OP("OpTypeVersion", "my_version");
|
||||
OpTypeVersion() = default;
|
||||
|
||||
std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& inputs) const override {
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
class OpTypeVersionParent : public OpType {
|
||||
public:
|
||||
OPENVINO_OP("OpTypeVersionParent", "my_version", OpType);
|
||||
OpTypeVersionParent() = default;
|
||||
|
||||
std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& inputs) const override {
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
class OpTypeVersionParentOld : public OpType {
|
||||
public:
|
||||
OPENVINO_OP("OpTypeVersionParentOld", "my_version1", OpType, 1);
|
||||
OpTypeVersionParentOld() = default;
|
||||
|
||||
std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& inputs) const override {
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
TEST(rtti, op_with_type) {
|
||||
auto op = OpType();
|
||||
auto type_info = op.get_type_info();
|
||||
ASSERT_EQ(type_info, OpType::get_type_info_static());
|
||||
ASSERT_EQ(strcmp(type_info.name, "OpType"), 0);
|
||||
ASSERT_EQ(type_info.version, 0);
|
||||
ASSERT_EQ(strcmp(type_info.version_id, "extension"), 0);
|
||||
ASSERT_NE(type_info.parent, nullptr);
|
||||
ASSERT_EQ(*type_info.parent, ngraph::op::Op::get_type_info_static());
|
||||
}
|
||||
|
||||
TEST(rtti, op_with_type_version) {
|
||||
auto op = OpTypeVersion();
|
||||
auto type_info = op.get_type_info();
|
||||
ASSERT_EQ(type_info, OpTypeVersion::get_type_info_static());
|
||||
ASSERT_EQ(strcmp(type_info.name, "OpTypeVersion"), 0);
|
||||
ASSERT_EQ(type_info.version, 0);
|
||||
ASSERT_EQ(strcmp(type_info.version_id, "my_version"), 0);
|
||||
ASSERT_NE(type_info.parent, nullptr);
|
||||
ASSERT_EQ(*type_info.parent, ngraph::op::Op::get_type_info_static());
|
||||
}
|
||||
|
||||
TEST(rtti, op_with_type_version_parent) {
|
||||
auto op = OpTypeVersionParent();
|
||||
auto type_info = op.get_type_info();
|
||||
ASSERT_EQ(type_info, OpTypeVersionParent::get_type_info_static());
|
||||
ASSERT_EQ(strcmp(type_info.name, "OpTypeVersionParent"), 0);
|
||||
ASSERT_EQ(type_info.version, 0);
|
||||
ASSERT_EQ(strcmp(type_info.version_id, "my_version"), 0);
|
||||
ASSERT_NE(type_info.parent, nullptr);
|
||||
ASSERT_EQ(*type_info.parent, OpType::get_type_info_static());
|
||||
}
|
||||
|
||||
TEST(rtti, op_with_type_version_parent_old) {
|
||||
auto op = OpTypeVersionParentOld();
|
||||
auto type_info = op.get_type_info();
|
||||
ASSERT_EQ(type_info, OpTypeVersionParentOld::get_type_info_static());
|
||||
ASSERT_EQ(strcmp(type_info.name, "OpTypeVersionParentOld"), 0);
|
||||
ASSERT_EQ(strcmp(type_info.version_id, "my_version1"), 0);
|
||||
ASSERT_EQ(type_info.version, 1);
|
||||
ASSERT_NE(type_info.parent, nullptr);
|
||||
ASSERT_EQ(*type_info.parent, OpType::get_type_info_static());
|
||||
}
|
||||
49
ngraph/test/type_info.cpp
Normal file
49
ngraph/test/type_info.cpp
Normal file
@ -0,0 +1,49 @@
|
||||
// Copyright (C) 2018-2021 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "openvino/core/type.hpp"
|
||||
|
||||
TEST(type_info, compare_old_type) {
|
||||
ov::DiscreteTypeInfo type1("type1", 0);
|
||||
ov::DiscreteTypeInfo type2("type2", 0);
|
||||
ov::DiscreteTypeInfo type3("type1", 1);
|
||||
ov::DiscreteTypeInfo type4("type3", 0, &type1);
|
||||
ov::DiscreteTypeInfo type5("type3", 0, &type2);
|
||||
ASSERT_TRUE(type1 != type2);
|
||||
ASSERT_TRUE(type1 == type1);
|
||||
ASSERT_TRUE(type1 < type2);
|
||||
ASSERT_TRUE(type2 > type1);
|
||||
ASSERT_TRUE(type1 >= type1);
|
||||
ASSERT_TRUE(type1 <= type1);
|
||||
ASSERT_TRUE(type3 >= type1);
|
||||
ASSERT_TRUE(type1 <= type3);
|
||||
ASSERT_FALSE(type4 != type5);
|
||||
ASSERT_FALSE(type4 < type5);
|
||||
}
|
||||
|
||||
TEST(type_info, compare_new_type) {
|
||||
ov::DiscreteTypeInfo type1("type1", 0, "version1");
|
||||
ov::DiscreteTypeInfo type2("type2", 0, "version1");
|
||||
ov::DiscreteTypeInfo type3("type1", 1, "version2");
|
||||
ov::DiscreteTypeInfo type4("type3", 0, "version3", &type1);
|
||||
ov::DiscreteTypeInfo type5("type3", 0, "version3", &type2);
|
||||
ASSERT_TRUE(type1 != type2);
|
||||
ASSERT_TRUE(type1 == type1);
|
||||
ASSERT_TRUE(type1 < type2);
|
||||
ASSERT_TRUE(type2 > type1);
|
||||
ASSERT_TRUE(type1 >= type1);
|
||||
ASSERT_TRUE(type1 <= type1);
|
||||
ASSERT_TRUE(type3 >= type1);
|
||||
ASSERT_TRUE(type1 <= type3);
|
||||
ASSERT_FALSE(type4 != type5);
|
||||
ASSERT_FALSE(type4 < type5);
|
||||
}
|
||||
|
||||
TEST(type_info, compare_new_with_old_type) {
|
||||
ov::DiscreteTypeInfo type1("type1", 0, "version1");
|
||||
ov::DiscreteTypeInfo type1_o("type1", 0);
|
||||
ASSERT_TRUE(type1 == type1_o);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user