diff --git a/mace/core/arg_helper.cc b/mace/core/arg_helper.cc index 9cf40d93a0d682c8a6dd04e90e869dd8514a127b..6fd9b63c752bed0a3bb0e44c0322588dcafd1d34 100644 --- a/mace/core/arg_helper.cc +++ b/mace/core/arg_helper.cc @@ -126,7 +126,6 @@ INSTANTIATE_GET_REPEATED_ARGUMENT(int64_t, ints, true) INSTANTIATE_GET_REPEATED_ARGUMENT(uint8_t, ints, true) INSTANTIATE_GET_REPEATED_ARGUMENT(uint16_t, ints, true) INSTANTIATE_GET_REPEATED_ARGUMENT(size_t, ints, true) -INSTANTIATE_GET_REPEATED_ARGUMENT(std::string, strings, false) #undef INSTANTIATE_GET_REPEATED_ARGUMENT } // namespace mace diff --git a/mace/core/runtime/opencl/opencl_allocator.cc b/mace/core/runtime/opencl/opencl_allocator.cc index 96b083cfcbd0fe9b5fea8cbd2862a69e0700fec5..a110ed19f30a55ac8bf43662d40da846a5d2cc9b 100644 --- a/mace/core/runtime/opencl/opencl_allocator.cc +++ b/mace/core/runtime/opencl/opencl_allocator.cc @@ -26,13 +26,9 @@ static cl_channel_type DataTypeToCLChannelType(const DataType t) { return CL_HALF_FLOAT; case DT_FLOAT: return CL_FLOAT; - case DT_INT8: - case DT_INT16: case DT_INT32: return CL_SIGNED_INT32; case DT_UINT8: - case DT_UINT16: - case DT_UINT32: return CL_UNSIGNED_INT32; default: LOG(FATAL) << "Image doesn't support the data type: " << t; diff --git a/mace/core/tensor.h b/mace/core/tensor.h index 1404bf023b6d35351cec21c2e5385cae1366bd74..a97800c20cd912fbbe1a60c6227428af9ba255ff 100644 --- a/mace/core/tensor.h +++ b/mace/core/tensor.h @@ -37,60 +37,49 @@ namespace mace { -#define SINGLE_ARG(...) __VA_ARGS__ -#define CASE(TYPE, STMTS) \ +#define MACE_SINGLE_ARG(...) __VA_ARGS__ +#define MACE_CASE(TYPE, STATEMENTS) \ case DataTypeToEnum::value: { \ typedef TYPE T; \ - STMTS; \ + STATEMENTS; \ break; \ } #ifdef MACE_ENABLE_OPENCL -#define CASES_WITH_DEFAULT(TYPE_ENUM, STMTS, INVALID, DEFAULT) \ - switch (TYPE_ENUM) { \ - CASE(half, SINGLE_ARG(STMTS)) \ - CASE(float, SINGLE_ARG(STMTS)) \ - CASE(double, SINGLE_ARG(STMTS)) \ - CASE(int32_t, SINGLE_ARG(STMTS)) \ - CASE(uint8_t, SINGLE_ARG(STMTS)) \ - CASE(uint16_t, SINGLE_ARG(STMTS)) \ - CASE(int16_t, SINGLE_ARG(STMTS)) \ - CASE(int8_t, SINGLE_ARG(STMTS)) \ - CASE(std::string, SINGLE_ARG(STMTS)) \ - CASE(int64_t, SINGLE_ARG(STMTS)) \ - CASE(bool, SINGLE_ARG(STMTS)) \ - case DT_INVALID: \ - INVALID; \ - break; \ - default: \ - DEFAULT; \ - break; \ +#define MACE_TYPE_ENUM_SWITCH( \ + TYPE_ENUM, STATEMENTS, INVALID_STATEMENTS, DEFAULT_STATEMENTS) \ + switch (TYPE_ENUM) { \ + MACE_CASE(half, MACE_SINGLE_ARG(STATEMENTS)) \ + MACE_CASE(float, MACE_SINGLE_ARG(STATEMENTS)) \ + MACE_CASE(uint8_t, MACE_SINGLE_ARG(STATEMENTS)) \ + MACE_CASE(int32_t, MACE_SINGLE_ARG(STATEMENTS)) \ + case DT_INVALID: \ + INVALID_STATEMENTS; \ + break; \ + default: \ + DEFAULT_STATEMENTS; \ + break; \ } #else -#define CASES_WITH_DEFAULT(TYPE_ENUM, STMTS, INVALID, DEFAULT) \ - switch (TYPE_ENUM) { \ - CASE(float, SINGLE_ARG(STMTS)) \ - CASE(double, SINGLE_ARG(STMTS)) \ - CASE(int32_t, SINGLE_ARG(STMTS)) \ - CASE(uint8_t, SINGLE_ARG(STMTS)) \ - CASE(uint16_t, SINGLE_ARG(STMTS)) \ - CASE(int16_t, SINGLE_ARG(STMTS)) \ - CASE(int8_t, SINGLE_ARG(STMTS)) \ - CASE(std::string, SINGLE_ARG(STMTS)) \ - CASE(int64_t, SINGLE_ARG(STMTS)) \ - CASE(bool, SINGLE_ARG(STMTS)) \ - case DT_INVALID: \ - INVALID; \ - break; \ - default: \ - DEFAULT; \ - break; \ +#define MACE_TYPE_ENUM_SWITCH( \ + TYPE_ENUM, STATEMENTS, INVALID_STATEMENTS, DEFAULT_STATEMENTS) \ + switch (TYPE_ENUM) { \ + MACE_CASE(float, MACE_SINGLE_ARG(STATEMENTS)) \ + MACE_CASE(uint8_t, MACE_SINGLE_ARG(STATEMENTS)) \ + MACE_CASE(int32_t, MACE_SINGLE_ARG(STATEMENTS)) \ + case DT_INVALID: \ + INVALID_STATEMENTS; \ + break; \ + default: \ + DEFAULT_STATEMENTS; \ + break; \ } #endif -#define CASES(TYPE_ENUM, STMTS) \ - CASES_WITH_DEFAULT(TYPE_ENUM, STMTS, LOG(FATAL) << "Type not set"; \ - , LOG(FATAL) << "Unexpected type: " << TYPE_ENUM;) +// `TYPE_ENUM` will be converted to template `T` in `STATEMENTS` +#define MACE_RUN_WITH_TYPE_ENUM(TYPE_ENUM, STATEMENTS) \ + MACE_TYPE_ENUM_SWITCH(TYPE_ENUM, STATEMENTS, LOG(FATAL) << "Invalid type"; \ + , LOG(FATAL) << "Unknown type: " << TYPE_ENUM;) namespace numerical_chars { inline std::ostream &operator<<(std::ostream &os, char c) { @@ -307,7 +296,7 @@ class Tensor { inline size_t SizeOfType() const { size_t type_size = 0; - CASES(dtype_, type_size = sizeof(T)); + MACE_RUN_WITH_TYPE_ENUM(dtype_, type_size = sizeof(T)); return type_size; } @@ -328,7 +317,7 @@ class Tensor { if (i != 0 && i % shape_.back() == 0) { os << "\n"; } - CASES(dtype_, (os << (this->data()[i]) << ", ")); + MACE_RUN_WITH_TYPE_ENUM(dtype_, (os << (this->data()[i]) << ", ")); } LOG(INFO) << os.str(); } diff --git a/mace/core/types.cc b/mace/core/types.cc index 44fd1d9271c1e5e62d94a7ff2de10e5322568124..05b6acb3c5af3072c774f6620b6d4f9077a72b8b 100644 --- a/mace/core/types.cc +++ b/mace/core/types.cc @@ -23,15 +23,8 @@ namespace mace { bool DataTypeCanUseMemcpy(DataType dt) { switch (dt) { case DT_FLOAT: - case DT_DOUBLE: - case DT_INT32: - case DT_INT64: - case DT_UINT32: - case DT_UINT16: case DT_UINT8: - case DT_INT16: - case DT_INT8: - case DT_BOOL: + case DT_INT32: return true; default: return false; @@ -44,15 +37,8 @@ std::string DataTypeToString(const DataType dt) { #ifdef MACE_ENABLE_OPENCL {DT_HALF, "DT_HALF"}, #endif - {DT_DOUBLE, "DT_DOUBLE"}, {DT_UINT8, "DT_UINT8"}, - {DT_INT8, "DT_INT8"}, - {DT_INT32, "DT_INT32"}, - {DT_UINT32, "DT_UINT32"}, - {DT_UINT16, "DT_UINT16"}, - {DT_INT64, "DT_INT64"}, - {DT_BOOL, "DT_BOOL"}, - {DT_STRING, "DT_STRING"}}; + {DT_INT32, "DT_UINT32"}}; MACE_CHECK(dt != DT_INVALID) << "Not support Invalid data type"; return dtype_string_map[dt]; } @@ -67,22 +53,10 @@ size_t GetEnumTypeSize(const DataType dt) { #endif case DT_UINT8: return sizeof(uint8_t); - case DT_INT8: - return sizeof(int8_t); - case DT_DOUBLE: - return sizeof(double); case DT_INT32: - return sizeof(int32_t); - case DT_UINT32: return sizeof(uint32_t); - case DT_UINT16: - return sizeof(uint16_t); - case DT_INT16: - return sizeof(int16_t); - case DT_INT64: - return sizeof(int64_t); default: - LOG(FATAL) << "Unsupported data type"; + LOG(FATAL) << "Unsupported data type: " << dt; return 0; } } diff --git a/mace/core/types.h b/mace/core/types.h index 3a7236810130db464f5b1736009f130c96fe1f48..28f5702314aefeedba001ea52c2e96db50c141e5 100644 --- a/mace/core/types.h +++ b/mace/core/types.h @@ -38,50 +38,28 @@ size_t GetEnumTypeSize(const DataType dt); std::string DataTypeToString(const DataType dt); template -struct IsValidDataType; +struct DataTypeToEnum; -template -struct DataTypeToEnum { - static_assert(IsValidDataType::value, "Specified Data Type not supported"); -}; - -// EnumToDataType::Type is the type for DataType constant VALUE, e.g. -// EnumToDataType::Type is float. template -struct EnumToDataType {}; // Specializations below - -// Template specialization for both DataTypeToEnum and EnumToDataType. -#define MATCH_TYPE_AND_ENUM(TYPE, ENUM) \ - template <> \ - struct DataTypeToEnum { \ - static DataType v() { return ENUM; } \ - static constexpr DataType value = ENUM; \ - }; \ - template <> \ - struct IsValidDataType { \ - static constexpr bool value = true; \ - }; \ - template <> \ - struct EnumToDataType { \ - typedef TYPE Type; \ - } +struct EnumToDataType; + +#define MACE_MAPPING_DATA_TYPE_AND_ENUM(DATA_TYPE, ENUM_VALUE) \ + template <> \ + struct DataTypeToEnum { \ + static DataType v() { return ENUM_VALUE; } \ + static constexpr DataType value = ENUM_VALUE; \ + }; \ + template <> \ + struct EnumToDataType { \ + typedef DATA_TYPE Type; \ + }; #ifdef MACE_ENABLE_OPENCL -MATCH_TYPE_AND_ENUM(half, DT_HALF); +MACE_MAPPING_DATA_TYPE_AND_ENUM(half, DT_HALF); #endif -MATCH_TYPE_AND_ENUM(float, DT_FLOAT); -MATCH_TYPE_AND_ENUM(double, DT_DOUBLE); -MATCH_TYPE_AND_ENUM(int32_t, DT_INT32); -MATCH_TYPE_AND_ENUM(uint16_t, DT_UINT16); -MATCH_TYPE_AND_ENUM(uint8_t, DT_UINT8); -MATCH_TYPE_AND_ENUM(int16_t, DT_INT16); -MATCH_TYPE_AND_ENUM(int8_t, DT_INT8); -MATCH_TYPE_AND_ENUM(std::string, DT_STRING); -MATCH_TYPE_AND_ENUM(int64_t, DT_INT64); -MATCH_TYPE_AND_ENUM(uint32_t, DT_UINT32); -MATCH_TYPE_AND_ENUM(bool, DT_BOOL); - -static const int32_t kint32_tmax = ((int32_t)0x7FFFFFFF); +MACE_MAPPING_DATA_TYPE_AND_ENUM(float, DT_FLOAT); +MACE_MAPPING_DATA_TYPE_AND_ENUM(uint8_t, DT_UINT8); +MACE_MAPPING_DATA_TYPE_AND_ENUM(int32_t, DT_INT32); } // namespace mace #endif // MACE_CORE_TYPES_H_ diff --git a/mace/ops/ops_test_util.h b/mace/ops/ops_test_util.h index 733673a7273dae6cc19f308e8561ef5c5fd16201..8900b3c7372255046b23cbbb5862608f624a2e18 100644 --- a/mace/ops/ops_test_util.h +++ b/mace/ops/ops_test_util.h @@ -100,16 +100,6 @@ class OpDefBuilder { return *this; } - OpDefBuilder AddStringsArg(const std::string &name, - const std::vector &values) { - auto arg = op_def_.add_arg(); - arg->set_name(name); - for (auto value : values) { - arg->add_strings(value); - } - return *this; - } - void Finalize(OperatorDef *op_def) const { MACE_CHECK(op_def != nullptr, "input should not be null."); *op_def = op_def_; diff --git a/mace/ops/resize_bilinear_benchmark.cc b/mace/ops/resize_bilinear_benchmark.cc index add324053b7881dd1c52a62bf21a74d0941a26ff..ad9545619757f6a3e349c57b9193e64f3497a691 100644 --- a/mace/ops/resize_bilinear_benchmark.cc +++ b/mace/ops/resize_bilinear_benchmark.cc @@ -44,7 +44,7 @@ void ResizeBilinearBenchmark(int iters, } else { MACE_NOT_IMPLEMENTED; } - net.AddInputFromArray("OutSize", {2}, + net.AddInputFromArray("OutSize", {2}, {output_height, output_width}); if (D == DeviceType::CPU) { diff --git a/mace/proto/mace.proto b/mace/proto/mace.proto index 393067dd6cc7d8e6bcc90d993fd8784b277781f9..d0294f96a56ca2497cbf5662be7d3a18ce79d620 100644 --- a/mace/proto/mace.proto +++ b/mace/proto/mace.proto @@ -11,45 +11,20 @@ enum NetMode { enum DataType { DT_INVALID = 0; - - // Data types that all computation devices are expected to be - // capable to support. DT_FLOAT = 1; - DT_DOUBLE = 2; - DT_INT32 = 3; - DT_UINT8 = 4; - DT_INT16 = 5; - DT_INT8 = 6; - DT_STRING = 7; - DT_INT64 = 8; - DT_UINT16 = 9; - DT_BOOL = 10; - DT_HALF = 19; - DT_UINT32 = 22; + DT_UINT8 = 2; + DT_HALF = 3; + DT_INT32 = 4; } message ConstTensor { - // The dimensions in the tensor. repeated int64 dims = 1; optional DataType data_type = 2 [default = DT_FLOAT]; - // For float repeated float float_data = 3 [packed = true]; - // For int32, uint8, int8, uint16, int16, bool, and float16 - // Note about float16: in storage we will basically convert float16 byte-wise - // to unsigned short and then store them in the int32_data field. repeated int32 int32_data = 4 [packed = true]; - // For bytes - optional bytes byte_data = 5; - // For strings - repeated bytes string_data = 6; - // For double - repeated double double_data = 9 [packed = true]; - // For int64 - repeated int64 int64_data = 10 [packed = true]; - // Optionally, a name for the tensor. - optional string name = 7; - optional int64 offset = 11; - optional int64 data_size = 12; + optional string name = 5; + optional int64 offset = 6; + optional int64 data_size = 7; optional uint32 node_id = 100; } @@ -61,7 +36,6 @@ message Argument { optional bytes s = 4; repeated float floats = 5; repeated int64 ints = 6; - repeated bytes strings = 7; } // for hexagon mace-nnlib diff --git a/mace/python/tools/convert_util.py b/mace/python/tools/convert_util.py index 4643931be2baec9da0cf82eeb4b7c689cbdb2bfd..2a685d322148a055fcec1a44d6dc52b09974a4ac 100644 --- a/mace/python/tools/convert_util.py +++ b/mace/python/tools/convert_util.py @@ -18,21 +18,11 @@ from mace.proto import mace_pb2 TF_DTYPE_2_MACE_DTYPE_MAP = { tf.float32: mace_pb2.DT_FLOAT, - tf.double: mace_pb2.DT_DOUBLE, tf.half: mace_pb2.DT_HALF, - tf.int64: mace_pb2.DT_INT64, tf.int32: mace_pb2.DT_INT32, tf.qint32: mace_pb2.DT_INT32, - tf.int16: mace_pb2.DT_INT16, - tf.qint16: mace_pb2.DT_INT16, - tf.int8: mace_pb2.DT_INT8, - tf.qint8: mace_pb2.DT_INT8, - tf.quint16: mace_pb2.DT_UINT16, - tf.uint16: mace_pb2.DT_UINT16, tf.quint8: mace_pb2.DT_UINT8, tf.uint8: mace_pb2.DT_UINT8, - tf.string: mace_pb2.DT_STRING, - tf.bool: mace_pb2.DT_BOOL, } diff --git a/mace/python/tools/model.jinja2 b/mace/python/tools/model.jinja2 index 4aaf6e47b5e656668456aaf837cdc3ee2f7d1164..75e2dea11e2e0a7b9b88b0072751a81d632ce2ae 100644 --- a/mace/python/tools/model.jinja2 +++ b/mace/python/tools/model.jinja2 @@ -68,10 +68,6 @@ void CreateNetArg(NetDef *net_def) { {% for int_value in net.arg[i].ints %} arg->add_ints({{ int_value }}); {% endfor %} - arg->mutable_strings()->Reserve({{ net.arg[i].strings|length }}); - {% for str_value in net.arg[i].strings %} - arg->add_strings({{ str_value }}); - {% endfor %} {% endfor %} } diff --git a/mace/python/tools/operator.jinja2 b/mace/python/tools/operator.jinja2 index bd7e36eb870276a9b37b8c249ed074c272d2a7f2..8fdf0b2c9b0266f3f93cadd85814bdecbd7d5686 100644 --- a/mace/python/tools/operator.jinja2 +++ b/mace/python/tools/operator.jinja2 @@ -91,10 +91,6 @@ void CreateOperator{{i}}(mace::OperatorDef *op) { {% for int_value in arg.ints %} arg->add_ints({{ int_value }}); {% endfor %} - arg->mutable_strings()->Reserve({{ arg.strings|length }}); - {% for str_value in arg.strings %} - arg->add_strings({{ str_value }}); - {% endfor %} {% endfor %}