add cmake for micro

.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'

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)

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.
 

micro/.gitignore

+build
+test/**/codegen

micro/.gitlab-ci.yml

+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

micro/CMakeLists.txt

+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)

micro/base/CMakeLists.txt

+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)

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

micro/cmake/find_hexagon_sdk.cmake

+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()

micro/cmake/toolchain/gcc-arm-none-eabi.cmake

+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)

micro/cmake/toolchain/hexagon6.toolchain.cmake

+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()

micro/cmake/toolchain/hexagon8.toolchain.cmake

+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)

micro/codegen/CMakeLists.txt

+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
+)

micro/framework/CMakeLists.txt

+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)

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<model::OutputShape *>(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));

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<int64_t>(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
 }

micro/include/CMakeLists.txt

+add_library(micro_include INTERFACE)
+target_include_directories(micro_include
+  INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+  INTERFACE $<INSTALL_INTERFACE:include>
+)

micro/model/CMakeLists.txt

+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)

micro/ops/CMakeLists.txt

+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)

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

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;

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<uint32_t>(shape_data_size));
   if (input_data_size != output_data_size) {

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

micro/port/CMakeLists.txt

+add_library(micro_port api.cc)
+target_include_directories(micro_port
+  PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../..>
+  PUBLIC $<INSTALL_INTERFACE:include>
+)
+target_compile_options(micro_port PRIVATE "-fPIC")

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<int64_t>(tv.tv_sec) * 1000000 + tv.tv_usec;
+#else
+  // you should rewrite this file in the platform source file.
+  return -1;
 #endif
 }
 

micro/test/CMakeLists.txt

+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)

micro/test/ccbaseline/CMakeLists.txt

+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()

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 {

micro/test/ccbenchmark/CMakeLists.txt

+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()

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 {

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_

micro/test/ccunit/CMakeLists.txt

+
+
+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()

micro/test/ccutils/CMakeLists.txt

+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()

micro/third_party/gflags/COPYING.txt

+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.

micro/third_party/gflags/gflags.cmake

+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 $<CONFIG:Debug>==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)

micro/third_party/googletest/LICENSE

+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.

micro/third_party/googletest/googletest.BUILD

+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"],
+)

micro/third_party/googletest/googletest.cmake

+  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)

micro/third_party/third_party.cmake

+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)

micro/tools/CMakeLists.txt

+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()

micro/tools/cmake/cmake-build-arm64-v8a-hexagon-stub.sh

+#!/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 ../../..

micro/tools/cmake/cmake-build-gcc-arm-none-eabi.sh

+#!/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 ../../..

micro/tools/cmake/cmake-build-hexagon6.sh

+#!/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 ../../..

micro/tools/cmake/cmake-build-hexagon8.sh

+#!/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 ../../..

micro/tools/cmake/cmake-build-host.sh

+#!/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 ../../..

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)

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

tools/python/run_micro_bazel.py

+# 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)

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 = []