From 6a397912706baca8ea3b0f7ea523e4149968677c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E5=AF=85?= <liyin@xiaomi.com>
Date: Thu, 9 Aug 2018 17:53:24 +0800
Subject: [PATCH] Support hexagon_nn version 2.1 in Hexagon SDK 3.4.0

---
 .../hexagon/hexagon_control_wrapper.cc        |  28 ++-
 third_party/nnlib/hexagon_nn.h                | 147 +++++++++++-
 .../nnlib/libhexagon_controller_2_1.so        | Bin 0 -> 15708 bytes
 third_party/nnlib/ops.h                       | 226 +++++++++++++++++-
 tools/bazel.rc                                |   1 +
 5 files changed, 391 insertions(+), 11 deletions(-)
 create mode 100755 third_party/nnlib/libhexagon_controller_2_1.so

diff --git a/mace/core/runtime/hexagon/hexagon_control_wrapper.cc b/mace/core/runtime/hexagon/hexagon_control_wrapper.cc
index 4e435ebf..986fe761 100644
--- a/mace/core/runtime/hexagon/hexagon_control_wrapper.cc
+++ b/mace/core/runtime/hexagon/hexagon_control_wrapper.cc
@@ -51,10 +51,9 @@ int HexagonControlWrapper::GetVersion() {
 
 bool HexagonControlWrapper::Config() {
   LOG(INFO) << "Hexagon config";
-  if (hexagon_nn_set_powersave_level(0) != 0) {
-    return false;
-  }
-  return hexagon_nn_config() == 0;
+  MACE_CHECK(hexagon_nn_set_powersave_level(0) == 0, "hexagon power error");
+  MACE_CHECK(hexagon_nn_config() == 0, "hexagon config error");
+  return true;
 }
 
 bool HexagonControlWrapper::Init() {
@@ -80,7 +79,10 @@ bool HexagonControlWrapper::SetupGraph(const NetDef &net_def,
   int64_t t0 = NowMicros();
 
   // const node
-  std::thread const_thread([&]() {
+#if defined(MACE_USE_NNLIB_CAF) || defined(MACE_USE_NNLIB_OLD)
+  std::thread const_thread([&]()
+#endif
+  {
     std::vector<hexagon_nn_const_node> const_node_list;
     for (const ConstTensor &const_tensor : net_def.tensors()) {
       std::vector<int> tensor_shape(const_tensor.dims().begin(),
@@ -124,10 +126,16 @@ bool HexagonControlWrapper::SetupGraph(const NetDef &net_def,
           "append const node error");
     }
     const_node_list.clear();
-  });
+  }
+#if defined(MACE_USE_NNLIB_CAF) || defined(MACE_USE_NNLIB_OLD)
+  );  // NOLINT
+#endif
 
   // op node
-  std::thread op_thread([&]() {
+#if defined(MACE_USE_NNLIB_CAF) || defined(MACE_USE_NNLIB_OLD)
+  std::thread op_thread([&]()
+#endif
+  {
     OpMap op_map;
     op_map.Init();
     std::vector<hexagon_nn_op_node> op_node_list;
@@ -197,10 +205,12 @@ bool HexagonControlWrapper::SetupGraph(const NetDef &net_def,
     op_node_list.clear();
     cached_inputs.clear();
     cached_outputs.clear();
-  });
-
+  }
+#if defined(MACE_USE_NNLIB_CAF) || defined(MACE_USE_NNLIB_OLD)
+  );  // NOLINT
   const_thread.join();
   op_thread.join();
+#endif
 
   // input info
   num_inputs_ = 0;
diff --git a/third_party/nnlib/hexagon_nn.h b/third_party/nnlib/hexagon_nn.h
index 84933ddb..f2aaaa88 100644
--- a/third_party/nnlib/hexagon_nn.h
+++ b/third_party/nnlib/hexagon_nn.h
@@ -225,7 +225,152 @@ __QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_execute_new)(
 }
 #endif
 
-#else  // nnlib version
+#elif defined(MACE_USE_NNLIB_2_1)  // nnlib version
+
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if !defined(__QAIC_STRING1_OBJECT_DEFINED__) && !defined(__STRING1_OBJECT__)
+#define __QAIC_STRING1_OBJECT_DEFINED__
+#define __STRING1_OBJECT__
+typedef struct _cstring1_s {
+   char* data;
+   int dataLen;
+} _cstring1_t;
+
+#endif /* __QAIC_STRING1_OBJECT_DEFINED__ */
+typedef struct hexagon_nn_input hexagon_nn_input;
+struct hexagon_nn_input {
+   unsigned int src_id;
+   unsigned int output_idx;
+};
+typedef struct hexagon_nn_output hexagon_nn_output;
+struct hexagon_nn_output {
+   unsigned int rank;
+   unsigned int max_sizes[8];
+   unsigned int elementsize;
+   int zero_offset;
+   float stepsize;
+};
+typedef struct hexagon_nn_perfinfo hexagon_nn_perfinfo;
+struct hexagon_nn_perfinfo {
+   unsigned int node_id;
+   unsigned int node_type;
+   unsigned int executions;
+   unsigned int unused;
+   unsigned int counter_lo;
+   unsigned int counter_hi;
+};
+typedef int hexagon_nn_nn_id;
+enum hexagon_nn_padding_type {
+   NN_PAD_NA,
+   NN_PAD_SAME,
+   NN_PAD_VALID,
+   NN_PAD_MIRROR_REFLECT,
+   NN_PAD_MIRROR_SYMMETRIC,
+   NN_PAD_SAME_CAFFE,
+   _32BIT_PLACEHOLDER_hexagon_nn_padding_type = 0x7fffffff
+};
+typedef enum hexagon_nn_padding_type hexagon_nn_padding_type;
+enum hexagon_nn_corner_type {
+   NN_CORNER_RELEASE,
+   NN_CORNER_TURBO,
+   NN_CORNER_NOMPLUS,
+   NN_CORNER_NOMINAL,
+   NN_CORNER_SVSPLUS,
+   NN_CORNER_SVS,
+   NN_CORNER_SVS2,
+   _32BIT_PLACEHOLDER_hexagon_nn_corner_type = 0x7fffffff
+};
+typedef enum hexagon_nn_corner_type hexagon_nn_corner_type;
+enum hexagon_nn_dcvs_type {
+   NN_DCVS_DEFAULT,
+   NN_DCVS_ENABLE,
+   NN_DCVS_DISABLE,
+   _32BIT_PLACEHOLDER_hexagon_nn_dcvs_type = 0x7fffffff
+};
+typedef enum hexagon_nn_dcvs_type hexagon_nn_dcvs_type;
+typedef struct hexagon_nn_tensordef hexagon_nn_tensordef;
+struct hexagon_nn_tensordef {
+   unsigned int batches;
+   unsigned int height;
+   unsigned int width;
+   unsigned int depth;
+   unsigned char* data;
+   int dataLen;
+   unsigned int data_valid_len;
+   unsigned int unused;
+};
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_config)(void) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_get_dsp_offset)(unsigned int* libhexagon_addr, unsigned int* fastrpc_shell_addr) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_init)(hexagon_nn_nn_id* g) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_set_debug_level)(hexagon_nn_nn_id id, int level) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_snpprint)(hexagon_nn_nn_id id, unsigned char* buf, int bufLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_getlog)(hexagon_nn_nn_id id, unsigned char* buf, int bufLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_append_node)(hexagon_nn_nn_id id, unsigned int node_id, unsigned int operation, hexagon_nn_padding_type padding, const hexagon_nn_input* inputs, int inputsLen, const hexagon_nn_output* outputs, int outputsLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_append_const_node)(hexagon_nn_nn_id id, unsigned int node_id, unsigned int batches, unsigned int height, unsigned int width, unsigned int depth, const unsigned char* data, int dataLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_append_empty_const_node)(hexagon_nn_nn_id id, unsigned int node_id, unsigned int batches, unsigned int height, unsigned int width, unsigned int depth, unsigned int size) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_populate_const_node)(hexagon_nn_nn_id id, unsigned int node_id, const unsigned char* data, int dataLen, unsigned int target_offset) __QAIC_HEADER_ATTRIBUTE;
+typedef struct hexagon_nn_op_node hexagon_nn_op_node;
+struct hexagon_nn_op_node {
+   unsigned int node_id;
+   unsigned int operation;
+   hexagon_nn_padding_type padding;
+   hexagon_nn_input* inputs;
+   int inputsLen;
+   hexagon_nn_output* outputs;
+   int outputsLen;
+};
+typedef struct hexagon_nn_const_node hexagon_nn_const_node;
+struct hexagon_nn_const_node {
+   unsigned int node_id;
+   hexagon_nn_tensordef tensor;
+};
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_append_node_list)(hexagon_nn_nn_id id, const hexagon_nn_op_node* ops, int opsLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_append_const_node_list)(hexagon_nn_nn_id id, const hexagon_nn_const_node* consts, int constsLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_prepare)(hexagon_nn_nn_id id) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_execute)(hexagon_nn_nn_id id, unsigned int batches_in, unsigned int height_in, unsigned int width_in, unsigned int depth_in, const unsigned char* data_in, int data_inLen, unsigned int* batches_out, unsigned int* height_out, unsigned int* width_out, unsigned int* depth_out, unsigned char* data_out, int data_outLen, unsigned int* data_len_out) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_teardown)(hexagon_nn_nn_id id) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_set_powersave_level)(unsigned int level) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_set_powersave_details)(hexagon_nn_corner_type corner, hexagon_nn_dcvs_type dcvs, unsigned int latency) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_get_perfinfo)(hexagon_nn_nn_id id, hexagon_nn_perfinfo* info_out, int info_outLen, unsigned int* n_items) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_reset_perfinfo)(hexagon_nn_nn_id id, unsigned int event) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_last_execution_cycles)(hexagon_nn_nn_id id, unsigned int* cycles_lo, unsigned int* cycles_hi) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_version)(int* ver) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_op_name_to_id)(const char* name, unsigned int* node_id) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_op_id_to_name)(unsigned int node_id, char* name, int nameLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_disable_dcvs)(void) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_GetHexagonBinaryVersion)(int* ver) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_PrintLog)(const unsigned char* buf, int bufLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_execute_new)(hexagon_nn_nn_id id, const hexagon_nn_tensordef* inputs, int inputsLen, hexagon_nn_tensordef* outputs, int outputsLen) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+
+#else  // nnlib version : MACE_USE_NNLIB_CAF
 
 #ifndef __QAIC_HEADER
 #define __QAIC_HEADER(ff) ff
diff --git a/third_party/nnlib/libhexagon_controller_2_1.so b/third_party/nnlib/libhexagon_controller_2_1.so
new file mode 100755
index 0000000000000000000000000000000000000000..3d592e01856d276bbfbcbfd1d768307719fd00ed
GIT binary patch
literal 15708
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
Xr<;X=H|-r6rFXPMh#sVw!PNUVzIZ<T

literal 0
HcmV?d00001

diff --git a/third_party/nnlib/ops.h b/third_party/nnlib/ops.h
index 48318c70..9e919813 100644
--- a/third_party/nnlib/ops.h
+++ b/third_party/nnlib/ops.h
@@ -218,7 +218,231 @@ DEF_OP(QuantizedBiasAdd_8p8to8)
 #undef DEF_OP_WREF
 #endif
 
-#else  // nnlib version
+#elif defined(MACE_USE_NNLIB_2_1)  // nnlib version
+
+DEF_OP(INPUT)
+DEF_OP(OUTPUT)
+DEF_OP(Nop)
+DEF_OP(Const)
+DEF_OP(Check)
+DEF_OP(Close_f)
+DEF_OP(Close_quint8)
+DEF_OP(Close_q_quint8)
+DEF_OP(Close_int32)
+DEF_OP(Close_qint32)
+DEF_OP(PPrint_8)
+DEF_OP(PPrint_32)
+DEF_OP(PPrint_f)
+DEF_OP(PreFree)
+DEF_OP(Flatten)
+
+#ifndef DEF_OP_WREF
+#define DEF_OP_WREF(NAME) DEF_OP(NAME) DEF_OP(NAME##_ref)
+#define __SELF_DEF_OP_WREF
+#endif
+
+DEF_OP_WREF(QuantizedConv2d_8x8to32)
+DEF_OP_WREF(QuantizedMatMul_8x8to32)
+DEF_OP_WREF(QuantizeDownAndShrinkRange_32to8)
+DEF_OP_WREF(QuantizedRelu_8)
+DEF_OP_WREF(QuantizedReluX_8)
+DEF_OP_WREF(QuantizedMaxPool_8)
+DEF_OP_WREF(QuantizedAvgPool_8)
+DEF_OP_WREF(QuantizedL2Pool_8)
+DEF_OP_WREF(QuantizedConcat_8)
+DEF_OP_WREF(QuantizedBiasAdd_8p8to32)
+DEF_OP_WREF(Min_f)
+DEF_OP_WREF(Max_f)
+DEF_OP_WREF(Quantize)
+DEF_OP_WREF(Dequantize)
+DEF_OP_WREF(Supernode_8x8p8to8)
+
+DEF_OP(QuantizedFlatten)
+DEF_OP(Softmax_f)
+DEF_OP(Conv2d_f)
+DEF_OP(MatMul_f)
+DEF_OP(Relu_f)
+DEF_OP(ReluX_f)
+DEF_OP(AvgPool_f)
+DEF_OP(L2Pool_f)
+DEF_OP(MaxPool_f)
+DEF_OP(Concat_f)
+DEF_OP(BiasAdd_f)
+DEF_OP(LRN_f)
+
+DEF_OP(Variable)
+DEF_OP(Assign)
+DEF_OP(Reshape)
+DEF_OP(QuantizedReshape)
+DEF_OP(Tanh_f)
+DEF_OP(Sigmoid_f)
+DEF_OP(Slice_8)
+DEF_OP(Slice_f)
+DEF_OP(QuantizedSlice_8)
+DEF_OP(Add_f)
+DEF_OP(Mul_f)
+DEF_OP(Minimum_f)
+DEF_OP(Maximum_f)
+
+DEF_OP_WREF(Requantize_32to8)
+DEF_OP_WREF(RequantizationRange_32)
+
+DEF_OP(Neg_f)
+DEF_OP(Sub_f)
+DEF_OP(AddN_f)
+DEF_OP(Range_int32)
+DEF_OP(Rank_int32)
+DEF_OP(Transpose_int32)
+DEF_OP(Transpose_f)
+DEF_OP(InstanceNorm_f)
+DEF_OP_WREF(QuantizedInstanceNorm_8)
+DEF_OP(Sub_int32)
+DEF_OP(Add_int32)
+DEF_OP(Split_f)
+DEF_OP(Dequantize_qint32_f)
+DEF_OP(PRelu_f)
+DEF_OP_WREF(QuantizedPRelu_8)
+DEF_OP(Sum_f)
+DEF_OP(Prod_f)
+DEF_OP(Mul_int32)
+DEF_OP(LogicalAnd_int32)
+DEF_OP(LogicalOr_int32)
+DEF_OP(LogicalXor_int32)
+DEF_OP(Shape_int32)
+DEF_OP(Pack_int32)
+DEF_OP(MirrorPad_f)
+DEF_OP(ResizeNearestNeighbor_f)
+DEF_OP(StridedSlice_int32)
+DEF_OP(StridedSlice_f)
+DEF_OP(ExpandDims_int32)
+DEF_OP(ExpandDims_f)
+
+DEF_OP(LogSoftmax_f)
+DEF_OP(Split_int32)
+DEF_OP(QuantizedSplit_8)
+
+DEF_OP(Deconv_f)
+DEF_OP_WREF(QuantizedDeconv_8x8to32)
+
+DEF_OP_WREF(QuantizedMul_8x8to32)
+DEF_OP_WREF(QuantizedAdd_8p8to32)
+DEF_OP_WREF(QuantizedSigmoid_8)
+DEF_OP_WREF(QuantizedTanh_8)
+DEF_OP_WREF(QuantizedSoftmax_8)
+DEF_OP_WREF(QuantizedLRN_8)
+DEF_OP_WREF(Quantizedpad2d_frame_8p)
+DEF_OP_WREF(QuantizedSub_8p8to32)
+DEF_OP_WREF(QuantizedMaximum_8)
+DEF_OP_WREF(QuantizedMinimum_8)
+
+DEF_OP(Pad_f)
+DEF_OP(SpaceToBatchND_f)
+DEF_OP(BatchToSpaceND_f)
+DEF_OP(QuantizedPad_8)
+DEF_OP(ResizeBilinear_f)
+DEF_OP(ConcatV2_f)
+DEF_OP(ConcatV2_int32)
+DEF_OP(Prod_int32)
+DEF_OP(Slice_int32)
+
+DEF_OP(QuantizedAdd_8p8to8)
+DEF_OP(QuantizedResizeBilinear_8)
+DEF_OP(Supernode_8x8p8to8_d32)
+DEF_OP(Convert_to_d32)
+DEF_OP(Convert_from_d32)
+DEF_OP_WREF(QuantizedMaxPool_8_d32)
+DEF_OP_WREF(QuantizedConcat_8_d32)
+DEF_OP_WREF(QuantizedAvgPool_8_d32)
+
+DEF_OP(Sink)
+
+DEF_OP_WREF(QuantizedPRelu_8_d32)
+DEF_OP_WREF(AutoQuantize)
+DEF_OP_WREF(QuantizedDepthwiseConv2d_8x8to32)
+DEF_OP_WREF(DepthwiseConv2d_f)
+DEF_OP(DepthwiseSupernode_8x8p8to8)
+DEF_OP(DepthwiseSupernode_8x8p8to8_d32)
+
+DEF_OP_WREF(QuantizedMul_8x8to8_d32)
+
+DEF_OP(FullyConnected_u8)
+#if 0
+DEF_OP_WREF(QuantizedFC_8x8p8to8)
+#endif
+
+DEF_OP_WREF(QuantizedAdd_8p8to8_d32)
+
+DEF_OP_WREF(QuantizedClamp_8)
+DEF_OP(Clamp_f)
+DEF_OP(QuantizeForTest_d32)
+DEF_OP(Close_d32)
+DEF_OP_WREF(QuantizedSub_8p8to8_d32)
+
+DEF_OP(InputSupernode_8x8p8to8_outd32)
+DEF_OP(QuantizedLRN_8_d32)
+DEF_OP_WREF(QuantizedBiasAdd_32p32to32)
+DEF_OP_WREF(Quantize_int32)
+
+DEF_OP(Supernode_8x8p32to8)
+DEF_OP(DepthwiseSupernode_8x8p32to8)
+DEF_OP(Supernode_8x8p32to8_d32)
+DEF_OP(DepthwiseSupernode_8x8p32to8_d32)
+DEF_OP(InputSupernode_8x8p32to8_outd32)
+
+DEF_OP(PPrint_8_d32)
+DEF_OP(PPrintWithPadding_8_d32)
+DEF_OP_WREF(AutoQuantize_d32)
+
+DEF_OP_WREF(QuantizedTanh_8_d32)
+DEF_OP_WREF(QuantizedSigmoid_8_d32)
+DEF_OP_WREF(QuantizedSoftmax_8_d32)
+
+
+DEF_OP_WREF(QuantizedL2Pool_8_d32)
+
+DEF_OP(Gather_f)
+DEF_OP(Gather_int32)
+DEF_OP(Gather_8)
+DEF_OP(Table_f)
+DEF_OP(Table_int32)
+DEF_OP(Table_8)
+
+DEF_OP(FillPadding_8_d32)
+DEF_OP(QuantizedResizeBilinear_8_d32)
+
+DEF_OP(QuantizeINPUT_f_to_8)
+DEF_OP_WREF(DeconvBias_8x8to32)
+
+DEF_OP(SpaceToBatchND_8)
+DEF_OP(BatchToSpaceND_8)
+
+
+DEF_OP(SpaceToDepth_f)
+DEF_OP(DepthToSpace_f)
+DEF_OP(SpaceToDepth_8)
+DEF_OP(DepthToSpace_8)
+
+DEF_OP(DequantizeOUTPUT_8tof)
+DEF_OP(QuantizedBatchNorm_8x8p8to8)
+DEF_OP(QuantizedBatchNorm_8x8p32to8)
+DEF_OP(QuantizedBatchNorm_8x8p8to8_d32)
+DEF_OP(QuantizedBatchNorm_8x8p32to8_d32)
+
+DEF_OP_WREF(QuantizedInstanceNorm_8_d32)
+DEF_OP_WREF(QuantizedInstanceNormBG_8)
+DEF_OP_WREF(QuantizedInstanceNormBG_8_d32)
+
+
+DEF_OP(ChannelShuffle_f)
+DEF_OP(ChannelShuffle_int32)
+DEF_OP(QuantizedChannelShuffle_8)
+
+#ifdef __SELF_DEF_OP_WREF
+#undef __SELF_DEF_OP_WREF
+#undef DEF_OP_WREF
+#endif
+
+#else  // nnlib version : MACE_USE_NNLIB_CAF
 
 DEF_OP(INPUT)
 DEF_OP(OUTPUT)
diff --git a/tools/bazel.rc b/tools/bazel.rc
index 22357b79..56229da7 100644
--- a/tools/bazel.rc
+++ b/tools/bazel.rc
@@ -10,6 +10,7 @@ build --copt=-std=c++11
 build --copt=-D_GLIBCXX_USE_C99_MATH_TR1
 build --copt=-DMACE_OBFUSCATE_LITERALS
 build --copt=-DGEMMLOWP_USE_OPENMP
+build --copt=-DMACE_USE_NNLIB_CAF
 
 # Usage example: bazel build --config android
 build:android --crosstool_top=//external:android/crosstool
-- 
GitLab