TVM_DLL

  1. #ifndef TVM_DLL
  2. #ifdef _WIN32
  3. #ifdef TVM_EXPORTS
  4. #define TVM_DLL __declspec(dllexport)
  5. #else
  6. #define TVM_DLL __declspec(dllimport)
  7. #endif
  8. #else
  9. #define TVM_DLL __attribute__((visibility("default")))
  10. #endif
  11. #endif

TVM_VERSION

  1. // TVM version
  2. #define TVM_VERSION "0.6.0"

TVM_REGISTER_GLOBAL / TVM_REGISTER_API

注册一个全局宏
例如：

  1. TVM_REGISTER_GLOBAL("MyPrint")
  2. .set_body([](TVMArgs args, TVMRetValue* rv) {
  3. });
  5. static __attribute__((unused)) ::tvm::runtime::Registry& __mk_ ## TVM##__COUNTER__ = ::tvm::runtime::Registry::Register(OpName)

TVM_REGISTER_OBJECT_TYPE
_

TVMREGISTER_NODE_TYPE
_Register a node type to object registry and reflection registry.

TVMDECLARE_INTRIN_UNARY
_Intrinsic operators

TVM_CHECK_TYPE_CODE

RELAY_REGISTER_OP

Register a new operator, or set attribute of the corresponding op.

RELAY_REGISTER_UNARY_OP

RELAY_REGISTER_BINARY_OP

RELAY_REGISTER_CMP_OP

这三个宏是对TVM_REGISTER_API和RELAY_REGISTER_OP的进一步封装，如下：

  1. /*! Quick helper macro
  2.  * - Expose a positional make function to construct the node.
  3.  * - Register op to the registry.
  4.  *
  5.  * We make the decision to always only expose positional argument.
  6.  * We will do rewrapping in the frontend to support language
  7.  * sugars such as keyword arguments and default value.
  9.  * \param OpName the name of registry.
  10.  */
  11. #define RELAY_REGISTER_UNARY_OP(OpName)                     \
  12.   TVM_REGISTER_API("relay.op._make." OpName)                \
  13.     .set_body_typed<Expr(Expr)>([](Expr data) {             \
  14.         static const Op& op = Op::Get(OpName);              \
  15.         return CallNode::make(op, {data}, Attrs(), {});     \
  16.       });                                                   \
  17.   RELAY_REGISTER_OP(OpName)                                 \
  18.     .set_num_inputs(1)                                      \
  19.     .add_argument("data", "Tensor", "The input tensor.")    \
  20.     .add_type_rel("Identity", IdentityRel)                  \
  21.     .set_attr<TOpPattern>("TOpPattern", kElemWise)          \
  22.     .set_attr<TOpIsStateful>("TOpIsStateful", false)        \
  23.     .set_attr<FInferCorrectLayout>("FInferCorrectLayout",   \
  24.                                    ElemwiseArbitraryLayout) \
  27. /*! Quick helper macro
  28.  * - Expose a positional make function to construct the node.
  29.  * - Register op to the registry.
  30.  *
  31.  * We make the decision to always only expose positional argument.
  32.  * We will do rewrapping in the frontend to support language
  33.  * sugars such as keyword arguments and default value.
  34.  *
  35.  * \param OpName the name of registry.
  36.  */
  37. #define RELAY_REGISTER_BINARY_OP(OpName)                          \
  38.   TVM_REGISTER_API("relay.op._make." OpName)                      \
  39.     .set_body_typed<Expr(Expr, Expr)>([](Expr lhs, Expr rhs) {    \
  40.         static const Op& op = Op::Get(OpName);                    \
  41.         return CallNode::make(op, {lhs, rhs}, Attrs(), {});       \
  42.       });                                                         \
  43.   RELAY_REGISTER_OP(OpName)                                       \
  44.     .set_num_inputs(2)                                            \
  45.     .add_argument("lhs", "Tensor", "The left hand side tensor.")  \
  46.     .add_argument("rhs", "Tensor", "The right hand side tensor.") \
  47.     .add_type_rel("Broadcast", BroadcastRel)                      \
  48.     .set_attr<TOpPattern>("TOpPattern", kBroadcast)               \
  49.     .set_attr<TOpIsStateful>("TOpIsStateful", false)              \
  50.     .set_attr<FInferCorrectLayout>("FInferCorrectLayout",         \
  51.                                    BinaryBroadcastLayout)
  53. // Comparisons
  54. #define RELAY_REGISTER_CMP_OP(OpName)                             \
  55.   TVM_REGISTER_API("relay.op._make." OpName)                      \
  56.   .set_body_typed<Expr(Expr, Expr)>([](Expr lhs, Expr rhs) {      \
  57.     static const Op& op = Op::Get(OpName);                        \
  58.     return CallNode::make(op, {lhs, rhs}, Attrs(), {});           \
  59.   });                                                             \
  60.   RELAY_REGISTER_OP(OpName)                                       \
  61.     .set_num_inputs(2)                                            \
  62.     .add_argument("lhs", "Tensor", "The left hand side tensor.")  \
  63.     .add_argument("rhs", "Tensor", "The right hand side tensor.") \
  64.     .add_type_rel("BroadcastComp", BroadcastCompRel)              \
  65.     .set_attr<TOpPattern>("TOpPattern", kBroadcast)               \
  66.     .set_attr<TOpIsStateful>("TOpIsStateful", false)              \
  67.     .set_attr<FInferCorrectLayout>("FInferCorrectLayout",         \
  68.                                    BinaryBroadcastLayout)