Nigel
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!4899 change to thread pool implemented by C 

Merge pull request !4899 from wangzhe/master
This commit is contained in:
mindspore-ci-bot 2020-08-26 21:20:32 +08:00 committed by Gitee
parent dc0626497e de33762c77
commit 43a61e46af
122 changed files with 1120 additions and 889 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
mindspore/lite/CMakeLists.txt
View File

@ -166,7 +166,6 @@ if (BUILD_DEVICE)
add_compile_definitions(ENABLE_ARM32) add_compile_definitions(ENABLE_ARM32)
endif () endif ()
if (PLATFORM_ARM64) if (PLATFORM_ARM64)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv8.2-a+dotprod+fp16")
add_compile_definitions(ENABLE_ARM64) add_compile_definitions(ENABLE_ARM64)
if (ENABLE_FP16) if (ENABLE_FP16)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv8.2-a+dotprod+fp16") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv8.2-a+dotprod+fp16")

8
mindspore/lite/include/context.h
View File

@ -20,6 +20,7 @@
#include <string> #include <string>
#include <memory> #include <memory>
#include "include/ms_tensor.h" #include "include/ms_tensor.h"
#include "include/thread_pool_config.h"
namespace mindspore::lite { namespace mindspore::lite {
/// \brief Allocator defined a memory pool for malloc memory and free memory dynamically. /// \brief Allocator defined a memory pool for malloc memory and free memory dynamically.
@ -27,13 +28,6 @@ namespace mindspore::lite {
/// \note List public class and interface for reference. /// \note List public class and interface for reference.
class Allocator; class Allocator;
/// \brief CpuBindMode defined for holding bind cpu strategy argument.
enum CpuBindMode {
MID_CPU = -1, /**< bind middle cpu first */
HIGHER_CPU = 1, /**< bind higher cpu first */
NO_BIND = 0 /**< no bind */
};
/// \brief DeviceType defined for holding user's preferred backend. /// \brief DeviceType defined for holding user's preferred backend.
typedef enum { typedef enum {
DT_CPU, /**< CPU device type */ DT_CPU, /**< CPU device type */

35
mindspore/lite/include/thread_pool_config.h Normal file
View File

@ -0,0 +1,35 @@
/**
* 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_INCLUDE_THREAD_POOL_CONFIG_H_
#define MINDSPORE_LITE_INCLUDE_THREAD_POOL_CONFIG_H_
/// \brief CpuBindMode defined for holding bind cpu strategy argument.
typedef enum Mode {
MID_CPU = -1, /**< bind middle cpu first */
HIGHER_CPU = 1, /**< bind higher cpu first */
NO_BIND = 0 /**< no bind */
} CpuBindMode;
/// \brief ThreadPoolId defined for specifying which thread pool to use.
typedef enum Id {
THREAD_POOL_DEFAULT = 0, /**< default thread pool id */
THREAD_POOL_SECOND = 1, /**< the second thread pool id */
THREAD_POOL_THIRD = 2, /**< the third thread pool id */
THREAD_POOL_FOURTH = 3 /**< the fourth thread pool id */
} ThreadPoolId;
#endif // LITE_MINDSPORE_LITE_INCLUDE_THREAD_POOL_CONFIG_H_

2
mindspore/lite/src/CMakeLists.txt
View File

@ -3,7 +3,7 @@ set(LITE_SRC
${CMAKE_CURRENT_SOURCE_DIR}/common/ms_tensor_utils.cc ${CMAKE_CURRENT_SOURCE_DIR}/common/ms_tensor_utils.cc
${CMAKE_CURRENT_SOURCE_DIR}/runtime/allocator.cc ${CMAKE_CURRENT_SOURCE_DIR}/runtime/allocator.cc
${CMAKE_CURRENT_SOURCE_DIR}/runtime/runtime_api.cc ${CMAKE_CURRENT_SOURCE_DIR}/runtime/runtime_api.cc
${CMAKE_CURRENT_SOURCE_DIR}/runtime/thread_pool.cc ${CMAKE_CURRENT_SOURCE_DIR}/runtime/thread_pool.c
${CMAKE_CURRENT_SOURCE_DIR}/runtime/workspace_pool.cc ${CMAKE_CURRENT_SOURCE_DIR}/runtime/workspace_pool.cc
${CMAKE_CURRENT_SOURCE_DIR}/ir/tensor.cc ${CMAKE_CURRENT_SOURCE_DIR}/ir/tensor.cc
${CMAKE_CURRENT_SOURCE_DIR}/context.cc ${CMAKE_CURRENT_SOURCE_DIR}/context.cc

5
mindspore/lite/src/lite_session.cc
View File

@ -247,7 +247,6 @@ std::vector<mindspore::tensor::MSTensor *> LiteSession::GetInputs() const { retu
int LiteSession::RunGraph(const session::KernelCallBack &before, const session::KernelCallBack &after) { int LiteSession::RunGraph(const session::KernelCallBack &before, const session::KernelCallBack &after) {
MS_EXCEPTION_IF_NULL(this->context_); MS_EXCEPTION_IF_NULL(this->context_);
SetMaxWokerNum(context_->thread_num_);
if (before == nullptr && after == nullptr) { if (before == nullptr && after == nullptr) {
return executor->Run(this->inputs_, this->outputs_, this->kernels_, this->context_->allocator.get()); return executor->Run(this->inputs_, this->outputs_, this->kernels_, this->context_->allocator.get());
} else { } else {
@ -264,7 +263,7 @@ int LiteSession::Init(Context *context) {
} }
this->context_->float16_priority = context->float16_priority; this->context_->float16_priority = context->float16_priority;
this->context_->cpu_bind_mode_ = context->cpu_bind_mode_; this->context_->cpu_bind_mode_ = context->cpu_bind_mode_;
ConfigThreadPool(context->cpu_bind_mode_, context->thread_num_); ConfigThreadPool(THREAD_POOL_DEFAULT, context->thread_num_, context->cpu_bind_mode_);
auto ret = KernelRegistry::GetInstance()->Init(); auto ret = KernelRegistry::GetInstance()->Init();
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "KernelRegistry Init Failed."; MS_LOG(ERROR) << "KernelRegistry Init Failed.";
@ -283,7 +282,7 @@ int LiteSession::Init(Context *context) {
void LiteSession::BindThread(bool if_bind) { void LiteSession::BindThread(bool if_bind) {
if (this->context_->cpu_bind_mode_ != NO_BIND) { if (this->context_->cpu_bind_mode_ != NO_BIND) {
DoAllThreadBind(if_bind, static_cast<int>(this->context_->cpu_bind_mode_)); BindThreads(THREAD_POOL_DEFAULT, if_bind, this->context_->cpu_bind_mode_);
} }
} }

4
mindspore/lite/src/runtime/kernel/arm/base/prior_box.cc
View File

@ -153,7 +153,7 @@ int PriorBoxCPUKernel::PriorBoxImpl(int task_id) {
return ret; return ret;
} }
int RunPriorBox(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int RunPriorBox(void *cdata, int task_id) {
auto prior_box = reinterpret_cast<PriorBoxCPUKernel *>(cdata); auto prior_box = reinterpret_cast<PriorBoxCPUKernel *>(cdata);
auto error_code = prior_box->PriorBoxImpl(task_id); auto error_code = prior_box->PriorBoxImpl(task_id);
@ -170,7 +170,7 @@ int PriorBoxCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail! Ret error code[" << prepare_ret << "]"; MS_LOG(ERROR) << "Prepare fail! Ret error code[" << prepare_ret << "]";
return prepare_ret; return prepare_ret;
} }
int error_code = LiteBackendParallelLaunch(RunPriorBox, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, RunPriorBox, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "PriorBox run error, error_code[" << error_code << "]"; MS_LOG(ERROR) << "PriorBox run error, error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/base/quant_dtype_cast.cc
View File

@ -95,7 +95,7 @@ int QuantDTypeCastCPUKernel::QuantDTypeCast(int task_id) {
return RET_OK; return RET_OK;
} }
int QuantDTypeCastRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int QuantDTypeCastRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<QuantDTypeCastCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<QuantDTypeCastCPUKernel *>(cdata);
auto ret = g_kernel->QuantDTypeCast(task_id); auto ret = g_kernel->QuantDTypeCast(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -119,7 +119,7 @@ int QuantDTypeCastCPUKernel::Run() {
int8_ptr_ = reinterpret_cast<int8_t *>(out_tensors_[0]->Data()); int8_ptr_ = reinterpret_cast<int8_t *>(out_tensors_[0]->Data());
} }
auto ret = LiteBackendParallelLaunch(QuantDTypeCastRun, this, thread_n_num_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, QuantDTypeCastRun, this, thread_n_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "Scale error error_code[" << ret << "]"; MS_LOG(ERROR) << "Scale error error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp16/activation_fp16.cc
View File

@ -92,7 +92,7 @@ int ActivationFp16CPUKernel::DoActivation(int task_id) {
return error_code; return error_code;
} }
int ActivationRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ActivationRun(void *cdata, int task_id) {
auto activation_kernel = reinterpret_cast<ActivationFp16CPUKernel *>(cdata); auto activation_kernel = reinterpret_cast<ActivationFp16CPUKernel *>(cdata);
auto error_code = activation_kernel->DoActivation(task_id); auto error_code = activation_kernel->DoActivation(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -115,7 +115,7 @@ int ActivationFp16CPUKernel::Run() {
return ret; return ret;
} }
int error_code = LiteBackendParallelLaunch(ActivationRun, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ActivationRun, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]"; MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

4
mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.cc
View File

@ -362,7 +362,7 @@ int ArithmeticFP16CPUKernel::DoArithmetic(int task_id) {
return RET_OK; return RET_OK;
} }
static int ArithmeticsRun_Fp16(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int ArithmeticsRun_Fp16(void *cdata, int task_id) {
auto arithmetic_kernel = reinterpret_cast<ArithmeticFP16CPUKernel *>(cdata); auto arithmetic_kernel = reinterpret_cast<ArithmeticFP16CPUKernel *>(cdata);
auto error_code = arithmetic_kernel->DoArithmetic(task_id); auto error_code = arithmetic_kernel->DoArithmetic(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -413,7 +413,7 @@ int ArithmeticFP16CPUKernel::Run() {
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_[1]->Data()), input1_fp16_, Float32ToFloat16(reinterpret_cast<float *>(in_tensors_[1]->Data()), input1_fp16_,
arithmeticParameter_->in_elements_num1_); arithmeticParameter_->in_elements_num1_);
} }
ret = LiteBackendParallelLaunch(ArithmeticsRun_Fp16, this, context_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ArithmeticsRun_Fp16, this, context_->thread_num_);
return ret; return ret;
} }

2
mindspore/lite/src/runtime/kernel/arm/fp16/batchnorm_fp16.cc
View File

@ -65,7 +65,7 @@ int BatchnormFp16CPUKernel::Run() {
input_ = in_tensors_.at(0)->Data(); input_ = in_tensors_.at(0)->Data();
output_ = out_tensors_.at(0)->Data(); output_ = out_tensors_.at(0)->Data();
} }
ret = LiteBackendParallelLaunch(BatchNormRun, this, op_parameter_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, BatchNormRun, this, op_parameter_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "BatchnormRun error error_code[" << ret << "]"; MS_LOG(ERROR) << "BatchnormRun error error_code[" << ret << "]";
} }

6
mindspore/lite/src/runtime/kernel/arm/fp16/cast_fp16.cc
View File

@ -30,13 +30,13 @@ using mindspore::schema::PrimitiveType_Cast;
namespace mindspore::kernel { namespace mindspore::kernel {
namespace { namespace {
int CastRun(int thread_id, LiteParallelGroupEnv *penv, void *cdata) { int CastRun(void *cdata, int task_id) {
if (cdata == nullptr) { if (cdata == nullptr) {
MS_LOG(ERROR) << "input cdata is nullptr!"; MS_LOG(ERROR) << "input cdata is nullptr!";
return RET_ERROR; return RET_ERROR;
} }
return reinterpret_cast<CastFp16CPUKernel *>(cdata)->DoCast(thread_id); return reinterpret_cast<CastFp16CPUKernel *>(cdata)->DoCast(task_id);
} }
} // namespace } // namespace
@ -91,7 +91,7 @@ int CastFp16CPUKernel::Run() {
if (data_num_ == 0) { if (data_num_ == 0) {
return RET_OK; return RET_OK;
} }
return LiteBackendParallelLaunch(CastRun, this, op_parameter_->thread_num_); return ParallelLaunch(THREAD_POOL_DEFAULT, CastRun, this, op_parameter_->thread_num_);
} }
kernel::LiteKernel *CpuCastFp16KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs, kernel::LiteKernel *CpuCastFp16KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,

4
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_1x1_fp16.cc
View File

@ -194,7 +194,7 @@ int Convolution1x1FP16CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
static int Convolution1x1Fp16Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int Convolution1x1Fp16Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<Convolution1x1FP16CPUKernel *>(cdata); auto conv = reinterpret_cast<Convolution1x1FP16CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -222,7 +222,7 @@ int Convolution1x1FP16CPUKernel::Run() {
execute_input_ + batch_index * conv_param_->input_h_ * conv_param_->input_w_ * conv_param_->input_channel_, 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_); execute_output_ + batch_index * matmul_param_->row_ * matmul_param_->col_);
int error_code = LiteBackendParallelLaunch(Convolution1x1Fp16Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, Convolution1x1Fp16Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv1x1 fp16 error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv1x1 fp16 error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_3x3_fp16.cc
View File

@ -197,7 +197,7 @@ int Convolution3x3FP16CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
static int Convolution3x3Fp16Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int Convolution3x3Fp16Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<Convolution3x3FP16CPUKernel *>(cdata); auto conv = reinterpret_cast<Convolution3x3FP16CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -251,7 +251,7 @@ int Convolution3x3FP16CPUKernel::Run() {
int in_channel = conv_param_->input_channel_; int in_channel = conv_param_->input_channel_;
PackNHWCToNHWC8Fp16(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel); PackNHWCToNHWC8Fp16(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
int error_code = LiteBackendParallelLaunch(Convolution3x3Fp16Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, Convolution3x3Fp16Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv3x3 fp16 error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv3x3 fp16 error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

4
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.cc
View File

@ -98,7 +98,7 @@ int ConvolutionDepthwiseFp16CPUKernel::Execute(int task_id) {
return RET_OK; return RET_OK;
} }
static int ConvDwFp16Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int ConvDwFp16Run(void *cdata, int task_id) {
auto conv_dw_fp16 = reinterpret_cast<ConvolutionDepthwiseFp16CPUKernel *>(cdata); auto conv_dw_fp16 = reinterpret_cast<ConvolutionDepthwiseFp16CPUKernel *>(cdata);
auto ret = conv_dw_fp16->Execute(task_id); auto ret = conv_dw_fp16->Execute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -125,7 +125,7 @@ int ConvolutionDepthwiseFp16CPUKernel::Run() {
return ret; return ret;
} }
ret = LiteBackendParallelLaunch(ConvDwFp16Run, this, conv_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConvDwFp16Run, this, conv_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ConvDwFp16Run error: error_code[" << ret << "]"; MS_LOG(ERROR) << "ConvDwFp16Run error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_slidewindow_fp16.cc
View File

@ -129,7 +129,7 @@ int ConvolutionDepthwiseSWFp16CPUKernel::Execute(int task_id) {
return RET_OK; return RET_OK;
} }
static int ConvDwSWFp16Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int ConvDwSWFp16Run(void *cdata, int task_id) {
auto conv_dw_fp16 = reinterpret_cast<ConvolutionDepthwiseSWFp16CPUKernel *>(cdata); auto conv_dw_fp16 = reinterpret_cast<ConvolutionDepthwiseSWFp16CPUKernel *>(cdata);
auto ret = conv_dw_fp16->Execute(task_id); auto ret = conv_dw_fp16->Execute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -171,7 +171,7 @@ int ConvolutionDepthwiseSWFp16CPUKernel::Run() {
packed_output_ = execute_output_; packed_output_ = execute_output_;
} }
ret = LiteBackendParallelLaunch(ConvDwSWFp16Run, this, conv_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConvDwSWFp16Run, this, conv_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ConvDwSWFp16Run error: error_code[" << ret << "]"; MS_LOG(ERROR) << "ConvDwSWFp16Run error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_fp16.cc
View File

@ -177,7 +177,7 @@ int ConvolutionFP16CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
static int ConvolutionFp16Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int ConvolutionFp16Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionFP16CPUKernel *>(cdata); auto conv = reinterpret_cast<ConvolutionFP16CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -206,7 +206,7 @@ int ConvolutionFP16CPUKernel::Run() {
int in_channel = conv_param_->input_channel_; int in_channel = conv_param_->input_channel_;
convert_func_(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel); convert_func_(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
int error_code = LiteBackendParallelLaunch(ConvolutionFp16Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionFp16Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv fp16 error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv fp16 error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_sw_fp16.cc
View File

@ -186,7 +186,7 @@ int ConvolutionSWFP16CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
static int ConvolutionSWFp16Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int ConvolutionSWFp16Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionSWFP16CPUKernel *>(cdata); auto conv = reinterpret_cast<ConvolutionSWFP16CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -219,7 +219,7 @@ int ConvolutionSWFP16CPUKernel::Run() {
int in_channel = conv_param_->input_channel_; int in_channel = conv_param_->input_channel_;
convert_func_(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel); convert_func_(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
int error_code = LiteBackendParallelLaunch(ConvolutionSWFp16Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionSWFp16Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv fp16 error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv fp16 error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

4
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_winograd_fp16.cc
View File

@ -347,7 +347,7 @@ int ConvolutionWinogradFP16CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
static int ConvolutionWinogradFp16Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int ConvolutionWinogradFp16Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionWinogradFP16CPUKernel *>(cdata); auto conv = reinterpret_cast<ConvolutionWinogradFP16CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -404,7 +404,7 @@ int ConvolutionWinogradFP16CPUKernel::Run() {
int in_channel = conv_param_->input_channel_; int in_channel = conv_param_->input_channel_;
PackNHWCToNHWC8Fp16(execute_input_, nhwc4_input_, in_batch, in_h * in_w, in_channel); PackNHWCToNHWC8Fp16(execute_input_, nhwc4_input_, in_batch, in_h * in_w, in_channel);
int error_code = LiteBackendParallelLaunch(ConvolutionWinogradFp16Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionWinogradFp16Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv winograd error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv winograd error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

4
mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.cc
View File

@ -137,7 +137,7 @@ int DeconvolutionDepthwiseFp16CPUKernel::Execute(int task_id) {
return RET_OK; return RET_OK;
} }
static int DeconvDwFp16Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int DeconvDwFp16Run(void *cdata, int task_id) {
auto deconv_dw_fp16 = reinterpret_cast<DeconvolutionDepthwiseFp16CPUKernel *>(cdata); auto deconv_dw_fp16 = reinterpret_cast<DeconvolutionDepthwiseFp16CPUKernel *>(cdata);
auto ret = deconv_dw_fp16->Execute(task_id); auto ret = deconv_dw_fp16->Execute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -178,7 +178,7 @@ int DeconvolutionDepthwiseFp16CPUKernel::Run() {
if (!need_align_) { if (!need_align_) {
packed_output_ = execute_output_; packed_output_ = execute_output_;
} }
ret = LiteBackendParallelLaunch(DeconvDwFp16Run, this, conv_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, DeconvDwFp16Run, this, conv_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "DeconvDwFp16Run error: error_code[" << ret << "]"; MS_LOG(ERROR) << "DeconvDwFp16Run error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc
View File

@ -137,7 +137,7 @@ void DeConvolutionFp16CPUKernel::FreeRunBuf() {
return; return;
} }
static int DeConvFp16Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int DeConvFp16Run(void *cdata, int task_id) {
auto deconv = reinterpret_cast<DeConvolutionFp16CPUKernel *>(cdata); auto deconv = reinterpret_cast<DeConvolutionFp16CPUKernel *>(cdata);
auto error_code = deconv->DoDeconv(task_id); auto error_code = deconv->DoDeconv(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -188,7 +188,7 @@ int DeConvolutionFp16CPUKernel::Run() {
for (int batch_index = 0; batch_index < conv_param_->input_batch_; batch_index++) { for (int batch_index = 0; batch_index < conv_param_->input_batch_; batch_index++) {
RowMajor2Col16MajorFp16(execute_input_, pack_input_, input_plane_, conv_param_->input_channel_); RowMajor2Col16MajorFp16(execute_input_, pack_input_, input_plane_, conv_param_->input_channel_);
error_code = LiteBackendParallelLaunch(DeConvFp16Run, this, thread_count_); error_code = ParallelLaunch(THREAD_POOL_DEFAULT, DeConvFp16Run, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "deconv fp32 run error! error_code[" << error_code << "]"; MS_LOG(ERROR) << "deconv fp32 run error! error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp16/pooling_fp16.cc
View File

@ -89,7 +89,7 @@ int PoolingFp16CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
static int PoolingFp16Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int PoolingFp16Impl(void *cdata, int task_id) {
auto pooling = reinterpret_cast<PoolingFp16CPUKernel *>(cdata); auto pooling = reinterpret_cast<PoolingFp16CPUKernel *>(cdata);
auto error_code = pooling->RunImpl(task_id); auto error_code = pooling->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -109,7 +109,7 @@ int PoolingFp16CPUKernel::Run() {
auto input_ptr = reinterpret_cast<float *>(in_tensors_.at(kInputIndex)->Data()); auto input_ptr = reinterpret_cast<float *>(in_tensors_.at(kInputIndex)->Data());
Float32ToFloat16(input_ptr, fp16_input_, ele_num); Float32ToFloat16(input_ptr, fp16_input_, ele_num);
int error_code = LiteBackendParallelLaunch(PoolingFp16Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, PoolingFp16Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "pooling error error_code[" << error_code << "]"; MS_LOG(ERROR) << "pooling error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp16/reduce_fp16.cc
View File

@ -67,7 +67,7 @@ int ReduceFp16CPUKernel::CallReduceUnit(int task_id) {
return ret; return ret;
} }
static int ReduceImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int ReduceImpl(void *cdata, int task_id) {
auto reduce = reinterpret_cast<ReduceFp16CPUKernel *>(cdata); auto reduce = reinterpret_cast<ReduceFp16CPUKernel *>(cdata);
auto error_code = reduce->CallReduceUnit(task_id); auto error_code = reduce->CallReduceUnit(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -112,7 +112,7 @@ int ReduceFp16CPUKernel::Run() {
inner_size_ *= tmp_shape_[k]; inner_size_ *= tmp_shape_[k];
} }
axis_size_ = tmp_shape_[axis]; axis_size_ = tmp_shape_[axis];
auto error_code = LiteBackendParallelLaunch(ReduceImpl, this, context_->thread_num_); auto error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ReduceImpl, this, context_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
FreeTmpBuffer(); FreeTmpBuffer();
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]"; MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";

4
mindspore/lite/src/runtime/kernel/arm/fp16/split_fp16.cc
View File

@ -63,7 +63,7 @@ int SplitFp16CPUKernel::Split(int task_id) {
return RET_OK; return RET_OK;
} }
static int SplitRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int SplitRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<SplitFp16CPUKernel *>(cdata); auto g_kernel = reinterpret_cast<SplitFp16CPUKernel *>(cdata);
auto ret = g_kernel->Split(task_id); auto ret = g_kernel->Split(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -97,7 +97,7 @@ int SplitFp16CPUKernel::Run() {
output_ptr_[i] = reinterpret_cast<float16_t *>(out_tensors_.at(i)->Data()); output_ptr_[i] = reinterpret_cast<float16_t *>(out_tensors_.at(i)->Data());
} }
} }
ret = LiteBackendParallelLaunch(SplitRun, this, thread_n_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, SplitRun, this, thread_n_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "split error error_code[" << ret << "]"; MS_LOG(ERROR) << "split error error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp16/transpose_fp16.cc
View File

@ -117,7 +117,7 @@ int TransposeFp16CPUKernel::TransposeParallel(int task_id) {
return RET_OK; return RET_OK;
} }
static int TransposeRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { static int TransposeRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<TransposeFp16CPUKernel *>(cdata); auto g_kernel = reinterpret_cast<TransposeFp16CPUKernel *>(cdata);
auto ret = g_kernel->TransposeParallel(task_id); auto ret = g_kernel->TransposeParallel(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -162,7 +162,7 @@ int TransposeFp16CPUKernel::Run() {
in_shape_ = const_cast<int *>(in_tensor->shape().data()); in_shape_ = const_cast<int *>(in_tensor->shape().data());
out_shape_ = const_cast<int *>(out_tensor->shape().data()); out_shape_ = const_cast<int *>(out_tensor->shape().data());
ret = LiteBackendParallelLaunch(TransposeRun, this, thread_h_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, TransposeRun, this, thread_h_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "Tranpose error error_code[" << ret << "]"; MS_LOG(ERROR) << "Tranpose error error_code[" << ret << "]";
FreeFp16Buffer(); FreeFp16Buffer();

4
mindspore/lite/src/runtime/kernel/arm/fp32/activation.cc
View File

@ -67,7 +67,7 @@ int ActivationCPUKernel::DoActivation(int task_id) {
return RET_OK; return RET_OK;
} }
int ActivationRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ActivationRun(void *cdata, int task_id) {
auto activation_kernel = reinterpret_cast<ActivationCPUKernel *>(cdata); auto activation_kernel = reinterpret_cast<ActivationCPUKernel *>(cdata);
auto error_code = activation_kernel->DoActivation(task_id); auto error_code = activation_kernel->DoActivation(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -83,7 +83,7 @@ int ActivationCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed."; MS_LOG(ERROR) << "Prepare failed.";
return ret; return ret;
} }
int error_code = LiteBackendParallelLaunch(ActivationRun, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ActivationRun, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]"; MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

8
mindspore/lite/src/runtime/kernel/arm/fp32/addn.cc
View File

@ -28,13 +28,13 @@ using mindspore::schema::PrimitiveType_AddN;
namespace mindspore::kernel { namespace mindspore::kernel {
namespace { namespace {
int AddNLaunch(int thread_id, LiteParallelGroupEnv *penv, void *cdata) { int AddNLaunch(void *cdata, int task_id) {
if (cdata == nullptr) { if (cdata == nullptr) {
MS_LOG(ERROR) << "Input cdata is nullptr!"; MS_LOG(ERROR) << "Input cdata is nullptr!";
return RET_NULL_PTR; return RET_NULL_PTR;
} }
auto kernel = reinterpret_cast<AddNCPUKernel *>(cdata); auto kernel = reinterpret_cast<AddNCPUKernel *>(cdata);
return kernel->AddNParallelRun(thread_id); return kernel->AddNParallelRun(task_id);
} }
} // namespace } // namespace
@ -74,7 +74,7 @@ int AddNCPUKernel::Run() {
in1_addr_ = input0_data; in1_addr_ = input0_data;
in2_addr_ = input1_data; in2_addr_ = input1_data;
out_addr_ = output_data; out_addr_ = output_data;
ret = LiteBackendParallelLaunch(AddNLaunch, this, op_parameter_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, AddNLaunch, this, op_parameter_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "addn launch fail!ret: " << ret; MS_LOG(ERROR) << "addn launch fail!ret: " << ret;
return RET_ERROR; return RET_ERROR;
@ -82,7 +82,7 @@ int AddNCPUKernel::Run() {
for (size_t i = 2; i < in_tensors_.size(); ++i) { for (size_t i = 2; i < in_tensors_.size(); ++i) {
in1_addr_ = reinterpret_cast<float *>(in_tensors_[i]->Data()); in1_addr_ = reinterpret_cast<float *>(in_tensors_[i]->Data());
in2_addr_ = output_data; in2_addr_ = output_data;
ret = LiteBackendParallelLaunch(AddNLaunch, this, op_parameter_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, AddNLaunch, this, op_parameter_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "addn launch fail!ret: " << ret << ", input index: " << i; MS_LOG(ERROR) << "addn launch fail!ret: " << ret << ", input index: " << i;
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic.cc
View File

@ -163,7 +163,7 @@ int ArithmeticCPUKernel::DoArithmetic(int task_id) {
return RET_OK; return RET_OK;
} }
int ArithmeticsRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ArithmeticsRun(void *cdata, int task_id) {
auto arithmetic_kernel = reinterpret_cast<ArithmeticCPUKernel *>(cdata); auto arithmetic_kernel = reinterpret_cast<ArithmeticCPUKernel *>(cdata);
auto error_code = arithmetic_kernel->DoArithmetic(task_id); auto error_code = arithmetic_kernel->DoArithmetic(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -193,7 +193,7 @@ int ArithmeticCPUKernel::Run() {
ComputeStrides(arithmeticParameter_->out_shape_, arithmeticParameter_->out_strides_, arithmeticParameter_->ndim_); ComputeStrides(arithmeticParameter_->out_shape_, arithmeticParameter_->out_strides_, arithmeticParameter_->ndim_);
} }
int error_code = LiteBackendParallelLaunch(ArithmeticsRun, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ArithmeticsRun, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Arithmetic function error error_code[" << error_code << "]"; MS_LOG(ERROR) << "Arithmetic function error error_code[" << error_code << "]";

4
mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic_self.cc
View File

@ -41,7 +41,7 @@ int ArithmeticSelfCPUKernel::ReSize() {
return RET_OK; return RET_OK;
} }
int ArithmeticSelfRuns(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ArithmeticSelfRuns(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ArithmeticSelfCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<ArithmeticSelfCPUKernel *>(cdata);
auto ret = g_kernel->DoArithmeticSelf(task_id); auto ret = g_kernel->DoArithmeticSelf(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -80,7 +80,7 @@ int ArithmeticSelfCPUKernel::Run() {
auto out_tensor = out_tensors_.at(0); auto out_tensor = out_tensors_.at(0);
in_ptr_ = reinterpret_cast<float *>(input_tensor->Data()); in_ptr_ = reinterpret_cast<float *>(input_tensor->Data());
out_ptr_ = reinterpret_cast<float *>(out_tensor->Data()); out_ptr_ = reinterpret_cast<float *>(out_tensor->Data());
ret = LiteBackendParallelLaunch(ArithmeticSelfRuns, this, thread_sz_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ArithmeticSelfRuns, this, thread_sz_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ArithmeticSelfRun error error_code[" << ret << "]"; MS_LOG(ERROR) << "ArithmeticSelfRun error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/batchnorm.cc
View File

@ -75,7 +75,7 @@ int BatchnormCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail! Ret error code: " << ret; MS_LOG(ERROR) << "Prepare fail! Ret error code: " << ret;
return ret; return ret;
} }
ret = LiteBackendParallelLaunch(BatchNormRun, this, op_parameter_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, BatchNormRun, this, op_parameter_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "BatchnormRun error error_code[" << ret << "]"; MS_LOG(ERROR) << "BatchnormRun error error_code[" << ret << "]";
} }
@ -88,7 +88,7 @@ int BatchnormCPUKernel::DoExecute(int task_id) {
return mindspore::lite::RET_OK; return mindspore::lite::RET_OK;
} }
int BatchNormRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int BatchNormRun(void *cdata, int task_id) {
auto kernel = reinterpret_cast<BatchnormCPUKernel *>(cdata); auto kernel = reinterpret_cast<BatchnormCPUKernel *>(cdata);
auto ret = kernel->DoExecute(task_id); auto ret = kernel->DoExecute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {

2
mindspore/lite/src/runtime/kernel/arm/fp32/batchnorm.h
View File

@ -48,7 +48,7 @@ class BatchnormCPUKernel : public LiteKernel {
void *variance_ = nullptr; void *variance_ = nullptr;
}; };
int BatchNormRun(int task_id, LiteParallelGroupEnv *penv, void *cdata); int BatchNormRun(void *cdata, int task_id);
} // namespace mindspore::kernel } // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_BATCHNORM_H_ #endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_BATCHNORM_H_

6
mindspore/lite/src/runtime/kernel/arm/fp32/cast.cc
View File

@ -30,13 +30,13 @@ using mindspore::schema::PrimitiveType_Cast;
namespace mindspore::kernel { namespace mindspore::kernel {
namespace { namespace {
int CastRun(int thread_id, LiteParallelGroupEnv *penv, void *cdata) { int CastRun(void *cdata, int task_id) {
if (cdata == nullptr) { if (cdata == nullptr) {
MS_LOG(ERROR) << "input cdata is nullptr!"; MS_LOG(ERROR) << "input cdata is nullptr!";
return RET_ERROR; return RET_ERROR;
} }
return reinterpret_cast<CastCPUKernel *>(cdata)->DoCast(thread_id); return reinterpret_cast<CastCPUKernel *>(cdata)->DoCast(task_id);
} }
} // namespace } // namespace
@ -111,7 +111,7 @@ int CastCPUKernel::Run() {
if (data_num_ == 0) { if (data_num_ == 0) {
return RET_OK; return RET_OK;
} }
return LiteBackendParallelLaunch(CastRun, this, op_parameter_->thread_num_); return ParallelLaunch(THREAD_POOL_DEFAULT, CastRun, this, op_parameter_->thread_num_);
} }
kernel::LiteKernel *CpuCastFp32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs, kernel::LiteKernel *CpuCastFp32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,

4
mindspore/lite/src/runtime/kernel/arm/fp32/constant_of_shape.cc
View File

@ -41,7 +41,7 @@ int ConstantOfShapeCPUKernel::DoExecute(int task_id) {
return RET_OK; return RET_OK;
} }
int ConstantOfShapeRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ConstantOfShapeRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ConstantOfShapeCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<ConstantOfShapeCPUKernel *>(cdata);
auto ret = g_kernel->DoExecute(task_id); auto ret = g_kernel->DoExecute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -62,7 +62,7 @@ int ConstantOfShapeCPUKernel::Run() {
param_->unit_ = UP_DIV(param_->element_sz_, thread_num); param_->unit_ = UP_DIV(param_->element_sz_, thread_num);
param_->op_parameter_.thread_num_ = thread_num; param_->op_parameter_.thread_num_ = thread_num;
out_ptr_ = reinterpret_cast<float *>(out_tensors_.front()->Data()); out_ptr_ = reinterpret_cast<float *>(out_tensors_.front()->Data());
auto ret = LiteBackendParallelLaunch(ConstantOfShapeRun, this, thread_num); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConstantOfShapeRun, this, thread_num);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ConstantOfShapeRun error error_code[" << ret << "]"; MS_LOG(ERROR) << "ConstantOfShapeRun error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/convolution.cc
View File

@ -172,7 +172,7 @@ int ConvolutionCPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int ConvolutionImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ConvolutionImpl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionCPUKernel *>(cdata); auto conv = reinterpret_cast<ConvolutionCPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -200,7 +200,7 @@ int ConvolutionCPUKernel::Run() {
PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_, PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_,
conv_param_->input_h_ * conv_param_->input_w_, conv_param_->input_channel_); conv_param_->input_h_ * conv_param_->input_w_, conv_param_->input_channel_);
int error_code = LiteBackendParallelLaunch(ConvolutionImpl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionImpl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

4
mindspore/lite/src/runtime/kernel/arm/fp32/convolution_1x1.cc
View File

@ -149,7 +149,7 @@ int Convolution1x1CPUKernel::DoConv1x1(int task_id) {
return RET_OK; return RET_OK;
} }
int Convolution1x1Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int Convolution1x1Run(void *cdata, int task_id) {
auto conv1x1 = reinterpret_cast<Convolution1x1CPUKernel *>(cdata); auto conv1x1 = reinterpret_cast<Convolution1x1CPUKernel *>(cdata);
auto error_code = conv1x1->DoConv1x1(task_id); auto error_code = conv1x1->DoConv1x1(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -179,7 +179,7 @@ int Convolution1x1CPUKernel::Run() {
Pre1x1Trans(src_in + batch_index * conv_param_->input_h_ * conv_param_->input_w_ * conv_param_->input_channel_, Pre1x1Trans(src_in + batch_index * conv_param_->input_h_ * conv_param_->input_w_ * conv_param_->input_channel_,
src_out + batch_index * matmul_param_->row_ * matmul_param_->col_); src_out + batch_index * matmul_param_->row_ * matmul_param_->col_);
int error_code = LiteBackendParallelLaunch(Convolution1x1Run, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, Convolution1x1Run, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv1x1 strassen error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv1x1 strassen error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/convolution_3x3.cc
View File

@ -208,7 +208,7 @@ int Convolution3x3CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int Convolution3x3Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int Convolution3x3Impl(void *cdata, int task_id) {
auto conv3x3 = reinterpret_cast<Convolution3x3CPUKernel *>(cdata); auto conv3x3 = reinterpret_cast<Convolution3x3CPUKernel *>(cdata);
auto error_code = conv3x3->RunImpl(task_id); auto error_code = conv3x3->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -258,7 +258,7 @@ int Convolution3x3CPUKernel::Run() {
PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_, PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_,
conv_param_->input_h_ * conv_param_->input_w_, conv_param_->input_channel_); conv_param_->input_h_ * conv_param_->input_w_, conv_param_->input_channel_);
int error_code = LiteBackendParallelLaunch(Convolution3x3Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, Convolution3x3Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv3x3 error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv3x3 error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

4
mindspore/lite/src/runtime/kernel/arm/fp32/convolution_depthwise.cc
View File

@ -89,7 +89,7 @@ int ConvolutionDepthwiseCPUKernel::Execute(int task_id) {
return RET_OK; return RET_OK;
} }
int ConvDwRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ConvDwRun(void *cdata, int task_id) {
auto conv_dw = reinterpret_cast<ConvolutionDepthwiseCPUKernel *>(cdata); auto conv_dw = reinterpret_cast<ConvolutionDepthwiseCPUKernel *>(cdata);
auto ret = conv_dw->Execute(task_id); auto ret = conv_dw->Execute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -116,7 +116,7 @@ int ConvolutionDepthwiseCPUKernel::Run() {
auto output_tensor = out_tensors_.at(kOutputIndex); auto output_tensor = out_tensors_.at(kOutputIndex);
output_ptr_ = reinterpret_cast<float *>(output_tensor->Data()); output_ptr_ = reinterpret_cast<float *>(output_tensor->Data());
ret = LiteBackendParallelLaunch(ConvDwRun, this, conv_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConvDwRun, this, conv_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ConvDwRun error: error_code[" << ret << "]"; MS_LOG(ERROR) << "ConvDwRun error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/convolution_depthwise_slidewindow.cc
View File

@ -123,7 +123,7 @@ int ConvolutionDepthwiseSWCPUKernel::Execute(int task_id) {
return RET_OK; return RET_OK;
} }
int ConvDwSWRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ConvDwSWRun(void *cdata, int task_id) {
auto conv_dw = reinterpret_cast<ConvolutionDepthwiseSWCPUKernel *>(cdata); auto conv_dw = reinterpret_cast<ConvolutionDepthwiseSWCPUKernel *>(cdata);
auto ret = conv_dw->Execute(task_id); auto ret = conv_dw->Execute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -167,7 +167,7 @@ int ConvolutionDepthwiseSWCPUKernel::Run() {
packed_output_ = output_ptr; packed_output_ = output_ptr;
} }
ret = LiteBackendParallelLaunch(ConvDwSWRun, this, conv_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConvDwSWRun, this, conv_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ConvDwSWRun error: error_code[" << ret << "]"; MS_LOG(ERROR) << "ConvDwSWRun error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/convolution_slidewindow.cc
View File

@ -159,7 +159,7 @@ int ConvolutionSWCPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int ConvolutionSWImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ConvolutionSWImpl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionSWCPUKernel *>(cdata); auto conv = reinterpret_cast<ConvolutionSWCPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -187,7 +187,7 @@ int ConvolutionSWCPUKernel::Run() {
PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_, PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_,
conv_param_->input_h_ * conv_param_->input_w_, conv_param_->input_channel_); conv_param_->input_h_ * conv_param_->input_w_, conv_param_->input_channel_);
int error_code = LiteBackendParallelLaunch(ConvolutionSWImpl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionSWImpl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

4
mindspore/lite/src/runtime/kernel/arm/fp32/convolution_winograd.cc
View File

@ -338,7 +338,7 @@ int ConvolutionWinogradCPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int ConvolutionWinogradImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ConvolutionWinogradImpl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionWinogradCPUKernel *>(cdata); auto conv = reinterpret_cast<ConvolutionWinogradCPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -390,7 +390,7 @@ int ConvolutionWinogradCPUKernel::Run() {
PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_, PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_,
conv_param_->input_h_ * conv_param_->input_w_, conv_param_->input_channel_); conv_param_->input_h_ * conv_param_->input_w_, conv_param_->input_channel_);
int error_code = LiteBackendParallelLaunch(ConvolutionWinogradImpl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionWinogradImpl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv winograd error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv winograd error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

6
mindspore/lite/src/runtime/kernel/arm/fp32/crop.cc
View File

@ -30,13 +30,13 @@ using mindspore::schema::PrimitiveType_Crop;
namespace mindspore::kernel { namespace mindspore::kernel {
namespace { namespace {
int CropLaunch(int thread_id, LiteParallelGroupEnv *penv, void *cdata) { int CropLaunch(void *cdata, int task_id) {
if (cdata == nullptr) { if (cdata == nullptr) {
MS_LOG(ERROR) << "Input cdata is nullptr!"; MS_LOG(ERROR) << "Input cdata is nullptr!";
return RET_NULL_PTR; return RET_NULL_PTR;
} }
auto kernel = reinterpret_cast<CropCPUKernel *>(cdata); auto kernel = reinterpret_cast<CropCPUKernel *>(cdata);
return kernel->CropParallelRun(thread_id); return kernel->CropParallelRun(task_id);
} }
} // namespace } // namespace
@ -68,7 +68,7 @@ int CropCPUKernel::Run() {
return RET_OK; return RET_OK;
} }
auto ret = LiteBackendParallelLaunch(CropLaunch, this, param->op_parameter_.thread_num_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, CropLaunch, this, param->op_parameter_.thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "Crop launch fail!ret: " << ret; MS_LOG(ERROR) << "Crop launch fail!ret: " << ret;
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution.cc
View File

@ -109,7 +109,7 @@ int DeConvolutionCPUKernel::InitParam() {
return RET_OK; return RET_OK;
} }
int DeConvFp32Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int DeConvFp32Run(void *cdata, int task_id) {
auto deconv = reinterpret_cast<DeConvolutionCPUKernel *>(cdata); auto deconv = reinterpret_cast<DeConvolutionCPUKernel *>(cdata);
auto error_code = deconv->DoDeconv(task_id); auto error_code = deconv->DoDeconv(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -194,7 +194,7 @@ int DeConvolutionCPUKernel::Run() {
RowMajor2Col12Major(input_ptr_, pack_input_, input_plane_, conv_param_->input_channel_); RowMajor2Col12Major(input_ptr_, pack_input_, input_plane_, conv_param_->input_channel_);
error_code = LiteBackendParallelLaunch(DeConvFp32Run, this, thread_count_); error_code = ParallelLaunch(THREAD_POOL_DEFAULT, DeConvFp32Run, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "deconv fp32 run error! error_code[" << error_code << "]"; MS_LOG(ERROR) << "deconv fp32 run error! error_code[" << error_code << "]";
return error_code; return error_code;

4
mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_depthwise.cc
View File

@ -134,7 +134,7 @@ int DeconvolutionDepthwiseCPUKernel::Execute(int task_id) {
return RET_OK; return RET_OK;
} }
int DeconvDwRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int DeconvDwRun(void *cdata, int task_id) {
auto deconv_dw = reinterpret_cast<DeconvolutionDepthwiseCPUKernel *>(cdata); auto deconv_dw = reinterpret_cast<DeconvolutionDepthwiseCPUKernel *>(cdata);
auto ret = deconv_dw->Execute(task_id); auto ret = deconv_dw->Execute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -178,7 +178,7 @@ int DeconvolutionDepthwiseCPUKernel::Run() {
packed_output_ = output_addr; packed_output_ = output_addr;
} }
ret = LiteBackendParallelLaunch(DeconvDwRun, this, conv_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, DeconvDwRun, this, conv_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "DeconvDwRun error: error_code[" << ret << "]"; MS_LOG(ERROR) << "DeconvDwRun error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/elu.cc
View File

@ -46,7 +46,7 @@ int EluCPUKernel::DoExcute(int task_id) {
return RET_OK; return RET_OK;
} }
int EluRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int EluRun(void *cdata, int task_id) {
auto EluData = reinterpret_cast<EluCPUKernel *>(cdata); auto EluData = reinterpret_cast<EluCPUKernel *>(cdata);
auto ret = EluData->DoExcute(task_id); auto ret = EluData->DoExcute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -65,7 +65,7 @@ int EluCPUKernel::Run() {
input_addr = reinterpret_cast<float *>(in_tensors_.front()->Data()); input_addr = reinterpret_cast<float *>(in_tensors_.front()->Data());
output_addr = reinterpret_cast<float *>(out_tensors_.front()->Data()); output_addr = reinterpret_cast<float *>(out_tensors_.front()->Data());
auto ret = LiteBackendParallelLaunch(EluRun, this, elu_parameter_->thread_num_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, EluRun, this, elu_parameter_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "Elu error: error_code[" << ret << "]"; MS_LOG(ERROR) << "Elu error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/embedding_lookup.cc
View File

@ -61,7 +61,7 @@ int EmbeddingLookupCPUKernel::DoExcute(int task_id) {
return RET_OK; return RET_OK;
} }
int EmbeddingLookupRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int EmbeddingLookupRun(void *cdata, int task_id) {
auto EmbeddingLookupData = reinterpret_cast<EmbeddingLookupCPUKernel *>(cdata); auto EmbeddingLookupData = reinterpret_cast<EmbeddingLookupCPUKernel *>(cdata);
auto ret = EmbeddingLookupData->DoExcute(task_id); auto ret = EmbeddingLookupData->DoExcute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -102,7 +102,7 @@ int EmbeddingLookupCPUKernel::Run() {
output_addr_ = reinterpret_cast<float *>(out_tensors_.front()->Data()); output_addr_ = reinterpret_cast<float *>(out_tensors_.front()->Data());
ids_addr_ = reinterpret_cast<int *>(in_tensors_.back()->Data()); ids_addr_ = reinterpret_cast<int *>(in_tensors_.back()->Data());
auto ret = LiteBackendParallelLaunch(EmbeddingLookupRun, this, embedding_lookup_parameter_->thread_num); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, EmbeddingLookupRun, this, embedding_lookup_parameter_->thread_num);
context_->allocator->Free(input_addr_); context_->allocator->Free(input_addr_);
context_->allocator->Free(embedding_lookup_parameter_->is_regulated_); context_->allocator->Free(embedding_lookup_parameter_->is_regulated_);
if (ret != RET_OK) { if (ret != RET_OK) {

4
mindspore/lite/src/runtime/kernel/arm/fp32/expandDims.cc
View File

@ -56,7 +56,7 @@ int ExpandDimsCPUKernel::DoExpandDims(int task_id) {
return RET_OK; return RET_OK;
} }
int ExpandDimsRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ExpandDimsRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ExpandDimsCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<ExpandDimsCPUKernel *>(cdata);
auto ret = g_kernel->DoExpandDims(task_id); auto ret = g_kernel->DoExpandDims(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -74,7 +74,7 @@ int ExpandDimsCPUKernel::Run() {
} }
in_ptr_ = reinterpret_cast<float *>(in_tensors_.at(0)->Data()); in_ptr_ = reinterpret_cast<float *>(in_tensors_.at(0)->Data());
out_ptr_ = reinterpret_cast<float *>(out_tensors_.at(0)->Data()); out_ptr_ = reinterpret_cast<float *>(out_tensors_.at(0)->Data());
auto ret = LiteBackendParallelLaunch(ExpandDimsRun, this, thread_sz_count_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, ExpandDimsRun, this, thread_sz_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ExpandDimsRun error error_code[" << ret << "]"; MS_LOG(ERROR) << "ExpandDimsRun error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/fill.cc
View File

@ -56,7 +56,7 @@ int FillCPUKernel::DoFill(int task_id) {
return RET_OK; return RET_OK;
} }
int FillRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int FillRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<FillCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<FillCPUKernel *>(cdata);
auto ret = g_kernel->DoFill(task_id); auto ret = g_kernel->DoFill(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -77,7 +77,7 @@ int FillCPUKernel::Run() {
auto fill_data = reinterpret_cast<float *>(fillData->Data()); auto fill_data = reinterpret_cast<float *>(fillData->Data());
src_data_ = fill_data[0]; src_data_ = fill_data[0];
out_ptr_ = reinterpret_cast<float *>(output->Data()); out_ptr_ = reinterpret_cast<float *>(output->Data());
auto ret = LiteBackendParallelLaunch(FillRun, this, thread_sz_count_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, FillRun, this, thread_sz_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "FillRun error error_code[" << ret << "]"; MS_LOG(ERROR) << "FillRun error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/fullconnection.cc
View File

@ -94,7 +94,7 @@ void FullconnectionCPUKernel::InitMatrixB(float *src_ptr, float *dst_ptr) {
RowMajor2Col8Major(src_ptr, dst_ptr, fc_param_->col_, fc_param_->deep_); RowMajor2Col8Major(src_ptr, dst_ptr, fc_param_->col_, fc_param_->deep_);
} }
int FcFp32MatmulRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int FcFp32MatmulRun(void *cdata, int task_id) {
auto fc = reinterpret_cast<FullconnectionCPUKernel *>(cdata); auto fc = reinterpret_cast<FullconnectionCPUKernel *>(cdata);
auto error_code = fc->DoMatmul(task_id); auto error_code = fc->DoMatmul(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -129,7 +129,7 @@ int FullconnectionCPUKernel::Run() {
if (!fc_param_->a_const_) InitMatrixA(a_ptr, a_c12_ptr_); if (!fc_param_->a_const_) InitMatrixA(a_ptr, a_c12_ptr_);
if (!fc_param_->b_const_) InitMatrixB(b_ptr, b_r8_ptr_); if (!fc_param_->b_const_) InitMatrixB(b_ptr, b_r8_ptr_);
LiteBackendParallelLaunch(FcFp32MatmulRun, this, thread_count_); ParallelLaunch(THREAD_POOL_DEFAULT, FcFp32MatmulRun, this, thread_count_);
return RET_OK; return RET_OK;
} }

4
mindspore/lite/src/runtime/kernel/arm/fp32/gather.cc
View File

@ -89,7 +89,7 @@ int GatherCPUKernel::DoGather(int task_id) {
return error_code; return error_code;
} }
int GatherRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int GatherRun(void *cdata, int task_id) {
auto gather_kernel = reinterpret_cast<GatherCPUKernel *>(cdata); auto gather_kernel = reinterpret_cast<GatherCPUKernel *>(cdata);
auto error_code = gather_kernel->DoGather(task_id); auto error_code = gather_kernel->DoGather(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -112,7 +112,7 @@ int GatherCPUKernel::Run() {
context_->allocator->Free(indices_data_); context_->allocator->Free(indices_data_);
return RET_ERROR; return RET_ERROR;
} }
int error_code = LiteBackendParallelLaunch(GatherRun, this, op_parameter_->thread_num_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, GatherRun, this, op_parameter_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Gather function error error_code[" << error_code << "]"; MS_LOG(ERROR) << "Gather function error error_code[" << error_code << "]";
} }

4
mindspore/lite/src/runtime/kernel/arm/fp32/gatherNd.cc
View File

@ -105,7 +105,7 @@ int GatherNdCPUKernel::DoGatherNd(int task_id) {
return RET_OK; return RET_OK;
} }
int GatherNdRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int GatherNdRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<GatherNdCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<GatherNdCPUKernel *>(cdata);
auto ret = g_kernel->DoGatherNd(task_id); auto ret = g_kernel->DoGatherNd(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -123,7 +123,7 @@ int GatherNdCPUKernel::Run() {
} }
in_ptr_ = reinterpret_cast<float *>(in_tensors_.front()->Data()); in_ptr_ = reinterpret_cast<float *>(in_tensors_.front()->Data());
out_ptr_ = reinterpret_cast<float *>(out_tensors_.front()->Data()); out_ptr_ = reinterpret_cast<float *>(out_tensors_.front()->Data());
auto ret = LiteBackendParallelLaunch(GatherNdRun, this, thread_sz_count_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, GatherNdRun, this, thread_sz_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "gatherNd error error_code[" << ret << "]"; MS_LOG(ERROR) << "gatherNd error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/leaky_relu.cc
View File

@ -30,7 +30,7 @@ using mindspore::schema::PrimitiveType_Prelu;
namespace mindspore::kernel { namespace mindspore::kernel {
namespace { namespace {
int LeakyReluRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int LeakyReluRun(void *cdata, int task_id) {
auto kernel_relu = reinterpret_cast<LeakyReluCPUKernel *>(cdata); auto kernel_relu = reinterpret_cast<LeakyReluCPUKernel *>(cdata);
auto ret = kernel_relu->DoExcute(task_id); auto ret = kernel_relu->DoExcute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -66,7 +66,7 @@ int LeakyReluCPUKernel::Run() {
input_data = reinterpret_cast<float *>(input->Data()); input_data = reinterpret_cast<float *>(input->Data());
output_data = reinterpret_cast<float *>(out_tensors_.at(0)->Data()); output_data = reinterpret_cast<float *>(out_tensors_.at(0)->Data());
auto ret = LiteBackendParallelLaunch(LeakyReluRun, this, context_->thread_num_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, LeakyReluRun, this, context_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "PReluDwRun error: error_code[" << ret << "]"; MS_LOG(ERROR) << "PReluDwRun error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/local_response_norm.cc
View File

@ -63,7 +63,7 @@ int LocalResponseNormCPUKernel::DoLocalResponseNorm(int task_id) {
return RET_OK; return RET_OK;
} }
int LocalResponseNormRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int LocalResponseNormRun(void *cdata, int task_id) {
auto lrn = reinterpret_cast<LocalResponseNormCPUKernel *>(cdata); auto lrn = reinterpret_cast<LocalResponseNormCPUKernel *>(cdata);
auto error_code = lrn->DoLocalResponseNorm(task_id); auto error_code = lrn->DoLocalResponseNorm(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -79,7 +79,7 @@ int LocalResponseNormCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret; MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret;
return prepare_ret; return prepare_ret;
} }
int error_code = LiteBackendParallelLaunch(LocalResponseNormRun, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, LocalResponseNormRun, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "LocalResponseNorm function error error_code[" << error_code << "]"; MS_LOG(ERROR) << "LocalResponseNorm function error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/matmul.cc
View File

@ -147,7 +147,7 @@ int MatmulCPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int MatmulFloatRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int MatmulFloatRun(void *cdata, int task_id) {
auto op = reinterpret_cast<MatmulCPUKernel *>(cdata); auto op = reinterpret_cast<MatmulCPUKernel *>(cdata);
auto error_code = op->RunImpl(task_id); auto error_code = op->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -178,7 +178,7 @@ int MatmulCPUKernel::Run() {
a_ptr_ = a_c12_ptr_ + i * params_->row_12_ * params_->deep_; a_ptr_ = a_c12_ptr_ + i * params_->row_12_ * params_->deep_;
b_ptr_ = b_r8_ptr_ + i * params_->deep_ * params_->col_8_; b_ptr_ = b_r8_ptr_ + i * params_->deep_ * params_->col_8_;
c_ptr_ = c_src + i * params_->row_ * params_->col_; c_ptr_ = c_src + i * params_->row_ * params_->col_;
LiteBackendParallelLaunch(MatmulFloatRun, this, thread_count_); ParallelLaunch(THREAD_POOL_DEFAULT, MatmulFloatRun, this, thread_count_);
} }
return RET_OK; return RET_OK;
} }

4
mindspore/lite/src/runtime/kernel/arm/fp32/one_hot.cc
View File

@ -81,7 +81,7 @@ int OneHotCPUKernel::ReSize() {
return RET_OK; return RET_OK;
} }
int RunOneHot(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int RunOneHot(void *cdata, int task_id) {
auto onehot_kernel = reinterpret_cast<OneHotCPUKernel *>(cdata); auto onehot_kernel = reinterpret_cast<OneHotCPUKernel *>(cdata);
if (onehot_kernel == nullptr) { if (onehot_kernel == nullptr) {
MS_LOG(ERROR) << "cast OneHotCPUKernel failed"; MS_LOG(ERROR) << "cast OneHotCPUKernel failed";
@ -166,7 +166,7 @@ int OneHotCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret; MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret;
return prepare_ret; return prepare_ret;
} }
int error_code = LiteBackendParallelLaunch(RunOneHot, this, context_->thread_num_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, RunOneHot, this, context_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "OneHot function error error_code[" << error_code << "]"; MS_LOG(ERROR) << "OneHot function error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/pad.cc
View File

@ -68,7 +68,7 @@ int PadCPUKernel::ReSize() {
return RET_OK; return RET_OK;
} }
int PadImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int PadImpl(void *cdata, int task_id) {
auto padKernel = reinterpret_cast<PadCPUKernel *>(cdata); auto padKernel = reinterpret_cast<PadCPUKernel *>(cdata);
int error_code = padKernel->RunImpl(task_id); int error_code = padKernel->RunImpl(task_id);
if (error_code != NNACL_OK) { if (error_code != NNACL_OK) {
@ -102,7 +102,7 @@ int PadCPUKernel::Run() {
auto output_data = reinterpret_cast<float *>(output->Data()); auto output_data = reinterpret_cast<float *>(output->Data());
memset(output_data, 0, output_size * sizeof(float)); memset(output_data, 0, output_size * sizeof(float));
int error_code = LiteBackendParallelLaunch(PadImpl, this, context_->thread_num_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, PadImpl, this, context_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Pad run error, error_code[" << error_code << "]"; MS_LOG(ERROR) << "Pad run error, error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/pooling.cc
View File

@ -78,7 +78,7 @@ int PoolingCPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int PoolingImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int PoolingImpl(void *cdata, int task_id) {
auto pooling = reinterpret_cast<PoolingCPUKernel *>(cdata); auto pooling = reinterpret_cast<PoolingCPUKernel *>(cdata);
auto error_code = pooling->RunImpl(task_id); auto error_code = pooling->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -94,7 +94,7 @@ int PoolingCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret; MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret;
return prepare_ret; return prepare_ret;
} }
int error_code = LiteBackendParallelLaunch(PoolingImpl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, PoolingImpl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "pooling error error_code[" << error_code << "]"; MS_LOG(ERROR) << "pooling error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/power.cc
View File

@ -30,7 +30,7 @@ int PowerCPUKernel::Init() { return RET_OK; }
int PowerCPUKernel::ReSize() { return RET_OK; } int PowerCPUKernel::ReSize() { return RET_OK; }
int PowerImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int PowerImpl(void *cdata, int task_id) {
auto kernel = reinterpret_cast<PowerCPUKernel *>(cdata); auto kernel = reinterpret_cast<PowerCPUKernel *>(cdata);
auto ret = kernel->RunImpl(task_id); auto ret = kernel->RunImpl(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -46,7 +46,7 @@ int PowerCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret; MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret;
return prepare_ret; return prepare_ret;
} }
auto ret = LiteBackendParallelLaunch(PowerImpl, this, thread_count_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, PowerImpl, this, thread_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "PowerCPUKernel error: " << ret; MS_LOG(ERROR) << "PowerCPUKernel error: " << ret;
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/prelu.cc
View File

@ -28,7 +28,7 @@ using mindspore::schema::PrimitiveType_CaffePReLU;
namespace mindspore::kernel { namespace mindspore::kernel {
namespace { namespace {
int PReluRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int PReluRun(void *cdata, int task_id) {
auto PRelu = reinterpret_cast<PReluCPUKernel *>(cdata); auto PRelu = reinterpret_cast<PReluCPUKernel *>(cdata);
auto ret = PRelu->DoExcute(task_id); auto ret = PRelu->DoExcute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -135,7 +135,7 @@ int PReluCPUKernel::Run() {
auto negative_slope_tensor = in_tensors_.at(1); auto negative_slope_tensor = in_tensors_.at(1);
prelu_param_->slope_ = reinterpret_cast<float *>(negative_slope_tensor->Data()); prelu_param_->slope_ = reinterpret_cast<float *>(negative_slope_tensor->Data());
auto ret = LiteBackendParallelLaunch(PReluRun, this, prelu_param_->op_parameter_.thread_num_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, PReluRun, this, prelu_param_->op_parameter_.thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "PRelu Run error: error_code[" << ret << "]"; MS_LOG(ERROR) << "PRelu Run error: error_code[" << ret << "]";
context_->allocator->Free(input_data_); context_->allocator->Free(input_data_);

6
mindspore/lite/src/runtime/kernel/arm/fp32/reduce.cc
View File

@ -95,7 +95,7 @@ int ReduceCPUKernel::CallReduceUnit(int task_id) {
return ret; return ret;
} }
int ReduceImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ReduceImpl(void *cdata, int task_id) {
auto reduce = reinterpret_cast<ReduceCPUKernel *>(cdata); auto reduce = reinterpret_cast<ReduceCPUKernel *>(cdata);
auto error_code = reduce->CallReduceUnit(task_id); auto error_code = reduce->CallReduceUnit(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -125,7 +125,7 @@ int ReduceCPUKernel::Run() {
inner_size_ *= tmp_shape_[k]; inner_size_ *= tmp_shape_[k];
} }
axis_size_ = tmp_shape_[axis]; axis_size_ = tmp_shape_[axis];
auto error_code = LiteBackendParallelLaunch(ReduceImpl, this, context_->thread_num_); auto error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ReduceImpl, this, context_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]"; MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;
@ -145,7 +145,7 @@ int ReduceCPUKernel::Run() {
} }
axis_size_ = tmp_shape_[last_reduce_axis]; axis_size_ = tmp_shape_[last_reduce_axis];
dst_data_ = reinterpret_cast<float *>(out_tensors_.at(0)->Data()); dst_data_ = reinterpret_cast<float *>(out_tensors_.at(0)->Data());
auto error_code = LiteBackendParallelLaunch(ReduceImpl, this, context_->thread_num_); auto error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ReduceImpl, this, context_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]"; MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/resize.cc
View File

@ -38,7 +38,7 @@ int ResizeCPUKernel::Init() {
return ReSize(); return ReSize();
} }
int ResizeImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ResizeImpl(void *cdata, int task_id) {
auto resize = reinterpret_cast<ResizeCPUKernel *>(cdata); auto resize = reinterpret_cast<ResizeCPUKernel *>(cdata);
auto error_code = resize->RunImpl(task_id); auto error_code = resize->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -94,7 +94,7 @@ int ResizeCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed."; MS_LOG(ERROR) << "Prepare failed.";
return RET_ERROR; return RET_ERROR;
} }
int error_code = LiteBackendParallelLaunch(ResizeImpl, this, context_->thread_num_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ResizeImpl, this, context_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Resize run error, error_code[" << error_code << "]"; MS_LOG(ERROR) << "Resize run error, error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/reverse.cc
View File

@ -100,7 +100,7 @@ int ReverseCPUKernel::Init() {
return ret; return ret;
} }
int ReverseRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ReverseRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ReverseCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<ReverseCPUKernel *>(cdata);
auto ret = g_kernel->DoReverse(task_id); auto ret = g_kernel->DoReverse(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -132,7 +132,7 @@ int ReverseCPUKernel::Run() {
} }
in_ptr_ = reinterpret_cast<float *>(in_tensors_[0]->Data()); in_ptr_ = reinterpret_cast<float *>(in_tensors_[0]->Data());
out_ptr_ = reinterpret_cast<float *>(out_tensors_[0]->Data()); out_ptr_ = reinterpret_cast<float *>(out_tensors_[0]->Data());
ret = LiteBackendParallelLaunch(ReverseRun, this, thread_sz_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ReverseRun, this, thread_sz_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "Reverse run error error_code[" << ret << "]"; MS_LOG(ERROR) << "Reverse run error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/roi_pooling.cc
View File

@ -72,7 +72,7 @@ int ROIPoolingCPUKernel::DoExecute(int task_id) {
return RET_OK; return RET_OK;
} }
int ROIPoolingRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ROIPoolingRun(void *cdata, int task_id) {
auto Data = reinterpret_cast<ROIPoolingCPUKernel *>(cdata); auto Data = reinterpret_cast<ROIPoolingCPUKernel *>(cdata);
auto ret = Data->DoExecute(task_id); auto ret = Data->DoExecute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -91,7 +91,7 @@ int ROIPoolingCPUKernel::Run() {
in_ptr_ = reinterpret_cast<float *>(in_tensors_.front()->Data()); in_ptr_ = reinterpret_cast<float *>(in_tensors_.front()->Data());
out_ptr_ = reinterpret_cast<float *>(out_tensors_.front()->Data()); out_ptr_ = reinterpret_cast<float *>(out_tensors_.front()->Data());
roi_ptr_ = reinterpret_cast<float *>(in_tensors_.at(1)->Data()); roi_ptr_ = reinterpret_cast<float *>(in_tensors_.at(1)->Data());
ret = LiteBackendParallelLaunch(ROIPoolingRun, this, param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ROIPoolingRun, this, param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ROIPooling error: error_code[" << ret << "]"; MS_LOG(ERROR) << "ROIPooling error: error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/scale.cc
View File

@ -137,7 +137,7 @@ int ScaleCPUKernel::Scale(int task_id) {
return RET_OK; return RET_OK;
} }
int ScaleRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ScaleRun(void *cdata, int task_id) {
auto scale = reinterpret_cast<ScaleCPUKernel *>(cdata); auto scale = reinterpret_cast<ScaleCPUKernel *>(cdata);
auto ret = scale->Scale(task_id); auto ret = scale->Scale(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -162,7 +162,7 @@ int ScaleCPUKernel::Run() {
auto out_tensor = out_tensors_.front(); auto out_tensor = out_tensors_.front();
output_ptr_ = reinterpret_cast<float *>(out_tensor->Data()); output_ptr_ = reinterpret_cast<float *>(out_tensor->Data());
ret = LiteBackendParallelLaunch(ScaleRun, this, op_parameter_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ScaleRun, this, op_parameter_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "Scale error error_code[" << ret << "]"; MS_LOG(ERROR) << "Scale error error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/scatter_nd.cc
View File

@ -137,7 +137,7 @@ int ScatterNDCPUKernel::ScatterND(int task_id) {
return RET_OK; return RET_OK;
} }
int ScatterNDRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ScatterNDRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ScatterNDCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<ScatterNDCPUKernel *>(cdata);
auto ret = g_kernel->ScatterND(task_id); auto ret = g_kernel->ScatterND(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -153,7 +153,7 @@ int ScatterNDCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << ret; MS_LOG(ERROR) << "Prepare fail!ret: " << ret;
return ret; return ret;
} }
ret = LiteBackendParallelLaunch(ScatterNDRun, this, thread_n_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ScatterNDRun, this, thread_n_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ScatterND error error_code[" << ret << "]"; MS_LOG(ERROR) << "ScatterND error error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

6
mindspore/lite/src/runtime/kernel/arm/fp32/slice.cc
View File

@ -29,13 +29,13 @@ using mindspore::schema::PrimitiveType_Slice;
namespace mindspore::kernel { namespace mindspore::kernel {
namespace { namespace {
int SliceLaunch(int thread_id, LiteParallelGroupEnv *penv, void *cdata) { int SliceLaunch(void *cdata, int task_id) {
if (cdata == nullptr) { if (cdata == nullptr) {
MS_LOG(ERROR) << "Input cdata is nullptr!"; MS_LOG(ERROR) << "Input cdata is nullptr!";
return RET_NULL_PTR; return RET_NULL_PTR;
} }
auto kernel = reinterpret_cast<SliceCPUKernel *>(cdata); auto kernel = reinterpret_cast<SliceCPUKernel *>(cdata);
return kernel->SliceParallelRun(thread_id); return kernel->SliceParallelRun(task_id);
} }
} // namespace } // namespace
@ -97,7 +97,7 @@ int SliceCPUKernel::Run() {
DoSliceNoParallel(input_data, output_data, param); DoSliceNoParallel(input_data, output_data, param);
return RET_OK; return RET_OK;
} }
ret = LiteBackendParallelLaunch(SliceLaunch, this, param->op_parameter_.thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, SliceLaunch, this, param->op_parameter_.thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "slice launch fail!ret: " << ret; MS_LOG(ERROR) << "slice launch fail!ret: " << ret;
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth.cc
View File

@ -74,7 +74,7 @@ int SpaceToDepthCPUKernel::SpaceToDepth(int task_id) {
return RET_OK; return RET_OK;
} }
int SpaceToDepthRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int SpaceToDepthRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<SpaceToDepthCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<SpaceToDepthCPUKernel *>(cdata);
auto ret = g_kernel->SpaceToDepth(task_id); auto ret = g_kernel->SpaceToDepth(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -93,7 +93,7 @@ int SpaceToDepthCPUKernel::Run() {
input_ptr_ = reinterpret_cast<float *>(in_tensors_[0]->Data()); input_ptr_ = reinterpret_cast<float *>(in_tensors_[0]->Data());
output_ptr_ = reinterpret_cast<float *>(out_tensors_[0]->Data()); output_ptr_ = reinterpret_cast<float *>(out_tensors_[0]->Data());
if (in_tensors_[0]->GetFormat() == schema::Format_NHWC) { if (in_tensors_[0]->GetFormat() == schema::Format_NHWC) {
ret = LiteBackendParallelLaunch(SpaceToDepthRun, this, thread_h_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, SpaceToDepthRun, this, thread_h_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "SpaceToDepth error error_code[" << ret << "]"; MS_LOG(ERROR) << "SpaceToDepth error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/sparse_to_dense.cc
View File

@ -39,7 +39,7 @@ int SparseToDenseCPUKernel::DoExcute(int task_id) {
return RET_OK; return RET_OK;
} }
int SparseToDenseRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int SparseToDenseRun(void *cdata, int task_id) {
auto s2ddata = reinterpret_cast<SparseToDenseCPUKernel *>(cdata); auto s2ddata = reinterpret_cast<SparseToDenseCPUKernel *>(cdata);
auto ret = s2ddata->DoExcute(task_id); auto ret = s2ddata->DoExcute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -70,7 +70,7 @@ int SparseToDenseCPUKernel::Run() {
std::vector<int> temp_shape = output0->shape(); std::vector<int> temp_shape = output0->shape();
output_shape_ = reinterpret_cast<int *>(temp_shape.data()); output_shape_ = reinterpret_cast<int *>(temp_shape.data());
ret = LiteBackendParallelLaunch(SparseToDenseRun, this, s2d_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, SparseToDenseRun, this, s2d_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "SparseToDenseRun error: error_code[" << ret << "]"; MS_LOG(ERROR) << "SparseToDenseRun error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/split.cc
View File

@ -62,7 +62,7 @@ int SplitCPUKernel::Split(int task_id) {
return RET_OK; return RET_OK;
} }
int SplitRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int SplitRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<SplitCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<SplitCPUKernel *>(cdata);
auto ret = g_kernel->Split(task_id); auto ret = g_kernel->Split(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -83,7 +83,7 @@ int SplitCPUKernel::Run() {
for (int i = 0; i < param->num_split_; i++) { for (int i = 0; i < param->num_split_; i++) {
output_ptr_[i] = reinterpret_cast<float *>(out_tensors_.at(i)->Data()); output_ptr_[i] = reinterpret_cast<float *>(out_tensors_.at(i)->Data());
} }
ret = LiteBackendParallelLaunch(SplitRun, this, thread_n_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, SplitRun, this, thread_n_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "Scale error error_code[" << ret << "]"; MS_LOG(ERROR) << "Scale error error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32/transpose.cc
View File

@ -72,7 +72,7 @@ int TransposeCPUKernel::TransposeParallel(int task_id) {
return RET_OK; return RET_OK;
} }
int TransposeRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int TransposeRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<TransposeCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<TransposeCPUKernel *>(cdata);
auto ret = g_kernel->TransposeParallel(task_id); auto ret = g_kernel->TransposeParallel(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -101,7 +101,7 @@ int TransposeCPUKernel::Run() {
in_shape_ = const_cast<int *>(in_tensor->shape().data()); in_shape_ = const_cast<int *>(in_tensor->shape().data());
out_shape_ = const_cast<int *>(out_tensor->shape().data()); out_shape_ = const_cast<int *>(out_tensor->shape().data());
ret = LiteBackendParallelLaunch(TransposeRun, this, thread_h_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, TransposeRun, this, thread_h_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "Tranpose error error_code[" << ret << "]"; MS_LOG(ERROR) << "Tranpose error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/unsqueeze.cc
View File

@ -55,7 +55,7 @@ int UnsqueezeCPUKernel::DoUnsqueeze(int task_id) {
return RET_OK; return RET_OK;
} }
int UnsqueezeRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int UnsqueezeRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<UnsqueezeCPUKernel *>(cdata); auto g_kernel = reinterpret_cast<UnsqueezeCPUKernel *>(cdata);
auto ret = g_kernel->DoUnsqueeze(task_id); auto ret = g_kernel->DoUnsqueeze(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -73,7 +73,7 @@ int UnsqueezeCPUKernel::Run() {
} }
in_ptr_ = reinterpret_cast<int8_t *>(in_tensors_.at(0)->Data()); in_ptr_ = reinterpret_cast<int8_t *>(in_tensors_.at(0)->Data());
out_ptr_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->Data()); out_ptr_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->Data());
ret = LiteBackendParallelLaunch(UnsqueezeRun, this, thread_sz_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, UnsqueezeRun, this, thread_sz_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "UnsqueezeRun error error_code[" << ret << "]"; MS_LOG(ERROR) << "UnsqueezeRun error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/fp32/where.cc
View File

@ -38,7 +38,7 @@ int WhereCPUKernel::DoExcute(int task_id) {
return RET_OK; return RET_OK;
} }
int WhereRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int WhereRun(void *cdata, int task_id) {
auto wheredata = reinterpret_cast<WhereCPUKernel *>(cdata); auto wheredata = reinterpret_cast<WhereCPUKernel *>(cdata);
auto ret = wheredata->DoExcute(task_id); auto ret = wheredata->DoExcute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -79,7 +79,7 @@ int WhereCPUKernel::Run() {
MS_LOG(ERROR) << "Error, inputs' length are zero !!!"; MS_LOG(ERROR) << "Error, inputs' length are zero !!!";
return RET_ERROR; return RET_ERROR;
} }
ret = LiteBackendParallelLaunch(WhereRun, this, where_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, WhereRun, this, where_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "WhereDwRun error: error_code[" << ret << "]"; MS_LOG(ERROR) << "WhereDwRun error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/fp32_grad/activation_grad.cc
View File

@ -70,7 +70,7 @@ int ActivationGradCPUKernel::DoActivation(int task_id) {
return RET_OK; return RET_OK;
} }
int ActivationGradRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ActivationGradRun(void *cdata, int task_id) {
auto activationGrad_kernel = reinterpret_cast<ActivationGradCPUKernel *>(cdata); auto activationGrad_kernel = reinterpret_cast<ActivationGradCPUKernel *>(cdata);
auto error_code = activationGrad_kernel->DoActivation(task_id); auto error_code = activationGrad_kernel->DoActivation(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -81,7 +81,7 @@ int ActivationGradRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
} }
int ActivationGradCPUKernel::Run() { int ActivationGradCPUKernel::Run() {
int error_code = LiteBackendParallelLaunch(ActivationGradRun, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ActivationGradRun, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]"; MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

6
mindspore/lite/src/runtime/kernel/arm/int8/add_int8.cc
View File

@ -102,17 +102,17 @@ int QuantizedAddCPUKernel::Run() {
TileDimensionsUint8(static_cast<uint8_t *>(in_tensors_.at(0)->Data()), TileDimensionsUint8(static_cast<uint8_t *>(in_tensors_.at(0)->Data()),
static_cast<uint8_t *>(in_tensors_.at(1)->Data()), reinterpret_cast<uint8_t *>(input0_data_), static_cast<uint8_t *>(in_tensors_.at(1)->Data()), reinterpret_cast<uint8_t *>(input0_data_),
reinterpret_cast<uint8_t *>(input1_data_), &tile_para); reinterpret_cast<uint8_t *>(input1_data_), &tile_para);
ret = LiteBackendParallelLaunch(AddInt8Run, this, thread_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, AddInt8Run, this, thread_count_);
ctx_->allocator->Free(input0_data_); ctx_->allocator->Free(input0_data_);
ctx_->allocator->Free(input1_data_); ctx_->allocator->Free(input1_data_);
return ret; return ret;
} }
ret = LiteBackendParallelLaunch(AddInt8Run, this, thread_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, AddInt8Run, this, thread_count_);
return ret; return ret;
} }
int AddInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int AddInt8Run(void *cdata, int task_id) {
auto add = reinterpret_cast<QuantizedAddCPUKernel *>(cdata); auto add = reinterpret_cast<QuantizedAddCPUKernel *>(cdata);
add->DoExecute(task_id); add->DoExecute(task_id);
return lite::RET_OK; return lite::RET_OK;

2
mindspore/lite/src/runtime/kernel/arm/int8/add_int8.h
View File

@ -46,7 +46,7 @@ class QuantizedAddCPUKernel : public LiteKernel {
int8_t *output_data_ = nullptr; int8_t *output_data_ = nullptr;
}; };
int AddInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata); int AddInt8Run(void *cdata, int task_id);
} // namespace mindspore::kernel } // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_INT8_ADD_INT8_H_ #endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_INT8_ADD_INT8_H_

8
mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc
View File

@ -36,11 +36,11 @@ using mindspore::schema::PrimitiveType_NotEqual;
namespace mindspore::kernel { namespace mindspore::kernel {
namespace { namespace {
int ArithmeticsInt8Launch(int thread_id, LiteParallelGroupEnv *penv, void *cdata) { int ArithmeticsInt8Launch(void *cdata, int task_id) {
auto arithmetic_kernel = reinterpret_cast<ArithmeticInt8CPUKernel *>(cdata); auto arithmetic_kernel = reinterpret_cast<ArithmeticInt8CPUKernel *>(cdata);
auto error_code = arithmetic_kernel->DoArithmetic(thread_id); auto error_code = arithmetic_kernel->DoArithmetic(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "ArithmeticsRun error thread_id[" << thread_id << "] error_code[" << error_code << "]"; MS_LOG(ERROR) << "ArithmeticsRun error thread_id[" << task_id << "] error_code[" << error_code << "]";
return error_code; return error_code;
} }
return RET_OK; return RET_OK;
@ -151,7 +151,7 @@ int ArithmeticInt8CPUKernel::Run() {
} }
TileDimensionsInt8(input_data0, input_data1, tile_data0_, tile_data1_, param); TileDimensionsInt8(input_data0, input_data1, tile_data0_, tile_data1_, param);
} }
ret = LiteBackendParallelLaunch(ArithmeticsInt8Launch, this, op_parameter_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ArithmeticsInt8Launch, this, op_parameter_->thread_num_);
if (param->broadcasting_) { if (param->broadcasting_) {
context_->allocator->Free(tile_data0_); context_->allocator->Free(tile_data0_);
context_->allocator->Free(tile_data1_); context_->allocator->Free(tile_data1_);

4
mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_self_int8.cc
View File

@ -65,7 +65,7 @@ int ArithmeticSelfInt8CPUKernel::ReSize() {
return RET_OK; return RET_OK;
} }
int ArithmeticSelfInt8Runs(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ArithmeticSelfInt8Runs(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ArithmeticSelfInt8CPUKernel *>(cdata); auto g_kernel = reinterpret_cast<ArithmeticSelfInt8CPUKernel *>(cdata);
auto ret = g_kernel->DoArithmeticSelf(task_id); auto ret = g_kernel->DoArithmeticSelf(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -104,7 +104,7 @@ int ArithmeticSelfInt8CPUKernel::Run() {
auto out_tensor = out_tensors_.at(0); auto out_tensor = out_tensors_.at(0);
in_ptr_ = reinterpret_cast<int8_t *>(input_tensor->Data()); in_ptr_ = reinterpret_cast<int8_t *>(input_tensor->Data());
out_ptr_ = reinterpret_cast<int8_t *>(out_tensor->Data()); out_ptr_ = reinterpret_cast<int8_t *>(out_tensor->Data());
ret = LiteBackendParallelLaunch(ArithmeticSelfInt8Runs, this, thread_sz_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ArithmeticSelfInt8Runs, this, thread_sz_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ArithmeticSelfRun error error_code[" << ret << "]"; MS_LOG(ERROR) << "ArithmeticSelfRun error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/int8/batchnorm_int8.cc
View File

@ -180,7 +180,7 @@ int BatchnormInt8CPUKernel::DoExecute(int task_id) {
return RET_OK; return RET_OK;
} }
int BatchNormInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int BatchNormInt8Run(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<BatchnormInt8CPUKernel *>(cdata); auto g_kernel = reinterpret_cast<BatchnormInt8CPUKernel *>(cdata);
auto ret = g_kernel->DoExecute(task_id); auto ret = g_kernel->DoExecute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -199,7 +199,7 @@ int BatchnormInt8CPUKernel::Run() {
in_addr_ = reinterpret_cast<int8_t *>(in_tensors_.at(0)->Data()); in_addr_ = reinterpret_cast<int8_t *>(in_tensors_.at(0)->Data());
out_addr_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->Data()); out_addr_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->Data());
int ret = LiteBackendParallelLaunch(BatchNormInt8Run, this, batchnorm_param_->op_parameter_.thread_num_); int ret = ParallelLaunch(THREAD_POOL_DEFAULT, BatchNormInt8Run, this, batchnorm_param_->op_parameter_.thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "BatchnormRun error error_code[" << ret << "]"; MS_LOG(ERROR) << "BatchnormRun error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/int8/concat_int8.cc
View File

@ -104,12 +104,12 @@ int ConcatInt8CPUKernel::Run() {
} }
output_data_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->Data()); output_data_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->Data());
ret = LiteBackendParallelLaunch(ConcatInt8Run, this, thread_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConcatInt8Run, this, thread_count_);
return ret; return ret;
} }
int ConcatInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ConcatInt8Run(void *cdata, int task_id) {
auto concat = reinterpret_cast<ConcatInt8CPUKernel *>(cdata); auto concat = reinterpret_cast<ConcatInt8CPUKernel *>(cdata);
concat->DoExecute(task_id); concat->DoExecute(task_id);
return lite::RET_OK; return lite::RET_OK;

2
mindspore/lite/src/runtime/kernel/arm/int8/concat_int8.h
View File

@ -56,7 +56,7 @@ class ConcatInt8CPUKernel : public ConcatBaseCPUKernel {
int8_t *output_data_ = nullptr; int8_t *output_data_ = nullptr;
}; };
int ConcatInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata); int ConcatInt8Run(void *cdata, int task_id);
} // namespace mindspore::kernel } // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_INT8_CONCAT_INT8_H_ #endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_INT8_CONCAT_INT8_H_

4
mindspore/lite/src/runtime/kernel/arm/int8/convolution_1x1_int8.cc
View File

@ -217,7 +217,7 @@ int Convolution1x1Int8CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int Convolution1x1Int8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int Convolution1x1Int8Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<Convolution1x1Int8CPUKernel *>(cdata); auto conv = reinterpret_cast<Convolution1x1Int8CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -253,7 +253,7 @@ int Convolution1x1Int8CPUKernel::Run() {
PackInputSum16x4Int8(packed_input_, input_sum_, matmul_param_->deep_, matmul_param_->col_, matmul_param_->row_, PackInputSum16x4Int8(packed_input_, input_sum_, matmul_param_->deep_, matmul_param_->col_, matmul_param_->row_,
conv_param_); conv_param_);
int error_code = LiteBackendParallelLaunch(Convolution1x1Int8Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, Convolution1x1Int8Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv1x1 fp16 error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv1x1 fp16 error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/int8/convolution_3x3_int8.cc
View File

@ -213,7 +213,7 @@ int Convolution3x3Int8CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int Convolution3x3Int8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int Convolution3x3Int8Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<Convolution3x3Int8CPUKernel *>(cdata); auto conv = reinterpret_cast<Convolution3x3Int8CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -238,7 +238,7 @@ int Convolution3x3Int8CPUKernel::Run() {
auto input_addr = reinterpret_cast<int8_t *>(in_tensors_.at(kInputIndex)->Data()); auto input_addr = reinterpret_cast<int8_t *>(in_tensors_.at(kInputIndex)->Data());
PackInputToC8Int8(input_addr, input_data_, conv_param_); PackInputToC8Int8(input_addr, input_data_, conv_param_);
int error_code = LiteBackendParallelLaunch(Convolution3x3Int8Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, Convolution3x3Int8Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv3x3 int8 error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv3x3 int8 error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

4
mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_int8.cc
View File

@ -128,7 +128,7 @@ int ConvolutionDepthwiseInt8CPUKernel::Execute(int task_id) {
return RET_OK; return RET_OK;
} }
int ConvDwInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ConvDwInt8Run(void *cdata, int task_id) {
auto conv_dw_int8 = reinterpret_cast<ConvolutionDepthwiseInt8CPUKernel *>(cdata); auto conv_dw_int8 = reinterpret_cast<ConvolutionDepthwiseInt8CPUKernel *>(cdata);
auto ret = conv_dw_int8->Execute(task_id); auto ret = conv_dw_int8->Execute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -164,7 +164,7 @@ int ConvolutionDepthwiseInt8CPUKernel::Run() {
packed_output_ = output_addr; packed_output_ = output_addr;
} }
ret = LiteBackendParallelLaunch(ConvDwInt8Run, this, conv_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConvDwInt8Run, this, conv_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "ConvDwInt8Run error: error_code[" << ret << "]"; MS_LOG(ERROR) << "ConvDwInt8Run error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/int8/convolution_int8.cc
View File

@ -338,7 +338,7 @@ int ConvolutionInt8CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int ConvolutionInt8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ConvolutionInt8Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionInt8CPUKernel *>(cdata); auto conv = reinterpret_cast<ConvolutionInt8CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id); auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -374,7 +374,7 @@ int ConvolutionInt8CPUKernel::Run() {
convert_func_(ori_input_data, nhwc4_input_, conv_param_->input_batch_, conv_param_->input_h_ * conv_param_->input_w_, convert_func_(ori_input_data, nhwc4_input_, conv_param_->input_batch_, conv_param_->input_h_ * conv_param_->input_w_,
conv_param_->input_channel_); conv_param_->input_channel_);
int error_code = LiteBackendParallelLaunch(ConvolutionInt8Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionInt8Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv int8 error error_code[" << error_code << "]"; MS_LOG(ERROR) << "conv int8 error error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

4
mindspore/lite/src/runtime/kernel/arm/int8/crop_int8.cc
View File

@ -67,7 +67,7 @@ int CropInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << ret; MS_LOG(ERROR) << "Prepare fail!ret: " << ret;
return ret; return ret;
} }
ret = LiteBackendParallelLaunch(CropInt8Run, this, thread_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, CropInt8Run, this, thread_count_);
return ret; return ret;
} }
@ -91,7 +91,7 @@ void PadOffset(int input_dim, CropParameter *crop_para) {
} }
} }
int CropInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int CropInt8Run(void *cdata, int task_id) {
auto crop = reinterpret_cast<CropInt8CPUKernel *>(cdata); auto crop = reinterpret_cast<CropInt8CPUKernel *>(cdata);
crop->DoExecute(task_id); crop->DoExecute(task_id);
return RET_OK; return RET_OK;

2
mindspore/lite/src/runtime/kernel/arm/int8/crop_int8.h
View File

@ -46,7 +46,7 @@ class CropInt8CPUKernel : public CropBaseCPUKernel {
CropParameter *crop_para_; CropParameter *crop_para_;
}; };
int CropInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata); int CropInt8Run(void *cdata, int task_id);
void PadOffset(int input_dim, CropParameter *crop_para); void PadOffset(int input_dim, CropParameter *crop_para);
} // namespace mindspore::kernel } // namespace mindspore::kernel

4
mindspore/lite/src/runtime/kernel/arm/int8/deconvolution_depthwise_int8.cc
View File

@ -164,7 +164,7 @@ int DeconvolutionDepthwiseInt8CPUKernel::Execute(int task_id) {
return RET_OK; return RET_OK;
} }
int DeconvDwInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int DeconvDwInt8Run(void *cdata, int task_id) {
auto deconv_dw_int8 = reinterpret_cast<DeconvolutionDepthwiseInt8CPUKernel *>(cdata); auto deconv_dw_int8 = reinterpret_cast<DeconvolutionDepthwiseInt8CPUKernel *>(cdata);
auto ret = deconv_dw_int8->Execute(task_id); auto ret = deconv_dw_int8->Execute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -196,7 +196,7 @@ int DeconvolutionDepthwiseInt8CPUKernel::Run() {
packed_output_ = output_addr; packed_output_ = output_addr;
} }
ret = LiteBackendParallelLaunch(DeconvDwInt8Run, this, conv_param_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, DeconvDwInt8Run, this, conv_param_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "DeconvDwInt8Run error: error_code[" << ret << "]"; MS_LOG(ERROR) << "DeconvDwInt8Run error: error_code[" << ret << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/int8/deconvolution_int8.cc
View File

@ -216,7 +216,7 @@ void DeConvInt8CPUKernel::FreeRunBuf() {
return; return;
} }
int DeConvInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int DeConvInt8Run(void *cdata, int task_id) {
auto deconv = reinterpret_cast<DeConvInt8CPUKernel *>(cdata); auto deconv = reinterpret_cast<DeConvInt8CPUKernel *>(cdata);
auto error_code = deconv->DoDeconv(task_id); auto error_code = deconv->DoDeconv(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -272,7 +272,7 @@ int DeConvInt8CPUKernel::Run() {
DeConvPackInputSum(input_ptr_, input_sum_, conv_param_->conv_quant_arg_.filter_quant_args_[0].zp_, DeConvPackInputSum(input_ptr_, input_sum_, conv_param_->conv_quant_arg_.filter_quant_args_[0].zp_,
UP_ROUND(matmul_param_->row_, C4NUM), UP_ROUND(matmul_param_->deep_, C16NUM), support_optimize_); UP_ROUND(matmul_param_->row_, C4NUM), UP_ROUND(matmul_param_->deep_, C16NUM), support_optimize_);
error_code = LiteBackendParallelLaunch(DeConvInt8Run, this, thread_count_); error_code = ParallelLaunch(THREAD_POOL_DEFAULT, DeConvInt8Run, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "deconv int8 run error! error_code[" << error_code << "]"; MS_LOG(ERROR) << "deconv int8 run error! error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/int8/div_int8.cc
View File

@ -87,7 +87,7 @@ int DivInt8CPUKernel::DoExecute(int task_id) {
return ret; return ret;
} }
int DivInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int DivInt8Run(void *cdata, int task_id) {
auto div_kernel = reinterpret_cast<DivInt8CPUKernel *>(cdata); auto div_kernel = reinterpret_cast<DivInt8CPUKernel *>(cdata);
auto ret = div_kernel->DoExecute(task_id); auto ret = div_kernel->DoExecute(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -123,7 +123,7 @@ int DivInt8CPUKernel::Run() {
static_cast<uint8_t *>(in_tensors_.at(1)->Data()), reinterpret_cast<uint8_t *>(tile0_data_), static_cast<uint8_t *>(in_tensors_.at(1)->Data()), reinterpret_cast<uint8_t *>(tile0_data_),
reinterpret_cast<uint8_t *>(tile1_data_), &tile_para); reinterpret_cast<uint8_t *>(tile1_data_), &tile_para);
} }
ret = LiteBackendParallelLaunch(DivInt8Run, this, op_parameter_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, DivInt8Run, this, op_parameter_->thread_num_);
if (broadcast_) { if (broadcast_) {
context_->allocator->Free(tile0_data_); context_->allocator->Free(tile0_data_);
context_->allocator->Free(tile1_data_); context_->allocator->Free(tile1_data_);

4
mindspore/lite/src/runtime/kernel/arm/int8/fullconnection_int8.cc
View File

@ -118,7 +118,7 @@ int FullconnectionInt8CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int FcInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int FcInt8Run(void *cdata, int task_id) {
auto fc = reinterpret_cast<FullconnectionInt8CPUKernel *>(cdata); auto fc = reinterpret_cast<FullconnectionInt8CPUKernel *>(cdata);
auto ret = fc->RunImpl(task_id); auto ret = fc->RunImpl(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -137,7 +137,7 @@ int FullconnectionInt8CPUKernel::Run() {
auto input_ptr = reinterpret_cast<int8_t *>(in_tensors_[0]->Data()); auto input_ptr = reinterpret_cast<int8_t *>(in_tensors_[0]->Data());
RowMajor2Row4x16Major(input_ptr, fc_param_->row_, fc_param_->deep_, a_r4x16_ptr_, d16_); RowMajor2Row4x16Major(input_ptr, fc_param_->row_, fc_param_->deep_, a_r4x16_ptr_, d16_);
CalcInputSums(input_ptr, fc_param_->row_, fc_param_->deep_, quant_params_.weight.zp_, input_sums_); CalcInputSums(input_ptr, fc_param_->row_, fc_param_->deep_, quant_params_.weight.zp_, input_sums_);
LiteBackendParallelLaunch(FcInt8Run, this, thread_count_); ParallelLaunch(THREAD_POOL_DEFAULT, FcInt8Run, this, thread_count_);
return RET_OK; return RET_OK;
} }

4
mindspore/lite/src/runtime/kernel/arm/int8/gatherNd_int8.cc
View File

@ -114,7 +114,7 @@ int GatherNdInt8CPUKernel::DoGatherNd(int task_id) {
return RET_OK; return RET_OK;
} }
int GatherNdInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int GatherNdInt8Run(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<GatherNdInt8CPUKernel *>(cdata); auto g_kernel = reinterpret_cast<GatherNdInt8CPUKernel *>(cdata);
auto ret = g_kernel->DoGatherNd(task_id); auto ret = g_kernel->DoGatherNd(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -132,7 +132,7 @@ int GatherNdInt8CPUKernel::Run() {
} }
in_ptr_ = reinterpret_cast<int8_t *>(in_tensors_.front()->Data()); in_ptr_ = reinterpret_cast<int8_t *>(in_tensors_.front()->Data());
out_ptr_ = reinterpret_cast<int8_t *>(out_tensors_.front()->Data()); out_ptr_ = reinterpret_cast<int8_t *>(out_tensors_.front()->Data());
auto ret = LiteBackendParallelLaunch(GatherNdInt8Run, this, thread_sz_count_); auto ret = ParallelLaunch(THREAD_POOL_DEFAULT, GatherNdInt8Run, this, thread_sz_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "gatherNd error error_code[" << ret << "]"; MS_LOG(ERROR) << "gatherNd error error_code[" << ret << "]";
return ret; return ret;

4
mindspore/lite/src/runtime/kernel/arm/int8/gather_int8.cc
View File

@ -111,7 +111,7 @@ int GatherInt8CPUKernel::DoGather(int task_id) {
return RET_OK; return RET_OK;
} }
int GatherInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int GatherInt8Run(void *cdata, int task_id) {
auto gather_kernel = reinterpret_cast<GatherInt8CPUKernel *>(cdata); auto gather_kernel = reinterpret_cast<GatherInt8CPUKernel *>(cdata);
auto error_code = gather_kernel->DoGather(task_id); auto error_code = gather_kernel->DoGather(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -127,7 +127,7 @@ int GatherInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret; MS_LOG(ERROR) << "Prepare fail!ret: " << prepare_ret;
return prepare_ret; return prepare_ret;
} }
int error_code = LiteBackendParallelLaunch(GatherInt8Run, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, GatherInt8Run, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Gather function error error_code[" << error_code << "]"; MS_LOG(ERROR) << "Gather function error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/int8/hswish_int8.cc
View File

@ -78,7 +78,7 @@ int HswishInt8CPUKernel::DoActivation(int task_id) {
return RET_OK; return RET_OK;
} }
int HswishInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int HswishInt8Run(void *cdata, int task_id) {
auto activation_kernel = reinterpret_cast<HswishInt8CPUKernel *>(cdata); auto activation_kernel = reinterpret_cast<HswishInt8CPUKernel *>(cdata);
auto error_code = activation_kernel->DoActivation(task_id); auto error_code = activation_kernel->DoActivation(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -94,7 +94,7 @@ int HswishInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed."; MS_LOG(ERROR) << "Prepare failed.";
return RET_ERROR; return RET_ERROR;
} }
int error_code = LiteBackendParallelLaunch(HswishInt8Run, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, HswishInt8Run, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "HswishInt8Run function error error_code[" << error_code << "]"; MS_LOG(ERROR) << "HswishInt8Run function error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.cc
View File

@ -82,13 +82,13 @@ int LeakyReluInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << ret; MS_LOG(ERROR) << "Prepare fail!ret: " << ret;
return ret; return ret;
} }
ret = LiteBackendParallelLaunch(PreluInt8Run, this, op_parameter_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, PreluInt8Run, this, op_parameter_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "RunPreluParam failed. errorcode: "; MS_LOG(ERROR) << "RunPreluParam failed. errorcode: ";
} }
return RET_OK; return RET_OK;
} }
int PreluInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int PreluInt8Run(void *cdata, int task_id) {
auto prelu = reinterpret_cast<LeakyReluInt8CPUKernel *>(cdata); auto prelu = reinterpret_cast<LeakyReluInt8CPUKernel *>(cdata);
prelu->DoExecute(task_id); prelu->DoExecute(task_id);
return RET_OK; return RET_OK;

2
mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.h
View File

@ -41,7 +41,7 @@ class LeakyReluInt8CPUKernel : public LeakyReluBaseCPUKernel {
private: private:
LeakyReluQuantArg quant_prelu_parm_; LeakyReluQuantArg quant_prelu_parm_;
}; };
int PreluInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata); int PreluInt8Run(void *cdata, int task_id);
} // namespace mindspore::kernel } // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_INT8_PRELU_INT8_H_ #endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_INT8_PRELU_INT8_H_

4
mindspore/lite/src/runtime/kernel/arm/int8/matmul_int8.cc
View File

@ -111,7 +111,7 @@ int MatmulInt8CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int MatmulInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int MatmulInt8Run(void *cdata, int task_id) {
auto op = reinterpret_cast<MatmulInt8CPUKernel *>(cdata); auto op = reinterpret_cast<MatmulInt8CPUKernel *>(cdata);
auto ret = op->RunImpl(task_id); auto ret = op->RunImpl(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -152,7 +152,7 @@ int MatmulInt8CPUKernel::Run() {
auto &q = quant_params_; auto &q = quant_params_;
CalcInputSums(cur_a_ptr, params_->row_, params_->deep_, q.weight.zp_, input_sums_); CalcInputSums(cur_a_ptr, params_->row_, params_->deep_, q.weight.zp_, input_sums_);
CalcWeightBiasSums(cur_b_ptr, params_->deep_, params_->col_, q.input.zp_, q.weight.zp_, NULL, weight_bias_sums_); CalcWeightBiasSums(cur_b_ptr, params_->deep_, params_->col_, q.input.zp_, q.weight.zp_, NULL, weight_bias_sums_);
ret = LiteBackendParallelLaunch(MatmulInt8Run, this, thread_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, MatmulInt8Run, this, thread_count_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "MatmulInt8Run error: [" << ret << "]"; MS_LOG(ERROR) << "MatmulInt8Run error: [" << ret << "]";
return ret; return ret;

6
mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.cc
View File

@ -86,17 +86,17 @@ int MulInt8CPUKernel::Run() {
} }
TileDimensionsInt8(static_cast<int8_t *>(in_tensors_.at(0)->Data()), TileDimensionsInt8(static_cast<int8_t *>(in_tensors_.at(0)->Data()),
static_cast<int8_t *>(in_tensors_.at(1)->Data()), input0_data_, input1_data_, &tile_para); static_cast<int8_t *>(in_tensors_.at(1)->Data()), input0_data_, input1_data_, &tile_para);
ret = LiteBackendParallelLaunch(MulInt8Run, this, thread_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, MulInt8Run, this, thread_count_);
ctx_->allocator->Free(input0_data_); ctx_->allocator->Free(input0_data_);
ctx_->allocator->Free(input1_data_); ctx_->allocator->Free(input1_data_);
return ret; return ret;
} }
ret = LiteBackendParallelLaunch(MulInt8Run, this, thread_count_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, MulInt8Run, this, thread_count_);
return ret; return ret;
} }
int MulInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int MulInt8Run(void *cdata, int task_id) {
auto mul = reinterpret_cast<MulInt8CPUKernel *>(cdata); auto mul = reinterpret_cast<MulInt8CPUKernel *>(cdata);
mul->DoExecute(task_id); mul->DoExecute(task_id);
return lite::RET_OK; return lite::RET_OK;

2
mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.h
View File

@ -46,7 +46,7 @@ class MulInt8CPUKernel : public LiteKernel {
int8_t *output_data_ = nullptr; int8_t *output_data_ = nullptr;
}; };
int MulInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata); int MulInt8Run(void *cdata, int task_id);
} // namespace mindspore::kernel } // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_INT8_MUL_INT8_H_ #endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_INT8_MUL_INT8_H_

4
mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc
View File

@ -112,7 +112,7 @@ int PadInt8CPUKernel::RunImpl(int task_id) {
return PadConstant4D(in_data_, out_data_, in_dims_, out_dims_, pad_param_->paddings_, task_id, context_->thread_num_); return PadConstant4D(in_data_, out_data_, in_dims_, out_dims_, pad_param_->paddings_, task_id, context_->thread_num_);
} }
int PadInt8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int PadInt8Impl(void *cdata, int task_id) {
auto resize = reinterpret_cast<PadInt8CPUKernel *>(cdata); auto resize = reinterpret_cast<PadInt8CPUKernel *>(cdata);
auto error_code = resize->RunImpl(task_id); auto error_code = resize->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -132,7 +132,7 @@ int PadInt8CPUKernel::Run() {
out_data_ = reinterpret_cast<int8_t *>(out_tensors_[0]->Data()); out_data_ = reinterpret_cast<int8_t *>(out_tensors_[0]->Data());
memset(out_data_, pad_param_->pad_quant_arg_.constant_value_[0], out_tensors_[0]->ElementsNum() * sizeof(int8_t)); memset(out_data_, pad_param_->pad_quant_arg_.constant_value_[0], out_tensors_[0]->ElementsNum() * sizeof(int8_t));
int error_code = LiteBackendParallelLaunch(PadInt8Impl, this, context_->thread_num_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, PadInt8Impl, this, context_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Resize run error, error_code[" << error_code << "]"; MS_LOG(ERROR) << "Resize run error, error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/int8/pooling_int8.cc
View File

@ -69,7 +69,7 @@ int PoolingInt8CPUKernel::RunImpl(int task_id) {
return RET_OK; return RET_OK;
} }
int PoolingInt8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int PoolingInt8Impl(void *cdata, int task_id) {
auto pooling = reinterpret_cast<PoolingInt8CPUKernel *>(cdata); auto pooling = reinterpret_cast<PoolingInt8CPUKernel *>(cdata);
auto error_code = pooling->RunImpl(task_id); auto error_code = pooling->RunImpl(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -85,7 +85,7 @@ int PoolingInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed."; MS_LOG(ERROR) << "Prepare failed.";
return RET_ERROR; return RET_ERROR;
} }
int error_code = LiteBackendParallelLaunch(PoolingInt8Impl, this, thread_count_); int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, PoolingInt8Impl, this, thread_count_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "poolingInt8 error error_code[" << error_code << "]"; MS_LOG(ERROR) << "poolingInt8 error error_code[" << error_code << "]";
return RET_ERROR; return RET_ERROR;

4
mindspore/lite/src/runtime/kernel/arm/int8/power_int8.cc
View File

@ -88,7 +88,7 @@ int PowerInt8CPUKernel::DoPower(int task_id) {
return ret; return ret;
} }
int PowerInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int PowerInt8Run(void *cdata, int task_id) {
auto power_kernel = reinterpret_cast<PowerInt8CPUKernel *>(cdata); auto power_kernel = reinterpret_cast<PowerInt8CPUKernel *>(cdata);
auto ret = power_kernel->DoPower(task_id); auto ret = power_kernel->DoPower(task_id);
if (ret != RET_OK) { if (ret != RET_OK) {
@ -103,7 +103,7 @@ int PowerInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed."; MS_LOG(ERROR) << "Prepare failed.";
return ret; return ret;
} }
ret = LiteBackendParallelLaunch(PowerInt8Run, this, op_parameter_->thread_num_); ret = ParallelLaunch(THREAD_POOL_DEFAULT, PowerInt8Run, this, op_parameter_->thread_num_);
if (ret != RET_OK) { if (ret != RET_OK) {
MS_LOG(ERROR) << "PowerInt8Run error, error_code[" << ret << "]"; MS_LOG(ERROR) << "PowerInt8Run error, error_code[" << ret << "]";
} }

6
mindspore/lite/src/runtime/kernel/arm/int8/reduce_int8.cc
View File

@ -235,7 +235,7 @@ int ReduceInt8CPUKernel::ReSize() {
return ret; return ret;
} }
int ReduceInt8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) { int ReduceInt8Impl(void *cdata, int task_id) {
auto reduce = reinterpret_cast<ReduceInt8CPUKernel *>(cdata); auto reduce = reinterpret_cast<ReduceInt8CPUKernel *>(cdata);
auto error_code = reduce->CallReduceUnit(task_id); auto error_code = reduce->CallReduceUnit(task_id);
if (error_code != RET_OK) { if (error_code != RET_OK) {
@ -284,7 +284,7 @@ int ReduceInt8CPUKernel::Run() {
inner_size_ *= tmp_shape_[k]; inner_size_ *= tmp_shape_[k];
} }
axis_size_ = tmp_shape_[axis]; axis_size_ = tmp_shape_[axis];
auto error_code = LiteBackendParallelLaunch(ReduceInt8Impl, this, context_->thread_num_); auto error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ReduceInt8Impl, this, context_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
FreeTmpBuffer(); FreeTmpBuffer();
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]"; MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";
@ -321,7 +321,7 @@ int ReduceInt8CPUKernel::Run() {
axis_size_ = tmp_shape_[last_reduce_axis]; axis_size_ = tmp_shape_[last_reduce_axis];
last_dst_data_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->Data()); last_dst_data_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->Data());
is_last_axis_ = true; is_last_axis_ = true;
auto error_code = LiteBackendParallelLaunch(ReduceInt8Impl, this, context_->thread_num_); auto error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ReduceInt8Impl, this, context_->thread_num_);
if (error_code != RET_OK) { if (error_code != RET_OK) {
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]"; MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";
FreeTmpBuffer(); FreeTmpBuffer();

Some files were not shown because too many files have changed in this diff Show More