diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 77c8ff318966f7ec80363837298c36a8055f60d1..5a86f2eb1729d784135f5499da6dcc7ba66af776 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -196,3 +196,9 @@ dynamic_linking_test: - rm -rf mace-models only: - triggers + +micro-child: + stage: build + trigger: + include: + - 'micro/.gitlab-ci.yml' diff --git a/CMakeLists.txt b/CMakeLists.txt index fe8fa6efc12625f5b84053bea57e7d5fb4cdf938..2ddf861c069ee1fad7904967fe993a8e6cbccd02 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -143,3 +143,7 @@ add_subdirectory(mace) if(MACE_ENABLE_TESTS OR MACE_ENABLE_BENCHMARKS) add_subdirectory(test) endif(MACE_ENABLE_TESTS OR MACE_ENABLE_BENCHMARKS) + +if(MACE_ENABLE_MICRO) + add_subdirectory(micro) +endif(MACE_ENABLE_MICRO) diff --git a/docs/micro-controllers/basic_usage.rst b/docs/micro-controllers/basic_usage.rst index f73f6c864df60653f9cfe4b268692c8adfff0775..a1228ecced3696772b39f4d97d51077b8f203a86 100644 --- a/docs/micro-controllers/basic_usage.rst +++ b/docs/micro-controllers/basic_usage.rst @@ -45,24 +45,25 @@ Here we use the har-cnn model as an example. cd path/to/mace # output lib path: build/har-cnn/model/har_cnn_micro.tar.gz CONF_FILE=/path/to/mace-models/micro-models/har-cnn/har-cnn.yml - python tools/converter.py convert --config=$CONF_FILE --enable_micro + python tools/python/convert.py --config=$CONF_FILE --enable_micro 4. Build Micro-Controllers engine and models to library on host. .. code-block:: sh - # copy convert result to micro dir ``path/to/micro``, which should not be the sub directory of the ``mace/``. - cp build/har-cnn/model/har_cnn_micro.tar.gz path/to/micro/ - cd path/to/micro - tar zxvf har_cnn_micro.tar.gz - bazel build //micro/codegen:libmicro.so + cd micro + ./tools/cmake/cmake-build-host.sh .. note:: - - This step can be skipped if you just want to run a model using ``tools/python/run_micro.py``, such as commands in step 5. + - The build result ``build/cmake-build/host/libmicro.a``'s abi is host, if you want to run the model on micro controllers, you should build the code with the right toolchain, for example - - The build result ``bazel-bin/micro/codegen/libmicro.so``'s abi is host, if you want to run the model on micro controllers, you should build the code with the target abi. + .. code-block:: sh + cd micro + export HEXAGON_SDK_ROOT=/home/user/Qualcomm/Hexagon_SDK/3.4.1 + export HEXAGON_TOOLS=/home/user/Qualcomm/HEXAGON_Tools/6.4.06 + ./tools/cmake/cmake-build-hexagon6.sh 5. Run the model on host. diff --git a/micro/.gitignore b/micro/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..7f1bd1122eeab9d7ebc6363eb1473b28b1088823 --- /dev/null +++ b/micro/.gitignore @@ -0,0 +1,2 @@ +build +test/**/codegen diff --git a/micro/.gitlab-ci.yml b/micro/.gitlab-ci.yml new file mode 100644 index 0000000000000000000000000000000000000000..6f244d5db207a4b47126b5d75834b7ed3406db68 --- /dev/null +++ b/micro/.gitlab-ci.yml @@ -0,0 +1,28 @@ +stages: + - convert + - build + - test + +model-convert: + stage: convert + script: + - rm -rf mace-models + - GIT_SSH_COMMAND="ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" git clone git@github.com:XiaoMi/mace-models.git + - > + - CONF_FILE=mace-models/micro-models/har-cnn/har-cnn.yml + - python tools/python/convert.py --config=${CONF_FILE} --enable_micro + artifacts: + paths: + - mace-models + untracked: true + +host-build: + stage: build + script: + - cd micro && ./tools/cmake/cmake-build-host.sh -DMICRO_MODEL_NAME=har_cnn + +host-test: + stage: test + script: + - CONF_FILE=mace-models/micro-models/har-cnn/har-cnn.yml + - python tools/python/run_micro.py --config $CONF_FILE --build --validate --model_name har_cnn diff --git a/micro/CMakeLists.txt b/micro/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..72f2b509930a0f22fa0a78f30a6a5b361af23171 --- /dev/null +++ b/micro/CMakeLists.txt @@ -0,0 +1,79 @@ +cmake_minimum_required(VERSION 3.7 FATAL_ERROR) +message("CMAKE_VERSION: ${CMAKE_VERSION}") +project(micro C CXX) + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") + +if(HEXAGON6) + # Does not work with "-O3" + add_compile_options(-O2) +endif() + +if(MACE_MICRO_ARM_NONE) + add_definitions(-DMACE_MICRO_ARM_NONE) +endif() + +option(MACE_ENABLE_BFLOAT16 "Whether to enable bfloat16 support" OFF) +option(MACE_MICRO_ENABLE_TESTS "Whether to enable Mace Micro tests" ON) + +if(MACE_ENABLE_BFLOAT16) + add_definitions(-DMACE_ENABLE_BFLOAT16) +endif() + +if(MACE_MICRO_NDEBUG) + add_definitions(-DMACE_MICRO_NDEBUG) +endif() + +include(third_party/third_party.cmake) + +add_subdirectory(include) +add_subdirectory(port) +add_subdirectory(base) +add_subdirectory(model) +add_subdirectory(framework) +add_subdirectory(ops) +add_subdirectory(codegen) + +file(GLOB micro_base_srcs base/*.cc) +file(GLOB micro_codegen_models_srcs codegen/models/**/*.cc) +file(GLOB micro_codegen_engines_srcs codegen/engines/**/*.cc) +file(GLOB micro_framework_srcs framework/*.cc) +file(GLOB micro_models_srcs model/*.cc) +file(GLOB micro_ops_nhwc_base_srcs ops/nhwc/base/*.cc) +file(GLOB micro_ops_nhwc_srcs ops/nhwc/*.cc) +file(GLOB micro_ops_srcs ops/*.cc) +file(GLOB micro_ops_utils_srcs ops/utils/*.cc) +file(GLOB micro_port_srcs port/*.cc) + +# To build a single library +add_library(micro + ${micro_base_srcs} + ${micro_codegen_models_srcs} + ${micro_codegen_engines_srcs} + ${micro_framework_srcs} + ${micro_models_srcs} + ${micro_ops_srcs} + ${micro_ops_nhwc_srcs} + ${micro_ops_nhwc_base_srcs} + ${micro_ops_utils_srcs} + ${micro_port_srcs} +) +target_include_directories(micro PUBLIC ..) + +install(TARGETS micro + ARCHIVE DESTINATION lib + LIBRARY DESTINATION lib + RUNTIME DESTINATION bin +) + +if(HEXAGON OR HEXAGON_STUB) + include(cmake/find_hexagon_sdk.cmake) +endif() + +if(NOT HEXAGON) + add_subdirectory(tools) +endif() + +if(MACE_MICRO_ENABLE_TESTS) + add_subdirectory(test) +endif(MACE_MICRO_ENABLE_TESTS) diff --git a/micro/base/CMakeLists.txt b/micro/base/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..59b58a7dc596a48ca37472d239cacfc95981d43a --- /dev/null +++ b/micro/base/CMakeLists.txt @@ -0,0 +1,11 @@ +add_library(micro_base + logger.cc + serialize.cc + utils.cc + value_to_str.cc +) +target_link_libraries(micro_base + PUBLIC micro_port + PUBLIC micro_include +) +target_compile_options(micro_base PUBLIC -fPIC) diff --git a/micro/base/logging.h b/micro/base/logging.h index a0e806ae19add3815f66498af3e67605247c6785..ebc995488675f005f4344e0b9ce09292af2a896f 100644 --- a/micro/base/logging.h +++ b/micro/base/logging.h @@ -26,7 +26,7 @@ namespace log { #define LOG(severity) \ micro::base::Logger(__FILE__, __LINE__, micro::severity) -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG #define LOG1(severity, value) LOG(severity) << value #define LOG2(severity, value1, value2) LOG(severity) << value1 << value2 #define LOG3(severity, value1, value2, value3) \ @@ -41,9 +41,9 @@ namespace log { #define LOG3(severity, value1, value2, value3) #define LOG4(severity, value1, value2, value3, value4) #define LOG5(severity, value1, value2, value3, value4, value5) -#endif // NDEBUG +#endif // MACE_MICRO_NDEBUG -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG #define MACE_ASSERT(condition) \ if (!(condition)) LOG(FATAL) << "Assert failed: "#condition // NOLINT #define MACE_ASSERT1(condition, str) \ @@ -54,7 +54,7 @@ namespace log { #define MACE_ASSERT(condition) #define MACE_ASSERT1(condition, string) #define MACE_ASSERT2(condition, string1, string2) -#endif // NDEBUG +#endif // MACE_MICRO_NDEBUG #define MACE_NOT_IMPLEMENTED MACE_ASSERT1(false, "not implemented") diff --git a/micro/cmake/find_hexagon_sdk.cmake b/micro/cmake/find_hexagon_sdk.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ea8e8e033fc04398fdb4cd81a2f78db19c19ebc8 --- /dev/null +++ b/micro/cmake/find_hexagon_sdk.cmake @@ -0,0 +1,27 @@ +if (NOT TARGET hexagon_sdk_headers_dsp) + add_library(hexagon_sdk_headers_dsp INTERFACE) + target_include_directories(hexagon_sdk_headers_dsp INTERFACE ${HEXAGON_SDK_ROOT}/incs) + target_include_directories(hexagon_sdk_headers_dsp INTERFACE ${HEXAGON_SDK_ROOT}/incs/stddef) + target_include_directories(hexagon_sdk_headers_dsp INTERFACE ${HEXAGON_SDK_ROOT}/libs/common/remote/ship/hexagon_Release_toolv81_v60) +endif() + +if (NOT TARGET hexagon_sdk_headers_arm) + add_library(hexagon_sdk_headers_arm INTERFACE) + target_include_directories(hexagon_sdk_headers_arm INTERFACE ${HEXAGON_SDK_ROOT}/incs) + target_include_directories(hexagon_sdk_headers_arm INTERFACE ${HEXAGON_SDK_ROOT}/incs/stddef) + target_include_directories(hexagon_sdk_headers_arm INTERFACE ${HEXAGON_SDK_ROOT}/libs/common/remote/ship/hexagon_Release_toolv81_v60) +endif() + +if (NOT TARGET hexagon_sdk_cdsprpc) + add_library(hexagon_sdk_cdsprpc SHARED IMPORTED) + set_target_properties(hexagon_sdk_cdsprpc + PROPERTIES IMPORTED_LOCATION "${HEXAGON_SDK_ROOT}/libs/common/remote/ship/android_Release_aarch64/libcdsprpc.so" + ) +endif() + +if (NOT TARGET hexagon_sdk_rpcmem) + add_library(hexagon_sdk_rpcmem STATIC IMPORTED) + set_target_properties(hexagon_sdk_rpcmem + PROPERTIES IMPORTED_LOCATION "${HEXAGON_SDK_ROOT}/libs/common/rpcmem/rpcmem.a" + ) +endif() diff --git a/micro/cmake/toolchain/gcc-arm-none-eabi.cmake b/micro/cmake/toolchain/gcc-arm-none-eabi.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a7610ae4f0ffa84340a43e2fffcceb254463bef6 --- /dev/null +++ b/micro/cmake/toolchain/gcc-arm-none-eabi.cmake @@ -0,0 +1,15 @@ +set(CMAKE_SYSTEM_PROCESSOR arm) + +set(CMAKE_C_COMPILER "${GCC_ARM_ROOT}/arm-none-eabi-gcc") +set(CMAKE_CXX_COMPILER "${GCC_ARM_ROOT}/arm-none-eabi-g++") +set(CMAKE_AR "${GCC_ARM_ROOT}/arm-none-eabi-ar" CACHE FILEPATH "Archiver") +set(CMAKE_LINKER "${GCC_ARM_ROOT}/arm-none-eabi-ld") +set(CMAKE_EXE_LINKER_FLAGS "--specs=nosys.specs" CACHE INTERNAL "") + +set(MACE_MICRO_ARM_NONE ON) + +set(CMAKE_FIND_ROOT_PATH "${GCC_ARM_ROOT}") +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) diff --git a/micro/cmake/toolchain/hexagon6.toolchain.cmake b/micro/cmake/toolchain/hexagon6.toolchain.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f54c63999960d2377671994ddd426e9b81a0ea83 --- /dev/null +++ b/micro/cmake/toolchain/hexagon6.toolchain.cmake @@ -0,0 +1,41 @@ +set(CMAKE_C_COMPILER "${HEXAGON_TOOLS}/qc/bin/hexagon-clang") +set(CMAKE_CXX_COMPILER "${HEXAGON_TOOLS}/qc/bin/hexagon-clang") +set(CMAKE_AR "${HEXAGON_TOOLS}/gnu/bin/hexagon-ar" CACHE FILEPATH "Archiver") +set(CMAKE_LINKER "${HEXAGON_TOOLS}/qc/bin/hexagon-llvm-link") + +set(CMAKE_FIND_ROOT_PATH "${HEXAGON_TOOLS}") +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + +set(HEXAGON ON) +set(HEXAGON6 ON) + +if (NOT TARGET hexagon_sdk_headers_dsp) + add_library(hexagon_sdk_headers_dsp INTERFACE) + target_include_directories(hexagon_sdk_headers_dsp INTERFACE ${HEXAGON_SDK_ROOT}/incs) + target_include_directories(hexagon_sdk_headers_dsp INTERFACE ${HEXAGON_SDK_ROOT}/incs/stddef) + target_include_directories(hexagon_sdk_headers_dsp INTERFACE ${HEXAGON_SDK_ROOT}/libs/common/remote/ship/hexagon_Release_toolv81_v60) +endif() + +if (NOT TARGET hexagon_sdk_headers_arm) + add_library(hexagon_sdk_headers_arm INTERFACE) + target_include_directories(hexagon_sdk_headers_arm INTERFACE ${HEXAGON_SDK_ROOT}/incs) + target_include_directories(hexagon_sdk_headers_arm INTERFACE ${HEXAGON_SDK_ROOT}/incs/stddef) + target_include_directories(hexagon_sdk_headers_arm INTERFACE ${HEXAGON_SDK_ROOT}/libs/common/remote/ship/hexagon_Release_toolv81_v60) +endif() + +if (NOT TARGET hexagon_sdk_cdsprpc) + add_library(hexagon_sdk_cdsprpc SHARED IMPORTED) + set_target_properties(hexagon_sdk_cdsprpc + PROPERTIES IMPORTED_LOCATION "${HEXAGON_SDK_ROOT}/libs/common/remote/ship/android_Release_aarch64/libcdsprpc.so" + ) +endif() + +if (NOT TARGET hexagon_sdk_rpcmem) + add_library(hexagon_sdk_rpcmem STATIC IMPORTED) + set_target_properties(hexagon_sdk_rpcmem + PROPERTIES IMPORTED_LOCATION "${HEXAGON_SDK_ROOT}/libs/common/rpcmem/rpcmem.a" + ) +endif() diff --git a/micro/cmake/toolchain/hexagon8.toolchain.cmake b/micro/cmake/toolchain/hexagon8.toolchain.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8cf83ed2024d60eb26b8c81cf68c3c00e23e09dc --- /dev/null +++ b/micro/cmake/toolchain/hexagon8.toolchain.cmake @@ -0,0 +1,13 @@ +set(CMAKE_C_COMPILER "${HEXAGON_TOOLS}/bin/hexagon-clang") +set(CMAKE_CXX_COMPILER "${HEXAGON_TOOLS}/bin/hexagon-clang") +set(CMAKE_AR "${HEXAGON_TOOLS}/bin/hexagon-ar" CACHE FILEPATH "Archiver") +set(CMAKE_LINKER ${HEXAGON_TOOLS}/bin/hexagon-link) + +set(CMAKE_FIND_ROOT_PATH "${HEXAGON_SDK_ROOT}") +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + +set(HEXAGON ON) +set(HEXAGON8 ON) diff --git a/micro/codegen/CMakeLists.txt b/micro/codegen/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..ee75d1a2d566a28e40fc4a86bf7600f8efdd8bdd --- /dev/null +++ b/micro/codegen/CMakeLists.txt @@ -0,0 +1,29 @@ +file(GLOB_RECURSE generated_models_srcs models *.cc) +add_library(generated_models + ${generated_models_srcs} +) +target_link_libraries(generated_models + micro_framework + micro_include + micro_model + micro_ops +) + +file(GLOB_RECURSE micro_engine_srcs engines micro_engine_factory.cc) +add_library(micro_engine + ${micro_engine_srcs} +) +target_link_libraries(micro_engine + micro_framework + micro_model + micro_ops + generated_models +) + +file(GLOB_RECURSE micro_engine_c_srcs engines micro_engine_c_interface.cc) +add_library(micro_engine_c + ${micro_engine_c_srcs} +) +target_link_libraries(micro_engine_c + micro_engine +) diff --git a/micro/framework/CMakeLists.txt b/micro/framework/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..bc314088e6be862969393a7e25f511db224be67c --- /dev/null +++ b/micro/framework/CMakeLists.txt @@ -0,0 +1,16 @@ +add_library(micro_framework + graph.cc + micro_engine.cc + op_context.cc + operator.cc + scratch_buffer.cc +) +target_link_libraries(micro_framework micro_include micro_base micro_model) + +add_library(micro_framework_for_optest + graph.cc + micro_engine.cc + op_context.cc + scratch_buffer.cc +) +target_link_libraries(micro_framework_for_optest micro_include micro_base micro_model) diff --git a/micro/framework/operator.cc b/micro/framework/operator.cc index 7a998f5900078fd6c273d6365e6319cd77fc8f91..3065484ce0a3512d9cce6f7666f26a352e9f9961 100644 --- a/micro/framework/operator.cc +++ b/micro/framework/operator.cc @@ -169,7 +169,7 @@ MaceStatus Operator::ResizeOutputShape(uint32_t idx, uint32_t dim_size, const int32_t *dims) { model::OutputShape *output_shape = const_cast(op_context_->output_resize_shape(idx)); -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG if (op_def_->output_shape(idx)->dim_size() < dim_size || output_shape->dim_size() < dim_size) { LOG(FATAL) << "Can not support dynamic dim_size. op_def_dim_size = " @@ -193,7 +193,7 @@ MaceStatus Operator::ResizeOutputShape(uint32_t idx, uint32_t dim_size, } MACE_ASSERT(def_output_shape_size >= input_shape_size); } -#endif // NDEBUG +#endif // MACE_MICRO_NDEBUG if (dim_size > 0) { base::memcpy(output_shape->mutable_dim(), dims, dim_size * sizeof(int32_t)); diff --git a/micro/framework/scratch_buffer.cc b/micro/framework/scratch_buffer.cc index 61fb18f023da27713983b5c2eeff71b2abd30d5d..425cbd37c672cddebf351e1dd92ff92cff15c3ff 100644 --- a/micro/framework/scratch_buffer.cc +++ b/micro/framework/scratch_buffer.cc @@ -20,7 +20,7 @@ namespace micro { namespace framework { -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG namespace { int64_t kDetectHandle = -1; } @@ -28,7 +28,7 @@ int64_t kDetectHandle = -1; ScratchBuffer::ScratchBuffer(MaceMicroEngineConfig *engine_config) : engine_config_(engine_config), offset_(0) { -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG int64_t cur_handle = reinterpret_cast(engine_config); MACE_ASSERT1(cur_handle != kDetectHandle, "Detect scratch buffer error."); kDetectHandle = cur_handle; @@ -36,7 +36,7 @@ ScratchBuffer::ScratchBuffer(MaceMicroEngineConfig *engine_config) : } ScratchBuffer::~ScratchBuffer() { -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG kDetectHandle = -1; #endif } diff --git a/micro/include/CMakeLists.txt b/micro/include/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..8c00fb14f07fb4b72d067c9d885854ec7fa4fc38 --- /dev/null +++ b/micro/include/CMakeLists.txt @@ -0,0 +1,5 @@ +add_library(micro_include INTERFACE) +target_include_directories(micro_include + INTERFACE $ + INTERFACE $ +) diff --git a/micro/model/CMakeLists.txt b/micro/model/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..c580af9161b7789591e4fb38265f30b9bf3b1f0c --- /dev/null +++ b/micro/model/CMakeLists.txt @@ -0,0 +1,10 @@ +add_library(micro_model + argument.cc + const_tensor.cc + input_output_info.cc + net_def.cc + operator_def.cc + output_shape.cc +) + +target_link_libraries(micro_model micro_base micro_include) diff --git a/micro/ops/CMakeLists.txt b/micro/ops/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..43ddce0a11c0fa03b6349f923fb8a588f0769fa8 --- /dev/null +++ b/micro/ops/CMakeLists.txt @@ -0,0 +1,50 @@ +set(MICRO_OPS_SRCS + shape.cc + reduce.cc + reshape.cc + matmul.cc + nhwc/depthwise_conv_2d_ref.cc + nhwc/conv_2d_c4_s4.cc + nhwc/depthwise_conv_2d_kb3_s4.cc + nhwc/pooling_ref.cc + nhwc/conv_2d_c3_s4.cc + nhwc/conv_2d_ref.cc + nhwc/depthwise_conv_2d_kb4_s4.cc + nhwc/depthwise_conv_2d_kb1_s4.cc + nhwc/base/depthwise_conv_2d_base.cc + nhwc/base/conv_2d_base.cc + nhwc/base/filter_op_base.cc + nhwc/base/pooling_base.cc + nhwc/depthwise_conv_2d_kb2_s4.cc + nhwc/conv_2d_c2_s4.cc + nhwc/batch_norm.cc + nhwc/pooling_s4.cc + bias_add.cc + softmax.cc + eltwise.cc + utils/gemm.cc + utils/crumb_utils.cc + utils/gemv.cc + utils/activation.cc + expand_dims.cc + squeeze.cc + activation.cc +) + +add_library(micro_ops + ${MICRO_OPS_SRCS} +) +target_link_libraries(micro_ops + micro_base + micro_framework +) + + +add_library(micro_ops_for_test + ${MICRO_OPS_SRCS} +) +target_link_libraries(micro_ops_for_test + micro_base + micro_framework_for_optest +) +target_compile_options(micro_ops_for_test PUBLIC -fPIC) diff --git a/micro/ops/matmul.h b/micro/ops/matmul.h index 000adc5305fdc2c0735ea4cede8bbe7b6da995db..94d9b03507a8c24064cc5db0e71aa03514c4acca 100644 --- a/micro/ops/matmul.h +++ b/micro/ops/matmul.h @@ -40,7 +40,7 @@ class MatMulOp : public framework::Operator { uint32_t input_b_dim_size_; const mifloat *bias_; -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG const int32_t *bias_dims_; uint32_t bias_dim_size_; #endif diff --git a/micro/ops/reduce.cc b/micro/ops/reduce.cc index 6ecce84db193afcc398fb2c0bc37b02c34264cef..5bf21869dbdfe22984547aab13ab27fa41285e8f 100644 --- a/micro/ops/reduce.cc +++ b/micro/ops/reduce.cc @@ -29,7 +29,7 @@ MaceStatus ReduceOpBase::OnInit() { } void ReduceOpBase::Validate() { -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG const int32_t input_dim_size = GetInputShapeDimSize(INPUT); const int32_t left = input_dim_size * -1; const int32_t right = input_dim_size; diff --git a/micro/ops/reshape.cc b/micro/ops/reshape.cc index 5b9c05d5d0b49423bfe7ab8607b27fda0f3ab868..26e80d794197d4ab6be47fa33499b4ca22536baf 100644 --- a/micro/ops/reshape.cc +++ b/micro/ops/reshape.cc @@ -89,7 +89,7 @@ MaceStatus ReshapeOp::Run() { MACE_RETURN_IF_ERROR(ValidShapeData(input_dims_, input_dim_size_, shape_data, shape_data_size)); -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG const int32_t output_data_size = base::accumulate_multi( shape_data, 0, static_cast(shape_data_size)); if (input_data_size != output_data_size) { diff --git a/micro/ops/strided_slice.h b/micro/ops/strided_slice.h index 39a64ca26e6d7aa8b12705fd96805568c8d800e6..51eff207c25e4f8c2af83b431b0ba6499c2ce1fb 100644 --- a/micro/ops/strided_slice.h +++ b/micro/ops/strided_slice.h @@ -188,7 +188,7 @@ class StridedSliceOp : public framework::Operator { for (uint32_t i = 0; i < input_dim_size_; ++i) { int32_t b = begin_[i]; int32_t s = end_[i]; -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG int32_t input_i = input_dims_[i]; if (!(0 <= b && b <= input_i)) { LOG(FATAL) << "In Slice, expected begin[" << i << "] in [0, " @@ -240,7 +240,7 @@ class StridedSliceOp : public framework::Operator { } else { begin_[d] = begin_[d] < 0 ? begin_[d] + dim_len : begin_[d]; end_[d] = begin_[d] + 1; -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG if (!(begin_[d] >= 0 && begin_[d] < dim_len)) { LOG(FATAL) << "slice begin indice of dimension '" << d << "': " << begin_[d] << ", is out of bound"; @@ -249,7 +249,7 @@ class StridedSliceOp : public framework::Operator { } } } -#ifndef NDEBUG +#ifndef MACE_MICRO_NDEBUG for (uint32_t i = 0; i < output_shape_idx_; ++i) { if (output_shape_[i] <= 0) { LOG(FATAL) << "Expected output_shape[" << i diff --git a/micro/port/CMakeLists.txt b/micro/port/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..03867ddee2ab78ddaf563c08d638550a4f71c5c0 --- /dev/null +++ b/micro/port/CMakeLists.txt @@ -0,0 +1,6 @@ +add_library(micro_port api.cc) +target_include_directories(micro_port + PUBLIC $ + PUBLIC $ +) +target_compile_options(micro_port PRIVATE "-fPIC") diff --git a/micro/port/api.cc b/micro/port/api.cc index b63ab07a682dedacae5559e2ea92775a2a40c78b..a7f78619c76ca13e23026e63fd96a6a9ddb7385b 100644 --- a/micro/port/api.cc +++ b/micro/port/api.cc @@ -39,13 +39,15 @@ void DebugLog(const char *str) { } int64_t NowMicros() { - // you should rewrite this file in the platform source file. #ifdef MACE_ENABLE_HEXAGON return HAP_perf_get_time_us(); -#else +#elif __linux__ struct timeval tv; gettimeofday(&tv, 0); return static_cast(tv.tv_sec) * 1000000 + tv.tv_usec; +#else + // you should rewrite this file in the platform source file. + return -1; #endif } diff --git a/micro/test/CMakeLists.txt b/micro/test/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..27d7f069bd132ef7c7ffe0bd53d704d1cbe67e55 --- /dev/null +++ b/micro/test/CMakeLists.txt @@ -0,0 +1,9 @@ +add_subdirectory(ccutils) + +if(NOT HEXAGON) + include(${PROJECT_SOURCE_DIR}/third_party/googletest/googletest.cmake) + add_subdirectory(ccunit) +endif() + +add_subdirectory(ccbenchmark) +add_subdirectory(ccbaseline) diff --git a/micro/test/ccbaseline/CMakeLists.txt b/micro/test/ccbaseline/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..fce339d952105d75844a12e455239739259969e8 --- /dev/null +++ b/micro/test/ccbaseline/CMakeLists.txt @@ -0,0 +1,59 @@ +if(HEXAGON OR HEXAGON_STUB) + execute_process( + COMMAND mkdir -p ${CMAKE_CURRENT_SOURCE_DIR}/codegen + COMMAND ${HEXAGON_SDK_ROOT}/tools/qaic/Ubuntu16/qaic + -mdll -o ${CMAKE_CURRENT_SOURCE_DIR}/codegen + -I${HEXAGON_SDK_ROOT}/libs/fastcv/dspCV/android_Debug/ship + -I${HEXAGON_SDK_ROOT}/libs/common/rpcmem/android_Debug/ship + -I${HEXAGON_SDK_ROOT}/libs/common/adspmsgd/ship/android_Debug + -I${HEXAGON_SDK_ROOT}/incs + -I${HEXAGON_SDK_ROOT}/libs/common/remote/ship/android_Debug + -I${HEXAGON_SDK_ROOT}/incs/stddef + ${CMAKE_CURRENT_SOURCE_DIR}/macemc/rpc/macemc.idl + WORKING_DIRECTORY . + ) +endif() + +if(HEXAGON AND MICRO_MODEL_NAME) + add_library(macemc_idl_skel + codegen/macemc_skel.c + ) + target_link_libraries(macemc_idl_skel hexagon_sdk_headers_dsp) + target_compile_options(macemc_idl_skel PRIVATE "-fPIC") + + add_library(macemc_skel SHARED + macemc/rpc/skel/macemc.cc + macemc/rpc/skel/micro_tester.cc + ) + target_compile_definitions(macemc_skel PUBLIC "-DMICRO_MODEL_NAME=${MICRO_MODEL_NAME}") + target_link_libraries(macemc_skel + micro_engine + micro_rpc_skel + hexagon_sdk_headers_dsp + -Wl,--whole-archive + macemc_idl_skel + -Wl,--no-whole-archive + ) +endif() + +if(HEXAGON_STUB) + add_library(macemc_idl_stub + codegen/macemc_stub.c + ) + target_link_libraries(macemc_idl_stub hexagon_sdk_headers_arm hexagon_sdk_cdsprpc) + + add_library(macemc_stub + macemc/rpc/stub/macemc.cc + ) + target_include_directories(macemc_stub PUBLIC . ) + target_link_libraries(macemc_stub) + target_link_libraries(macemc_stub macemc_idl_stub micro_rpc_stub) + + add_executable(micro_cc_baseline + test_baseline_main.cc + ) + target_link_libraries(micro_cc_baseline macemc_stub) + if(ANDROID) + target_link_libraries(micro_cc_baseline log) + endif() +endif() diff --git a/micro/test/ccbaseline/macemc/rpc/stub/macemc.cc b/micro/test/ccbaseline/macemc/rpc/stub/macemc.cc index d23d17d4622dd4f7c9dd9e3690a3a4376edbd34b..0445c720b0992188263234dcab790a1ecf86e9c1 100644 --- a/micro/test/ccbaseline/macemc/rpc/stub/macemc.cc +++ b/micro/test/ccbaseline/macemc/rpc/stub/macemc.cc @@ -13,7 +13,7 @@ // limitations under the License. #include "macemc/rpc/stub/macemc.h" -#include "micro/test/ccbaseline/codegen/macemc.h" +#include "codegen/macemc.h" namespace micro { namespace testing { diff --git a/micro/test/ccbenchmark/CMakeLists.txt b/micro/test/ccbenchmark/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..c77c0eadcb94a35f21ca70877d9d31d0598e32c8 --- /dev/null +++ b/micro/test/ccbenchmark/CMakeLists.txt @@ -0,0 +1,114 @@ +if(HEXAGON OR HEXAGON_STUB) + execute_process( + COMMAND mkdir -p ${CMAKE_CURRENT_SOURCE_DIR}/codegen + COMMAND ${HEXAGON_SDK_ROOT}/tools/qaic/Ubuntu16/qaic + -mdll -o ${CMAKE_CURRENT_SOURCE_DIR}/codegen + -I${HEXAGON_SDK_ROOT}/libs/fastcv/dspCV/android_Release/ship + -I${HEXAGON_SDK_ROOT}/libs/common/rpcmem/android_Release/ship + -I${HEXAGON_SDK_ROOT}/libs/common/adspmsgd/ship/android_Release + -I${HEXAGON_SDK_ROOT}/incs + -I${HEXAGON_SDK_ROOT}/libs/common/remote/ship/android_Release + -I${HEXAGON_SDK_ROOT}/incs/stddef + ${CMAKE_CURRENT_SOURCE_DIR}/micro/rpc/benchmark.idl + WORKING_DIRECTORY . + ) +endif() + +add_library(micro_benchmark_utils + micro/benchmark_utils/test_benchmark.cc +) +target_include_directories(micro_benchmark_utils PUBLIC .) +target_link_libraries(micro_benchmark_utils + PUBLIC micro_base + PUBLIC micro_ccutils +) + +add_library(micro_benchmark_lib + micro/ops/reduce_benchmark.cc + micro/ops/eltwise_benchmark.cc + micro/ops/activation_benchmark.cc + micro/ops/matmul_benchmark.cc + micro/ops/softmax_benchmark.cc + micro/ops/bias_add_benchmark.cc + micro/ops/nhwc/conv_2d_benchmark.cc + micro/ops/nhwc/pooling_benchmark.cc + micro/ops/nhwc/conv_2d_opt_benchmark.cc + micro/ops/nhwc/batch_norm_benchmark.cc + micro/ops/nhwc/depthwise_conv_2d_benchmark.cc + micro/ops/nhwc/depthwise_conv_2d_opt_benchmark.cc +) +target_link_libraries(micro_benchmark_lib + PUBLIC micro_base + PUBLIC micro_ccutils + PUBLIC micro_ops_for_test + PUBLIC micro_framework_for_optest + PUBLIC micro_benchmark_utils +) +target_include_directories(micro_benchmark_lib PUBLIC .) + +if(NOT HEXAGON_STUB AND NOT HEXAGON) + add_executable(micro_cc_benchmark + micro/test_benchmark_main.cc + ) + target_link_libraries(micro_cc_benchmark + PRIVATE micro_base + PRIVATE micro_ccutils + PRIVATE micro_ops_for_test + PRIVATE micro_framework_for_optest + PRIVATE micro_benchmark_utils + -Wl,--whole-archive + PUBLIC micro_benchmark_lib + -Wl,--no-whole-archive + ) +endif() + +if(HEXAGON_STUB) + add_library(benchmark_idl_stub + codegen/benchmark_stub.c + ) + target_link_libraries(benchmark_idl_stub + PUBLIC hexagon_sdk_headers_arm + PUBLIC hexagon_sdk_cdsprpc + ) + + add_library(benchmark_stub + micro/rpc/stub/benchmark.cc + ) + target_link_libraries(benchmark_stub + PUBLIC benchmark_idl_stub + PUBLIC micro_rpc_stub + ) + target_include_directories(benchmark_stub + PUBLIC . + PUBLIC ${PROJECT_SOURCE_DIR} + ) + + add_executable(micro_cc_benchmark + micro/test_benchmark_main.cc + ) + target_link_libraries(micro_cc_benchmark + benchmark_stub + ) + if(ANDROID) + target_link_libraries(micro_cc_benchmark log) + endif() +endif() + +if(HEXAGON) + add_library(benchmark_idk_skel + codegen/benchmark_skel.c + ) + target_link_libraries(benchmark_idk_skel hexagon_sdk_headers_dsp) + target_compile_options(benchmark_idk_skel PRIVATE -fPIC) + + add_library(benchmark_skel SHARED + micro/rpc/skel/benchmark.c + ) + target_link_libraries(benchmark_skel + benchmark_idk_skel + micro_benchmark_utils + -Wl,--whole-archive + micro_benchmark_lib + -Wl,--no-whole-archive + ) +endif() diff --git a/micro/test/ccbenchmark/micro/rpc/stub/benchmark.cc b/micro/test/ccbenchmark/micro/rpc/stub/benchmark.cc index 22745167a7efd5ff8b81ab26667dc7f77b52f638..ce55230d403ec4403b4b6945a3900a8e4924e8c0 100644 --- a/micro/test/ccbenchmark/micro/rpc/stub/benchmark.cc +++ b/micro/test/ccbenchmark/micro/rpc/stub/benchmark.cc @@ -13,7 +13,7 @@ // limitations under the License. #include "micro/rpc/stub/benchmark.h" -#include "micro/test/ccbenchmark/codegen/benchmark.h" +#include "codegen/benchmark.h" namespace micro { namespace testing { diff --git a/micro/test/ccbenchmark/micro/rpc/stub/benchmark.h b/micro/test/ccbenchmark/micro/rpc/stub/benchmark.h index 4816a7389085509173598d40780e878514140946..178f9bf1052bc95d27eda9534947d7a0e4ec538b 100644 --- a/micro/test/ccbenchmark/micro/rpc/stub/benchmark.h +++ b/micro/test/ccbenchmark/micro/rpc/stub/benchmark.h @@ -31,6 +31,6 @@ class Benchmark : public rpc::stub::BaseHandle { } // namespace testing } // namespace micro -void BenchmarkRun(); +extern "C" void BenchmarkRun(); #endif // MICRO_TEST_CCBENCHMARK_MICRO_RPC_STUB_BENCHMARK_H_ diff --git a/micro/test/ccunit/CMakeLists.txt b/micro/test/ccunit/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..f760593893b629e69aea968e1a292da32aab74cb --- /dev/null +++ b/micro/test/ccunit/CMakeLists.txt @@ -0,0 +1,44 @@ + + +add_executable(micro_ops_test + micro/ops/stack_test.cc + micro/ops/reshape_test.cc + micro/ops/eltwise_test.cc + micro/ops/nhwc/pooling_test.cc + micro/ops/nhwc/conv_2d_test.cc + micro/ops/nhwc/depthwise_conv_2d_opt_test.cc + micro/ops/nhwc/batch_norm_test.cc + micro/ops/nhwc/depthwise_conv_2d_test.cc + micro/ops/nhwc/conv_2d_opt_test.cc + micro/ops/squeeze_test.cc + micro/ops/reduce_test.cc + micro/ops/strided_slice_test.cc + micro/ops/matmul_test.cc + micro/ops/shape_test.cc + micro/ops/activation_test.cc + micro/ops/argmax_test.cc + micro/ops/softmax_test.cc + micro/ops/bias_add_test.cc + micro/ops/expand_dims_test.cc +) +target_link_libraries(micro_ops_test + PRIVATE micro_base + PRIVATE micro_ops_for_test + PRIVATE micro_ccutils + PRIVATE gtest + PRIVATE gtest_main +) + +if(MICRO_MODEL_NAME) + add_executable(micro_cc_test + micro/model/net_def_test.cc + micro/framework/graph_test.cc + micro/codegen/engine_test.cc + ) + target_link_libraries(micro_cc_test + micro_engine + gtest + gtest_main + ) + target_compile_definitions(micro_cc_test PRIVATE "-DMICRO_MODEL_NAME=${MICRO_MODEL_NAME}") +endif() diff --git a/micro/test/ccutils/CMakeLists.txt b/micro/test/ccutils/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b60050d4a11c16fe6ef8c2e543150524a7c2408 --- /dev/null +++ b/micro/test/ccutils/CMakeLists.txt @@ -0,0 +1,28 @@ +add_library(micro_ccutils + micro/ops/test_utils.cc + micro/ops/operator.test.cc + micro/ops/substitute_op.cc + micro/common/global_buffer.cc +) + +target_include_directories(micro_ccutils PUBLIC .) +target_link_libraries(micro_ccutils micro_base micro_framework_for_optest) + +if(HEXAGON_STUB) + add_library(micro_rpc_stub + rpc/stub/base_handle.cc + ) + target_include_directories(micro_rpc_stub PUBLIC .) + target_link_libraries(micro_rpc_stub PUBLIC hexagon_sdk_headers_arm) +endif() + +if(HEXAGON) + add_library(micro_rpc_skel + rpc/skel/base_func.cc + ) + target_include_directories(micro_rpc_skel PUBLIC .) + target_link_libraries(micro_rpc_skel + PUBLIC hexagon_sdk_headers_dsp + ) + target_compile_options(micro_rpc_skel PUBLIC "-fPIC") +endif() diff --git a/micro/test/ccutils/rpc/qaic.sh b/micro/test/ccutils/rpc/qaic.sh old mode 100644 new mode 100755 diff --git a/micro/third_party/gflags/COPYING.txt b/micro/third_party/gflags/COPYING.txt new file mode 100644 index 0000000000000000000000000000000000000000..d15b0c24134de8ce0185ac22cb2dd96e23911fab --- /dev/null +++ b/micro/third_party/gflags/COPYING.txt @@ -0,0 +1,28 @@ +Copyright (c) 2006, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/micro/third_party/gflags/gflags.cmake b/micro/third_party/gflags/gflags.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2a4f0343d901f70406c97dfae2c63917381890b3 --- /dev/null +++ b/micro/third_party/gflags/gflags.cmake @@ -0,0 +1,50 @@ +INCLUDE(ExternalProject) + +set(GFLAGS_SRCS_DIR "${MACE_THIRD_PARTY_DIR}/gflags") +set(GFLAGS_INSTALL_DIR "${MACE_THIRD_PARTY_DIR}/install/gflags") +set(GFLAGS_INCLUDE_DIR "${GFLAGS_INSTALL_DIR}/include" CACHE PATH "gflags include directory." FORCE) + +if(MSVC) + set(GFLAGS_LIBRARIES "${GFLAGS_INSTALL_DIR}/lib/gflags_static.lib" CACHE FILEPATH "GFLAGS_LIBRARIES" FORCE) +else(MSVC) + set(GFLAGS_LIBRARIES "${GFLAGS_INSTALL_DIR}/lib/libgflags.a" CACHE FILEPATH "GFLAGS_LIBRARIES" FORCE) +endif(MSVC) + +include_directories(SYSTEM ${GFLAGS_INCLUDE_DIR}) + +# Mirror of https://github.com/gflags/gflags/archive/v2.2.2.zip +set(GFLAGS_URL "https://cnbj1.fds.api.xiaomi.com/mace/third-party/gflags/v2.2.2.zip") +set(GFLAGS_HASH "SHA256=19713a36c9f32b33df59d1c79b4958434cb005b5b47dc5400a7a4b078111d9b5") + +ExternalProject_Add( + gflags_gflags + URL_HASH "${GFLAGS_HASH}" + URL "${GFLAGS_URL}" + PREFIX ${GFLAGS_SRCS_DIR} + UPDATE_COMMAND "" + BUILD_BYPRODUCTS ${GFLAGS_LIBRARIES} + CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${GFLAGS_INSTALL_DIR} + -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER} + -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER} + -DBUILD_STATIC_LIBS=ON + -DBUILD_TESTING=OFF + -DCMAKE_BUILD_TYPE=Release + -DCMAKE_GENERATOR=${CMAKE_GENERATOR} + ${THIRD_PARTY_EXTRA_CMAKE_ARGS} +) + +if(MSVC) + add_custom_command(TARGET gflags_gflags POST_BUILD + COMMAND if $==1 (${CMAKE_COMMAND} -E copy ${GFLAGS_INSTALL_DIR}/lib/gflags_static_debug.lib ${GFLAGS_INSTALL_DIR}/lib/gflags_static.lib) + ) +endif(MSVC) + +add_library(gflags STATIC IMPORTED GLOBAL) +set_property(TARGET gflags PROPERTY IMPORTED_LOCATION ${GFLAGS_LIBRARIES}) +add_dependencies(gflags gflags_gflags) + +if(MSVC) + set_target_properties(gflags + PROPERTIES IMPORTED_LINK_INTERFACE_LIBRARIES + Shlwapi.lib) +endif(MSVC) diff --git a/micro/third_party/googletest/LICENSE b/micro/third_party/googletest/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1941a11f8ce94389160b458927a29ba217542818 --- /dev/null +++ b/micro/third_party/googletest/LICENSE @@ -0,0 +1,28 @@ +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/micro/third_party/googletest/googletest.BUILD b/micro/third_party/googletest/googletest.BUILD new file mode 100644 index 0000000000000000000000000000000000000000..4612f3ba6a33621d9810ae63926f7ca7b59489dc --- /dev/null +++ b/micro/third_party/googletest/googletest.BUILD @@ -0,0 +1,32 @@ +licenses(["notice"]) + +exports_files(["LICENSE"]) + +cc_library( + name = "gtest", + srcs = [ + "googletest/src/gtest-all.cc", + "googlemock/src/gmock-all.cc", + ], + hdrs = glob([ + "**/*.h", + "googletest/src/*.cc", + "googlemock/src/*.cc", + ]), + includes = [ + "googlemock", + "googletest", + "googletest/include", + "googlemock/include", + ], + linkopts = ["-pthread"], + visibility = ["//visibility:public"], +) + +cc_library( + name = "gtest_main", + srcs = ["googlemock/src/gmock_main.cc"], + linkopts = ["-pthread"], + visibility = ["//visibility:public"], + deps = [":gtest"], +) diff --git a/micro/third_party/googletest/googletest.cmake b/micro/third_party/googletest/googletest.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bb5e02e55cfbf2896e3347d4848710e12ef1bf62 --- /dev/null +++ b/micro/third_party/googletest/googletest.cmake @@ -0,0 +1,52 @@ + enable_testing() + + include(ExternalProject) + + set(GTEST_SOURCES_DIR ${MACE_THIRD_PARTY_DIR}/gtest) + set(GTEST_INSTALL_DIR ${MACE_THIRD_PARTY_DIR}/install/gtest) + set(GTEST_INCLUDE_DIR "${GTEST_INSTALL_DIR}/include" CACHE PATH "gtest include directory." FORCE) + + include_directories(SYSTEM ${GTEST_INCLUDE_DIR}) + + if(MSVC) + set(GTEST_LIBRARIES + "${GTEST_INSTALL_DIR}/lib/gtest.lib" CACHE FILEPATH "gtest libraries." FORCE) + set(GTEST_MAIN_LIBRARIES + "${GTEST_INSTALL_DIR}/lib/gtest_main.lib" CACHE FILEPATH "gtest main libraries." FORCE) + else(MSVC) + set(GTEST_LIBRARIES + "${GTEST_INSTALL_DIR}/lib/libgtest.a" CACHE FILEPATH "gtest libraries." FORCE) + set(GTEST_MAIN_LIBRARIES + "${GTEST_INSTALL_DIR}/lib/libgtest_main.a" CACHE FILEPATH "gtest main libraries." FORCE) + endif(MSVC) + + # Mirror of "https://github.com/google/googletest/archive/release-1.8.0.zip" + set(GTEST_URL "https://cnbj1.fds.api.xiaomi.com/mace/third-party/googletest/googletest-release-1.8.0.zip") + set(GTEST_HASH "SHA256=f3ed3b58511efd272eb074a3a6d6fb79d7c2e6a0e374323d1e6bcbcc1ef141bf") + + ExternalProject_Add( + extern_gtest + URL_HASH "${GTEST_HASH}" + URL "${GTEST_URL}" + PREFIX ${GTEST_SOURCES_DIR} + UPDATE_COMMAND "" + BUILD_BYPRODUCTS ${GTEST_LIBRARIES} ${GTEST_MAIN_LIBRARIES} + CMAKE_ARGS -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} + -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER} + -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER} + -DCMAKE_INSTALL_PREFIX=${GTEST_INSTALL_DIR} + -DBUILD_GMOCK=ON + -Dgtest_disable_pthreads=ON + -Dgtest_force_shared_crt=ON + -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} + -DCMAKE_GENERATOR=${CMAKE_GENERATOR} + ${THIRD_PARTY_EXTRA_CMAKE_ARGS} + ) + + add_library(gtest STATIC IMPORTED GLOBAL) + set_property(TARGET gtest PROPERTY IMPORTED_LOCATION ${GTEST_LIBRARIES}) + add_dependencies(gtest extern_gtest) + + add_library(gtest_main STATIC IMPORTED GLOBAL) + set_property(TARGET gtest_main PROPERTY IMPORTED_LOCATION ${GTEST_MAIN_LIBRARIES}) + add_dependencies(gtest_main extern_gtest) diff --git a/micro/third_party/third_party.cmake b/micro/third_party/third_party.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a5b0fcdb80c35a94051342d153fefc44c44d2e80 --- /dev/null +++ b/micro/third_party/third_party.cmake @@ -0,0 +1,42 @@ +set(MACE_THIRD_PARTY_DIR "${PROJECT_BINARY_DIR}/third_party" CACHE STRING "Third party libraries download & build directories.") + +# Forwarding the cross compile flags +set(THIRD_PARTY_EXTRA_CMAKE_ARGS + -DCMAKE_C_FLAGS=${MACE_CC_FLAGS} + -DCMAKE_CXX_FLAGS=${MACE_CC_FLAGS} +) + +if(CMAKE_TOOLCHAIN_FILE) + set(THIRD_PARTY_EXTRA_CMAKE_ARGS + ${THIRD_PARTY_EXTRA_CMAKE_ARGS} + -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE} + ) +endif(CMAKE_TOOLCHAIN_FILE) + +if(CROSSTOOL_ROOT) + set(THIRD_PARTY_EXTRA_CMAKE_ARGS + ${THIRD_PARTY_EXTRA_CMAKE_ARGS} + -DCROSSTOOL_ROOT=${CROSSTOOL_ROOT} + ) +endif(CROSSTOOL_ROOT) + +if(ANDROID_ABI) + set(THIRD_PARTY_EXTRA_CMAKE_ARGS + ${THIRD_PARTY_EXTRA_CMAKE_ARGS} + -DANDROID_ABI=${ANDROID_ABI} + ) +endif(ANDROID_ABI) + +if(ANDROID_NATIVE_API_LEVEL) + set(THIRD_PARTY_EXTRA_CMAKE_ARGS + ${THIRD_PARTY_EXTRA_CMAKE_ARGS} + -DANDROID_NATIVE_API_LEVEL=${ANDROID_NATIVE_API_LEVEL} + ) +endif(ANDROID_NATIVE_API_LEVEL) + +if(PLATFORM) + set(THIRD_PARTY_EXTRA_CMAKE_ARGS + ${THIRD_PARTY_EXTRA_CMAKE_ARGS} + -DPLATFORM=${PLATFORM} + ) +endif(PLATFORM) diff --git a/micro/tools/CMakeLists.txt b/micro/tools/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..8e52b4b42d053743d3aafe26535ac0d46f833dfb --- /dev/null +++ b/micro/tools/CMakeLists.txt @@ -0,0 +1,9 @@ +if(MICRO_MODEL_NAME) + include (${PROJECT_SOURCE_DIR}/third_party/gflags/gflags.cmake) + add_executable(micro_run_static micro_run.cc) + target_link_libraries(micro_run_static micro_engine gflags) + target_compile_definitions(micro_run_static PRIVATE "-DMICRO_MODEL_NAME=${MICRO_MODEL_NAME}") + if(NOT ANDROID) + target_link_libraries(micro_run_static pthread) + endif() +endif() diff --git a/micro/tools/cmake/cmake-build-arm64-v8a-hexagon-stub.sh b/micro/tools/cmake/cmake-build-arm64-v8a-hexagon-stub.sh new file mode 100755 index 0000000000000000000000000000000000000000..d8b5379eb083228ca36e01412277b365ea06cbc8 --- /dev/null +++ b/micro/tools/cmake/cmake-build-arm64-v8a-hexagon-stub.sh @@ -0,0 +1,28 @@ +#!/bin/bash +if [ -z "$ANDROID_NDK_HOME" ]; then + echo "ANDROID_NDK_HOME is undefined"; +fi + +if [ -z "$HEXAGON_SDK_ROOT" ]; then + echo "HEXAGON_SDK_ROOT is undefined"; +fi + +BUILD_DIR=build/cmake-build/arm64-v8a +mkdir -p ${BUILD_DIR} +cd ${BUILD_DIR} + +cmake ../../.. \ + -DANDROID_ABI="arm64-v8a" \ + -DCMAKE_TOOLCHAIN_FILE=${ANDROID_NDK_HOME}/build/cmake/android.toolchain.cmake \ + -DHEXAGON_SDK_ROOT=${HEXAGON_SDK_ROOT} \ + -DANDROID_NATIVE_API_LEVEL=21 \ + -DCMAKE_BUILD_TYPE=Release \ + -DANDROID_STL=c++_shared \ + -DMACE_ENABLE_RPCMEM=ON \ + -DCMAKE_INSTALL_PREFIX=install \ + -DHEXAGON_STUB=ON \ + $@ || exit 1 + +cmake --build . -- -j || exit 1 + +cd ../../.. diff --git a/micro/tools/cmake/cmake-build-gcc-arm-none-eabi.sh b/micro/tools/cmake/cmake-build-gcc-arm-none-eabi.sh new file mode 100755 index 0000000000000000000000000000000000000000..45d098c19d69c8f70f1ae8caf6931d4a86f122c0 --- /dev/null +++ b/micro/tools/cmake/cmake-build-gcc-arm-none-eabi.sh @@ -0,0 +1,18 @@ +#!/bin/bash +if [ -z "$GCC_ARM_ROOT" ]; then + echo "GCC_ARM_ROOT is undefined"; +fi + +BUILD_DIR=build/cmake-build/gcc-arm-none-eabi +mkdir -p ${BUILD_DIR} +cd ${BUILD_DIR} + +cmake ../../.. \ + -DGCC_ARM_ROOT=${GCC_ARM_ROOT} \ + -DCMAKE_TOOLCHAIN_FILE=./cmake/toolchain/gcc-arm-none-eabi.cmake \ + -DCMAKE_INSTALL_PREFIX=install \ + $@ || exit 1 + +cmake --build . -- -j || exit 1 + +cd ../../.. diff --git a/micro/tools/cmake/cmake-build-hexagon6.sh b/micro/tools/cmake/cmake-build-hexagon6.sh new file mode 100755 index 0000000000000000000000000000000000000000..1c78408954f84d20a17135720755870fdd7bd044 --- /dev/null +++ b/micro/tools/cmake/cmake-build-hexagon6.sh @@ -0,0 +1,26 @@ +#!/bin/bash + +# HEXAGON_TOOLS is the path of "HEXAGON_Tools/6.*.*" toolchain +if [ -z "$HEXAGON_TOOLS" ]; then + echo "HEXAGON_TOOLS is undefined"; +fi + +# HEXAGON_SDK_ROOT is the path of "Hexagon_SDK/3.*.*" +if [ -z "$HEXAGON_SDK_ROOT" ]; then + echo "HEXAGON_SDK_ROOT is undefined"; +fi + +BUILD_DIR=build/cmake-build/hexagon6 +mkdir -p ${BUILD_DIR} +cd ${BUILD_DIR} + +cmake ../../.. \ + -DHEXAGON_SDK_ROOT=${HEXAGON_SDK_ROOT} \ + -DHEXAGON_TOOLS=${HEXAGON_TOOLS} \ + -DCMAKE_TOOLCHAIN_FILE=./cmake/toolchain/hexagon6.toolchain.cmake \ + -DCMAKE_INSTALL_PREFIX=install \ + $@ || exit 1 + +cmake --build . -- -j || exit 1 + +cd ../../.. diff --git a/micro/tools/cmake/cmake-build-hexagon8.sh b/micro/tools/cmake/cmake-build-hexagon8.sh new file mode 100755 index 0000000000000000000000000000000000000000..7baa821f040d3247f04ea8caf8d5e9992ae10b07 --- /dev/null +++ b/micro/tools/cmake/cmake-build-hexagon8.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +# HEXAGON_TOOLS is the path of "HEXAGON_Tools/8.*.*" toolchain +if [ -z "$HEXAGON_TOOLS" ]; then + echo "HEXAGON_TOOLS is undefined"; +fi + +# HEXAGON_SDK_ROOT is the path of "Hexagon_SDK/3.*.*" +if [ -z "$HEXAGON_SDK_ROOT" ]; then + echo "HEXAGON_SDK_ROOT is undefined"; +fi + +BUILD_DIR=build/cmake-build/hexagon8 +mkdir -p ${BUILD_DIR} && cd ${BUILD_DIR} + +cmake ../../.. \ + -DHEXAGON_SDK_ROOT=${HEXAGON_SDK_ROOT} \ + -DHEXAGON_TOOLS=${HEXAGON_TOOLS} \ + -DCMAKE_TOOLCHAIN_FILE=./cmake/toolchain/hexagon8.toolchain.cmake \ + -DCMAKE_INSTALL_PREFIX=install \ + $@ || exit 1 + +cmake --build . -- -j || exit 1 + +cd ../../.. diff --git a/micro/tools/cmake/cmake-build-host.sh b/micro/tools/cmake/cmake-build-host.sh new file mode 100755 index 0000000000000000000000000000000000000000..d9ec5b7bbd8a1886c479473c1cada1446775a151 --- /dev/null +++ b/micro/tools/cmake/cmake-build-host.sh @@ -0,0 +1,12 @@ +#!/bin/bash +BUILD_DIR=build/cmake-build/host +mkdir -p ${BUILD_DIR} && cd ${BUILD_DIR} + +cmake ../../.. \ + -DMACE_MICRO_ENABLE_TESTS=ON \ + -DCMAKE_INSTALL_PREFIX=install \ + $@ || exit 1 + +cmake --build . -- -j || exit 1 + +cd ../../.. diff --git a/tools/python/convert.py b/tools/python/convert.py index f35c229174ae68888886d1cead9ec9c1b20648a0..f12e613dbe559c00431ab0e8d563cb4004543cab 100644 --- a/tools/python/convert.py +++ b/tools/python/convert.py @@ -227,6 +227,10 @@ def parse_args(): type=str, default="build", help="output dir") + parser.add_argument( + "--enable_micro", + action="store_true", + help="enable convert micro.") flgs, _ = parser.parse_known_args() return flgs @@ -234,4 +238,4 @@ def parse_args(): if __name__ == '__main__': flags = parse_args() conf = config_parser.parse(flags.config) - convert(conf, flags.output) + convert(conf, flags.output, flags.enable_micro) diff --git a/tools/python/run_micro.py b/tools/python/run_micro.py index 9008ec02be7faf0245462595ec153d1f0b8bf87e..e100db2c45e32385d1950a354b390d65f187fa1e 100644 --- a/tools/python/run_micro.py +++ b/tools/python/run_micro.py @@ -43,11 +43,10 @@ def join_2d_array(xs): def build_engine(model_name, data_type): mace_check(flags.model_name is not None and len(model_name) > 0, "you should specify model name for build.") - command = "bazel build //micro/tools:micro_run_static" \ - " --config optimization " \ - " --copt \"-DMICRO_MODEL_NAME=%s\"" % model_name + command = "cd micro && tools/cmake/cmake-build-host.sh" \ + " -DMICRO_MODEL_NAME=%s -DCMAKE_BUILD_TYPE=Release" % model_name if data_type == mace_pb2.DT_BFLOAT16: - command += " --copt \"-DMACE_ENABLE_BFLOAT16\"" + command += " -DMACE_ENABLE_BFLOAT16=ON" print("The current engine's data type is bfloat16.") device.execute(command) @@ -169,7 +168,7 @@ def run_model_with_conf(flags, args, model_name, model_conf): if flags.vlog_level > 0: envs += ["MACE_CPP_MIN_VLOG_LEVEL=%s" % flags.vlog_level] - target = Target("bazel-bin/micro/tools/micro_run_static", [], + target = Target("micro/build/cmake-build/host/tools/micro_run_static", [], opts=opts, envs=envs) run_target.run_target(target_abi, install_dir, target, device_ids="host") diff --git a/tools/python/run_micro_bazel.py b/tools/python/run_micro_bazel.py new file mode 100644 index 0000000000000000000000000000000000000000..9008ec02be7faf0245462595ec153d1f0b8bf87e --- /dev/null +++ b/tools/python/run_micro_bazel.py @@ -0,0 +1,292 @@ +# Copyright 2020 The MACE Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import argparse +import copy +import numpy as np +import shutil +import tempfile + +from micro_converter import MicroConverter +from py_proto import mace_pb2 +import run_target +from utils import util +from utils import device +from utils import config_parser +from utils.target import Target +from utils.config_parser import ModelKeys +from utils.util import MaceLogger +from utils.util import mace_check +import validate +import layers_validate + + +def join_2d_array(xs): + return ":".join([",".join([str(y) for y in x]) for x in xs]) + + +def build_engine(model_name, data_type): + mace_check(flags.model_name is not None and len(model_name) > 0, + "you should specify model name for build.") + command = "bazel build //micro/tools:micro_run_static" \ + " --config optimization " \ + " --copt \"-DMICRO_MODEL_NAME=%s\"" % model_name + if data_type == mace_pb2.DT_BFLOAT16: + command += " --copt \"-DMACE_ENABLE_BFLOAT16\"" + print("The current engine's data type is bfloat16.") + device.execute(command) + + +def get_model_conf_by_name(flags, conf): + for name, model_conf in conf["models"].items(): + if not flags.model_name or name == flags.model_name: + return model_conf + return None + + +def run_model(flags, args, conf): + model_conf = get_model_conf_by_name(flags, conf) + mace_check(model_conf is not None, "Get model conf failed.") + model_conf = config_parser.normalize_model_config(model_conf) + run_model_with_conf(flags, args, flags.model_name, model_conf) + + +def gen_sub_model_conf(output_config, flags, conf): + model_conf = copy.deepcopy(get_model_conf_by_name(flags, conf)) + model_conf['subgraphs'][0]['output_tensors'] = \ + output_config['output_tensors'] + model_conf['subgraphs'][0]['output_shapes'] = \ + output_config['output_shapes'] + return model_conf + + +def run_layers_validate(flags, args, original_conf): + model_name = flags.model_name + original_model_dir = flags.output + "/" + \ + original_conf['library_name'] + "/model" + model_dir = "/tmp/micro_run/model" + device.execute("mkdir -p %s" % model_dir) + device.execute("cp -p %s/%s.pb %s" % + (original_model_dir, model_name, model_dir)) + params_file_path = "%s/%s.data" % (original_model_dir, model_name) + output_configs = layers_validate.get_layers( + model_dir, model_name, flags.layers) + + for i in range(len(output_configs)): + sub_model_conf = gen_sub_model_conf( + output_configs[i], flags, original_conf) + with open(output_configs[i]['model_file_path'], "rb") as model_file: + net_def = mace_pb2.NetDef() + net_def.ParseFromString(model_file.read()) + with open(params_file_path, "rb") as params_file: + weights = bytearray(params_file.read()) + micro_conf = \ + config_parser.normalize_model_config(sub_model_conf) + MicroConverter(micro_conf, net_def, + weights, model_name).gen_code() + build_engine(model_name, micro_conf[ModelKeys.data_type]) + run_model_with_conf(flags, args, model_name, micro_conf) + + +def run_model_with_conf(flags, args, model_name, model_conf): + target_abi = "host" + dev = device.HostDevice("host", target_abi) + install_dir = "/tmp/micro_run/" + model_name + + if ModelKeys.check_tensors in model_conf: + model_conf[ModelKeys.output_tensors] = model_conf[ + ModelKeys.check_tensors] + model_conf[ModelKeys.output_shapes] = model_conf[ + ModelKeys.check_shapes] + + model_args = {"model_name": model_name, + "input_node": ",".join( + model_conf[ModelKeys.input_tensors]), + "input_shape": join_2d_array( + model_conf[ModelKeys.input_shapes]), + "output_node": ",".join( + model_conf[ModelKeys.output_tensors]), + "output_shape": join_2d_array( + model_conf[ModelKeys.output_shapes]), + "input_data_format": ",".join( + [df.name for df in + model_conf[ModelKeys.input_data_formats]]), + "output_data_format": ",".join( + [df.name for df in + model_conf[ModelKeys.output_data_formats]]) + } + + opts = ["--%s=%s" % (arg_key, arg_val) for arg_key, arg_val in + model_args.items()] + args + + # generate data start + tmp_dir_name = tempfile.mkdtemp() + input_file_prefix = tmp_dir_name + "/" + model_name + if ModelKeys.validation_inputs_data in model_conf: + input_tensor = model_conf[ModelKeys.input_tensors] + input_data = model_conf[ModelKeys.validation_inputs_data] + mace_check(len(input_tensor) == len(input_data), + "len(input_tensor) != len(validate_data") + + for i in range(len(input_tensor)): + util.download_or_get_file( + model_conf[ModelKeys.validation_inputs_data][i], "", + util.formatted_file_name(input_file_prefix, + input_tensor[i])) + else: + generate_input_data(input_file_prefix, + model_conf[ModelKeys.input_tensors], + model_conf[ModelKeys.input_shapes], + model_conf[ModelKeys.input_ranges], + model_conf[ModelKeys.input_data_types]) + + dev.install(Target(tmp_dir_name), install_dir + "/validate_in") + target_input_file = "%s/validate_in/%s" % ( + install_dir, model_name) + target_output_dir = "%s/validate_out" % install_dir + dev.mkdir(target_output_dir) + target_output_file = target_output_dir + "/" + model_name + opts += ["--input_file=%s" % target_input_file, + "--output_file=%s" % target_output_file] + # generate data end + + envs = [] + if flags.vlog_level > 0: + envs += ["MACE_CPP_MIN_VLOG_LEVEL=%s" % flags.vlog_level] + + target = Target("bazel-bin/micro/tools/micro_run_static", [], + opts=opts, envs=envs) + run_target.run_target(target_abi, install_dir, target, + device_ids="host") + + if flags.validate: + validate_model_file = util.download_or_get_model( + model_conf[ModelKeys.model_file_path], + model_conf[ModelKeys.model_sha256_checksum], + tmp_dir_name) + + validate_weight_file = "" + if ModelKeys.weight_file_path in model_conf: + validate_weight_file = util.download_or_get_model( + model_conf[ModelKeys.weight_file_path], + model_conf[ModelKeys.weight_sha256_checksum], + tmp_dir_name) + + dev.pull(Target(target_output_dir), tmp_dir_name + "/validate_out") + output_file_prefix = tmp_dir_name + "/validate_out/" + model_name + validate.validate(model_conf[ModelKeys.platform], + validate_model_file, + validate_weight_file, + input_file_prefix, + output_file_prefix, + model_conf[ModelKeys.input_shapes], + model_conf[ModelKeys.output_shapes], + model_conf[ModelKeys.input_data_formats], + model_conf[ModelKeys.output_data_formats], + model_conf[ModelKeys.input_tensors], + model_conf[ModelKeys.output_tensors], + flags.validate_threshold, + model_conf[ModelKeys.input_data_types], + flags.backend, + "", + "") + shutil.rmtree(tmp_dir_name) + + +def generate_input_data(input_file, input_node, input_shape, input_ranges, + input_data_type): + np.random.seed() + for i in range(len(input_node)): + data = np.random.random(input_shape[i]) * ( + input_ranges[i][1] - input_ranges[i][0]) + input_ranges[i][0] + input_file_name = util.formatted_file_name(input_file, input_node[i]) + MaceLogger.info('Generate input file: %s' % input_file_name) + if input_data_type[i] == mace_pb2.DT_FLOAT: + np_data_type = np.float32 + elif input_data_type[i] == mace_pb2.DT_INT32: + np_data_type = np.int32 + + data.astype(np_data_type).tofile(input_file_name) + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--config", + type=str, + default="", + help="yaml conf path" + ) + parser.add_argument( + "--model_name", + type=str, + default="", + help="model name in yaml conf" + ) + parser.add_argument( + "--validate", + action="store_true", + help="enable validate" + ) + parser.add_argument( + "--validate_threshold", + type=float, + default="0.99", + help="validate threshold" + ) + parser.add_argument( + "--layers", + type=str, + default="-1", + help="'start_layer:end_layer' or 'layer', similar to python slice." + " Use with --validate flag.") + parser.add_argument( + "--backend", + type=str, + default="tensorflow", + help="onnx backend framework") + parser.add_argument( + "--build", + action="store_true", + help="if build before run" + ) + parser.add_argument( + '--output', + type=str, + default="build", + help="output dir") + parser.add_argument( + '--vlog_level', + type=int, + default="0", + help="vlog level") + + return parser.parse_known_args() + + +if __name__ == "__main__": + flags, args = parse_args() + conf = config_parser.parse(flags.config) + if flags.build or flags.validate: + micro_conf = config_parser.normalize_model_config( + conf[ModelKeys.models][flags.model_name]) + build_engine(flags.model_name, micro_conf[ModelKeys.data_type]) + if flags.validate and flags.layers != "-1": + run_layers_validate(flags, args, conf) + else: + run_model(flags, args, conf) diff --git a/tools/python/utils/device.py b/tools/python/utils/device.py index 0b1740888b09460698589cd1244733b590f6e7c9..8aa755f2002a8803c259a01d362f5f12ee5eadcd 100644 --- a/tools/python/utils/device.py +++ b/tools/python/utils/device.py @@ -37,7 +37,7 @@ def execute(cmd, verbose=True): if not verbose: if p.wait() != 0: - raise Exception("errorcode: %s" % p.returncode) + raise Exception("\"%s\" with errorcode: %s" % (cmd, p.returncode)) return p.stdout.read() buf = []