Replace name direct_map_op with builtin_op

Signed-off-by: Chen Xin <jack.chen@verisilicon.com>

BUILD

@@ -28,7 +28,7 @@ cc_library(
     ],
     hdrs = [
         "include/tim/vx/context.h",
-        "include/tim/vx/direct_map_op.h",
+        "include/tim/vx/builtin_op.h",
         "include/tim/vx/graph.h",
         "include/tim/vx/operation.h",
         "include/tim/vx/ops.h",
@@ -45,9 +45,9 @@ cc_library(
         "src/tim/vx/compile_option.cc",
         "src/tim/vx/graph_private.h",
         "src/tim/vx/graph.cc",
-        "src/tim/vx/direct_map_op_impl.cc",
+        "src/tim/vx/builtin_op_impl.cc",
-        "src/tim/vx/direct_map_op.cc",
+        "src/tim/vx/builtin_op.cc",
-        "src/tim/vx/direct_map_op_impl.h",
+        "src/tim/vx/builtin_op_impl.h",
         "src/tim/vx/op_impl.cc",
         "src/tim/vx/op_impl.h",
         "src/tim/vx/operation.cc",

include/tim/vx/builtin_op.h

@@ -21,17 +21,17 @@
 *    DEALINGS IN THE SOFTWARE.
 *
 *****************************************************************************/
-#ifndef TIM_VX_DIRECTMAPOP_H
+#ifndef TIM_VX_BUILTIN_OP_H_
-#define TIM_VX_DIRECTMAPOP_H
+#define TIM_VX_BUILTIN_OP_H_
 
 #include "tim/vx/operation.h"
-
+#define DirectMapOp BuiltinOp
 namespace tim {
 namespace vx {
 // interface
-class DirectMapOp : public Operation {
+class BuiltinOp : public Operation {
   public:
-  DirectMapOp(Graph* graph, uint32_t kind, int in_cnt = 0, int out_cnt = 0,
+  BuiltinOp(Graph* graph, uint32_t kind, int in_cnt = 0, int out_cnt = 0,
               DataLayout layout = DataLayout::ANY);
 };
 

include/tim/vx/ops/activations.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_ACTIVATIONS_H_
 #define TIM_VX_OPS_ACTIVATIONS_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -73,7 +73,7 @@ namespace ops {
  */
 
 #define DECLARE_NO_PARAMETER_ACTIVATION(NAME)          \
-  class NAME : public DirectMapOp {                    \
+  class NAME : public BuiltinOp {                    \
    public:                                             \
     NAME(Graph* graph);                                \
     std::shared_ptr<Operation> Clone(                  \
@@ -92,7 +92,7 @@ DECLARE_NO_PARAMETER_ACTIVATION(SoftRelu)
 
 #undef DEFINE_NO_PARAMETER_ACTIVATION
 
-class Elu : public DirectMapOp {
+class Elu : public BuiltinOp {
  public:
   Elu(Graph* graph);
   Elu(Graph* graph, float alpha);
@@ -103,7 +103,7 @@ class Elu : public DirectMapOp {
   float alpha_;
 };
 
-class Prelu : public DirectMapOp {
+class Prelu : public BuiltinOp {
  public:
   Prelu(Graph* graph, int axis);
   std::shared_ptr<Operation> Clone(
@@ -113,7 +113,7 @@ class Prelu : public DirectMapOp {
   int axis_;
 };
 
-class HardSigmoid : public DirectMapOp {
+class HardSigmoid : public BuiltinOp {
  public:
   HardSigmoid(Graph* graph, float alpha, float beta);
   std::shared_ptr<Operation> Clone(
@@ -124,7 +124,7 @@ class HardSigmoid : public DirectMapOp {
   float beta_;
 };
 
-class LeakyRelu : public DirectMapOp {
+class LeakyRelu : public BuiltinOp {
  public:
   LeakyRelu(Graph* graph, float alpha);
   std::shared_ptr<Operation> Clone(
@@ -134,7 +134,7 @@ class LeakyRelu : public DirectMapOp {
   float alpha_;
 };
 
-class Linear : public DirectMapOp {
+class Linear : public BuiltinOp {
  public:
   Linear(Graph* graph, float a, float b = 0.0);
   std::shared_ptr<Operation> Clone(
@@ -145,7 +145,7 @@ class Linear : public DirectMapOp {
   float b_;
 };
 
-class Gelu : public DirectMapOp {
+class Gelu : public BuiltinOp {
  public:
   /****************************************************************************
   *Non-approximate calculations will also have errors when the data type is
@@ -156,7 +156,7 @@ class Gelu : public DirectMapOp {
       std::shared_ptr<Graph>& graph) const override;
 };
 
-class Selu : public DirectMapOp {
+class Selu : public BuiltinOp {
  public:
   Selu(Graph* graph, float alpha = 1.67326, float gamma = 1.0507);
 
@@ -168,7 +168,7 @@ class Selu : public DirectMapOp {
   float gamma_;
 };
 
-class Celu : public DirectMapOp {
+class Celu : public BuiltinOp {
  public:
   Celu(Graph* graph, float alpha);
 

include/tim/vx/ops/addn.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_ADDN_H_
 #define TIM_VX_OPS_ADDN_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -37,7 +37,7 @@ namespace ops {
  * ```
  */
 
-class AddN : public DirectMapOp {
+class AddN : public BuiltinOp {
  public:
   AddN(Graph* graph, uint32_t num_inputs);
 

include/tim/vx/ops/arg.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_ARG_H_
 #define TIM_VX_OPS_ARG_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -37,7 +37,7 @@ namespace ops {
  */
 
 #define DECLARE_ARG_OP(NAME)                           \
-  class Arg##NAME : public DirectMapOp {                 \
+  class Arg##NAME : public BuiltinOp {                 \
    public:                                             \
     Arg##NAME(Graph* graph, int32_t axis);             \
     std::shared_ptr<Operation> Clone(                  \

include/tim/vx/ops/batch2space.h

@@ -26,7 +26,7 @@
 
 #include <vector>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -43,7 +43,7 @@ namespace ops {
  * - crop : corp the output tensor for ROI usage.
  */
 
-class Batch2Space : public DirectMapOp {
+class Batch2Space : public BuiltinOp {
  public:
   Batch2Space(Graph* graph, const std::vector<int>& block_size,
                const std::vector<int>& crop,

include/tim/vx/ops/batchnorm.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef OVXLIBXX_OPERATIONS_BATCHNORM_H_
 #define OVXLIBXX_OPERATIONS_BATCHNORM_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -40,7 +40,7 @@ namespace ops {
  * $$y_i=\gamma\hat x_i+\beta\equiv BN_{\gamma,\beta}(x_i)$$
  */
 
-class BatchNorm : public DirectMapOp {
+class BatchNorm : public BuiltinOp {
   public:
     BatchNorm(Graph* graph, float eps, DataLayout input_layout = DataLayout::WHCN);
 

include/tim/vx/ops/broadcast.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef OVXLIBXX_OPERATIONS_BROADCAST_H_
 #define OVXLIBXX_OPERATIONS_BROADCAST_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -43,7 +43,7 @@ namespace ops {
  *   of the operand shape corresponds to. For BroadcastInDim.
  */
 
-class Broadcast : public DirectMapOp {
+class Broadcast : public BuiltinOp {
   public:
     Broadcast(Graph* graph, const std::vector<int32_t>& shape, const std::vector<int32_t>& dimensions = {});
 

include/tim/vx/ops/clip.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef OVXLIBXX_OPERATIONS_CLIP_H_
 #define OVXLIBXX_OPERATIONS_CLIP_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 
 namespace tim {
@@ -36,7 +36,7 @@ namespace ops {
  * Clip(x) : min if x <= min; x if min < x < max; max if x >= max
  */
 
-class Clip : public DirectMapOp {
+class Clip : public BuiltinOp {
   public:
     Clip(Graph* graph, float min, float max);
 

include/tim/vx/ops/concat.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_CONCAT_H_
 #define TIM_VX_OPS_CONCAT_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -37,7 +37,7 @@ namespace ops {
  * - axis : Which axis to concat on.
  */
 
-class Concat : public DirectMapOp {
+class Concat : public BuiltinOp {
  public:
   Concat(Graph* graph, uint32_t axis, int input_cnt);
 

include/tim/vx/ops/conv1d.h

@@ -26,13 +26,13 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
 namespace ops {
 
-class Conv1d : public DirectMapOp {
+class Conv1d : public BuiltinOp {
  public:
   Conv1d(Graph* graph, PadType padding, uint32_t stride,
          uint32_t dilation, int32_t multiplier = 0,

include/tim/vx/ops/conv2d.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -55,7 +55,7 @@ namespace ops {
  * - layout : WHCN or CWHN.
  */
 
-class Conv2d : public DirectMapOp {
+class Conv2d : public BuiltinOp {
  public:
   Conv2d(Graph* graph, PadType padding,
          const std::array<uint32_t, 2>& stride,

include/tim/vx/ops/conv3d.h

@@ -25,7 +25,7 @@
 #define TIM_VX_OPS_CONV3D_H_
 
 #include <array>
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -54,7 +54,7 @@ namespace ops {
  * - kernel_layout : WHDIcOc
  */
 
-class Conv3d : public DirectMapOp {
+class Conv3d : public BuiltinOp {
  public:
   Conv3d(Graph* graph, PadType padding,
          const std::array<int32_t, 3>& stride,

include/tim/vx/ops/custom_base.h

@@ -24,7 +24,7 @@
 #ifndef TIM_VX_OPS_CUSTOM_BASE_H_
 #define TIM_VX_OPS_CUSTOM_BASE_H_
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include <typeinfo>
 #include <tuple>
 

include/tim/vx/ops/deconv.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -53,7 +53,7 @@ namespace ops {
  * - kernel_layout: Layout for kernel, WHIO by default.
  */
 
-class DeConv2d : public DirectMapOp {
+class DeConv2d : public BuiltinOp {
   public:
     DeConv2d(Graph* graph, int32_t oc_count_, PadType pad_type,
         const std::array<uint32_t, 2>& ksize,

include/tim/vx/ops/deconv1d.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -49,7 +49,7 @@ namespace ops {
  * the output tensor.
  */
 
-class DeConv1d : public DirectMapOp {
+class DeConv1d : public BuiltinOp {
   public:
     DeConv1d(Graph* graph, PadType pad_type,
         uint32_t stride, uint32_t output_padding, uint32_t group = 1,

include/tim/vx/ops/depth2space.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_DEPTH2SPACE_H_
 #define TIM_VX_OPS_DEPTH2SPACE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -45,7 +45,7 @@ namespace ops {
  * - crop : corp the output tensor for ROI usage.
  */
 
-class DepthToSpace : public DirectMapOp {
+class DepthToSpace : public BuiltinOp {
  public:
   enum depth2space_mode {
     CRD_mode = 0,

include/tim/vx/ops/dropout.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef OVXLIBXX_OPERATIONS_DROPOUT_H_
 #define OVXLIBXX_OPERATIONS_DROPOUT_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 
 namespace tim {
@@ -40,7 +40,7 @@ namespace ops {
  * for Dropout operator.
  */
 
-class Dropout : public DirectMapOp {
+class Dropout : public BuiltinOp {
  public:
   Dropout(Graph* graph, float ratio);
 

include/tim/vx/ops/elementwise.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_ELEMENTWISE_H_
 #define TIM_VX_OPS_ELEMENTWISE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -67,7 +67,7 @@ namespace ops {
  */
 
 #define DECLARE_ELEMENTWISE_OP(NAME)                   \
-  class NAME : public DirectMapOp {                      \
+  class NAME : public BuiltinOp {                      \
    public:                                             \
     NAME(Graph* graph);                                \
     std::shared_ptr<Operation> Clone(                  \
@@ -81,14 +81,14 @@ DECLARE_ELEMENTWISE_OP(Sub)
 DECLARE_ELEMENTWISE_OP(Pow)
 DECLARE_ELEMENTWISE_OP(FloorDiv)
 
-class Multiply : public DirectMapOp {
+class Multiply : public BuiltinOp {
  public:
   Multiply(Graph* graph, float scale = 1.0f);
 
   std::shared_ptr<Operation> Clone(std::shared_ptr<Graph>& graph) const override;
 };
 
-class Div : public DirectMapOp {
+class Div : public BuiltinOp {
  public:
   Div(Graph* graph, float scale = 1.0f);
 

include/tim/vx/ops/erf.h

@@ -24,7 +24,7 @@
 #ifndef TIM_VX_OPS_ERF_H_
 #define TIM_VX_OPS_ERF_H_
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "tim/vx/types.h"
 
 namespace tim {
@@ -39,7 +39,7 @@ namespace ops {
  * - no parameters
  */
 
-class Erf : public DirectMapOp {
+class Erf : public BuiltinOp {
    public:
     Erf(Graph* graph);
     std::shared_ptr<Operation> Clone(std::shared_ptr<Graph>& graph) const override;

include/tim/vx/ops/fullyconnected.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_FULLYCONNECTED_H_
 #define TIM_VX_OPS_FULLYCONNECTED_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -39,7 +39,7 @@ namespace ops {
  * - weights: the output channel number for weight tensor.
  */
 
-class FullyConnected : public DirectMapOp {
+class FullyConnected : public BuiltinOp {
  public:
   FullyConnected(Graph* graph, uint32_t axis);
   FullyConnected(Graph* graph, uint32_t axis, uint32_t weights);

include/tim/vx/ops/gather.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_GATHER_H_
 #define TIM_VX_OPS_GATHER_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -35,7 +35,7 @@ namespace ops {
  * Gather slices from input, **axis** according to **indices**.
  */
 
-class Gather : public DirectMapOp {
+class Gather : public BuiltinOp {
  public:
   Gather(Graph* Graph, int axis, int batch_dims = 0);
 

include/tim/vx/ops/gather_elements.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_GATHER_ELEMENTS_H_
 #define TIM_VX_OPS_GATHER_ELEMENTS_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -39,7 +39,7 @@ namespace ops {
  * https://github.com/onnx/onnx/blob/main/docs/Operators.md#GatherElements
  */
 
-class GatherElements : public DirectMapOp {
+class GatherElements : public BuiltinOp {
  public:
   GatherElements(Graph* Graph, int axis);
 

include/tim/vx/ops/gathernd.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_GATHERND_H_
 #define TIM_VX_OPS_GATHERND_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -35,7 +35,7 @@ namespace ops {
  * An operation similar to Gather but gathers across multiple axis at once.
  */
 
-class GatherNd : public DirectMapOp {
+class GatherNd : public BuiltinOp {
  public:
   GatherNd(Graph* Graph);
 

include/tim/vx/ops/groupedconv1d.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -53,7 +53,7 @@ namespace ops {
  * - layout : WCN or CWN.
  */
 
-class GroupedConv1d : public DirectMapOp {
+class GroupedConv1d : public BuiltinOp {
  public:
   GroupedConv1d(Graph* graph, PadType padding, std::array<uint32_t, 2> pad,
                 uint32_t stride, uint32_t dilation, uint32_t group,

include/tim/vx/ops/groupedconv2d.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -53,7 +53,7 @@ namespace ops {
  * - layout : WHCN or CWHN.
  */
 
-class GroupedConv2d : public DirectMapOp {
+class GroupedConv2d : public BuiltinOp {
  public:
   GroupedConv2d(Graph* graph, PadType padding,
          const std::array<uint32_t, 2>& strides,

include/tim/vx/ops/grucell.h

@@ -25,7 +25,7 @@
 #define TIM_VX_OPS_GRUCELL_H_
 
 #include <array>
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "vsi_nn_pub.h"
 
 namespace tim {
@@ -42,7 +42,7 @@ namespace ops {
  *   False = "before", True = "after".
  */
 
-class GRUCell : public DirectMapOp {
+class GRUCell : public BuiltinOp {
  public:
   enum ActivationType {
     kNONE = 0,

include/tim/vx/ops/instancenormalization.h

@@ -23,12 +23,12 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_INSTANCENOMALIZATION_H_
 #define TIM_VX_OPS_INSTANCENOMALIZATION_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
 namespace ops {
-class InstanceNormalization : public DirectMapOp {
+class InstanceNormalization : public BuiltinOp {
  public:
   InstanceNormalization(Graph* graph, float eps = 1e-5f);
 

include/tim/vx/ops/l2normalization.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_L2NOMALIZATION_H_
 #define TIM_VX_OPS_L2NOMALIZATION_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 /**
  * ## L2Normalization
@@ -40,7 +40,7 @@
 namespace tim {
 namespace vx {
 namespace ops {
-class L2Normalization : public DirectMapOp {
+class L2Normalization : public BuiltinOp {
  public:
   L2Normalization(Graph* graph, int32_t axis);
 

include/tim/vx/ops/layernormalization.h

@@ -25,12 +25,12 @@
 #define TIM_VX_OPS_LAYERNOMALIZATION_H_
 
 #include <cstdint>
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
 namespace ops {
-class LayerNormalization : public DirectMapOp {
+class LayerNormalization : public BuiltinOp {
  public:
   LayerNormalization(Graph* graph, int32_t axis = 0, float eps = 1e-5f);
 

include/tim/vx/ops/localresponsenormalization.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_LOCALRESPONSENORMALIZATION_H_
 #define TIM_VX_OPS_LOCALRESPONSENORMALIZATION_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 /**
  * ## LocalResponseNormalization
@@ -45,7 +45,7 @@
 namespace tim {
 namespace vx {
 namespace ops {
-class LocalResponseNormalization : public DirectMapOp {
+class LocalResponseNormalization : public BuiltinOp {
  public:
   LocalResponseNormalization(Graph* graph, uint32_t size, float alpha,
                              float beta, float bias, int32_t axis);

include/tim/vx/ops/logical.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_LOGICAL_H_
 #define TIM_VX_OPS_LOGICAL_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -40,7 +40,7 @@ namespace ops {
  */
 
 #define DECLARE_LOGICAL_OP(NAME)                       \
-  class Logical##NAME : public DirectMapOp {             \
+  class Logical##NAME : public BuiltinOp {             \
    public:                                             \
     Logical##NAME(Graph* graph);                       \
     std::shared_ptr<Operation> Clone(                  \

include/tim/vx/ops/logsoftmax.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_LOG_SOFTMAX_H_
 #define TIM_VX_OPS_LOG_SOFTMAX_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -39,7 +39,7 @@ namespace ops {
  * ```
  */
 
-class LogSoftmax : public DirectMapOp {
+class LogSoftmax : public BuiltinOp {
  public:
   LogSoftmax(Graph* graph, int32_t axis, float beta = 1.f);
 

include/tim/vx/ops/matmul.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_MATMUL_H_
 #define TIM_VX_OPS_MATMUL_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -40,7 +40,7 @@ namespace ops {
  * - adjoint_b: If True, b is conjugated and transposed before multiplication.
  */
 
-class Matmul : public DirectMapOp {
+class Matmul : public BuiltinOp {
  public:
   Matmul(Graph* graph, bool transpose_a = false, bool transpose_b = false,
     bool adjoint_a = false, bool adjoint_b = false);

include/tim/vx/ops/maxpoolwithargmax.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "tim/vx/types.h"
 
 namespace tim {
@@ -44,7 +44,7 @@ namespace ops {
  * - round_type : CEILING or FLOOR.
  */
 
-class MaxpoolWithArgmax : public DirectMapOp {
+class MaxpoolWithArgmax : public BuiltinOp {
  public:
   MaxpoolWithArgmax(Graph* graph, PadType padding,
          const std::array<uint32_t, 2>& ksize,

include/tim/vx/ops/maxpoolwithargmax2.h

@@ -27,7 +27,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "tim/vx/types.h"
 
 namespace tim {
@@ -45,7 +45,7 @@ namespace ops {
  * - round_type : CEILING or FLOOR.
  */
 
-class MaxpoolWithArgmax2 : public DirectMapOp {
+class MaxpoolWithArgmax2 : public BuiltinOp {
  public:
   MaxpoolWithArgmax2(Graph* graph, PadType padding,
          const std::array<uint32_t, 2>& ksize,

include/tim/vx/ops/maxunpool2d.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "tim/vx/types.h"
 
 namespace tim {
@@ -42,7 +42,7 @@ namespace ops {
  * - ksize : filter size.
  */
 
-class MaxUnpool2d : public DirectMapOp {
+class MaxUnpool2d : public BuiltinOp {
  public:
   MaxUnpool2d(Graph* graph, const std::array<uint32_t, 2>& ksize,
          const std::array<uint32_t, 2>& stride, DataLayout layout = DataLayout::WHCN);

include/tim/vx/ops/moments.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_MOMENTS_H_
 #define TIM_VX_OPS_MOMENTS_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -39,7 +39,7 @@ namespace ops {
  * - keep_dims : Produce moments with the same dimensionality as input.
  */
 
-class Moments : public DirectMapOp {
+class Moments : public BuiltinOp {
  public:
   Moments(Graph* graph, const std::vector<int32_t>& axes,
           bool keep_dims = false);

include/tim/vx/ops/nbg.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_NBG_H_
 #define TIM_VX_OPS_NBG_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -36,7 +36,7 @@ namespace ops {
  * a bianry file.
  */
 
-class NBG : public DirectMapOp {
+class NBG : public BuiltinOp {
  public:
   NBG(Graph* graph, const char* binary, size_t input_count, size_t output_count);
 

include/tim/vx/ops/onehot.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPERATION_ONE_HOT_H_
 #define TIM_VX_OPERATION_ONE_HOT_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -40,7 +40,7 @@ namespace ops {
  * - axis : The axis to fill.
  */
 
-class OneHot : public DirectMapOp {
+class OneHot : public BuiltinOp {
  public:
   OneHot(Graph* graph, int32_t depth, float on_value = 1, float off_value = 0,
          int32_t axis = 0);

include/tim/vx/ops/pad.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPERATION_PAD_H_
 #define TIM_VX_OPERATION_PAD_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -40,7 +40,7 @@ namespace ops {
  * - back_size : Add pad values to the right and bottom.
  */
 
-class Pad : public DirectMapOp {
+class Pad : public BuiltinOp {
  public:
   typedef enum {
     // signature

include/tim/vx/ops/pool2d.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "tim/vx/types.h"
 
 namespace tim {
@@ -64,7 +64,7 @@ namespace ops {
  *
  */
 
-class Pool2d : public DirectMapOp {
+class Pool2d : public BuiltinOp {
  public:
   /* for Classic Pool2d, pool does not support auto-completion of pad value,
   you need to specify pad size explicitly, it is recommended to use the second api.*/

include/tim/vx/ops/reduce.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_REDUCE_H_
 #define TIM_VX_OPS_REDUCE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -95,7 +95,7 @@ namespace ops {
  */
 
 #define DECLARE_REDUCE_OP(NAME)                                  \
-  class Reduce##NAME : public DirectMapOp {                        \
+  class Reduce##NAME : public BuiltinOp {                        \
    public:                                                       \
     Reduce##NAME(Graph* graph, const std::vector<int32_t>& axis, \
                  bool keep_dims);                                \

include/tim/vx/ops/relational_operations.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_RELATIONAL_H_
 #define TIM_VX_OPS_RELATIONAL_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -56,7 +56,7 @@ namespace ops {
  */
 
 #define DECLARE_RELATIONAL_OP(NAME)                    \
-  class NAME : public DirectMapOp {                      \
+  class NAME : public BuiltinOp {                      \
    public:                                             \
     NAME(Graph* graph);                                \
     std::shared_ptr<Operation> Clone(                  \

include/tim/vx/ops/reorg.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_REORG_H_
 #define TIM_VX_OPS_REORG_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -35,7 +35,7 @@ namespace ops {
  * The layer used in YOLOv2. See also https://github.com/pjreddie/darknet/blob/master/src/reorg_layer.c
  */
 
-class Reorg : public DirectMapOp {
+class Reorg : public BuiltinOp {
  public:
   Reorg(Graph* graph, const uint32_t stride);
 

include/tim/vx/ops/reshape.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_RESHAPE_H_
 #define TIM_VX_OPS_RESHAPE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {

include/tim/vx/ops/resize.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_RESIZE_H_
 #define TIM_VX_OPS_RESIZE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -44,7 +44,7 @@ namespace ops {
  * - target_height / target_width : output height / width. DO NOT use it with factor together.
  */
 
-class Resize : public DirectMapOp {
+class Resize : public BuiltinOp {
  public:
   Resize(Graph* graph, ResizeType type, float factor, bool align_corners,
          bool half_pixel_centers, int target_height, int target_width,

include/tim/vx/ops/resize1d.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_RESIZE1D_H_
 #define TIM_VX_OPS_RESIZE1D_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -44,7 +44,7 @@ namespace ops {
  * - target_height / target_width : output height / width. DO NOT use it with factor together.
  */
 
-class Resize1d : public DirectMapOp {
+class Resize1d : public BuiltinOp {
  public:
   Resize1d(Graph* graph, ResizeType type, float factor, bool align_corners,
          bool half_pixel_centers, int target_size,

include/tim/vx/ops/reverse.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_REVERSE_H_
 #define TIM_VX_OPS_REVERSE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -37,7 +37,7 @@ namespace ops {
  * - axis : The indices of the dimensions to reverse. 
  */
 
-class Reverse : public DirectMapOp {
+class Reverse : public BuiltinOp {
  public:
   Reverse(Graph* graph, const std::vector<int32_t>& axis);
 

include/tim/vx/ops/roi_align.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_ROI_ALIGN_H_
 #define TIM_VX_OPS_ROI_ALIGN_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -47,7 +47,7 @@ namespace ops {
  *   used to compute the output.
  */
 
-class RoiAlign : public DirectMapOp {
+class RoiAlign : public BuiltinOp {
  public:
   RoiAlign(Graph* graph, int32_t output_height, int32_t output_width,
             float height_ratio, float width_ratio, int32_t height_sample_num,

include/tim/vx/ops/roi_pool.h

@@ -25,7 +25,7 @@
 #define TIM_VX_OPS_ROI_POOL_H_
 
 #include <array>
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "tim/vx/types.h"
 
 namespace tim {
@@ -44,7 +44,7 @@ namespace ops {
  *
  */
 
-class RoiPool : public DirectMapOp {
+class RoiPool : public BuiltinOp {
  public:
   RoiPool(Graph* graph, PoolType type, float scale,
             const std::array<uint32_t, 2>& size);

include/tim/vx/ops/scatternd.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_SCATTERND_H_
 #define TIM_VX_OPS_SCATTERND_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -37,7 +37,7 @@ namespace ops {
  * - shape : The shape of the resulting tensor. 
  */
 
-class ScatterND : public DirectMapOp {
+class ScatterND : public BuiltinOp {
  public:
   ScatterND(Graph* graph, const std::vector<uint32_t>& shape);
 

include/tim/vx/ops/select.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_SELECT_H_
 #define TIM_VX_OPS_SELECT_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -36,7 +36,7 @@ namespace ops {
  * from both input tensors: O[i] = C[i] ? x[i] : y[i].
  */
 
-class Select : public DirectMapOp {
+class Select : public BuiltinOp {
  public:
   Select(Graph* graph);
 

include/tim/vx/ops/shuffle_channel.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_SHUFFLE_H_
 #define TIM_VX_OPS_SHUFFLE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -38,7 +38,7 @@ namespace ops {
  * ```
  */
 
-class ShuffleChannel : public DirectMapOp {
+class ShuffleChannel : public BuiltinOp {
   public:
    explicit ShuffleChannel(Graph* graph, int32_t num_groups, int32_t index_axis);
    std::shared_ptr<Operation> Clone(std::shared_ptr<Graph>& graph) const override;

include/tim/vx/ops/signal_frame.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_SIGNALFRAME_H_
 #define TIM_VX_OPS_SIGNALFRAME_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -39,7 +39,7 @@ namespace ops {
  * ```
  */
 
-class SignalFrame : public DirectMapOp {
+class SignalFrame : public BuiltinOp {
   public:
    SignalFrame(Graph* graph, uint32_t window_length, uint32_t step, uint32_t pad_end=0,
       uint32_t axis=0);

include/tim/vx/ops/simple_operations.h

@@ -23,14 +23,14 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_SIMPLE_OPERATIONS_H_
 #define TIM_VX_OPS_SIMPLE_OPERATIONS_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
 namespace ops {
 
 #define DECLARE_SIMPLE_OP(NAME)                        \
-  class NAME : public DirectMapOp {                      \
+  class NAME : public BuiltinOp {                      \
    public:                                             \
     NAME(Graph* graph);                                \
     std::shared_ptr<Operation> Clone(                  \

include/tim/vx/ops/slice.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_SLICE_H_
 #define TIM_VX_OPS_SLICE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -38,7 +38,7 @@ namespace ops {
  * - length : the size of the slice in each dimension.
  */
 
-class Slice : public DirectMapOp {
+class Slice : public BuiltinOp {
  public:
   Slice(Graph* graph, uint32_t dims, const std::vector<int32_t>& start,
         const std::vector<int32_t>& length);

include/tim/vx/ops/softmax.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_SOFTMAX_H_
 #define TIM_VX_OPS_SOFTMAX_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -42,7 +42,7 @@ namespace ops {
  * ```
  */
 
-class Softmax : public DirectMapOp {
+class Softmax : public BuiltinOp {
  public:
   Softmax(Graph* graph, float beta, int32_t axis);
 

include/tim/vx/ops/space2batch.h

@@ -26,7 +26,7 @@
 
 #include <vector>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -46,7 +46,7 @@ namespace ops {
  * - pad : the paddings for each spatial dimension of the input tensor.
  */
 
-class Space2Batch : public DirectMapOp {
+class Space2Batch : public BuiltinOp {
  public:
   Space2Batch(Graph* graph, const std::vector<int>& block_size,
                const std::vector<int>& pad,

include/tim/vx/ops/space2depth.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_SPACE2DEPTH_H_
 #define TIM_VX_OPS_SPACE2DEPTH_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -38,7 +38,7 @@ namespace ops {
  * transformation of DepthToSpace.
  */
 
-class SpaceToDepth : public DirectMapOp {
+class SpaceToDepth : public BuiltinOp {
  public:
   SpaceToDepth(Graph* graph, std::vector<int> block_size,
                DataLayout layout = DataLayout::WHCN);

include/tim/vx/ops/spatial_transformer.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_SPATIAL_TRANSFORMER_H_
 #define TIM_VX_OPS_SPATIAL_TRANSFORMER_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -40,7 +40,7 @@ namespace ops {
             It is the output of the localization network.
  */
 
-class SpatialTransformer : public DirectMapOp {
+class SpatialTransformer : public BuiltinOp {
  public:
   SpatialTransformer(Graph* graph, uint32_t output_h, uint32_t output_w,
     bool has_theta_1_1, bool has_theta_1_2, bool has_theta_1_3,

include/tim/vx/ops/split.h

@@ -25,7 +25,7 @@
 #define TIM_VX_OPS_SPLIT_H_
 #include <vector>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -40,7 +40,7 @@ namespace ops {
  * - slices : indicating the number of splits along given axis.
  */
 
-class Split : public DirectMapOp {
+class Split : public BuiltinOp {
  public:
   Split(Graph* graph, uint32_t axis, std::vector<uint32_t> slices);
 

include/tim/vx/ops/squeeze.h

@@ -24,7 +24,7 @@
 #ifndef TIM_VX_OPS_SQUEEZE_H_
 #define TIM_VX_OPS_SQUEEZE_H_
 #include <vector>
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -38,7 +38,7 @@ namespace ops {
  * - axis : the dimensions to squeeze.
  */
 
-class Squeeze : public DirectMapOp {
+class Squeeze : public BuiltinOp {
  public:
   Squeeze(Graph* graph, std::vector<uint32_t> axis);
 

include/tim/vx/ops/stack.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_STACK_H_
 #define TIM_VX_OPS_STACK_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -37,7 +37,7 @@ namespace ops {
  * Dimensions below the dimension specified by axis will be packed together with other inputs.
  */
 
-class Stack : public DirectMapOp {
+class Stack : public BuiltinOp {
  public:
   Stack(Graph* graph, uint32_t axis, int input_cnt);
 

include/tim/vx/ops/stridedslice.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_STRIDEDSLICE_H_
 #define TIM_VX_OPS_STRIDEDSLICE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -52,7 +52,7 @@ namespace ops {
  * e.g. begin[i] = x, end[i] = x + 1.
  */
 
-class StridedSlice : public DirectMapOp {
+class StridedSlice : public BuiltinOp {
  public:
   StridedSlice(Graph* graph, const std::vector<int32_t> begin_dims,
                const std::vector<int32_t> end_dims,

include/tim/vx/ops/svdf.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "tim/vx/types.h"
 
 namespace tim {
@@ -43,7 +43,7 @@ namespace ops {
  * - spectrogram_length : corresponds to the fixed-size of the memory.
  */
 
-class Svdf : public DirectMapOp {
+class Svdf : public BuiltinOp {
  public:
   Svdf(Graph* graph, int32_t rank, int32_t num_units, int32_t spectrogram_length);
 

include/tim/vx/ops/tile.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_TILE_H_
 #define TIM_VX_OPS_TILE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -37,7 +37,7 @@ namespace ops {
  *                Length must be the same as the number of dimensions in input.
  */
 
-class Tile : public DirectMapOp {
+class Tile : public BuiltinOp {
  public:
   Tile(Graph* graph, const std::vector<int32_t>& multiples);
 

include/tim/vx/ops/topk.h

@@ -26,7 +26,7 @@
 
 #include <array>
 
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "tim/vx/types.h"
 
 namespace tim {
@@ -41,7 +41,7 @@ namespace ops {
  * - k : Number of top elements to look for along the last dimension.
  */
 
-class Topk : public DirectMapOp {
+class Topk : public BuiltinOp {
  public:
   Topk(Graph* graph, uint32_t k);
 

include/tim/vx/ops/transpose.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_TRANSPOSE_H_
 #define TIM_VX_OPS_TRANSPOSE_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -41,7 +41,7 @@ namespace ops {
  * 2-D input Tensors.
  */
 
-class Transpose : public DirectMapOp {
+class Transpose : public BuiltinOp {
  public:
   Transpose(Graph* graph, const std::vector<uint32_t>& perm);
 

include/tim/vx/ops/unidirectional_sequence_gru.h

@@ -25,7 +25,7 @@
 #define TIM_VX_OPS_UNIDIRECTIONAL_SEQUENCE_GRU_H_
 
 #include <array>
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 #include "vsi_nn_pub.h"
 
 namespace tim {
@@ -46,7 +46,7 @@ namespace ops {
  *   in the False case, it will be [feature, timesteps, batch].
  */
 
-class UnidirectionalSequenceGRU : public DirectMapOp {
+class UnidirectionalSequenceGRU : public BuiltinOp {
  public:
   enum ActivationType {
     kNONE = 0,

include/tim/vx/ops/unidirectional_sequence_lstm.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_UNIDIRECTIONAL_SEQUENCE_LSTM_H_
 #define TIM_VX_OPS_UNIDIRECTIONAL_SEQUENCE_LSTM_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -32,7 +32,7 @@ namespace ops {
      * ## Unidirectional sequence lstm
      *  how to bind input/output: take unidirectional_sequence_lstm_test.cc
      */
-    class UnidirectionalSequenceLstm: public DirectMapOp {
+    class UnidirectionalSequenceLstm: public BuiltinOp {
      public:
       enum ActivationType {
         kNONE = 0,

include/tim/vx/ops/unstack.h

@@ -23,7 +23,7 @@
 *****************************************************************************/
 #ifndef TIM_VX_OPS_UNSTACK_H_
 #define TIM_VX_OPS_UNSTACK_H_
-#include "tim/vx/direct_map_op.h"
+#include "tim/vx/builtin_op.h"
 
 namespace tim {
 namespace vx {
@@ -37,7 +37,7 @@ namespace ops {
  * Negative values wrap around, so the valid range is [-R, R).
  */
 
-class Unstack : public DirectMapOp {
+class Unstack : public BuiltinOp {
  public:
   Unstack(Graph* graph, int32_t axis, uint32_t output_num);
 

src/tim/transform/ops/activation_layout_inference.h

@@ -28,7 +28,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/addn_layout_inference.h

@@ -25,7 +25,7 @@
 #define TIM_LAYOUT_INFER_ADDN_LAYOUT_INFERENCE_H_
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/addn.h"
 
 namespace tim {

src/tim/transform/ops/arg_layout_inference.h

@@ -25,7 +25,7 @@
 #define TIM_LAYOUT_INFER_ARG_OPS_LAYOUT_INFERENCE_H_
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/arg.h"
 namespace tim {
 namespace transform {

src/tim/transform/ops/batch2space_layout_inference.h

@@ -28,7 +28,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 namespace tim {
 namespace transform {
 class Batch2SpaceLayoutInfer : public OpLayoutInfer {

src/tim/transform/ops/broadcast_layout_inference.h

@@ -26,7 +26,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/concat_layout_inferene.h

@@ -28,7 +28,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/conv2d_layout_inference.h

@@ -26,7 +26,7 @@
 
 #include "tim/vx/ops/conv2d.h"
 
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "permute_vector.h"
 #include "ops/op_layout_inference.h"
 

src/tim/transform/ops/deconv2d_layout_inference.h

@@ -26,7 +26,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/deconv.h"
 
 namespace tim {

src/tim/transform/ops/default_layout_inference.h

@@ -33,7 +33,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/depth2space_layout_inference.h

@@ -28,7 +28,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/elementwise_layout_inference.h

@@ -28,7 +28,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/fullyconnected_layout_inference.h

@@ -28,7 +28,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/gather_layout_inference.h

@@ -25,7 +25,7 @@
 #define TIM_LAYOUT_INFER_GATHER_LAYOUT_INFERENCE_H_
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/gather.h"
 
 namespace tim {

src/tim/transform/ops/gather_nd_layout_inference.h

@@ -25,7 +25,7 @@
 #define TIM_LAYOUT_INFER_GATHER_ND_LAYOUT_INFERENCE_H_
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/gathernd.h"
 
 namespace tim {

src/tim/transform/ops/grouped_conv2d_layout_inference.h

@@ -26,7 +26,7 @@
 
 #include "tim/vx/ops/groupedconv2d.h"
 
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "permute_vector.h"
 #include "ops/op_layout_inference.h"
 

src/tim/transform/ops/l2normalization_layout_inference.h

@@ -25,7 +25,7 @@
 #define TIM_LAYOUT_INFER_L2_NORMALIZATION_LAYOUT_INFERENCE_H_
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/l2normalization.h"
 
 namespace tim {

src/tim/transform/ops/logical_layout_inference.h

@@ -25,7 +25,7 @@
 #define TIM_LAYOUT_INFER_LOGICAL_OPS_LAYOUT_INFERENCE_H_
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/logical.h"
 
 namespace tim {

src/tim/transform/ops/lrn_layout_inference.h

@@ -27,7 +27,7 @@
 #include "tim/vx/ops/localresponsenormalization.h"
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/op_layout_inference.cc

@@ -24,7 +24,7 @@
 
 #include "op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/transpose.h"
 #include "type_utils.h"
 

src/tim/transform/ops/pad_layout_inference.h

@@ -28,7 +28,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 namespace tim {
 namespace transform {
 class PadLayoutInfer : public OpLayoutInfer {

src/tim/transform/ops/pool2d_layout_inference.h

@@ -26,7 +26,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/pool2d.h"
 
 namespace tim {

src/tim/transform/ops/reduce_layout_inference.h

@@ -30,7 +30,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/resize_layout_inference.h

@@ -28,7 +28,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 namespace tim {
 namespace transform {
 class ResizeLayoutInfer : public OpLayoutInfer {

src/tim/transform/ops/reverse_layout_inference.h

@@ -25,7 +25,7 @@
 #define TIM_LAYOUT_INFER_REVERSE_LAYOUT_INFERENCE_H_
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/reverse.h"
 
 namespace tim {

src/tim/transform/ops/select_layout_inference.h

@@ -25,7 +25,7 @@
 #define TIM_LAYOUT_INFER_SELECT_LAYOUT_INFERENCE_H_
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/select.h"
 
 namespace tim {

src/tim/transform/ops/simple_ops_layout_inference.h

@@ -28,7 +28,7 @@
 
 #include "ops/op_layout_inference.h"
 #include "permute_vector.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 
 namespace tim {
 namespace transform {

src/tim/transform/ops/slice_layout_inference.h

@@ -25,7 +25,7 @@
 #define TIM_LAYOUT_INFER_SLICE_LAYOUT_INFERENCE_H_
 
 #include "ops/op_layout_inference.h"
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "tim/vx/ops/slice.h"
 
 namespace tim {

src/tim/transform/ops/softmax_layout_inference.h

@@ -26,7 +26,7 @@
 
 #include "tim/vx/ops/softmax.h"
 
-#include "direct_map_op_impl.h"
+#include "builtin_op_impl.h"
 #include "permute_vector.h"
 #include "ops/op_layout_inference.h"