From 7e0396572d23926bc1a9747ad409db6465a87f5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E5=AF=85?= Date: Sat, 24 Feb 2018 19:02:31 +0800 Subject: [PATCH] Fast rpc client --- .../hexagon/hexagon_control_wrapper.cc | 243 ++++++++++++------ .../hexagon/hexagon_controller_dummy.cc | 2 + mace/core/runtime/hexagon/hexagon_nn.h | 71 +++-- mace/core/runtime/hexagon/hexagon_nn_ops.h | 48 ++++ .../runtime/hexagon/libhexagon_controller.so | Bin 16348 -> 16464 bytes mace/core/runtime/hexagon/ops.h | 181 +++++++++++++ mace/core/tensor.h | 2 +- 7 files changed, 437 insertions(+), 110 deletions(-) create mode 100644 mace/core/runtime/hexagon/hexagon_nn_ops.h create mode 100644 mace/core/runtime/hexagon/ops.h diff --git a/mace/core/runtime/hexagon/hexagon_control_wrapper.cc b/mace/core/runtime/hexagon/hexagon_control_wrapper.cc index eab3a902..61fa9715 100644 --- a/mace/core/runtime/hexagon/hexagon_control_wrapper.cc +++ b/mace/core/runtime/hexagon/hexagon_control_wrapper.cc @@ -3,8 +3,17 @@ // #include "mace/core/runtime/hexagon/hexagon_control_wrapper.h" -#include -#include +#include "mace/core/runtime/hexagon/hexagon_nn_ops.h" +#include +#include + +namespace { + inline int64_t NowMicros() { + struct timeval tv; + gettimeofday(&tv, nullptr); + return static_cast(tv.tv_sec) * 1000000 + tv.tv_usec; + } +} namespace mace { @@ -20,7 +29,7 @@ enum { int HexagonControlWrapper::GetVersion() { int version; - hexagon_nn_version(&version); + MACE_CHECK(hexagon_nn_version(&version) == 0, "get version error"); return version; } @@ -44,75 +53,121 @@ bool HexagonControlWrapper::Finalize() { return hexagon_controller_DeInitHexagon() == 0; } -bool HexagonControlWrapper::SetupGraph(const NetDef& net_def) { +bool HexagonControlWrapper::SetupGraph(const NetDef &net_def) { LOG(INFO) << "Hexagon setup graph"; + + int64_t t0 = NowMicros(); + // const node - for (const ConstTensor& tensor_proto: net_def.tensors()) { - vector tensor_shape(tensor_proto.dims().begin(), - tensor_proto.dims().end()); - while (tensor_shape.size() < 4) { - tensor_shape.insert(tensor_shape.begin(), 1); - } + std::thread const_thread([&]() { + std::cout << "thread function\n"; + vector const_node_list; + for (const ConstTensor &tensor_proto: net_def.tensors()) { + vector tensor_shape(tensor_proto.dims().begin(), + tensor_proto.dims().end()); + while (tensor_shape.size() < 4) { + tensor_shape.insert(tensor_shape.begin(), 1); + } - if (tensor_proto.data_type() == DataType::DT_INT32 - && tensor_proto.data_size() == 0) { - hexagon_nn_append_const_node(nn_id_, node_id(tensor_proto.node_id()), - tensor_shape[0], tensor_shape[1], - tensor_shape[2], tensor_shape[3], - NULL, - 0); - } else { - unique_ptr tensor = serializer_.Deserialize(tensor_proto, - DeviceType::CPU); - hexagon_nn_append_const_node(nn_id_, node_id(tensor_proto.node_id()), - tensor_shape[0], tensor_shape[1], - tensor_shape[2], tensor_shape[3], - reinterpret_cast( - tensor->raw_data()), - tensor->raw_size()); + hexagon_nn_const_node const_node; + const_node.node_id = node_id(tensor_proto.node_id()); + const_node.tensor.batches = tensor_shape[0]; + const_node.tensor.height = tensor_shape[1]; + const_node.tensor.width = tensor_shape[2]; + const_node.tensor.depth = tensor_shape[3]; + + if (tensor_proto.data_type() == DataType::DT_INT32 + && tensor_proto.data_size() == 0) { + const_node.tensor.data = NULL; + const_node.tensor.dataLen = 0; + } else { + const_node.tensor.data = + const_cast(tensor_proto.data()); + const_node.tensor.dataLen = + tensor_proto.data_size() * GetEnumTypeSize(tensor_proto.data_type()); + } + const_node_list.push_back(const_node); + // 255 is magic number: why fastrpc limits sequence length to that? + if (const_node_list.size() >= 250) { + MACE_CHECK(hexagon_nn_append_const_node_list(nn_id_, + const_node_list.data(), + const_node_list.size()) + == 0, "append const node error"); + const_node_list.clear(); + } } - VLOG(1) << "Const: " << tensor_proto.name() - << ", node_id: " << node_id(tensor_proto.node_id()) - << "\n\t shape: " << tensor_shape[0] << " " << tensor_shape[1] - << " " << tensor_shape[2] << " " << tensor_shape[3]; - } - // op node - for (const OperatorDef& op: net_def.op()) { - unsigned int op_id; - MACE_CHECK(hexagon_nn_op_name_to_id(op.type().data(), &op_id) == 0, - "invalid op: ", op.name(), ", type: ", op.type()); - vector inputs(op.node_input().size()); - for (size_t i = 0; i < op.node_input().size(); ++i) { - inputs[i].src_id = node_id(op.node_input()[i].node_id()); - inputs[i].output_idx = op.node_input()[i].output_port(); + if (!const_node_list.empty()) { + MACE_CHECK(hexagon_nn_append_const_node_list(nn_id_, + const_node_list.data(), + const_node_list.size()) == 0, + "append const node error"); } - vector outputs(op.out_max_byte_size().size()); - for (size_t i = 0; i < op.out_max_byte_size().size(); ++i) { - outputs[i].max_size = op.out_max_byte_size()[i]; - } - - hexagon_nn_padding_type padding_type = static_cast( - op.padding()); - - hexagon_nn_append_node(nn_id_, node_id(op.node_id()), op_id, padding_type, - inputs.data(), inputs.size(), - outputs.data(), outputs.size()); + const_node_list.clear(); + }); - if (VLOG_IS_ON(1)) { - VLOG(1) << "Op: " << op.name() - << ", type: " << op.type() - << ", node_id: " << node_id(op.node_id()) - << ", padding_type: " << padding_type; - - for (const auto &input: inputs) { - VLOG(1) << "\t input: " << input.src_id << ":" << input.output_idx; + // op node + std::thread op_thread([&]() { + OpMap op_map; + op_map.Init(); + vector op_node_list; + vector> cached_inputs; + vector> cached_outputs; + vector inputs; + vector outputs; + + for (const OperatorDef &op: net_def.op()) { + int op_id = op_map.GetOpId(op.type()); + inputs.resize(op.node_input().size()); + for (size_t i = 0; i < op.node_input().size(); ++i) { + inputs[i].src_id = node_id(op.node_input()[i].node_id()); + inputs[i].output_idx = op.node_input()[i].output_port(); + } + outputs.resize(op.out_max_byte_size().size()); + for (size_t i = 0; i < op.out_max_byte_size().size(); ++i) { + outputs[i].max_size = op.out_max_byte_size()[i]; } - for (const auto &output: outputs) { - VLOG(1) << "\t output: " << output.max_size; + cached_inputs.push_back(inputs); + cached_outputs.push_back(outputs); + + hexagon_nn_padding_type + padding_type = static_cast( + op.padding()); + + hexagon_nn_op_node op_node; + op_node.node_id = node_id(op.node_id()); + op_node.operation = op_id; + op_node.padding = padding_type; + op_node.inputs = cached_inputs.back().data(); + op_node.inputsLen = inputs.size(); + op_node.outputs = cached_outputs.back().data(); + op_node.outputsLen = outputs.size(); + + op_node_list.push_back(op_node); + if (op_node_list.size() >= 125) { + MACE_CHECK(hexagon_nn_append_node_list(nn_id_, + op_node_list.data(), + op_node_list.size()) == 0, + "append node error"); + op_node_list.clear(); + cached_inputs.clear(); + cached_outputs.clear(); } } - } + + if (!op_node_list.empty()) { + MACE_CHECK(hexagon_nn_append_node_list(nn_id_, + op_node_list.data(), + op_node_list.size()) == 0, + "append node error"); + } + op_node_list.clear(); + cached_inputs.clear(); + cached_outputs.clear(); + }); + + const_thread.join(); + op_thread.join(); // input info num_inputs_ = 0; @@ -146,7 +201,15 @@ bool HexagonControlWrapper::SetupGraph(const NetDef& net_def) { << "\n\t type: " << output_info.data_type(); } - return hexagon_nn_prepare(nn_id_) == 0; + int64_t t1 = NowMicros(); + + int res = hexagon_nn_prepare(nn_id_); + + int64_t t2 = NowMicros(); + + VLOG(0) << "Setup time: " << t1 - t0 << " " << t2 - t1; + + return res == 0; } bool HexagonControlWrapper::TeardownGraph() { @@ -159,35 +222,42 @@ bool HexagonControlWrapper::TeardownGraph() { void HexagonControlWrapper::PrintLog() { char *buf; if ((buf = new char[PRINT_BUFSIZE]) == NULL) return; - hexagon_nn_getlog(nn_id_, reinterpret_cast(buf), PRINT_BUFSIZE); + MACE_CHECK(hexagon_nn_getlog(nn_id_, + reinterpret_cast(buf), + PRINT_BUFSIZE) == 0, "print log error"); LOG(INFO) << string(buf); - delete []buf; + delete[]buf; } void HexagonControlWrapper::PrintGraph() { LOG(INFO) << "Print Graph"; char *buf; if ((buf = new char[PRINT_BUFSIZE]) == NULL) return; - hexagon_nn_snpprint(nn_id_, reinterpret_cast(buf), PRINT_BUFSIZE); + MACE_CHECK(hexagon_nn_snpprint(nn_id_, + reinterpret_cast(buf), + PRINT_BUFSIZE) == 0, "print graph error"); LOG(INFO) << string(buf); - delete []buf; + delete[]buf; } void HexagonControlWrapper::SetDebugLevel(int level) { LOG(INFO) << "Set debug level: " << level; - hexagon_nn_set_debug_level(nn_id_, level); + MACE_CHECK(hexagon_nn_set_debug_level(nn_id_, level) == 0, + "set debug level error"); } void HexagonControlWrapper::SetGraphMode(int mode) { LOG(INFO) << "Set dsp mode: " << mode; - hexagon_nn_set_graph_mode(nn_id_, mode); + MACE_CHECK(hexagon_nn_set_graph_mode(nn_id_, mode) == 0, "set mode error"); } void HexagonControlWrapper::GetPerfInfo() { LOG(INFO) << "Get perf info"; vector perf_info(MAX_NODE); unsigned int n_items = 0; - hexagon_nn_get_perfinfo(nn_id_, perf_info.data(), MAX_NODE, &n_items); + MACE_CHECK( + hexagon_nn_get_perfinfo(nn_id_, perf_info.data(), MAX_NODE, &n_items) == 0, + "get perf info error"); std::unordered_map node_id_counters; std::unordered_map> node_type_counters; @@ -197,8 +267,9 @@ void HexagonControlWrapper::GetPerfInfo() { for (int i = 0; i < n_items; ++i) { unsigned int node_id = perf_info[i].node_id; unsigned int node_type_id = perf_info[i].node_type; - node_id_counters[node_id] = ((static_cast(perf_info[i].counter_hi) << 32) - + perf_info[i].counter_lo) * 1.0f / perf_info[i].executions; + node_id_counters[node_id] = + ((static_cast(perf_info[i].counter_hi) << 32) + + perf_info[i].counter_lo) * 1.0f / perf_info[i].executions; char node_type_buf[MAX_NODE]; hexagon_nn_op_id_to_name(node_type_id, node_type_buf, MAX_NODE); @@ -216,7 +287,7 @@ void HexagonControlWrapper::GetPerfInfo() { total_duration += node_id_counters[node_id]; } - for (auto& node_type_counter: node_type_counters) { + for (auto &node_type_counter: node_type_counters) { LOG(INFO) << "node type: " << node_type_counter.first << ", time: " << node_type_counter.second.first << ", duration: " << node_type_counter.second.second; @@ -226,12 +297,13 @@ void HexagonControlWrapper::GetPerfInfo() { void HexagonControlWrapper::ResetPerfInfo() { LOG(INFO) << "Reset perf info"; - hexagon_nn_reset_perfinfo(nn_id_, NN_GRAPH_PERFEVENT_UTIME); + MACE_CHECK(hexagon_nn_reset_perfinfo(nn_id_, NN_GRAPH_PERFEVENT_UTIME) == 0, + "reset perf error"); } bool HexagonControlWrapper::ExecuteGraph(const Tensor &input_tensor, Tensor *output_tensor) { - LOG(INFO) << "Execute graph: " << nn_id_; + VLOG(2) << "Execute graph: " << nn_id_; // single input and single output MACE_ASSERT(num_inputs_ == 1, "Wrong inputs num"); MACE_ASSERT(num_outputs_ == 1, "Wrong outputs num"); @@ -255,6 +327,7 @@ bool HexagonControlWrapper::ExecuteGraph(const Tensor &input_tensor, output_tensor->raw_mutable_data()), output_tensor->raw_size(), &output_bytes); + MACE_CHECK(res == 0, "execute error"); MACE_ASSERT(output_shape == output_shapes_[0], "wrong output shape inferred"); @@ -299,16 +372,16 @@ bool HexagonControlWrapper::ExecuteGraphNew(const vector &input_tensors, outputs, num_outputs); for (int i = 0; i < num_outputs; ++i) { - vector output_shape {outputs[i].batches, outputs[i].height, - outputs[i].width, outputs[i].depth}; - MACE_ASSERT(output_shape == output_shapes_[i], + vector output_shape{outputs[i].batches, outputs[i].height, + outputs[i].width, outputs[i].depth}; + MACE_ASSERT(output_shape == output_shapes_[i], "wrong output shape inferred"); MACE_ASSERT(outputs[i].data_valid_len == (*output_tensors)[i].raw_size(), "wrong output bytes inferred."); } - delete [] inputs; - delete [] outputs; + delete[] inputs; + delete[] outputs; return res == 0; }; @@ -323,7 +396,10 @@ bool HexagonControlWrapper::ExecuteGraphPreQuantize(const Tensor &input_tensor, float *min_in_data = input_tensors[1].mutable_data(); input_tensors[2].Resize({1, 1, 1, 1}); float *max_in_data = input_tensors[2].mutable_data(); - quantizer_.Quantize(input_tensor, &input_tensors[0], min_in_data, max_in_data); + quantizer_.Quantize(input_tensor, + &input_tensors[0], + min_in_data, + max_in_data); if (!ExecuteGraphNew(input_tensors, &output_tensors)) { return false; } @@ -332,7 +408,10 @@ bool HexagonControlWrapper::ExecuteGraphPreQuantize(const Tensor &input_tensor, const float *min_out_data = output_tensors[1].data(); const float *max_out_data = output_tensors[2].data(); - quantizer_.DeQuantize(output_tensors[0], *min_out_data, *max_out_data, output_tensor); + quantizer_.DeQuantize(output_tensors[0], + *min_out_data, + *max_out_data, + output_tensor); return true; } diff --git a/mace/core/runtime/hexagon/hexagon_controller_dummy.cc b/mace/core/runtime/hexagon/hexagon_controller_dummy.cc index 94eb7fe9..fdc62ede 100644 --- a/mace/core/runtime/hexagon/hexagon_controller_dummy.cc +++ b/mace/core/runtime/hexagon/hexagon_controller_dummy.cc @@ -21,7 +21,9 @@ __QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_set_graph_mode)(hexagon_nn_nn_ __QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_snpprint)(hexagon_nn_nn_id id, unsigned char* buf, int bufLen) __QAIC_HEADER_ATTRIBUTE { return 0; } __QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_getlog)(hexagon_nn_nn_id id, unsigned char* buf, int bufLen) __QAIC_HEADER_ATTRIBUTE { return 0; } __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 { return 0; } +__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 { return 0; } __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 { return 0; } +__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 { return 0; } __QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_prepare)(hexagon_nn_nn_id id) __QAIC_HEADER_ATTRIBUTE { return 0; } __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 { return 0; } __QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_teardown)(hexagon_nn_nn_id id) __QAIC_HEADER_ATTRIBUTE { return 0; } diff --git a/mace/core/runtime/hexagon/hexagon_nn.h b/mace/core/runtime/hexagon/hexagon_nn.h index b2190344..3bfd79c0 100644 --- a/mace/core/runtime/hexagon/hexagon_nn.h +++ b/mace/core/runtime/hexagon/hexagon_nn.h @@ -30,51 +30,66 @@ extern "C" { #define __QAIC_STRING1_OBJECT_DEFINED__ #define __STRING1_OBJECT__ typedef struct _cstring1_s { - char* data; - int dataLen; + 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; + unsigned int src_id; + unsigned int output_idx; }; typedef struct hexagon_nn_output hexagon_nn_output; struct hexagon_nn_output { - unsigned int max_size; - unsigned int unused; + unsigned int max_size; + unsigned int unused; }; 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; + 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 + 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; 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; + 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; +}; +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_config)(void) __QAIC_HEADER_ATTRIBUTE; __QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_init)(void) __QAIC_HEADER_ATTRIBUTE; @@ -83,7 +98,9 @@ __QAIC_HEADER_EXPORT int __QAIC_HEADER(hexagon_nn_set_graph_mode)(hexagon_nn_nn_ __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_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)(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_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; diff --git a/mace/core/runtime/hexagon/hexagon_nn_ops.h b/mace/core/runtime/hexagon/hexagon_nn_ops.h new file mode 100644 index 00000000..dfb3b386 --- /dev/null +++ b/mace/core/runtime/hexagon/hexagon_nn_ops.h @@ -0,0 +1,48 @@ +// +// Copyright (c) 2018 XiaoMi All rights reserved. +// + +#ifndef LIBMACE_HEXAGON_NN_OPS_H +#define LIBMACE_HEXAGON_NN_OPS_H + +#include "mace/utils/logging.h" +#include + +namespace mace { + +#define OP_INVALID -1 + +typedef enum op_type_enum { +#define DEF_OP(NAME, ...) OP_##NAME, + +#include "mace/core/runtime/hexagon/ops.h" + NN_OPS_MAX + +#undef DEF_OP +} op_type; + +class OpMap { + public: + void Init() { +#define DEF_OP(NAME) \ + op_map_[#NAME] = OP_##NAME; + +#include "mace/core/runtime/hexagon/ops.h" + +#undef DEF_OP + } + + int GetOpId(const std::string &op_type) { + if (op_map_.find(op_type) != end(op_map_)) { + return op_map_[op_type]; + } else { + LOG(ERROR) << "DSP unsupoorted op type: " << op_type; + return OP_INVALID; + } + } + private: + std::unordered_map op_map_; +}; +} // namespace mace + +#endif // LIBMACE_HEXAGON_NN_OPS_H diff --git a/mace/core/runtime/hexagon/libhexagon_controller.so b/mace/core/runtime/hexagon/libhexagon_controller.so index 9ee02ba7d5993fec5db466c7675ed8e1e9951d78..42dbfabb2cb90dfdcff463f4d46cac981de0dacf 100755 GIT binary patch literal 16464 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 literal 16348 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 WWM&AI_FjbFuJ;9W$RU}?ruV-RiGmCO diff --git a/mace/core/runtime/hexagon/ops.h b/mace/core/runtime/hexagon/ops.h new file mode 100644 index 00000000..79b503cd --- /dev/null +++ b/mace/core/runtime/hexagon/ops.h @@ -0,0 +1,181 @@ +/* + * You probably want to + * + * ## ##### ##### + * # # # # # # + * # # # # # # + * ###### # # # # + * # # # # # # + * # # ##### ##### + * + * + * # # #### ##### ###### #### + * ## # # # # # # # + * # # # # # # # ##### #### + * # # # # # # # # # + * # ## # # # # # # # + * # # #### ##### ###### #### + * + * + * ## ##### + * # # # + * # # # + * ###### # + * # # # + * # # # + * + * + * ##### # # ###### + * # # # # + * # ###### ##### + * # # # # + * # # # # + * # # # ###### + * + * + * ###### # # ##### + * # ## # # # + * ##### # # # # # + * # # # # # # + * # # ## # # + * ###### # # ##### + * + * otherwise the interface becomes incompatible. + */ +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(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(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(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(QuantizedSpaceToBatchND_8) +DEF_OP(QuantizedBatchToSpaceND_8) +DEF_OP(QuantizedPad_8) +DEF_OP(ResizeBilinear_f) +DEF_OP(QuantizedResizeBilinear_8) +DEF_OP(ConcatV2_f) +DEF_OP(ConcatV2_int32) +DEF_OP(Prod_int32) +DEF_OP(Slice_int32) + +DEF_OP(QuantizedAdd_8p8to8) + +DEF_OP_WREF(AutoQuantize) +DEF_OP_WREF(QuantizedDepthwiseConv2d_8x8to32) +DEF_OP(DepthwiseConv2d_f) +DEF_OP(QuantizedBiasAdd_8p8to8) + +#ifdef __SELF_DEF_OP_WREF +#undef __SELF_DEF_OP_WREF +#undef DEF_OP_WREF +#endif + diff --git a/mace/core/tensor.h b/mace/core/tensor.h index c3511564..d3014e8b 100644 --- a/mace/core/tensor.h +++ b/mace/core/tensor.h @@ -298,7 +298,7 @@ class Tensor { return type_size; } - inline void Copy(Tensor &other) { + inline void Copy(const Tensor &other) { alloc_ = other.alloc_; dtype_ = other.dtype_; ResizeLike(other); -- GitLab