!9363 return errorcode in thread pool

From: @hangangqiang
Reviewed-by: 
Signed-off-by:

mindspore/lite/include/errorcode.h

@@ -28,13 +28,14 @@ using STATUS = int;
 constexpr int RET_OK = 0; /**< No error occurs. */
 
 /* Common error code, range: [-1, -100）*/
-constexpr int RET_ERROR = -1;         /**< Common error code. */
-constexpr int RET_NULL_PTR = -2;      /**< NULL pointer returned.*/
-constexpr int RET_PARAM_INVALID = -3; /**< Invalid parameter.*/
-constexpr int RET_NO_CHANGE = -4;     /**< No change. */
-constexpr int RET_SUCCESS_EXIT = -5;  /**< No error but exit. */
-constexpr int RET_MEMORY_FAILED = -6; /**< Fail to create memory. */
-constexpr int RET_NOT_SUPPORT = -7;   /**< Fail to support. */
+constexpr int RET_ERROR = -1;             /**< Common error code. */
+constexpr int RET_NULL_PTR = -2;          /**< NULL pointer returned.*/
+constexpr int RET_PARAM_INVALID = -3;     /**< Invalid parameter.*/
+constexpr int RET_NO_CHANGE = -4;         /**< No change. */
+constexpr int RET_SUCCESS_EXIT = -5;      /**< No error but exit. */
+constexpr int RET_MEMORY_FAILED = -6;     /**< Fail to create memory. */
+constexpr int RET_NOT_SUPPORT = -7;       /**< Fail to support. */
+constexpr int RET_THREAD_POOL_ERROR = -8; /**< Error occur in thread pool. */
 
 /* Executor error code, range: [-100,-200) */
 constexpr int RET_OUT_OF_TENSOR_RANGE = -100; /**< Failed to check range. */

mindspore/lite/src/errorcode.cc

@@ -29,6 +29,7 @@ std::string GetErrorInfo(STATUS status) {
                                          {RET_SUCCESS_EXIT, "No error but exit."},
                                          {RET_MEMORY_FAILED, "Fail to create memory."},
                                          {RET_NOT_SUPPORT, "Fail to support."},
+                                         {RET_THREAD_POOL_ERROR, "Thread pool error."},
                                          {RET_OUT_OF_TENSOR_RANGE, "Failed to check range."},
                                          {RET_INPUT_TENSOR_ERROR, "Failed to check input tensor."},
                                          {RET_REENTRANT_ERROR, "Exist executor running."},

mindspore/lite/src/lite_kernel.cc

@@ -17,13 +17,14 @@
 #include "src/lite_kernel.h"
 #include <algorithm>
 #include <queue>
+#include <set>
 #include "src/tensor.h"
 #include "src/common/utils.h"
 
 namespace mindspore::kernel {
 using mindspore::lite::RET_ERROR;
 using mindspore::lite::RET_OK;
-
+#ifdef SUPPORT_TRAIN
 void *LiteKernel::workspace_ = nullptr;
 
 void LiteKernel::AllocWorkspace(size_t size) {
@@ -40,7 +41,7 @@ void LiteKernel::FreeWorkspace() {
   free(workspace_);
   workspace_ = nullptr;
 }
-
+#endif
 bool LiteKernel::IsReady(const std::vector<lite::Tensor *> &scope_tensors) {
   return std::all_of(this->in_tensors().begin(), this->in_tensors().end(), [&](lite::Tensor *kernel_in_tensor) {
     if (IsContain(scope_tensors, kernel_in_tensor)) {

mindspore/lite/src/lite_kernel.h

@@ -169,15 +169,18 @@ class LiteKernel {
   void set_desc(const KernelKey kernel_key) { desc_ = kernel_key; }
 
   const mindspore::lite::PrimitiveC *GetPrimitive() const { return primitive_; }
+
+  SubGraphType subgraph_type() const { return this->subgraph_type_; }
+
+  virtual std::string ToString() const;
+
+#ifdef SUPPORT_TRAIN
   void set_workspace_size(size_t value) { workspace_size_ = value; }
   size_t workspace_size() { return workspace_size_; }
   static void AllocWorkspace(size_t size);
   static void FreeWorkspace();
   void *workspace() { return workspace_; }
-
-  SubGraphType subgraph_type() const { return this->subgraph_type_; }
-
-  virtual std::string ToString() const;
+#endif
 
  protected:
   bool InferShapeDone() { return !(primitive_ != nullptr && !primitive_->infer_flag()); }
@@ -195,9 +198,11 @@ class LiteKernel {
   bool train_mode_ = false;
   bool trainable_ = false;  // paramaters of this Kernel are trained in Train Session
   bool is_model_output_ = false;
+  SubGraphType subgraph_type_ = kNotSubGraph;
+#ifdef SUPPORT_TRAIN
   size_t workspace_size_ = 0;
   static void *workspace_;
-  SubGraphType subgraph_type_ = kNotSubGraph;
+#endif
 };
 
 typedef LiteKernel *(*KernelCreator)(const std::vector<lite::Tensor *> &inputs,

mindspore/lite/src/runtime/thread_pool.c

@@ -40,7 +40,7 @@
 #endif
 
 #define RET_TP_OK (0)
-#define RET_TP_ERROR (1)
+#define RET_TP_ERROR (-8)
 #define RET_TP_SYSTEM_ERROR (-1)
 
 #define MAX_THREAD_NUM (8)
@@ -49,6 +49,8 @@
 typedef struct {
   int (*func)(void *arg, int);
   void *content;
+  int *return_code;
+  int task_num;
 } Task;
 
 typedef struct Thread {
@@ -669,8 +671,11 @@ int DistributeTask(struct ThreadPool *thread_pool, Task *task, int task_num) {
     return RET_TP_ERROR;
   }
   bool k_success_flag = false;
-  int size = thread_pool->thread_num < task_num ? thread_pool->thread_num : task_num;
-  for (int i = 0; i < size - 1; ++i) {
+  if (thread_pool->thread_num < task_num) {
+    LOG_ERROR("task_num: %d should not be larger than thread num: %d", task_num, thread_pool->thread_num);
+    return RET_TP_ERROR;
+  }
+  for (int i = 0; i < task_num - 1; ++i) {
     do {
       k_success_flag = true;
       if (!PushTaskToQueue(thread_pool, i, task)) {
@@ -683,9 +688,18 @@ int DistributeTask(struct ThreadPool *thread_pool, Task *task, int task_num) {
     LOG_ERROR("task->func is nullptr");
     return RET_TP_ERROR;
   }
-  task->func(task->content, size - 1);
+  if (task->task_num <= task_num - 1) {
+    LOG_ERROR("task_num out of range in master thread");
+    return RET_TP_ERROR;
+  }
+  task->return_code[task_num - 1] = task->func(task->content, task_num - 1);
   // wait
   WaitAllThread(thread_pool);
+  for (size_t i = 0; i < task->task_num; i++) {
+    if (task->return_code[i] != 0) {
+      return task->return_code[i];
+    }
+  }
   return RET_TP_OK;
 }
 
@@ -697,14 +711,26 @@ int AddTask(struct ThreadPool *thread_pool, int func(void *, int), void *content
   // if single thread, run master thread
   if (thread_pool->thread_num <= 1 || task_num <= 1) {
     for (int i = 0; i < task_num; ++i) {
-      func(content, i);
+      int ret = func(content, i);
+      if (ret != 0) {
+        return ret;
+      }
     }
     return RET_TP_OK;
   }
   Task task;
   task.func = func;
   task.content = content;
-  return DistributeTask(thread_pool, &task, task_num);
+  task.return_code = (int *)malloc(sizeof(int) * task_num);
+  task.task_num = task_num;
+  if (task.return_code == NULL) {
+    LOG_ERROR("malloc return code return nullptr");
+    return RET_TP_ERROR;
+  }
+  memset(task.return_code, 0, sizeof(int) * task_num);
+  int ret = DistributeTask(thread_pool, &task, task_num);
+  free(task.return_code);
+  return ret;
 }
 
 int ParallelLaunch(struct ThreadPool *thread_pool, int (*func)(void *, int), void *content, int task_num) {
@@ -730,7 +756,11 @@ void ThreadRun(Thread *thread) {
           LOG_ERROR("task->func is nullptr");
           return;
         }
-        task->func(task->content, thread_id);
+        if (task->task_num <= thread_id) {
+          LOG_ERROR("task_num out of range in worker thread");
+          return;
+        }
+        task->return_code[thread_id] = task->func(task->content, thread_id);
         atomic_fetch_sub_explicit(&thread->task_size, 1, memory_order_release);
         spin_count = 0;
         sem_trywait(&thread->sem);

mindspore/lite/src/tensor.cc

@@ -209,10 +209,15 @@ int32_t Tensor::Width() const {
 }
 
 size_t Tensor::Size() const {
-  size_t size = DataTypeSize(this->data_type_);
-  size *= (format_ == schema::Format::Format_NC4HW4 || format_ == schema::Format::Format_NHWC4) ? ElementsC4Num()
-                                                                                                : ElementsNum();
-  return size;
+  size_t element_size = DataTypeSize(this->data_type_);
+  auto element_num = (format_ == schema::Format::Format_NC4HW4 || format_ == schema::Format::Format_NHWC4)
+                       ? ElementsC4Num()
+                       : ElementsNum();
+  if (element_num < 0) {
+    MS_LOG(ERROR) << "Element number of tensor should large than 0 : " << element_num;
+    return 0;
+  }
+  return element_size * element_num;
 }
 
 int Tensor::ElementsNum() const {

mindspore/lite/test/models_with_several_inputs_or_without_outputs.cfg

@@ -1,7 +1,7 @@
 lite-model_arbitrary-image-stylization-inceptionv3_dr_transfer_1.tflite
 lite-model_arbitrary-image-stylization-inceptionv3_int8_transfer_1.tflite
 lite-model_arbitrary-image-stylization-inceptionv3_fp16_transfer_1.tflite;2
-lite-model_arbitrary-image-stylization-inceptionv3-dynamic-shapes_dr_transfer_1.tflite
+# lite-model_arbitrary-image-stylization-inceptionv3-dynamic-shapes_dr_transfer_1.tflite # has nan input for rsqrt
 lite-model_cartoongan_dr_1.tflite
 mindspore_efficientnet_b0.mindir
 mindspore_efficientnet_b4minus.mindir
@@ -17,7 +17,7 @@ lite-model_east-text-detector_dr_1.tflite
 magenta_arbitrary-image-stylization-v1-256_fp16_transfer_1.tflite;2
 magenta_arbitrary-image-stylization-v1-256_int8_transfer_1.tflite
 magenta_arbitrary-image-stylization-v1-256_int8_prediction_1.tflite
-albert_lite_base_squadv1_1.tflite;3
+# albert_lite_base_squadv1_1.tflite;3 # input need in range [0,2)
 efficientnet_lite0_int8_2.tflite
 efficientnet_lite1_int8_2.tflite
 efficientnet_lite2_int8_2.tflite
@@ -26,7 +26,7 @@ efficientnet_lite4_int8_2.tflite
 mtk_transformer_encoder.tflite
 mtk_transformer_decoder_joint.tflite
 ml_ei_facedetection.onnx
-mobilebert_1_default_1.tflite;3
+# mobilebert_1_default_1.tflite;3  # input need in range [0,2)
 quant_aware_bank_card_detection_inception.onnx
 quant_aware_bank_card_recognition_fcny.onnx
 quant_aware_identify_card_detect.onnx

mindspore/lite/test/run_benchmark_nets.sh

@@ -784,6 +784,9 @@ function Run_x86_sse() {
     # Run converted models which has several inputs or does not need to be cared about the accuracy:
     while read line; do
         model_name=${line%%;*}
+        if [[ $model_name == \#* ]]; then
+          continue
+        fi
         model_name_len=${#model_name}
         input_params=${line:model_name_len+1}
         input_num=${input_params%%;*}
@@ -1163,7 +1166,7 @@ function Run_arm64() {
         else
             run_result='arm64_gpu_fp16: '${model_name}' failed'; echo ${run_result} >> ${run_benchmark_result_file}; return 1
         fi
-	#sleep 1
+    #sleep 1
     done < ${models_gpu_fp16_config}
 
     # Run GPU weightquant converted models:
@@ -1182,7 +1185,7 @@ function Run_arm64() {
         else
             run_result='arm64_gpu_weightquant: '${model_name}' failed'; echo ${run_result} >> ${run_benchmark_result_file}; return 1
         fi
-	#sleep 1
+    #sleep 1
     done < ${models_gpu_weightquant_config}
 
     # Run mindir converted models:
@@ -1206,8 +1209,8 @@ function Run_arm64() {
         # run benchmark test without clib data
         echo ${model_name} >> "${run_arm64_log_file}"
         echo 'cd /data/local/tmp/benchmark_test' > adb_run_cmd.txt
-        echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp/benchmark_test;./benchmark --modelFile='${model_name}'.ms --warmUpLoopCount=1 --loopCount=2' >> "{run_arm64_log_file}"
-        echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp/benchmark_test;./benchmark --modelFile='${model_name}'.ms --warmUpLoopCount=1 --loopCount=2' >> adb_run_cmd.txt
+        echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp/benchmark_test;./benchmark --modelFile='${model_name}'.ms --inDataFile=/data/local/tmp/input_output/input/'${model_name}'.ms.bin --warmUpLoopCount=1 --loopCount=2' >> "{run_arm64_log_file}"
+        echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp/benchmark_test;./benchmark --modelFile='${model_name}'.ms --inDataFile=/data/local/tmp/input_output/input/'${model_name}'.ms.bin --warmUpLoopCount=1 --loopCount=2' >> adb_run_cmd.txt
         adb -s ${device_id} shell < adb_run_cmd.txt >> "${run_arm64_log_file}"
         if [ $? = 0 ]; then
             run_result='arm64: '${model_name}' pass'; echo ${run_result} >> ${run_benchmark_result_file}
@@ -1266,6 +1269,9 @@ function Run_arm64() {
     # Run converted models which has several inputs or does not need to be cared about the accuracy:
     while read line; do
         model_name=${line%%;*}
+        if [[ $model_name == \#* ]]; then
+          continue
+        fi
         model_name_len=${#model_name}
         input_params=${line:model_name_len+1}
         input_num=${input_params%%;*}
@@ -1379,15 +1385,15 @@ echo ${basepath}
 while getopts "r:m:d:" opt; do
     case ${opt} in
         r)
-	    release_path=${OPTARG}
+            release_path=${OPTARG}
             echo "release_path is ${OPTARG}"
             ;;
         m)
-	    models_path=${OPTARG}
+            models_path=${OPTARG}
             echo "models_path is ${OPTARG}"
             ;;
         d)
-	    device_id=${OPTARG}
+            device_id=${OPTARG}
             echo "device_id is ${OPTARG}"
             ;;
         ?)

mindspore/lite/tools/benchmark/benchmark.cc

@@ -33,11 +33,37 @@ static const char *DELIM_COLON = ":";
 static const char *DELIM_COMMA = ",";
 static const char *DELIM_SLASH = "/";
 
-int Benchmark::GenerateRandomData(size_t size, void *data) {
+int Benchmark::GenerateRandomData(size_t size, void *data, TypeId data_type) {
   MS_ASSERT(data != nullptr);
-  char *casted_data = static_cast<char *>(data);
-  for (size_t i = 0; i < size; i++) {
-    casted_data[i] = static_cast<char>(i);
+  switch (data_type) {
+    case kNumberTypeFloat32:
+    case kNumberTypeFloat:
+      FillInputData<float>(size, data, std::uniform_real_distribution<float>(-0.5f, 0.5f));
+      break;
+    case kNumberTypeFloat64:
+      FillInputData<double>(size, data, std::uniform_real_distribution<double>(-0.5, 0.5));
+      break;
+    case kNumberTypeInt64:
+      FillInputData<int64_t>(size, data, std::uniform_int_distribution<int64_t>(0, 99));
+      break;
+    case kNumberTypeInt:
+    case kNumberTypeInt32:
+      FillInputData<int32_t>(size, data, std::uniform_int_distribution<int32_t>(0, 99));
+      break;
+    case kNumberTypeInt16:
+      FillInputData<int16_t>(size, data, std::uniform_int_distribution<int16_t>(0, 99));
+      break;
+    case kNumberTypeInt8:
+      FillInputData<int8_t>(size, data, std::uniform_int_distribution<int8_t>(-127, 127));
+      break;
+    case kNumberTypeUInt8:
+      FillInputData<uint8_t>(size, data, std::uniform_int_distribution<uint8_t>(0, 254));
+      break;
+    default:
+      char *casted_data = static_cast<char *>(data);
+      for (size_t i = 0; i < size; i++) {
+        casted_data[i] = static_cast<char>(i);
+      }
   }
   return RET_OK;
 }
@@ -54,7 +80,7 @@ int Benchmark::GenerateInputData() {
     if (tensor->data_type() == kObjectTypeString) {
       status = StringsToMSTensor({"you're the best."}, tensor);
     } else {
-      status = GenerateRandomData(tensor->Size(), input_data);
+      status = GenerateRandomData(tensor->Size(), input_data, tensor->data_type());
     }
     if (status != RET_OK) {
       std::cerr << "GenerateRandomData for inTensor failed: " << status << std::endl;

mindspore/lite/tools/benchmark/benchmark.h

@@ -19,6 +19,7 @@
 
 #include <getopt.h>
 #include <signal.h>
+#include <random>
 #include <unordered_map>
 #include <fstream>
 #include <iostream>
@@ -124,7 +125,7 @@ class MS_API Benchmark {
   // call GenerateRandomData to fill inputTensors
   int GenerateInputData();
 
-  int GenerateRandomData(size_t size, void *data);
+  int GenerateRandomData(size_t size, void *data, TypeId data_type);
 
   int ReadInputFile();
 
@@ -224,6 +225,14 @@ class MS_API Benchmark {
     }
   }
 
+  template <typename T, typename Distribution>
+  void FillInputData(int size, void *data, Distribution distribution) {
+    MS_ASSERT(data != nullptr);
+    int elements_num = size / sizeof(T);
+    (void)std::generate_n(static_cast<T *>(data), elements_num,
+                          [&]() { return static_cast<T>(distribution(random_engine_)); });
+  }
+
   int MarkPerformance();
 
   int MarkAccuracy();
@@ -249,6 +258,7 @@ class MS_API Benchmark {
 
   KernelCallBack before_call_back_;
   KernelCallBack after_call_back_;
+  std::mt19937 random_engine_;
 };
 
 int MS_API RunBenchmark(int argc, const char **argv);