!5840 add multi-thread-pool support

Merge pull request !5840 from hangq/master

mindspore/lite/internal/src/kernel/fp32/matmul.cc

@@ -148,6 +148,10 @@ int DoMatMul(const TensorPtrVector &in_tensors, const TensorPtrVector &out_tenso
   params->col_8_ = UP_ROUND(params->col_, 8);
 
   MatMulCPUKernelData *kernel_data = (MatMulCPUKernelData *)malloc(sizeof(MatMulCPUKernelData));
+  if (kernel_data == NULL) {
+    LITE_ERROR_LOG("Malloc MatMulCPUKernelData failed");
+    return RET_MEMORY_FAILED;
+  }
   kernel_data->a_c12_ptr_
     = reinterpret_cast<float *>(allocator->Malloc(params->batch * params->row_12_ * params->deep_ * sizeof(float)));
   if (kernel_data->a_c12_ptr_ == NULL) {

mindspore/lite/java/build_aar.sh

@@ -33,7 +33,7 @@ build_mslite_arm64() {
 }
 
 build_mslite_arm32() {
-    # build mindspore-lite arm64
+    # build mindspore-lite arm32
     cd ${TOP_PATH}
     bash build.sh -I arm32
     COMPILE_RET=$?

mindspore/lite/java/java/app/src/main/native/runtime/ms_tensor.cpp

@@ -170,6 +170,7 @@ extern "C" JNIEXPORT jboolean JNICALL Java_com_mindspore_lite_MSTensor_setData(J
   auto *data_arr = env->GetByteArrayElements(data, &is_copy);
   auto *local_data = ms_tensor_ptr->MutableData();
   memcpy(local_data, data_arr, data_len);
+  env->ReleaseByteArrayElements(data, data_arr, JNI_ABORT);
   return static_cast<jboolean>(true);
 }
 
@@ -200,6 +201,7 @@ extern "C" JNIEXPORT jboolean JNICALL Java_com_mindspore_lite_MSTensor_setByteBu
   auto *data_arr = env->GetByteArrayElements(data, &is_copy);
   auto *local_data = ms_tensor_ptr->MutableData();
   memcpy(local_data, data_arr, data_len);
+  env->ReleaseByteArrayElements(data, data_arr, JNI_ABORT);
   return static_cast<jboolean>(true);
 }
 

mindspore/lite/src/CMakeLists.txt

@@ -17,6 +17,7 @@ set(LITE_SRC
         ${CMAKE_CURRENT_SOURCE_DIR}/runtime/workspace_pool.cc
         ${CMAKE_CURRENT_SOURCE_DIR}/tensor.cc
         ${CMAKE_CURRENT_SOURCE_DIR}/executor.cc
+        ${CMAKE_CURRENT_SOURCE_DIR}/inner_context.cc
         ${CMAKE_CURRENT_SOURCE_DIR}/kernel_registry.cc
         ${CMAKE_CURRENT_SOURCE_DIR}/lite_kernel.cc
         ${CMAKE_CURRENT_SOURCE_DIR}/populate_parameter.cc

mindspore/lite/src/inner_context.cc

@@ -0,0 +1,47 @@
+/**
+ * Copyright 2020 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+
+#include "src/inner_context.h"
+#include "include/errorcode.h"
+#include "utils/log_adapter.h"
+
+namespace mindspore::lite {
+int InnerContext::Init() {
+  if (this->thread_pool_ == nullptr) {
+    this->thread_pool_ = CreateLiteThreadPool(this->thread_num_, this->cpu_bind_mode_);
+    if (this->thread_pool_ == nullptr) {
+      MS_LOG(ERROR) << "Create ThreadPool failed";
+      return RET_NULL_PTR;
+    }
+  }
+  if (this->allocator == nullptr) {
+    this->allocator = Allocator::Create();
+    if (this->allocator == nullptr) {
+      MS_LOG(ERROR) << "Create Allocator failed";
+      return RET_NULL_PTR;
+    }
+  }
+  return RET_OK;
+}
+
+InnerContext::~InnerContext() {
+  if (this->thread_pool_ != NULL) {
+    DestroyThreadPool(this->thread_pool_);
+    free(this->thread_pool_);
+    this->thread_pool_ = NULL;
+  }
+}
+}  // namespace mindspore::lite

mindspore/lite/src/inner_context.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2020 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+
+#ifndef MINDSPORE_LITE_SRC_INNER_CONTEXT_H
+#define MINDSPORE_LITE_SRC_INNER_CONTEXT_H
+
+#include "include/context.h"
+#include "src/runtime/runtime_api.h"
+#include "src/runtime/allocator.h"
+
+namespace mindspore::lite {
+struct InnerContext : public Context {
+ public:
+  struct ThreadPool *thread_pool_ = nullptr;
+
+ public:
+  int Init();
+
+  virtual ~InnerContext();
+};
+}  // namespace mindspore::lite
+
+#endif  // MINDSPORE_LITE_SRC_INNER_CONTEXT_H

mindspore/lite/src/kernel_registry.cc

@@ -98,7 +98,7 @@ const kernel::KernelCreator *KernelRegistry::GetCreatorArrays() { return creator
 
 kernel::LiteKernel *KernelRegistry::GetKernel(const std::vector<Tensor *> &in_tensors,
                                               const std::vector<Tensor *> &out_tensors, const PrimitiveC *primitive,
-                                              const Context *ctx, const kernel::KernelKey &key) {
+                                              const InnerContext *ctx, const kernel::KernelKey &key) {
   MS_ASSERT(nullptr != primitive);
   MS_ASSERT(nullptr != ctx);
   auto parameter = kernel::PopulateParameter(primitive);

mindspore/lite/src/kernel_registry.h

@@ -45,7 +45,7 @@ class KernelRegistry {
                  kernel::KernelCreator creator);
   bool Merge(const std::unordered_map<kernel::KernelKey, kernel::KernelCreator> &newCreators);
   kernel::LiteKernel *GetKernel(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                                const PrimitiveC *primitive, const Context *ctx, const kernel::KernelKey &key);
+                                const PrimitiveC *primitive, const InnerContext *ctx, const kernel::KernelKey &key);
 
  protected:
   static const int device_type_length_{kKernelArch_MAX - kKernelArch_MIN + 1};

mindspore/lite/src/lite_kernel.h

@@ -24,7 +24,7 @@
 #endif
 #include "src/ops/primitive_c.h"
 #include "nnacl/op_base.h"
-#include "include/context.h"
+#include "src/inner_context.h"
 #include "src/tensor.h"
 #include "include/errorcode.h"
 
@@ -56,7 +56,7 @@ class LiteKernel {
   LiteKernel() = default;
   // parameter should be deleted or freed by caller, and should be deleted or freed after LiteKernel is deleted
   LiteKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &in_tensors,
-             const std::vector<lite::Tensor *> &out_tensors, const lite::Context *ctx,
+             const std::vector<lite::Tensor *> &out_tensors, const lite::InnerContext *ctx,
              const mindspore::lite::PrimitiveC *primitive)
       : op_parameter_(parameter),
         in_tensors_(in_tensors),
@@ -156,7 +156,7 @@ class LiteKernel {
   std::vector<lite::Tensor *> in_tensors_;
   std::vector<lite::Tensor *> out_tensors_;
   const mindspore::lite::PrimitiveC *primitive_ = nullptr;
-  const lite::Context *context_ = nullptr;
+  const lite::InnerContext *context_ = nullptr;
   std::vector<LiteKernel *> in_kernels_;
   std::vector<LiteKernel *> out_kernels_;
   bool train_mode_ = false;
@@ -168,7 +168,7 @@ class SubGraphKernel : public LiteKernel {
   explicit SubGraphKernel(const std::vector<lite::Tensor *> &inputs, const std::vector<lite::Tensor *> &outputs,
                           const std::vector<kernel::LiteKernel *> &in_kernels,
                           const std::vector<kernel::LiteKernel *> &out_kernels,
-                          const std::vector<kernel::LiteKernel *> &nodes, const lite::Context *ctx,
+                          const std::vector<kernel::LiteKernel *> &nodes, const lite::InnerContext *ctx,
                           const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(nullptr, inputs, outputs, ctx, primitive), nodes_(nodes) {
     in_kernels_ = in_kernels;
@@ -186,7 +186,7 @@ class SubGraphKernel : public LiteKernel {
 
 typedef LiteKernel *(*KernelCreator)(const std::vector<lite::Tensor *> &inputs,
                                      const std::vector<lite::Tensor *> &outputs, OpParameter *parameter,
-                                     const lite::Context *ctx, const KernelKey &desc,
+                                     const lite::InnerContext *ctx, const KernelKey &desc,
                                      const mindspore::lite::PrimitiveC *primitive);
 
 class LiteKernelUtil {

mindspore/lite/src/lite_session.cc

@@ -17,10 +17,10 @@
 #include "src/lite_session.h"
 #include <vector>
 #include <utility>
+#include "src/runtime/runtime_api.h"
 #include "include/errorcode.h"
 #include "utils/log_adapter.h"
 #include "src/scheduler.h"
-#include "src/runtime/runtime_api.h"
 #include "src/runtime/allocator.h"
 #include "src/executor.h"
 #include "src/common/utils.h"
@@ -51,6 +51,8 @@ static bool WeightTensorNeedCopy(const lite::Model *model, const uint32_t tensor
   });
 }
 
+LiteSession::LiteSession() { this->is_running_.store(false); }
+
 int LiteSession::ConvertTensors(const lite::Model *model) {
   MS_ASSERT(model != nullptr);
   copyed_tensor_idxes_.clear();
@@ -247,15 +249,22 @@ void LiteSession::InitGraphInOutTensors(const lite::Model *model) {
 }
 
 int LiteSession::CompileGraph(Model *model) {
+  bool expected = false;
+  if (!is_running_.compare_exchange_strong(expected, true)) {
+    MS_LOG(ERROR) << "Not support multi-threading";
+    return RET_ERROR;
+  }
   // model.MetaGraph ==> kernels
   if (model == nullptr) {
     MS_LOG(ERROR) << "The input model is nullptr.";
+    is_running_.store(false);
     return RET_PARAM_INVALID;
   }
 
   auto ret = ConvertTensors(model);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "ConvertTensors failed: " << ret;
+    is_running_.store(false);
     return ret;
   }
 
@@ -266,47 +275,71 @@ int LiteSession::CompileGraph(Model *model) {
   ret = scheduler.Schedule(model, &tensors_, &kernels_);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "Schedule kernels failed: " << ret;
+    is_running_.store(false);
     return ret;
   }
 
-  executor->Prepare(this->kernels_);
+  ret = executor->Prepare(this->kernels_);
+  if (ret != RET_OK) {
+    MS_LOG(ERROR) << "Prepare kernels failed: " << ret;
+    is_running_.store(false);
+    return ret;
+  }
 #ifndef SUPPORT_TRAIN
   model->Free();
 #endif
+  is_running_.store(false);
   return RET_OK;
 }
 
 std::vector<mindspore::tensor::MSTensor *> LiteSession::GetInputs() const { return this->input_vec_; }
 
 int LiteSession::RunGraph(const session::KernelCallBack &before, const session::KernelCallBack &after) {
+  bool expected = false;
+  if (!is_running_.compare_exchange_strong(expected, true)) {
+    MS_LOG(ERROR) << "Not support multi-threading";
+    return RET_ERROR;
+  }
+  STATUS ret = RET_ERROR;
   MS_ASSERT(this->context_);
   if (before == nullptr && after == nullptr) {
-    return executor->Run(this->inputs_, this->outputs_, this->kernels_, this->context_->allocator.get());
+    ret = executor->Run(this->inputs_, this->outputs_, this->kernels_, this->context_->allocator.get());
   } else {
-    return executor->Run(this->inputs_, this->outputs_, this->kernels_, this->context_->allocator.get(), before, after);
+    ret = executor->Run(this->inputs_, this->outputs_, this->kernels_, this->context_->allocator.get(), before, after);
   }
+  is_running_.store(false);
+  return ret;
 }
 
 int LiteSession::Init(Context *context) {
+  bool expected = false;
+  if (!is_running_.compare_exchange_strong(expected, true)) {
+    MS_LOG(ERROR) << "Not support multi-threading";
+    return RET_ERROR;
+  }
+
   MS_ASSERT(nullptr != context);
-  this->context_ = new (std::nothrow) Context();
+  this->context_ = new (std::nothrow) InnerContext();
   if (this->context_ == nullptr) {
-    MS_LOG(ERROR) << "new context failed";
+    MS_LOG(ERROR) << "New Context failed";
+    is_running_.store(false);
     return RET_MEMORY_FAILED;
   }
-  // context->thread_num_, context->allocator, context->device_ctx
-  this->context_->thread_num_ = context->thread_num_;
   this->context_->allocator = context->allocator;
+  this->context_->thread_num_ = context->thread_num_;
+  this->context_->cpu_bind_mode_ = context->cpu_bind_mode_;
   this->context_->device_type_ = context->device_type_;
   this->context_->float16_priority = context->float16_priority;
-  this->context_->cpu_bind_mode_ = context->cpu_bind_mode_;
-  if (context_->allocator == nullptr) {
-    context_->allocator = Allocator::Create();
+  auto ret = this->context_->Init();
+  if (ret != RET_OK) {
+    MS_LOG(ERROR) << "Init Context failed";
+    is_running_.store(false);
+    return ret;
   }
-  ConfigThreadPool(THREAD_POOL_DEFAULT, context->thread_num_, context->cpu_bind_mode_);
-  auto ret = KernelRegistry::GetInstance()->Init();
+  ret = KernelRegistry::GetInstance()->Init();
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "KernelRegistry Init Failed.";
+    is_running_.store(false);
     return ret;
   }
 #if SUPPORT_GPU
@@ -319,19 +352,27 @@ int LiteSession::Init(Context *context) {
 #endif
   executor = new Executor();
   if (nullptr == executor) {
-    MS_LOG(ERROR) << "new Executor failed";
+    MS_LOG(ERROR) << "New Executor failed";
+    is_running_.store(false);
     return RET_ERROR;
   }
+  is_running_.store(false);
   return RET_OK;
 }
 
 void LiteSession::BindThread(bool if_bind) {
   if (this->context_->cpu_bind_mode_ != NO_BIND) {
-    BindThreads(THREAD_POOL_DEFAULT, if_bind, this->context_->cpu_bind_mode_);
+    MS_ASSERT(this->context_->thread_pool_ != NULL);
+    BindThreads(this->context_->thread_pool_, if_bind, this->context_->cpu_bind_mode_);
   }
 }
 
 LiteSession::~LiteSession() {
+  bool expected = false;
+  if (!is_running_.compare_exchange_strong(expected, true)) {
+    MS_LOG(ERROR) << "Not support multi-threading";
+    return;
+  }
   for (size_t i = 0; i < tensors_.size(); i++) {
     auto *tensor = tensors_.at(i);
     MS_ASSERT(tensor != nullptr);
@@ -358,6 +399,7 @@ LiteSession::~LiteSession() {
   delete this->context_;
   delete this->executor;
   this->executor = nullptr;
+  is_running_.store(false);
 }
 
 std::vector<mindspore::tensor::MSTensor *> LiteSession::GetInputsByName(const std::string &name) const {
@@ -426,6 +468,11 @@ void LiteSession::ResetInputsShape(const std::vector<std::vector<int>> &dims) {
 
 int LiteSession::Resize(const std::vector<mindspore::tensor::MSTensor *> &inputs,
                         const std::vector<std::vector<int>> &dims) {
+  bool expected = false;
+  if (!is_running_.compare_exchange_strong(expected, true)) {
+    MS_LOG(ERROR) << "Not support multi-threading";
+    return RET_ERROR;
+  }
   std::vector<std::vector<int>> old_dims;
   for (size_t i = 0; i < inputs_.size(); ++i) {
     old_dims.push_back(inputs_[i]->shape());
@@ -433,6 +480,7 @@ int LiteSession::Resize(const std::vector<mindspore::tensor::MSTensor *> &inputs
   auto ret = ResizeInputs(inputs, dims);
   if (ret != RET_OK) {
     ResetInputsShape(old_dims);
+    is_running_.store(false);
     return ret;
   }
 
@@ -444,8 +492,10 @@ int LiteSession::Resize(const std::vector<mindspore::tensor::MSTensor *> &inputs
     if (resize_ret != RET_OK) {
       MS_LOG(ERROR) << "restore kernel size fail!ret: " << resize_ret;
     }
+    is_running_.store(false);
     return ret;
   }
+  is_running_.store(false);
   return RET_OK;
 }
 }  // namespace lite

mindspore/lite/src/lite_session.h

@@ -21,11 +21,12 @@
 #include <vector>
 #include <string>
 #include <unordered_map>
+#include <atomic>
 #include "src/lite_kernel.h"
 #include "include/ms_tensor.h"
 #include "include/lite_session.h"
 #include "include/model.h"
-#include "include/context.h"
+#include "src/inner_context.h"
 #include "schema/model_generated.h"
 #include "src/executor.h"
 #include "src/tensor.h"
@@ -34,7 +35,7 @@ namespace mindspore {
 namespace lite {
 class LiteSession : public session::LiteSession {
  public:
-  LiteSession() = default;
+  LiteSession();
 
   ~LiteSession() override;
 
@@ -81,14 +82,13 @@ class LiteSession : public session::LiteSession {
 
   void InitGraphOutputTensorMap(const lite::Model *model);
 
-  int ResizeInputs(const std::vector<mindspore::tensor::MSTensor *> &inputs,
-                   const std::vector<std::vector<int>> &dims);
+  int ResizeInputs(const std::vector<mindspore::tensor::MSTensor *> &inputs, const std::vector<std::vector<int>> &dims);
 
  private:
   void ResetInputsShape(const std::vector<std::vector<int>> &dims);
 
  protected:
-  Context *context_ = nullptr;
+  InnerContext *context_ = nullptr;
   std::vector<kernel::LiteKernel *> kernels_;
   std::vector<Tensor *> tensors_;
   std::vector<size_t> copyed_tensor_idxes_;
@@ -107,6 +107,7 @@ class LiteSession : public session::LiteSession {
   // graph output tensor name -- output tensor
   std::unordered_map<std::string, mindspore::tensor::MSTensor *> output_tensor_map_;
   Executor *executor = nullptr;
+  std::atomic<bool> is_running_ = false;
 };
 }  // namespace lite
 }  // namespace mindspore

mindspore/lite/src/model.cc

@@ -18,6 +18,7 @@
 #include "utils/log_adapter.h"
 #include "include/errorcode.h"
 #include "src/common/graph_util.h"
+#include "include/version.h"
 
 namespace mindspore::lite {
 namespace {
@@ -100,6 +101,11 @@ Model *Model::Import(const char *model_buf, size_t size) {
   if (meta_graph->version() != nullptr) {
     model->version_ = meta_graph->version()->c_str();
   }
+
+  if (model->version_ != Version()) {
+    MS_LOG(WARNING) << "model version is " << model->version_ << ", inference version is " << Version() << " not equal";
+  }
+
   auto in_count = meta_graph->inputIndex()->size();
   for (uint32_t i = 0; i < in_count; ++i) {
     model->input_indices_.push_back(size_t(meta_graph->inputIndex()->GetAs<uint32_t>(i)));

mindspore/lite/src/runtime/kernel/arm/base/arg_min_max_base.cc

@@ -93,7 +93,7 @@ int ArgMinMaxBaseCPUKernel::Run() {
 
 kernel::LiteKernel *CpuArgMinMaxInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                   const std::vector<lite::Tensor *> &outputs, OpParameter *op_parameter,
-                                                  const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                  const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                   const mindspore::lite::PrimitiveC *primitive) {
   if (op_parameter == nullptr) {
     MS_LOG(ERROR) << "Input op_parameter is nullptr!";
@@ -117,7 +117,7 @@ kernel::LiteKernel *CpuArgMinMaxInt8KernelCreator(const std::vector<lite::Tensor
 
 kernel::LiteKernel *CpuArgMinMaxFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                   const std::vector<lite::Tensor *> &outputs, OpParameter *op_parameter,
-                                                  const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                  const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                   const mindspore::lite::PrimitiveC *primitive) {
   if (op_parameter == nullptr) {
     MS_LOG(ERROR) << "Input op_parameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/arg_min_max_base.h

@@ -24,7 +24,7 @@ namespace mindspore::kernel {
 class ArgMinMaxBaseCPUKernel : public LiteKernel {
  public:
   ArgMinMaxBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                         const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                         const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                          const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {}
 

mindspore/lite/src/runtime/kernel/arm/base/batch_to_space_base.cc

@@ -55,7 +55,7 @@ int BatchToSpaceBaseCPUKernel::ReSize() {
 
 kernel::LiteKernel *CpuBatchToSpaceInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                      const std::vector<lite::Tensor *> &outputs,
-                                                     OpParameter *op_parameter, const lite::Context *ctx,
+                                                     OpParameter *op_parameter, const lite::InnerContext *ctx,
                                                      const kernel::KernelKey &desc,
                                                      const mindspore::lite::PrimitiveC *primitive) {
   if (op_parameter == nullptr) {
@@ -80,7 +80,7 @@ kernel::LiteKernel *CpuBatchToSpaceInt8KernelCreator(const std::vector<lite::Ten
 
 kernel::LiteKernel *CpuBatchToSpaceFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                      const std::vector<lite::Tensor *> &outputs,
-                                                     OpParameter *op_parameter, const lite::Context *ctx,
+                                                     OpParameter *op_parameter, const lite::InnerContext *ctx,
                                                      const kernel::KernelKey &desc,
                                                      const mindspore::lite::PrimitiveC *primitive) {
   if (op_parameter == nullptr) {

mindspore/lite/src/runtime/kernel/arm/base/batch_to_space_base.h

@@ -25,7 +25,7 @@ namespace mindspore::kernel {
 class BatchToSpaceBaseCPUKernel : public LiteKernel {
  public:
   BatchToSpaceBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                            const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                            const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                             const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {}
 

mindspore/lite/src/runtime/kernel/arm/base/concat_base.cc

@@ -38,7 +38,7 @@ int ConcatBaseCPUKernel::ReSize() {
 
 kernel::LiteKernel *CpuConcatInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const Context *ctx, const kernel::KernelKey &desc,
+                                               const InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -62,7 +62,7 @@ kernel::LiteKernel *CpuConcatInt8KernelCreator(const std::vector<lite::Tensor *>
 
 kernel::LiteKernel *CpuConcatInt32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const Context *ctx, const kernel::KernelKey &desc,
+                                                const InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -86,7 +86,7 @@ kernel::LiteKernel *CpuConcatInt32KernelCreator(const std::vector<lite::Tensor *
 
 kernel::LiteKernel *CpuConcatFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const Context *ctx, const kernel::KernelKey &desc,
+                                               const InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/concat_base.h

@@ -22,13 +22,13 @@
 #include "nnacl/concat_parameter.h"
 #include "src/runtime/kernel/arm/base/layout_transform.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class ConcatBaseCPUKernel : public LiteKernel {
  public:
   ConcatBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                      const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                      const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                       const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {
     concat_param_ = reinterpret_cast<ConcatParameter *>(op_parameter_);
@@ -44,7 +44,7 @@ class ConcatBaseCPUKernel : public LiteKernel {
 
  protected:
   int axis_;
-  const Context *ctx_;
+  const InnerContext *ctx_;
   int thread_count_;
   ConcatParameter *concat_param_ = nullptr;
 };

mindspore/lite/src/runtime/kernel/arm/base/convolution_base.h

@@ -29,7 +29,7 @@
 #include "include/context.h"
 #include "src/runtime/kernel/arm/base/layout_transform.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 using mindspore::schema::PadMode;
 using mindspore::schema::QuantType;
 
@@ -37,7 +37,7 @@ namespace mindspore::kernel {
 class ConvolutionBaseCPUKernel : public LiteKernel {
  public:
   ConvolutionBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                           const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                           const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                            const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {
     op_parameter_->thread_num_ = ctx->thread_num_;
@@ -64,7 +64,7 @@ class ConvolutionBaseCPUKernel : public LiteKernel {
   int tile_num_;
   void *bias_data_ = nullptr;
   void *nhwc4_input_ = nullptr;
-  const Context *ctx_;
+  const InnerContext *ctx_;
   int thread_count_;
   ConvParameter *conv_param_;
   ConvQuantArg *conv_quant_arg_;

mindspore/lite/src/runtime/kernel/arm/base/crop_base.cc

@@ -32,7 +32,7 @@ int CropBaseCPUKernel::Init() { return RET_OK; }
 
 kernel::LiteKernel *CpuCropInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                              const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                             const Context *ctx, const kernel::KernelKey &desc,
+                                             const InnerContext *ctx, const kernel::KernelKey &desc,
                                              const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -56,7 +56,7 @@ kernel::LiteKernel *CpuCropInt8KernelCreator(const std::vector<lite::Tensor *> &
 
 kernel::LiteKernel *CpuCropInt32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                               const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                              const Context *ctx, const kernel::KernelKey &desc,
+                                              const InnerContext *ctx, const kernel::KernelKey &desc,
                                               const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -80,7 +80,7 @@ kernel::LiteKernel *CpuCropInt32KernelCreator(const std::vector<lite::Tensor *>
 
 kernel::LiteKernel *CpuCropFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                              const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                             const Context *ctx, const kernel::KernelKey &desc,
+                                             const InnerContext *ctx, const kernel::KernelKey &desc,
                                              const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/crop_base.h

@@ -21,13 +21,13 @@
 #include "src/lite_kernel.h"
 #include "nnacl/crop_parameter.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class CropBaseCPUKernel : public LiteKernel {
  public:
   CropBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                    const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                    const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                     const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), thread_count_(ctx->thread_num_) {}
   ~CropBaseCPUKernel() = default;

mindspore/lite/src/runtime/kernel/arm/base/depth_to_space_base.cc

@@ -63,7 +63,7 @@ int DepthToSpaceBaseCPUKernel::ReSize() {
 
 kernel::LiteKernel *CpuDepthToSpaceInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                      const std::vector<lite::Tensor *> &outputs,
-                                                     OpParameter *op_parameter, const lite::Context *ctx,
+                                                     OpParameter *op_parameter, const lite::InnerContext *ctx,
                                                      const kernel::KernelKey &desc,
                                                      const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(desc.type == schema::PrimitiveType_DepthToSpace);
@@ -89,7 +89,7 @@ kernel::LiteKernel *CpuDepthToSpaceInt8KernelCreator(const std::vector<lite::Ten
 
 kernel::LiteKernel *CpuDepthToSpaceFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                      const std::vector<lite::Tensor *> &outputs,
-                                                     OpParameter *op_parameter, const lite::Context *ctx,
+                                                     OpParameter *op_parameter, const lite::InnerContext *ctx,
                                                      const kernel::KernelKey &desc,
                                                      const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(desc.type == schema::PrimitiveType_DepthToSpace);

mindspore/lite/src/runtime/kernel/arm/base/depth_to_space_base.h

@@ -25,7 +25,7 @@ namespace mindspore::kernel {
 class DepthToSpaceBaseCPUKernel : public LiteKernel {
  public:
   DepthToSpaceBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                            const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                            const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                             const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {}
 

mindspore/lite/src/runtime/kernel/arm/base/fullconnection_base.cc

@@ -34,7 +34,7 @@ int FullconnectionBaseCPUKernel::Init() {
 
 kernel::LiteKernel *CpuFullConnectionInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                        const std::vector<lite::Tensor *> &outputs,
-                                                       OpParameter *opParameter, const lite::Context *ctx,
+                                                       OpParameter *opParameter, const lite::InnerContext *ctx,
                                                        const kernel::KernelKey &desc,
                                                        const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
@@ -55,7 +55,7 @@ kernel::LiteKernel *CpuFullConnectionInt8KernelCreator(const std::vector<lite::T
 }
 kernel::LiteKernel *CpuFullConnectionFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                        const std::vector<lite::Tensor *> &outputs,
-                                                       OpParameter *opParameter, const lite::Context *ctx,
+                                                       OpParameter *opParameter, const lite::InnerContext *ctx,
                                                        const kernel::KernelKey &desc,
                                                        const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);

mindspore/lite/src/runtime/kernel/arm/base/fullconnection_base.h

@@ -22,13 +22,13 @@
 #include "include/context.h"
 #include "nnacl/matmul_parameter.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class FullconnectionBaseCPUKernel : public LiteKernel {
  public:
   FullconnectionBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                              const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                              const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                               const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {
     fc_param_ = reinterpret_cast<MatMulParameter *>(op_parameter_);
@@ -42,7 +42,7 @@ class FullconnectionBaseCPUKernel : public LiteKernel {
  protected:
   MatMulParameter *fc_param_;
   int thread_stride_;
-  const Context *ctx_;
+  const InnerContext *ctx_;
   int thread_count_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/arm/base/leaky_relu_base.cc

@@ -31,7 +31,7 @@ int LeakyReluBaseCPUKernel::Init() { return RET_OK; }
 
 kernel::LiteKernel *CpuLeakyReluInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                   const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                  const Context *ctx, const kernel::KernelKey &desc,
+                                                  const InnerContext *ctx, const kernel::KernelKey &desc,
                                                   const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/leaky_relu_base.h

@@ -22,13 +22,13 @@
 #include "nnacl/leaky_relu_parameter.h"
 #include "src/runtime/kernel/arm/base/layout_transform.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class LeakyReluBaseCPUKernel : public LiteKernel {
  public:
   LeakyReluBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                         const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                         const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                          const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {}
 

mindspore/lite/src/runtime/kernel/arm/base/matmul_base.cc

@@ -28,7 +28,7 @@ using mindspore::schema::PrimitiveType_MatMul;
 namespace mindspore::kernel {
 kernel::LiteKernel *CpuMatmulKernelCreator(const std::vector<lite::Tensor *> &inputs,
                                            const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                           const lite::Context *ctx, const kernel::KernelKey &desc,
+                                           const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                            const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Concat);

mindspore/lite/src/runtime/kernel/arm/base/matmul_base.h

@@ -22,13 +22,13 @@
 #include "include/context.h"
 #include "nnacl/matmul_parameter.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class MatmulBaseCPUKernel : public LiteKernel {
  public:
   MatmulBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                      const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                      const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                       const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {
     params_ = reinterpret_cast<MatMulParameter *>(op_parameter_);
@@ -42,7 +42,7 @@ class MatmulBaseCPUKernel : public LiteKernel {
  protected:
   MatMulParameter *params_;
   int thread_stride_;
-  const Context *ctx_;
+  const InnerContext *ctx_;
   int thread_count_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/arm/base/pad.cc

@@ -30,7 +30,7 @@ namespace mindspore::kernel {
 
 kernel::LiteKernel *CpuPadInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                             const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                            const lite::Context *ctx, const kernel::KernelKey &desc,
+                                            const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                             const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Pad);
@@ -51,7 +51,7 @@ kernel::LiteKernel *CpuPadInt8KernelCreator(const std::vector<lite::Tensor *> &i
 
 kernel::LiteKernel *CpuPadFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                             const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                            const lite::Context *ctx, const kernel::KernelKey &desc,
+                                            const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                             const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Pad);

mindspore/lite/src/runtime/kernel/arm/base/pooling_base.cc

@@ -92,7 +92,7 @@ int PoolingBaseCPUKernel::ReSize() {
 
 kernel::LiteKernel *CpuPoolingInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const Context *ctx, const kernel::KernelKey &desc,
+                                                const InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -116,7 +116,7 @@ kernel::LiteKernel *CpuPoolingInt8KernelCreator(const std::vector<lite::Tensor *
 
 kernel::LiteKernel *CpuPoolingFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const Context *ctx, const kernel::KernelKey &desc,
+                                                const InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/pooling_base.h

@@ -22,14 +22,14 @@
 #include "nnacl/fp32/pooling.h"
 #include "include/errorcode.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 using mindspore::lite::RET_ERROR;
 using mindspore::lite::RET_OK;
 namespace mindspore::kernel {
 class PoolingBaseCPUKernel : public LiteKernel {
  public:
   PoolingBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                       const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                       const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                        const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {
     pooling_param_ = reinterpret_cast<PoolingParameter *>(op_parameter_);
@@ -43,7 +43,7 @@ class PoolingBaseCPUKernel : public LiteKernel {
   void FreeQuantParam();
 
  protected:
-  const Context *ctx_;
+  const InnerContext *ctx_;
   int thread_count_;
   PoolingParameter *pooling_param_;
   QuantArg **pooling_quant_arg_ = nullptr;

mindspore/lite/src/runtime/kernel/arm/base/power_base.cc

@@ -33,7 +33,7 @@ int PowerBaseCPUKernel::ReSize() { return RET_OK; }
 
 kernel::LiteKernel *CpuPowerInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                               const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                              const lite::Context *ctx, const kernel::KernelKey &desc,
+                                              const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                               const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -57,7 +57,7 @@ kernel::LiteKernel *CpuPowerInt8KernelCreator(const std::vector<lite::Tensor *>
 
 kernel::LiteKernel *CpuPowerFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                               const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                              const lite::Context *ctx, const kernel::KernelKey &desc,
+                                              const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                               const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Power);

mindspore/lite/src/runtime/kernel/arm/base/power_base.h

@@ -25,7 +25,7 @@ namespace mindspore::kernel {
 class PowerBaseCPUKernel : public LiteKernel {
  public:
   PowerBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                     const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                     const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                      const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {
     param_ = reinterpret_cast<PowerParameter *>(op_parameter_);

mindspore/lite/src/runtime/kernel/arm/base/prior_box.cc

@@ -168,7 +168,7 @@ int PriorBoxCPUKernel::Run() {
     MS_LOG(ERROR) << "Prepare fail! Ret error code[" << prepare_ret << "]";
     return prepare_ret;
   }
-  int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, RunPriorBox, this, thread_count_);
+  int error_code = ParallelLaunch(this->context_->thread_pool_, RunPriorBox, this, thread_count_);
   if (error_code != RET_OK) {
     MS_LOG(ERROR) << "PriorBox run error, error_code[" << error_code << "]";
     return RET_ERROR;
@@ -178,7 +178,7 @@ int PriorBoxCPUKernel::Run() {
 
 kernel::LiteKernel *CpuPriorBoxKernelCreator(const std::vector<lite::Tensor *> &inputs,
                                              const std::vector<lite::Tensor *> &outputs, OpParameter *op_parameter,
-                                             const Context *ctx, const kernel::KernelKey &desc,
+                                             const InnerContext *ctx, const kernel::KernelKey &desc,
                                              const mindspore::lite::PrimitiveC *primitive) {
   if (op_parameter == nullptr) {
     MS_LOG(ERROR) << "Input op_parameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/prior_box.h

@@ -22,13 +22,13 @@
 #include "nnacl/reshape_parameter.h"
 #include "nnacl/prior_box.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class PriorBoxCPUKernel : public LiteKernel {
  public:
   PriorBoxCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                    const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                    const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                     const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {
     prior_box_param_ = reinterpret_cast<PriorBoxParameter *>(op_parameter_);
@@ -41,7 +41,7 @@ class PriorBoxCPUKernel : public LiteKernel {
   int PriorBoxImpl(int task_id);
 
  protected:
-  const Context *ctx_;
+  const InnerContext *ctx_;
   int thread_count_;
 
  private:

mindspore/lite/src/runtime/kernel/arm/base/quant_dtype_cast.cc

@@ -83,8 +83,8 @@ int QuantDTypeCastCPUKernel::QuantDTypeCast(int task_id) {
     MS_LOG(ERROR) << "QuantDTypeCast need quantization parameters which is not found.";
     return RET_ERROR;
   }
-  auto quant_arg = !in_tensors_.front()->GetQuantParams().empty() ? in_tensors_.front()->GetQuantParams().front() :
-                   out_tensors_.front()->GetQuantParams().front();
+  auto quant_arg = !in_tensors_.front()->GetQuantParams().empty() ? in_tensors_.front()->GetQuantParams().front()
+                                                                  : out_tensors_.front()->GetQuantParams().front();
   int ret;
   if (inverse_) {
     ret = DoDequantizeInt8(int8_ptr_ + thread_offset, float32_ptr_ + thread_offset, quant_arg.scale,
@@ -124,7 +124,7 @@ int QuantDTypeCastCPUKernel::Run() {
     int8_ptr_ = reinterpret_cast<int8_t *>(out_tensors_[0]->MutableData());
   }
 
-  auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, QuantDTypeCastRun, this, thread_n_num_);
+  auto ret = ParallelLaunch(this->context_->thread_pool_, QuantDTypeCastRun, this, thread_n_num_);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "Scale error error_code[" << ret << "]";
     return RET_ERROR;
@@ -135,7 +135,7 @@ int QuantDTypeCastCPUKernel::Run() {
 
 kernel::LiteKernel *CpuQuantDTypeCastFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                        const std::vector<lite::Tensor *> &outputs,
-                                                       OpParameter *opParameter, const lite::Context *ctx,
+                                                       OpParameter *opParameter, const lite::InnerContext *ctx,
                                                        const kernel::KernelKey &desc,
                                                        const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {

mindspore/lite/src/runtime/kernel/arm/base/quant_dtype_cast.h

@@ -24,7 +24,7 @@ namespace mindspore::kernel {
 class QuantDTypeCastCPUKernel : public LiteKernel {
  public:
   QuantDTypeCastCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                          const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                          const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                           const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), thread_num_(ctx->thread_num_) {}
   ~QuantDTypeCastCPUKernel() = default;

mindspore/lite/src/runtime/kernel/arm/base/reduce_base.cc

@@ -171,7 +171,7 @@ int ReduceBaseCPUKernel::ReSize() {
 
 kernel::LiteKernel *CpuReduceFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const lite::Context *ctx, const kernel::KernelKey &desc,
+                                               const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Reduce);
@@ -200,7 +200,7 @@ kernel::LiteKernel *CpuReduceFp32KernelCreator(const std::vector<lite::Tensor *>
 
 kernel::LiteKernel *CpuMeanFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                              const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                             const lite::Context *ctx, const kernel::KernelKey &desc,
+                                             const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                              const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Mean);
@@ -229,7 +229,7 @@ kernel::LiteKernel *CpuMeanFp32KernelCreator(const std::vector<lite::Tensor *> &
 
 kernel::LiteKernel *CpuReduceInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const lite::Context *ctx, const kernel::KernelKey &desc,
+                                               const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Reduce);

mindspore/lite/src/runtime/kernel/arm/base/reduce_base.h

@@ -26,7 +26,7 @@ namespace mindspore::kernel {
 class ReduceBaseCPUKernel : public LiteKernel {
  public:
   ReduceBaseCPUKernel(OpParameter *param, const std::vector<lite::Tensor *> &inputs,
-                      const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                      const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                       const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(param, inputs, outputs, ctx, primitive) {}
   virtual ~ReduceBaseCPUKernel() = default;

mindspore/lite/src/runtime/kernel/arm/base/reshape_base.cc

@@ -32,7 +32,7 @@ int ReshapeBaseCPUKernel::Init() { return RET_OK; }
 
 kernel::LiteKernel *CpuReshapeInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const Context *ctx, const kernel::KernelKey &desc,
+                                                const InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -56,7 +56,7 @@ kernel::LiteKernel *CpuReshapeInt8KernelCreator(const std::vector<lite::Tensor *
 
 kernel::LiteKernel *CpuReshapeInt32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                  const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                 const Context *ctx, const kernel::KernelKey &desc,
+                                                 const InnerContext *ctx, const kernel::KernelKey &desc,
                                                  const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -80,7 +80,7 @@ kernel::LiteKernel *CpuReshapeInt32KernelCreator(const std::vector<lite::Tensor
 
 kernel::LiteKernel *CpuReshapeFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const Context *ctx, const kernel::KernelKey &desc,
+                                                const InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/reshape_base.h

@@ -21,13 +21,13 @@
 #include "src/lite_kernel.h"
 #include "nnacl/reshape_parameter.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class ReshapeBaseCPUKernel : public LiteKernel {
  public:
   ReshapeBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                       const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                       const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                        const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx) {
     reshape_param_ = reinterpret_cast<ReshapeParameter *>(op_parameter_);
@@ -39,7 +39,7 @@ class ReshapeBaseCPUKernel : public LiteKernel {
   int Run() override { return 0; }
 
  protected:
-  const Context *ctx_;
+  const InnerContext *ctx_;
   ReshapeParameter *reshape_param_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/arm/base/resize_base.cc

@@ -107,7 +107,7 @@ int ResizeBaseCPUKernel::Init() {
 
 kernel::LiteKernel *CpuResizeFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const lite::Context *ctx, const kernel::KernelKey &desc,
+                                               const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -132,7 +132,7 @@ kernel::LiteKernel *CpuResizeFp32KernelCreator(const std::vector<lite::Tensor *>
 
 kernel::LiteKernel *CpuResizeInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const lite::Context *ctx, const kernel::KernelKey &desc,
+                                               const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/resize_base.h

@@ -27,9 +27,9 @@ namespace mindspore::kernel {
 class ResizeBaseCPUKernel : public LiteKernel {
  public:
   ResizeBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                      const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                      const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                       const mindspore::lite::PrimitiveC *primitive)
-      : LiteKernel(parameter, inputs, outputs, ctx, primitive), context_(ctx) {}
+      : LiteKernel(parameter, inputs, outputs, ctx, primitive) {}
 
   virtual ~ResizeBaseCPUKernel() = default;
 
@@ -37,7 +37,6 @@ class ResizeBaseCPUKernel : public LiteKernel {
   int ReSize() override { return 0; };
 
  protected:
-  const lite::Context *context_;
   int method_;
   int64_t new_height_;
   int64_t new_width_;

mindspore/lite/src/runtime/kernel/arm/base/slice_base.cc

@@ -63,7 +63,7 @@ int SliceBaseCPUKernel::ReSize() {
 
 kernel::LiteKernel *CpuSliceInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                               const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                              const lite::Context *ctx, const kernel::KernelKey &desc,
+                                              const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                               const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -87,7 +87,7 @@ kernel::LiteKernel *CpuSliceInt8KernelCreator(const std::vector<lite::Tensor *>
 
 kernel::LiteKernel *CpuSliceFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                               const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                              const lite::Context *ctx, const kernel::KernelKey &desc,
+                                              const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                               const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/slice_base.h

@@ -25,7 +25,7 @@ namespace mindspore::kernel {
 class SliceBaseCPUKernel : public LiteKernel {
  public:
   SliceBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                     const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                     const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                      const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {
     param_ = reinterpret_cast<SliceParameter *>(op_parameter_);

mindspore/lite/src/runtime/kernel/arm/base/softmax_base.cc

@@ -58,7 +58,7 @@ int SoftmaxBaseCPUKernel::ReSize() {
 
 kernel::LiteKernel *CpuSoftmaxInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -82,7 +82,7 @@ kernel::LiteKernel *CpuSoftmaxInt8KernelCreator(const std::vector<lite::Tensor *
 
 kernel::LiteKernel *CpuSoftmaxFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/softmax_base.h

@@ -25,7 +25,7 @@ namespace mindspore::kernel {
 class SoftmaxBaseCPUKernel : public LiteKernel {
  public:
   SoftmaxBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                       const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                       const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                        const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {
     softmax_param_ = reinterpret_cast<SoftmaxParameter *>(op_parameter_);
@@ -37,7 +37,7 @@ class SoftmaxBaseCPUKernel : public LiteKernel {
   int Run() override { return 0; }
 
  protected:
-  const lite::Context *ctx_;
+  const lite::InnerContext *ctx_;
   int thread_count_;
   SoftmaxParameter *softmax_param_;
 };

mindspore/lite/src/runtime/kernel/arm/base/split_base.cc

@@ -66,7 +66,7 @@ int SplitBaseCPUKernel::ReSize() {
 
 kernel::LiteKernel *CpuSplitInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                               const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                              const Context *ctx, const kernel::KernelKey &desc,
+                                              const InnerContext *ctx, const kernel::KernelKey &desc,
                                               const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -90,7 +90,7 @@ kernel::LiteKernel *CpuSplitInt8KernelCreator(const std::vector<lite::Tensor *>
 
 kernel::LiteKernel *CpuSplitInt32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const Context *ctx, const kernel::KernelKey &desc,
+                                               const InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";
@@ -114,7 +114,7 @@ kernel::LiteKernel *CpuSplitInt32KernelCreator(const std::vector<lite::Tensor *>
 
 kernel::LiteKernel *CpuSplitFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                               const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                              const Context *ctx, const kernel::KernelKey &desc,
+                                              const InnerContext *ctx, const kernel::KernelKey &desc,
                                               const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/split_base.h

@@ -21,13 +21,13 @@
 #include "src/lite_kernel.h"
 #include "nnacl/split_parameter.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class SplitBaseCPUKernel : public LiteKernel {
  public:
   SplitBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                     const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                     const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                      const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {
     param = reinterpret_cast<SplitParameter *>(op_parameter_);
@@ -39,7 +39,7 @@ class SplitBaseCPUKernel : public LiteKernel {
   int Run() override { return 0; }
 
  protected:
-  const Context *ctx_;
+  const InnerContext *ctx_;
   int thread_count_;
   int thread_n_stride_;
   int thread_n_num_;

mindspore/lite/src/runtime/kernel/arm/base/squeeze_base.cc

@@ -31,7 +31,7 @@ int SqueezeBaseCPUKernel::Init() { return RET_OK; }
 
 kernel::LiteKernel *CpuSqueezeInt8KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const Context *ctx, const kernel::KernelKey &desc,
+                                                const InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/base/squeeze_base.h

@@ -22,13 +22,13 @@
 #include "nnacl/squeeze_parameter.h"
 #include "src/runtime/kernel/arm/base/layout_transform.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class SqueezeBaseCPUKernel : public LiteKernel {
  public:
   SqueezeBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                       const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                       const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                        const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive), ctx_(ctx), thread_count_(ctx->thread_num_) {}
 
@@ -42,7 +42,7 @@ class SqueezeBaseCPUKernel : public LiteKernel {
 
  protected:
   int *axis_;
-  const Context *ctx_;
+  const InnerContext *ctx_;
   int thread_count_;
 };
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/arm/base/strided_slice.cc

@@ -118,7 +118,7 @@ int StridedSliceCPUKernel::Run() {
 
 kernel::LiteKernel *CpuStridedSliceKernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                  const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                 const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                 const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                  const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(desc.type == schema::PrimitiveType_StridedSlice);
   if (opParameter == nullptr) {

mindspore/lite/src/runtime/kernel/arm/base/strided_slice.h

@@ -25,7 +25,7 @@ namespace mindspore::kernel {
 class StridedSliceCPUKernel : public LiteKernel {
  public:
   StridedSliceCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                        const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                        const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                         const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~StridedSliceCPUKernel() override = default;

mindspore/lite/src/runtime/kernel/arm/fp16/activation_fp16.cc

@@ -115,7 +115,7 @@ int ActivationFp16CPUKernel::Run() {
     return ret;
   }
 
-  int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ActivationRun, this, thread_count_);
+  int error_code = ParallelLaunch(this->context_->thread_pool_, ActivationRun, this, thread_count_);
   if (error_code != RET_OK) {
     MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]";
     FreeTmpBuffer();
@@ -132,7 +132,7 @@ int ActivationFp16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuActivationFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                    const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                   const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                   const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                    const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Activation);

mindspore/lite/src/runtime/kernel/arm/fp16/activation_fp16.h

@@ -25,7 +25,7 @@ namespace mindspore::kernel {
 class ActivationFp16CPUKernel : public LiteKernel {
  public:
   ActivationFp16CPUKernel(OpParameter *param, const std::vector<lite::Tensor *> &inputs,
-                          const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                          const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                           const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(param, inputs, outputs, ctx, primitive), thread_count_(ctx->thread_num_) {
     type_ = (reinterpret_cast<ActivationParameter *>(param))->type_;

mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.cc

@@ -202,7 +202,7 @@ int ArithmeticFP16CPUKernel::Run() {
     FreeTmpBuffer();
     return RET_ERROR;
   }
-  ret = ParallelLaunch(THREAD_POOL_DEFAULT, ArithmeticsRunFp16, this, context_->thread_num_);
+  ret = ParallelLaunch(this->context_->thread_pool_, ArithmeticsRunFp16, this, context_->thread_num_);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "ArithmeticsRunFp16 run error error_code[" << ret << "]";
   }
@@ -231,7 +231,7 @@ void ArithmeticFP16CPUKernel::FreeTmpBuffer() {
 
 kernel::LiteKernel *CpuArithmeticFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                    const std::vector<lite::Tensor *> &outputs, OpParameter *parameter,
-                                                   const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                   const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                    const mindspore::lite::PrimitiveC *primitive) {
   if (parameter == nullptr) {
     MS_LOG(ERROR) << "input parameter is null!";

mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.h

@@ -36,7 +36,7 @@ typedef struct {
 class ArithmeticFP16CPUKernel : public LiteKernel {
  public:
   ArithmeticFP16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                          const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                          const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                           const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {
     param_ = reinterpret_cast<ArithmeticParameter *>(parameter);

mindspore/lite/src/runtime/kernel/arm/fp16/batchnorm_fp16.cc

@@ -62,7 +62,7 @@ int BatchnormFp16CPUKernel::Run() {
     return RET_ERROR;
   }
 
-  ret = ParallelLaunch(THREAD_POOL_DEFAULT, BatchNormRun, this, op_parameter_->thread_num_);
+  ret = ParallelLaunch(this->context_->thread_pool_, BatchNormRun, this, op_parameter_->thread_num_);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "BatchnormRun error error_code[" << ret << "]";
   }
@@ -92,7 +92,7 @@ void BatchnormFp16CPUKernel::FreeInputAndOutput() {
 
 kernel::LiteKernel *CpuBatchnormFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                   const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                  const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                  const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                   const mindspore::lite::PrimitiveC *primitive) {
   auto *kernel = new (std::nothrow) BatchnormFp16CPUKernel(opParameter, inputs, outputs, ctx, primitive);
   if (kernel == nullptr) {

mindspore/lite/src/runtime/kernel/arm/fp16/batchnorm_fp16.h

@@ -24,7 +24,7 @@ namespace mindspore::kernel {
 class BatchnormFp16CPUKernel : public BatchnormCPUKernel {
  public:
   BatchnormFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                         const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                         const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                          const mindspore::lite::PrimitiveC *primitive)
       : BatchnormCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   virtual ~BatchnormFp16CPUKernel() {}

mindspore/lite/src/runtime/kernel/arm/fp16/cast_fp16.cc

@@ -91,12 +91,12 @@ int CastFp16CPUKernel::Run() {
   if (data_num_ == 0) {
     return RET_OK;
   }
-  return ParallelLaunch(THREAD_POOL_DEFAULT, CastRun, this, op_parameter_->thread_num_);
+  return ParallelLaunch(this->context_->thread_pool_, CastRun, this, op_parameter_->thread_num_);
 }
 
 kernel::LiteKernel *CpuCastFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                              const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                             const lite::Context *ctx, const kernel::KernelKey &desc,
+                                             const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                              const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/fp16/cast_fp16.h

@@ -23,7 +23,7 @@ namespace mindspore::kernel {
 class CastFp16CPUKernel : public LiteKernel {
  public:
   CastFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                    const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                    const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                     const mindspore::lite::PrimitiveC *primitive)
       : LiteKernel(parameter, inputs, outputs, ctx, primitive) {}
 

mindspore/lite/src/runtime/kernel/arm/fp16/common_fp16.cc

@@ -18,7 +18,7 @@
 #include "nnacl/fp16/cast_fp16.h"
 
 namespace mindspore::kernel {
-float16_t *ConvertInputFp32toFp16(lite::Tensor *input, const lite::Context *ctx) {
+float16_t *ConvertInputFp32toFp16(lite::Tensor *input, const lite::InnerContext *ctx) {
   float16_t *fp16_data = nullptr;
   auto data_type = input->data_type();
   if (data_type == kNumberTypeFloat32) {
@@ -32,7 +32,7 @@ float16_t *ConvertInputFp32toFp16(lite::Tensor *input, const lite::Context *ctx)
   return fp16_data;
 }
 
-float16_t *MallocOutputFp16(lite::Tensor *output, const lite::Context *ctx) {
+float16_t *MallocOutputFp16(lite::Tensor *output, const lite::InnerContext *ctx) {
   float16_t *fp16_data = nullptr;
   auto data_type = output->data_type();
   if (data_type == kNumberTypeFloat32) {

mindspore/lite/src/runtime/kernel/arm/fp16/common_fp16.h

@@ -20,9 +20,9 @@
 #include "src/lite_kernel.h"
 
 namespace mindspore::kernel {
-float16_t *ConvertInputFp32toFp16(lite::Tensor *input, const lite::Context *ctx);
+float16_t *ConvertInputFp32toFp16(lite::Tensor *input, const lite::InnerContext *ctx);
 
-float16_t *MallocOutputFp16(lite::Tensor *output, const lite::Context *ctx);
+float16_t *MallocOutputFp16(lite::Tensor *output, const lite::InnerContext *ctx);
 
 bool IsExistFp16Tensor(const std::vector<lite::Tensor *> &inputs, const std::vector<lite::Tensor *> &outputs);
 }  // namespace mindspore::kernel

mindspore/lite/src/runtime/kernel/arm/fp16/concat_fp16.cc

@@ -142,7 +142,7 @@ int ConcatFp16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuConcatFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *parameter,
-                                               const Context *ctx, const kernel::KernelKey &desc,
+                                               const InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   if (parameter == nullptr) {
     MS_LOG(ERROR) << "Input parameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/fp16/concat_fp16.h

@@ -22,13 +22,13 @@
 #include "include/context.h"
 #include "src/runtime/kernel/arm/base/concat_base.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class ConcatFp16CPUKernel : public ConcatBaseCPUKernel {
  public:
   ConcatFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                      const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                      const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                       const mindspore::lite::PrimitiveC *primitive)
       : ConcatBaseCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
 

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_1x1_fp16.cc

@@ -216,7 +216,7 @@ int Convolution1x1FP16CPUKernel::Run() {
       execute_input_ + batch_index * conv_param_->input_h_ * conv_param_->input_w_ * conv_param_->input_channel_,
       execute_output_ + batch_index * matmul_param_->row_ * matmul_param_->col_);
 
-    int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, Convolution1x1Fp16Impl, this, thread_count_);
+    int error_code = ParallelLaunch(this->context_->thread_pool_, Convolution1x1Fp16Impl, this, thread_count_);
     if (error_code != RET_OK) {
       MS_LOG(ERROR) << "conv1x1 fp16 error error_code[" << error_code << "]";
       return RET_ERROR;

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_1x1_fp16.h

@@ -29,7 +29,7 @@ namespace mindspore::kernel {
 class Convolution1x1FP16CPUKernel : public ConvolutionBaseFP16CPUKernel {
  public:
   Convolution1x1FP16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                              const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                              const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                               const mindspore::lite::PrimitiveC *primitive)
       : ConvolutionBaseFP16CPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~Convolution1x1FP16CPUKernel() override;

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_3x3_fp16.cc

@@ -237,7 +237,7 @@ int Convolution3x3FP16CPUKernel::Run() {
   int in_channel = conv_param_->input_channel_;
   PackNHWCToNHWC8Fp16(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
 
-  int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, Convolution3x3Fp16Impl, this, thread_count_);
+  int error_code = ParallelLaunch(this->context_->thread_pool_, Convolution3x3Fp16Impl, this, thread_count_);
   if (error_code != RET_OK) {
     MS_LOG(ERROR) << "conv3x3 fp16 error error_code[" << error_code << "]";
     FreeTmpBuffer();

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_3x3_fp16.h

@@ -27,7 +27,7 @@ namespace mindspore::kernel {
 class Convolution3x3FP16CPUKernel : public ConvolutionBaseFP16CPUKernel {
  public:
   Convolution3x3FP16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                              const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                              const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                               const mindspore::lite::PrimitiveC *primitive)
       : ConvolutionBaseFP16CPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~Convolution3x3FP16CPUKernel() override {

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_base_fp16.h

@@ -27,7 +27,7 @@ namespace mindspore::kernel {
 class ConvolutionBaseFP16CPUKernel : public ConvolutionBaseCPUKernel {
  public:
   ConvolutionBaseFP16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                               const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                               const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                                const mindspore::lite::PrimitiveC *primitive)
       : ConvolutionBaseCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~ConvolutionBaseFP16CPUKernel() override;

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.cc

@@ -125,7 +125,7 @@ int ConvolutionDepthwiseFp16CPUKernel::Run() {
     return ret;
   }
 
-  ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConvDwFp16Run, this, conv_param_->thread_num_);
+  ret = ParallelLaunch(this->context_->thread_pool_, ConvDwFp16Run, this, conv_param_->thread_num_);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "ConvDwFp16Run error: error_code[" << ret << "]";
     return RET_ERROR;
@@ -138,7 +138,7 @@ int ConvolutionDepthwiseFp16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuConvDwFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const Context *ctx, const kernel::KernelKey &desc,
+                                               const InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_DepthwiseConv2D);

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.h

@@ -35,7 +35,7 @@ namespace mindspore::kernel {
 class ConvolutionDepthwiseFp16CPUKernel : public ConvolutionBaseFP16CPUKernel {
  public:
   ConvolutionDepthwiseFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                                    const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                                    const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                                     const mindspore::lite::PrimitiveC *primitive)
       : ConvolutionBaseFP16CPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~ConvolutionDepthwiseFp16CPUKernel() override;

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_slidewindow_fp16.cc

@@ -171,7 +171,7 @@ int ConvolutionDepthwiseSWFp16CPUKernel::Run() {
     packed_output_ = execute_output_;
   }
 
-  ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConvDwSWFp16Run, this, conv_param_->thread_num_);
+  ret = ParallelLaunch(this->context_->thread_pool_, ConvDwSWFp16Run, this, conv_param_->thread_num_);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "ConvDwSWFp16Run error: error_code[" << ret << "]";
     return RET_ERROR;

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_slidewindow_fp16.h

@@ -36,7 +36,7 @@ namespace mindspore::kernel {
 class ConvolutionDepthwiseSWFp16CPUKernel : public ConvolutionBaseFP16CPUKernel {
  public:
   ConvolutionDepthwiseSWFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                                      const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                                      const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                                       const mindspore::lite::PrimitiveC *primitive)
       : ConvolutionBaseFP16CPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~ConvolutionDepthwiseSWFp16CPUKernel() override;

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_fp16.cc

@@ -200,7 +200,7 @@ int ConvolutionFP16CPUKernel::Run() {
   int in_channel = conv_param_->input_channel_;
   convert_func_(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
 
-  int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionFp16Impl, this, thread_count_);
+  int error_code = ParallelLaunch(this->context_->thread_pool_, ConvolutionFp16Impl, this, thread_count_);
   if (error_code != RET_OK) {
     MS_LOG(ERROR) << "conv fp16 error error_code[" << error_code << "]";
     FreeTmpBuffer();
@@ -214,7 +214,7 @@ int ConvolutionFP16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuConvFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                              const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                             const Context *ctx, const kernel::KernelKey &desc,
+                                             const InnerContext *ctx, const kernel::KernelKey &desc,
                                              const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Conv2D);

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_fp16.h

@@ -26,7 +26,7 @@ namespace mindspore::kernel {
 class ConvolutionFP16CPUKernel : public ConvolutionBaseFP16CPUKernel {
  public:
   ConvolutionFP16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                           const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                           const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                            const mindspore::lite::PrimitiveC *primitive)
       : ConvolutionBaseFP16CPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~ConvolutionFP16CPUKernel() override {

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_sw_fp16.cc

@@ -214,7 +214,7 @@ int ConvolutionSWFP16CPUKernel::Run() {
   int in_channel = conv_param_->input_channel_;
   convert_func_(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
 
-  int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionSWFp16Impl, this, thread_count_);
+  int error_code = ParallelLaunch(this->context_->thread_pool_, ConvolutionSWFp16Impl, this, thread_count_);
   if (error_code != RET_OK) {
     MS_LOG(ERROR) << "conv fp16 error error_code[" << error_code << "]";
     FreeTmpBuffer();

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_sw_fp16.h

@@ -25,7 +25,7 @@ namespace mindspore::kernel {
 class ConvolutionSWFP16CPUKernel : public ConvolutionBaseFP16CPUKernel {
  public:
   ConvolutionSWFP16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                             const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                             const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                              const mindspore::lite::PrimitiveC *primitive)
       : ConvolutionBaseFP16CPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~ConvolutionSWFP16CPUKernel() override {

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_winograd_fp16.cc

@@ -393,7 +393,7 @@ int ConvolutionWinogradFP16CPUKernel::Run() {
   int in_channel = conv_param_->input_channel_;
   PackNHWCToNHWC8Fp16(execute_input_, nhwc4_input_, in_batch, in_h * in_w, in_channel);
 
-  int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionWinogradFp16Impl, this, thread_count_);
+  int error_code = ParallelLaunch(this->context_->thread_pool_, ConvolutionWinogradFp16Impl, this, thread_count_);
   if (error_code != RET_OK) {
     MS_LOG(ERROR) << "conv winograd error error_code[" << error_code << "]";
     FreeTmpBuffer();

mindspore/lite/src/runtime/kernel/arm/fp16/convolution_winograd_fp16.h

@@ -30,7 +30,7 @@ namespace mindspore::kernel {
 class ConvolutionWinogradFP16CPUKernel : public ConvolutionBaseFP16CPUKernel {
  public:
   ConvolutionWinogradFP16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                                   const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                                   const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                                    const mindspore::lite::PrimitiveC *primitive, int out_unit)
       : ConvolutionBaseFP16CPUKernel(parameter, inputs, outputs, ctx, primitive), output_unit_(out_unit) {}
   ~ConvolutionWinogradFP16CPUKernel() override {

mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.cc

@@ -178,7 +178,7 @@ int DeconvolutionDepthwiseFp16CPUKernel::Run() {
   if (!need_align_) {
     packed_output_ = execute_output_;
   }
-  ret = ParallelLaunch(THREAD_POOL_DEFAULT, DeconvDwFp16Run, this, conv_param_->thread_num_);
+  ret = ParallelLaunch(this->context_->thread_pool_, DeconvDwFp16Run, this, conv_param_->thread_num_);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "DeconvDwFp16Run error: error_code[" << ret << "]";
     return RET_ERROR;
@@ -197,7 +197,7 @@ int DeconvolutionDepthwiseFp16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuDeconvDwFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                  const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                 const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                 const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                  const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_DeDepthwiseConv2D);

mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.h

@@ -37,7 +37,7 @@ namespace mindspore::kernel {
 class DeconvolutionDepthwiseFp16CPUKernel : public ConvolutionBaseFP16CPUKernel {
  public:
   DeconvolutionDepthwiseFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                                      const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                                      const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                                       const mindspore::lite::PrimitiveC *primitive)
       : ConvolutionBaseFP16CPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~DeconvolutionDepthwiseFp16CPUKernel() override;

mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc

@@ -188,7 +188,7 @@ int DeConvolutionFp16CPUKernel::Run() {
   for (int batch_index = 0; batch_index < conv_param_->input_batch_; batch_index++) {
     RowMajor2Col16MajorFp16(execute_input_, pack_input_, input_plane_, conv_param_->input_channel_);
 
-    error_code = ParallelLaunch(THREAD_POOL_DEFAULT, DeConvFp16Run, this, thread_count_);
+    error_code = ParallelLaunch(this->context_->thread_pool_, DeConvFp16Run, this, thread_count_);
     if (error_code != RET_OK) {
       MS_LOG(ERROR) << "deconv fp32 run error! error_code[" << error_code << "]";
       return RET_ERROR;
@@ -204,7 +204,7 @@ int DeConvolutionFp16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuDeConvFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const lite::Context *ctx, const kernel::KernelKey &desc,
+                                               const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_DeConv2D);

mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.h

@@ -33,7 +33,7 @@ namespace mindspore::kernel {
 class DeConvolutionFp16CPUKernel : public ConvolutionBaseFP16CPUKernel {
  public:
   DeConvolutionFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                             const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                             const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                              const mindspore::lite::PrimitiveC *primitive)
       : ConvolutionBaseFP16CPUKernel(parameter, inputs, outputs, ctx, primitive) {
     matmul_param_ = new (std::nothrow) MatMulParameter();

mindspore/lite/src/runtime/kernel/arm/fp16/fullconnection_fp16.cc

@@ -154,7 +154,7 @@ int FullconnectionFP16CPUKernel::Run() {
   } else {
     InitMatrixA(reinterpret_cast<float16_t *>(in_tensors_[0]->MutableData()), a_pack_ptr_);
   }
-  ParallelLaunch(THREAD_POOL_DEFAULT, FcFP16Run, this, thread_count_);
+  ParallelLaunch(this->context_->thread_pool_, FcFP16Run, this, thread_count_);
   if (out_tensor->data_type() == kNumberTypeFloat32) {
     auto size = out_tensor->ElementsNum();
     auto out_tensor_data = reinterpret_cast<float *>(out_tensor->MutableData());
@@ -165,7 +165,7 @@ int FullconnectionFP16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuFullConnectionFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                        const std::vector<lite::Tensor *> &outputs,
-                                                       OpParameter *opParameter, const lite::Context *ctx,
+                                                       OpParameter *opParameter, const lite::InnerContext *ctx,
                                                        const kernel::KernelKey &desc,
                                                        const mindspore::lite::PrimitiveC *primitive) {
   auto *kernel = new (std::nothrow) FullconnectionFP16CPUKernel(opParameter, inputs, outputs, ctx, primitive);

mindspore/lite/src/runtime/kernel/arm/fp16/fullconnection_fp16.h

@@ -29,7 +29,7 @@ namespace mindspore::kernel {
 class FullconnectionFP16CPUKernel : public FullconnectionBaseCPUKernel {
  public:
   explicit FullconnectionFP16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                                       const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                                       const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                                        const mindspore::lite::PrimitiveC *primitive)
       : FullconnectionBaseCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~FullconnectionFP16CPUKernel() override;

mindspore/lite/src/runtime/kernel/arm/fp16/fused_batchnorm_fp16.cc

@@ -79,7 +79,7 @@ int FusedBatchnormFp16CPUKernel::DoExecute(int task_id) {
 
 kernel::LiteKernel *CpuFusedBatchnormFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                        const std::vector<lite::Tensor *> &outputs,
-                                                       OpParameter *op_parameter, const lite::Context *ctx,
+                                                       OpParameter *op_parameter, const lite::InnerContext *ctx,
                                                        const kernel::KernelKey &desc,
                                                        const mindspore::lite::PrimitiveC *primitive) {
   FusedBatchnormFp16CPUKernel *kernel =

mindspore/lite/src/runtime/kernel/arm/fp16/fused_batchnorm_fp16.h

@@ -24,7 +24,7 @@ namespace mindspore::kernel {
 class FusedBatchnormFp16CPUKernel : public FusedBatchnormCPUKernel {
  public:
   FusedBatchnormFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                              const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                              const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                               const mindspore::lite::PrimitiveC *primitive)
       : FusedBatchnormCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   virtual ~FusedBatchnormFp16CPUKernel() {}

mindspore/lite/src/runtime/kernel/arm/fp16/matmul_fp16.cc

@@ -216,7 +216,7 @@ int MatmulFP16CPUKernel::Run() {
     current_a_ = a_pack_ptr_ + i * params_->row_16_ * params_->deep_;
     current_b_ = b_pack_ptr_ + i * params_->deep_ * params_->col_8_;
     current_c_ = c_ptr + i * params_->row_ * params_->col_;
-    ParallelLaunch(THREAD_POOL_DEFAULT, MatmulFP16Run, this, thread_count_);
+    ParallelLaunch(this->context_->thread_pool_, MatmulFP16Run, this, thread_count_);
   }
   if (out_tensor->data_type() == kNumberTypeFloat32) {
     auto size = out_tensor->ElementsNum();
@@ -228,7 +228,7 @@ int MatmulFP16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuMatmulFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const lite::Context *ctx, const kernel::KernelKey &desc,
+                                               const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   auto *kernel = new (std::nothrow) MatmulFP16CPUKernel(opParameter, inputs, outputs, ctx, primitive);
   if (kernel == nullptr) {

mindspore/lite/src/runtime/kernel/arm/fp16/matmul_fp16.h

@@ -29,7 +29,7 @@ namespace mindspore::kernel {
 class MatmulFP16CPUKernel : public MatmulBaseCPUKernel {
  public:
   explicit MatmulFP16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                               const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                               const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                                const mindspore::lite::PrimitiveC *primitive)
       : MatmulBaseCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~MatmulFP16CPUKernel() override;

mindspore/lite/src/runtime/kernel/arm/fp16/pad_fp16.cc

@@ -55,7 +55,7 @@ int PadFp16CPUKernel::Run() {
   }
 
   memset(output_, 0, output_tensor->ElementsNum() * sizeof(float16_t));
-  ret = ParallelLaunch(THREAD_POOL_DEFAULT, PadImpl, this, op_parameter_->thread_num_);
+  ret = ParallelLaunch(this->context_->thread_pool_, PadImpl, this, op_parameter_->thread_num_);
   if (ret != RET_OK) {
     MS_LOG(ERROR) << "BatchnormRun error error_code[" << ret << "]";
   }
@@ -78,9 +78,8 @@ void PadFp16CPUKernel::FreeInputAndOutput() {
 }
 
 kernel::LiteKernel *CpuPadFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
-                                            const std::vector<lite::Tensor *> &outputs,
-                                            OpParameter *opParameter, const lite::Context *ctx,
-                                            const kernel::KernelKey &desc,
+                                            const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
+                                            const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                             const mindspore::lite::PrimitiveC *primitive) {
   auto *kernel = new (std::nothrow) PadFp16CPUKernel(opParameter, inputs, outputs, ctx, primitive);
   if (kernel == nullptr) {

mindspore/lite/src/runtime/kernel/arm/fp16/pad_fp16.h

@@ -24,7 +24,7 @@ namespace mindspore::kernel {
 class PadFp16CPUKernel : public PadCPUKernel {
  public:
   PadFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                   const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                   const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                    const mindspore::lite::PrimitiveC *primitive)
       : PadCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
 

mindspore/lite/src/runtime/kernel/arm/fp16/pooling_fp16.cc

@@ -88,7 +88,7 @@ int PoolingFp16CPUKernel::Run() {
   MS_ASSERT(out_data_type_ == kNumberTypeFloat32 || out_data_type_ == kNumberTypeFloat16);
   fp16_output_ = MallocOutputFp16(out_tensor, context_);
 
-  int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, PoolingFp16Impl, this, thread_count_);
+  int error_code = ParallelLaunch(this->context_->thread_pool_, PoolingFp16Impl, this, thread_count_);
   if (error_code != RET_OK) {
     MS_LOG(ERROR) << "pooling error error_code[" << error_code << "]";
     return RET_ERROR;
@@ -108,7 +108,7 @@ int PoolingFp16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuPoolingFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const Context *ctx, const kernel::KernelKey &desc,
+                                                const InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/fp16/pooling_fp16.h

@@ -25,7 +25,7 @@ namespace mindspore::kernel {
 class PoolingFp16CPUKernel : public PoolingBaseCPUKernel {
  public:
   PoolingFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                       const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                       const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                        const mindspore::lite::PrimitiveC *primitive)
       : PoolingBaseCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~PoolingFp16CPUKernel() override = default;

mindspore/lite/src/runtime/kernel/arm/fp16/reduce_fp16.cc

@@ -102,7 +102,7 @@ int ReduceFp16CPUKernel::Run() {
     outer_size_ = outer_sizes_[i];
     inner_size_ = inner_sizes_[i];
     axis_size_ = axis_sizes_[i];
-    auto error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ReduceImpl, this, context_->thread_num_);
+    auto error_code = ParallelLaunch(this->context_->thread_pool_, ReduceImpl, this, context_->thread_num_);
     if (error_code != RET_OK) {
       FreeTmpBuffer();
       MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";
@@ -166,7 +166,7 @@ int ReduceFp16CPUKernel::MallocTmpBuffer() {
 
 kernel::LiteKernel *CpuReduceFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                               const lite::Context *ctx, const kernel::KernelKey &desc,
+                                               const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Reduce);
@@ -195,7 +195,7 @@ kernel::LiteKernel *CpuReduceFp16KernelCreator(const std::vector<lite::Tensor *>
 
 kernel::LiteKernel *CpuMeanFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                              const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                             const lite::Context *ctx, const kernel::KernelKey &desc,
+                                             const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                              const mindspore::lite::PrimitiveC *primitive) {
   MS_ASSERT(opParameter != nullptr);
   MS_ASSERT(desc.type == schema::PrimitiveType_Mean);

mindspore/lite/src/runtime/kernel/arm/fp16/reduce_fp16.h

@@ -31,7 +31,7 @@ class ReduceFp16CPUKernel : public ReduceBaseCPUKernel {
 
  public:
   ReduceFp16CPUKernel(OpParameter *param, const std::vector<lite::Tensor *> &inputs,
-                      const std::vector<lite::Tensor *> &outputs, const lite::Context *ctx,
+                      const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
                       const mindspore::lite::PrimitiveC *primitive)
       : ReduceBaseCPUKernel(param, inputs, outputs, ctx, primitive) {}
   ~ReduceFp16CPUKernel() = default;

mindspore/lite/src/runtime/kernel/arm/fp16/reshape_fp16.cc

@@ -76,7 +76,7 @@ int ReshapeFp16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuReshapeFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const Context *ctx, const kernel::KernelKey &desc,
+                                                const InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";

mindspore/lite/src/runtime/kernel/arm/fp16/reshape_fp16.h

@@ -23,13 +23,13 @@
 #include "include/context.h"
 #include "src/runtime/kernel/arm/fp32/reshape.h"
 
-using mindspore::lite::Context;
+using mindspore::lite::InnerContext;
 
 namespace mindspore::kernel {
 class ReshapeFp16CPUKernel : public ReshapeCPUKernel {
  public:
   ReshapeFp16CPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
-                       const std::vector<lite::Tensor *> &outputs, const Context *ctx,
+                       const std::vector<lite::Tensor *> &outputs, const InnerContext *ctx,
                        const mindspore::lite::PrimitiveC *primitive)
       : ReshapeCPUKernel(parameter, inputs, outputs, ctx, primitive) {}
   ~ReshapeFp16CPUKernel() = default;

mindspore/lite/src/runtime/kernel/arm/fp16/softmax_fp16.cc

@@ -126,7 +126,7 @@ int SoftmaxFp16CPUKernel::Run() {
 
 kernel::LiteKernel *CpuSoftmaxFp16KernelCreator(const std::vector<lite::Tensor *> &inputs,
                                                 const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
-                                                const lite::Context *ctx, const kernel::KernelKey &desc,
+                                                const lite::InnerContext *ctx, const kernel::KernelKey &desc,
                                                 const mindspore::lite::PrimitiveC *primitive) {
   if (opParameter == nullptr) {
     MS_LOG(ERROR) << "Input opParameter is nullptr!";