colin
/
TIM-VX
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace name direct_map_op with builtin_op 

Signed-off-by: Chen Xin <jack.chen@verisilicon.com>
This commit is contained in:
Chen Xin 2022-09-14 15:20:57 +08:00 committed by Sven
parent 113c3722cb
commit 9b13b6f677
181 changed files with 371 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
BUILD
View File

@ -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/direct_map_op.cc",
"src/tim/vx/direct_map_op_impl.h",
"src/tim/vx/builtin_op_impl.cc",
"src/tim/vx/builtin_op.cc",
"src/tim/vx/builtin_op_impl.h",
"src/tim/vx/op_impl.cc",
"src/tim/vx/op_impl.h",
"src/tim/vx/operation.cc",

10
include/tim/vx/direct_map_op.h → include/tim/vx/builtin_op.h
View File

@ -21,17 +21,17 @@
* DEALINGS IN THE SOFTWARE.
*
*****************************************************************************/
#ifndef TIM_VX_DIRECTMAPOP_H
#define TIM_VX_DIRECTMAPOP_H
#ifndef TIM_VX_BUILTIN_OP_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);
};

20
include/tim/vx/ops/activations.h
View File

@ -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);

4
include/tim/vx/ops/addn.h
View File

@ -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);

4
include/tim/vx/ops/arg.h
View File

@ -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( \

4
include/tim/vx/ops/batch2space.h
View File

@ -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,

4
include/tim/vx/ops/batchnorm.h
View File

@ -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);

4
include/tim/vx/ops/broadcast.h
View File

@ -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 = {});

4
include/tim/vx/ops/clip.h
View File

@ -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);

4
include/tim/vx/ops/concat.h
View File

@ -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);

4
include/tim/vx/ops/conv1d.h
View File

@ -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,

4
include/tim/vx/ops/conv2d.h
View File

@ -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,

4
include/tim/vx/ops/conv3d.h
View File

@ -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,

2
include/tim/vx/ops/custom_base.h
View File

@ -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>

4
include/tim/vx/ops/deconv.h
View File

@ -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,

4
include/tim/vx/ops/deconv1d.h
View File

@ -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,

4
include/tim/vx/ops/depth2space.h
View File

@ -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,

4
include/tim/vx/ops/dropout.h
View File

@ -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);

8
include/tim/vx/ops/elementwise.h
View File

@ -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);

4
include/tim/vx/ops/erf.h
View File

@ -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;

4
include/tim/vx/ops/fullyconnected.h
View File

@ -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);

4
include/tim/vx/ops/gather.h
View File

@ -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);

4
include/tim/vx/ops/gather_elements.h
View File

@ -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);

4
include/tim/vx/ops/gathernd.h
View File

@ -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);

4
include/tim/vx/ops/groupedconv1d.h
View File

@ -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,

4
include/tim/vx/ops/groupedconv2d.h
View File

@ -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,

4
include/tim/vx/ops/grucell.h
View File

@ -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,

4
include/tim/vx/ops/instancenormalization.h
View File

@ -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);

4
include/tim/vx/ops/l2normalization.h
View File

@ -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);

4
include/tim/vx/ops/layernormalization.h
View File

@ -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);

4
include/tim/vx/ops/localresponsenormalization.h
View File

@ -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);

4
include/tim/vx/ops/logical.h
View File

@ -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( \

4
include/tim/vx/ops/logsoftmax.h
View File

@ -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);

4
include/tim/vx/ops/matmul.h
View File

@ -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);

4
include/tim/vx/ops/maxpoolwithargmax.h
View File

@ -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,

4
include/tim/vx/ops/maxpoolwithargmax2.h
View File

@ -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,

4
include/tim/vx/ops/maxunpool2d.h
View File

@ -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);

4
include/tim/vx/ops/moments.h
View File

@ -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);

4
include/tim/vx/ops/nbg.h
View File

@ -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);

4
include/tim/vx/ops/onehot.h
View File

@ -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);

4
include/tim/vx/ops/pad.h
View File

@ -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

4
include/tim/vx/ops/pool2d.h
View File

@ -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.*/

4
include/tim/vx/ops/reduce.h
View File

@ -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); \

4
include/tim/vx/ops/relational_operations.h
View File

@ -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( \

4
include/tim/vx/ops/reorg.h
View File

@ -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);

2
include/tim/vx/ops/reshape.h
View File

@ -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 {

4
include/tim/vx/ops/resize.h
View File

@ -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,

4
include/tim/vx/ops/resize1d.h
View File

@ -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,

4
include/tim/vx/ops/reverse.h
View File

@ -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);

4
include/tim/vx/ops/roi_align.h
View File

@ -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,

4
include/tim/vx/ops/roi_pool.h
View File

@ -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);

4
include/tim/vx/ops/scatternd.h
View File

@ -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);

4
include/tim/vx/ops/select.h
View File

@ -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);

4
include/tim/vx/ops/shuffle_channel.h
View File

@ -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;

4
include/tim/vx/ops/signal_frame.h
View File

@ -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);

4
include/tim/vx/ops/simple_operations.h
View File

@ -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( \

4
include/tim/vx/ops/slice.h
View File

@ -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);

4
include/tim/vx/ops/softmax.h
View File

@ -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);

4
include/tim/vx/ops/space2batch.h
View File

@ -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,

4
include/tim/vx/ops/space2depth.h
View File

@ -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);

4
include/tim/vx/ops/spatial_transformer.h
View File

@ -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,

4
include/tim/vx/ops/split.h
View File

@ -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);

4
include/tim/vx/ops/squeeze.h
View File

@ -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);

4
include/tim/vx/ops/stack.h
View File

@ -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);

4
include/tim/vx/ops/stridedslice.h
View File

@ -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,

4
include/tim/vx/ops/svdf.h
View File

@ -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);

4
include/tim/vx/ops/tile.h
View File

@ -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);

4
include/tim/vx/ops/topk.h
View File

@ -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);

4
include/tim/vx/ops/transpose.h
View File

@ -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);

4
include/tim/vx/ops/unidirectional_sequence_gru.h
View File

@ -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,

4
include/tim/vx/ops/unidirectional_sequence_lstm.h
View File

@ -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,

4
include/tim/vx/ops/unstack.h
View File

@ -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);

2
src/tim/transform/ops/activation_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/addn_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/arg_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/batch2space_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/broadcast_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/concat_layout_inferene.h
View File

@ -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 {

2
src/tim/transform/ops/conv2d_layout_inference.h
View File

@ -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"

2
src/tim/transform/ops/deconv2d_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/default_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/depth2space_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/elementwise_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/fullyconnected_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/gather_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/gather_nd_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/grouped_conv2d_layout_inference.h
View File

@ -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"

2
src/tim/transform/ops/l2normalization_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/logical_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/lrn_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/op_layout_inference.cc
View File

@ -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"

2
src/tim/transform/ops/pad_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/pool2d_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/reduce_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/resize_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/reverse_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/select_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/simple_ops_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/slice_layout_inference.h
View File

@ -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 {

2
src/tim/transform/ops/softmax_layout_inference.h
View File

@ -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"

Some files were not shown because too many files have changed in this diff Show More