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)
endif ()
if (PLATFORM_ARM64)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv8.2-a+dotprod+fp16")
add_compile_definitions(ENABLE_ARM64)
if (ENABLE_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 <memory>
#include "include/ms_tensor.h"
#include "include/thread_pool_config.h"
namespace mindspore::lite {
/// \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.
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.
typedef enum {
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}/runtime/allocator.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}/ir/tensor.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) {
MS_EXCEPTION_IF_NULL(this->context_);
SetMaxWokerNum(context_->thread_num_);
if (before == nullptr && after == nullptr) {
return executor->Run(this->inputs_, this->outputs_, this->kernels_, this->context_->allocator.get());
} else {
@ -264,7 +263,7 @@ int LiteSession::Init(Context *context) {
}
this->context_->float16_priority = context->float16_priority;
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();
if (ret != RET_OK) {
MS_LOG(ERROR) << "KernelRegistry Init Failed.";
@ -283,7 +282,7 @@ int LiteSession::Init(Context *context) {
void LiteSession::BindThread(bool if_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;
}
int RunPriorBox(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int RunPriorBox(void *cdata, int task_id) {
auto prior_box = reinterpret_cast<PriorBoxCPUKernel *>(cdata);
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 << "]";
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) {
MS_LOG(ERROR) << "PriorBox run error, error_code[" << error_code << "]";
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;
}
int QuantDTypeCastRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int QuantDTypeCastRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<QuantDTypeCastCPUKernel *>(cdata);
auto ret = g_kernel->QuantDTypeCast(task_id);
if (ret != RET_OK) {
@ -119,7 +119,7 @@ int QuantDTypeCastCPUKernel::Run() {
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) {
MS_LOG(ERROR) << "Scale error error_code[" << ret << "]";
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;
}
int ActivationRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ActivationRun(void *cdata, int task_id) {
auto activation_kernel = reinterpret_cast<ActivationFp16CPUKernel *>(cdata);
auto error_code = activation_kernel->DoActivation(task_id);
if (error_code != RET_OK) {
@ -115,7 +115,7 @@ int ActivationFp16CPUKernel::Run() {
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) {
MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]";
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;
}
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 error_code = arithmetic_kernel->DoArithmetic(task_id);
if (error_code != RET_OK) {
@ -413,7 +413,7 @@ int ArithmeticFP16CPUKernel::Run() {
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_[1]->Data()), input1_fp16_,
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;
}

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();
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) {
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 {
int CastRun(int thread_id, LiteParallelGroupEnv *penv, void *cdata) {
int CastRun(void *cdata, int task_id) {
if (cdata == nullptr) {
MS_LOG(ERROR) << "input cdata is nullptr!";
return RET_ERROR;
}
return reinterpret_cast<CastFp16CPUKernel *>(cdata)->DoCast(thread_id);
return reinterpret_cast<CastFp16CPUKernel *>(cdata)->DoCast(task_id);
}
} // namespace
@ -91,7 +91,7 @@ int CastFp16CPUKernel::Run() {
if (data_num_ == 0) {
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,

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;
}
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 error_code = conv->RunImpl(task_id);
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_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) {
MS_LOG(ERROR) << "conv1x1 fp16 error error_code[" << error_code << "]";
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;
}
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 error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) {
@ -251,7 +251,7 @@ int Convolution3x3FP16CPUKernel::Run() {
int in_channel = conv_param_->input_channel_;
PackNHWCToNHWC8Fp16(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
int error_code = LiteBackendParallelLaunch(Convolution3x3Fp16Impl, this, thread_count_);
int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, Convolution3x3Fp16Impl, this, thread_count_);
if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv3x3 fp16 error error_code[" << error_code << "]";
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;
}
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 ret = conv_dw_fp16->Execute(task_id);
if (ret != RET_OK) {
@ -125,7 +125,7 @@ int ConvolutionDepthwiseFp16CPUKernel::Run() {
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) {
MS_LOG(ERROR) << "ConvDwFp16Run error: error_code[" << ret << "]";
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;
}
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 ret = conv_dw_fp16->Execute(task_id);
if (ret != RET_OK) {
@ -171,7 +171,7 @@ int ConvolutionDepthwiseSWFp16CPUKernel::Run() {
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) {
MS_LOG(ERROR) << "ConvDwSWFp16Run error: error_code[" << ret << "]";
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;
}
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 error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) {
@ -206,7 +206,7 @@ int ConvolutionFP16CPUKernel::Run() {
int in_channel = conv_param_->input_channel_;
convert_func_(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
int error_code = LiteBackendParallelLaunch(ConvolutionFp16Impl, this, thread_count_);
int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionFp16Impl, this, thread_count_);
if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv fp16 error error_code[" << error_code << "]";
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;
}
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 error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) {
@ -219,7 +219,7 @@ int ConvolutionSWFP16CPUKernel::Run() {
int in_channel = conv_param_->input_channel_;
convert_func_(reinterpret_cast<void *>(execute_input_), nhwc4_input_, in_batch, in_h * in_w, in_channel);
int error_code = LiteBackendParallelLaunch(ConvolutionSWFp16Impl, this, thread_count_);
int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionSWFp16Impl, this, thread_count_);
if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv fp16 error error_code[" << error_code << "]";
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;
}
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 error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) {
@ -404,7 +404,7 @@ int ConvolutionWinogradFP16CPUKernel::Run() {
int in_channel = conv_param_->input_channel_;
PackNHWCToNHWC8Fp16(execute_input_, nhwc4_input_, in_batch, in_h * in_w, in_channel);
int error_code = LiteBackendParallelLaunch(ConvolutionWinogradFp16Impl, this, thread_count_);
int error_code = ParallelLaunch(THREAD_POOL_DEFAULT, ConvolutionWinogradFp16Impl, this, thread_count_);
if (error_code != RET_OK) {
MS_LOG(ERROR) << "conv winograd error error_code[" << error_code << "]";
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;
}
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 ret = deconv_dw_fp16->Execute(task_id);
if (ret != RET_OK) {
@ -178,7 +178,7 @@ int DeconvolutionDepthwiseFp16CPUKernel::Run() {
if (!need_align_) {
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) {
MS_LOG(ERROR) << "DeconvDwFp16Run error: error_code[" << ret << "]";
return RET_ERROR;

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

@ -137,7 +137,7 @@ void DeConvolutionFp16CPUKernel::FreeRunBuf() {
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 error_code = deconv->DoDeconv(task_id);
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++) {
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) {
MS_LOG(ERROR) << "deconv fp32 run error! error_code[" << error_code << "]";
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;
}
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 error_code = pooling->RunImpl(task_id);
if (error_code != RET_OK) {
@ -109,7 +109,7 @@ int PoolingFp16CPUKernel::Run() {
auto input_ptr = reinterpret_cast<float *>(in_tensors_.at(kInputIndex)->Data());
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) {
MS_LOG(ERROR) << "pooling error error_code[" << error_code << "]";
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;
}
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 error_code = reduce->CallReduceUnit(task_id);
if (error_code != RET_OK) {
@ -112,7 +112,7 @@ int ReduceFp16CPUKernel::Run() {
inner_size_ *= tmp_shape_[k];
}
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) {
FreeTmpBuffer();
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;
}
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 ret = g_kernel->Split(task_id);
if (ret != RET_OK) {
@ -97,7 +97,7 @@ int SplitFp16CPUKernel::Run() {
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) {
MS_LOG(ERROR) << "split error error_code[" << ret << "]";
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;
}
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 ret = g_kernel->TransposeParallel(task_id);
if (ret != RET_OK) {
@ -162,7 +162,7 @@ int TransposeFp16CPUKernel::Run() {
in_shape_ = const_cast<int *>(in_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) {
MS_LOG(ERROR) << "Tranpose error error_code[" << ret << "]";
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;
}
int ActivationRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ActivationRun(void *cdata, int task_id) {
auto activation_kernel = reinterpret_cast<ActivationCPUKernel *>(cdata);
auto error_code = activation_kernel->DoActivation(task_id);
if (error_code != RET_OK) {
@ -83,7 +83,7 @@ int ActivationCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed.";
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) {
MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]";
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 {
int AddNLaunch(int thread_id, LiteParallelGroupEnv *penv, void *cdata) {
int AddNLaunch(void *cdata, int task_id) {
if (cdata == nullptr) {
MS_LOG(ERROR) << "Input cdata is nullptr!";
return RET_NULL_PTR;
}
auto kernel = reinterpret_cast<AddNCPUKernel *>(cdata);
return kernel->AddNParallelRun(thread_id);
return kernel->AddNParallelRun(task_id);
}
} // namespace
@ -74,7 +74,7 @@ int AddNCPUKernel::Run() {
in1_addr_ = input0_data;
in2_addr_ = input1_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) {
MS_LOG(ERROR) << "addn launch fail!ret: " << ret;
return RET_ERROR;
@ -82,7 +82,7 @@ int AddNCPUKernel::Run() {
for (size_t i = 2; i < in_tensors_.size(); ++i) {
in1_addr_ = reinterpret_cast<float *>(in_tensors_[i]->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) {
MS_LOG(ERROR) << "addn launch fail!ret: " << ret << ", input index: " << i;
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;
}
int ArithmeticsRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ArithmeticsRun(void *cdata, int task_id) {
auto arithmetic_kernel = reinterpret_cast<ArithmeticCPUKernel *>(cdata);
auto error_code = arithmetic_kernel->DoArithmetic(task_id);
if (error_code != RET_OK) {
@ -193,7 +193,7 @@ int ArithmeticCPUKernel::Run() {
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) {
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;
}
int ArithmeticSelfRuns(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ArithmeticSelfRuns(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ArithmeticSelfCPUKernel *>(cdata);
auto ret = g_kernel->DoArithmeticSelf(task_id);
if (ret != RET_OK) {
@ -80,7 +80,7 @@ int ArithmeticSelfCPUKernel::Run() {
auto out_tensor = out_tensors_.at(0);
in_ptr_ = reinterpret_cast<float *>(input_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) {
MS_LOG(ERROR) << "ArithmeticSelfRun error error_code[" << 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;
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) {
MS_LOG(ERROR) << "BatchnormRun error error_code[" << ret << "]";
}
@ -88,7 +88,7 @@ int BatchnormCPUKernel::DoExecute(int task_id) {
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 ret = kernel->DoExecute(task_id);
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;
};
int BatchNormRun(int task_id, LiteParallelGroupEnv *penv, void *cdata);
int BatchNormRun(void *cdata, int task_id);
} // namespace mindspore::kernel
#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 {
int CastRun(int thread_id, LiteParallelGroupEnv *penv, void *cdata) {
int CastRun(void *cdata, int task_id) {
if (cdata == nullptr) {
MS_LOG(ERROR) << "input cdata is nullptr!";
return RET_ERROR;
}
return reinterpret_cast<CastCPUKernel *>(cdata)->DoCast(thread_id);
return reinterpret_cast<CastCPUKernel *>(cdata)->DoCast(task_id);
}
} // namespace
@ -111,7 +111,7 @@ int CastCPUKernel::Run() {
if (data_num_ == 0) {
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,

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;
}
int ConstantOfShapeRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ConstantOfShapeRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ConstantOfShapeCPUKernel *>(cdata);
auto ret = g_kernel->DoExecute(task_id);
if (ret != RET_OK) {
@ -62,7 +62,7 @@ int ConstantOfShapeCPUKernel::Run() {
param_->unit_ = UP_DIV(param_->element_sz_, thread_num);
param_->op_parameter_.thread_num_ = thread_num;
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) {
MS_LOG(ERROR) << "ConstantOfShapeRun error error_code[" << 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;
}
int ConvolutionImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ConvolutionImpl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionCPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) {
@ -200,7 +200,7 @@ int ConvolutionCPUKernel::Run() {
PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_,
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) {
MS_LOG(ERROR) << "conv error error_code[" << error_code << "]";
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;
}
int Convolution1x1Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int Convolution1x1Run(void *cdata, int task_id) {
auto conv1x1 = reinterpret_cast<Convolution1x1CPUKernel *>(cdata);
auto error_code = conv1x1->DoConv1x1(task_id);
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_,
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) {
MS_LOG(ERROR) << "conv1x1 strassen error error_code[" << error_code << "]";
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;
}
int Convolution3x3Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int Convolution3x3Impl(void *cdata, int task_id) {
auto conv3x3 = reinterpret_cast<Convolution3x3CPUKernel *>(cdata);
auto error_code = conv3x3->RunImpl(task_id);
if (error_code != RET_OK) {
@ -258,7 +258,7 @@ int Convolution3x3CPUKernel::Run() {
PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_,
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) {
MS_LOG(ERROR) << "conv3x3 error error_code[" << error_code << "]";
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;
}
int ConvDwRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ConvDwRun(void *cdata, int task_id) {
auto conv_dw = reinterpret_cast<ConvolutionDepthwiseCPUKernel *>(cdata);
auto ret = conv_dw->Execute(task_id);
if (ret != RET_OK) {
@ -116,7 +116,7 @@ int ConvolutionDepthwiseCPUKernel::Run() {
auto output_tensor = out_tensors_.at(kOutputIndex);
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) {
MS_LOG(ERROR) << "ConvDwRun error: error_code[" << ret << "]";
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;
}
int ConvDwSWRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ConvDwSWRun(void *cdata, int task_id) {
auto conv_dw = reinterpret_cast<ConvolutionDepthwiseSWCPUKernel *>(cdata);
auto ret = conv_dw->Execute(task_id);
if (ret != RET_OK) {
@ -167,7 +167,7 @@ int ConvolutionDepthwiseSWCPUKernel::Run() {
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) {
MS_LOG(ERROR) << "ConvDwSWRun error: error_code[" << ret << "]";
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;
}
int ConvolutionSWImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ConvolutionSWImpl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionSWCPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) {
@ -187,7 +187,7 @@ int ConvolutionSWCPUKernel::Run() {
PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_,
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) {
MS_LOG(ERROR) << "conv error error_code[" << error_code << "]";
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;
}
int ConvolutionWinogradImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ConvolutionWinogradImpl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionWinogradCPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) {
@ -390,7 +390,7 @@ int ConvolutionWinogradCPUKernel::Run() {
PackNHWCToNHWC4Fp32(ori_input_data, nhwc4_input_, conv_param_->input_batch_,
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) {
MS_LOG(ERROR) << "conv winograd error error_code[" << error_code << "]";
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 {
int CropLaunch(int thread_id, LiteParallelGroupEnv *penv, void *cdata) {
int CropLaunch(void *cdata, int task_id) {
if (cdata == nullptr) {
MS_LOG(ERROR) << "Input cdata is nullptr!";
return RET_NULL_PTR;
}
auto kernel = reinterpret_cast<CropCPUKernel *>(cdata);
return kernel->CropParallelRun(thread_id);
return kernel->CropParallelRun(task_id);
}
} // namespace
@ -68,7 +68,7 @@ int CropCPUKernel::Run() {
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) {
MS_LOG(ERROR) << "Crop launch fail!ret: " << ret;
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;
}
int DeConvFp32Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int DeConvFp32Run(void *cdata, int task_id) {
auto deconv = reinterpret_cast<DeConvolutionCPUKernel *>(cdata);
auto error_code = deconv->DoDeconv(task_id);
if (error_code != RET_OK) {
@ -194,7 +194,7 @@ int DeConvolutionCPUKernel::Run() {
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) {
MS_LOG(ERROR) << "deconv fp32 run error! error_code[" << 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;
}
int DeconvDwRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int DeconvDwRun(void *cdata, int task_id) {
auto deconv_dw = reinterpret_cast<DeconvolutionDepthwiseCPUKernel *>(cdata);
auto ret = deconv_dw->Execute(task_id);
if (ret != RET_OK) {
@ -178,7 +178,7 @@ int DeconvolutionDepthwiseCPUKernel::Run() {
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) {
MS_LOG(ERROR) << "DeconvDwRun error: error_code[" << ret << "]";
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;
}
int EluRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int EluRun(void *cdata, int task_id) {
auto EluData = reinterpret_cast<EluCPUKernel *>(cdata);
auto ret = EluData->DoExcute(task_id);
if (ret != RET_OK) {
@ -65,7 +65,7 @@ int EluCPUKernel::Run() {
input_addr = reinterpret_cast<float *>(in_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) {
MS_LOG(ERROR) << "Elu error: error_code[" << ret << "]";
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;
}
int EmbeddingLookupRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int EmbeddingLookupRun(void *cdata, int task_id) {
auto EmbeddingLookupData = reinterpret_cast<EmbeddingLookupCPUKernel *>(cdata);
auto ret = EmbeddingLookupData->DoExcute(task_id);
if (ret != RET_OK) {
@ -102,7 +102,7 @@ int EmbeddingLookupCPUKernel::Run() {
output_addr_ = reinterpret_cast<float *>(out_tensors_.front()->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(embedding_lookup_parameter_->is_regulated_);
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;
}
int ExpandDimsRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ExpandDimsRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ExpandDimsCPUKernel *>(cdata);
auto ret = g_kernel->DoExpandDims(task_id);
if (ret != RET_OK) {
@ -74,7 +74,7 @@ int ExpandDimsCPUKernel::Run() {
}
in_ptr_ = reinterpret_cast<float *>(in_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) {
MS_LOG(ERROR) << "ExpandDimsRun error error_code[" << 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;
}
int FillRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int FillRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<FillCPUKernel *>(cdata);
auto ret = g_kernel->DoFill(task_id);
if (ret != RET_OK) {
@ -77,7 +77,7 @@ int FillCPUKernel::Run() {
auto fill_data = reinterpret_cast<float *>(fillData->Data());
src_data_ = fill_data[0];
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) {
MS_LOG(ERROR) << "FillRun error error_code[" << 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_);
}
int FcFp32MatmulRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int FcFp32MatmulRun(void *cdata, int task_id) {
auto fc = reinterpret_cast<FullconnectionCPUKernel *>(cdata);
auto error_code = fc->DoMatmul(task_id);
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_->b_const_) InitMatrixB(b_ptr, b_r8_ptr_);
LiteBackendParallelLaunch(FcFp32MatmulRun, this, thread_count_);
ParallelLaunch(THREAD_POOL_DEFAULT, FcFp32MatmulRun, this, thread_count_);
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;
}
int GatherRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int GatherRun(void *cdata, int task_id) {
auto gather_kernel = reinterpret_cast<GatherCPUKernel *>(cdata);
auto error_code = gather_kernel->DoGather(task_id);
if (error_code != RET_OK) {
@ -112,7 +112,7 @@ int GatherCPUKernel::Run() {
context_->allocator->Free(indices_data_);
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) {
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;
}
int GatherNdRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int GatherNdRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<GatherNdCPUKernel *>(cdata);
auto ret = g_kernel->DoGatherNd(task_id);
if (ret != RET_OK) {
@ -123,7 +123,7 @@ int GatherNdCPUKernel::Run() {
}
in_ptr_ = reinterpret_cast<float *>(in_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) {
MS_LOG(ERROR) << "gatherNd error error_code[" << 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 {
int LeakyReluRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int LeakyReluRun(void *cdata, int task_id) {
auto kernel_relu = reinterpret_cast<LeakyReluCPUKernel *>(cdata);
auto ret = kernel_relu->DoExcute(task_id);
if (ret != RET_OK) {
@ -66,7 +66,7 @@ int LeakyReluCPUKernel::Run() {
input_data = reinterpret_cast<float *>(input->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) {
MS_LOG(ERROR) << "PReluDwRun error: error_code[" << ret << "]";
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;
}
int LocalResponseNormRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int LocalResponseNormRun(void *cdata, int task_id) {
auto lrn = reinterpret_cast<LocalResponseNormCPUKernel *>(cdata);
auto error_code = lrn->DoLocalResponseNorm(task_id);
if (error_code != RET_OK) {
@ -79,7 +79,7 @@ int LocalResponseNormCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << 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) {
MS_LOG(ERROR) << "LocalResponseNorm function error error_code[" << error_code << "]";
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;
}
int MatmulFloatRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int MatmulFloatRun(void *cdata, int task_id) {
auto op = reinterpret_cast<MatmulCPUKernel *>(cdata);
auto error_code = op->RunImpl(task_id);
if (error_code != RET_OK) {
@ -178,7 +178,7 @@ int MatmulCPUKernel::Run() {
a_ptr_ = a_c12_ptr_ + i * params_->row_12_ * params_->deep_;
b_ptr_ = b_r8_ptr_ + i * params_->deep_ * params_->col_8_;
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;
}

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

@ -81,7 +81,7 @@ int OneHotCPUKernel::ReSize() {
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);
if (onehot_kernel == nullptr) {
MS_LOG(ERROR) << "cast OneHotCPUKernel failed";
@ -166,7 +166,7 @@ int OneHotCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << 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) {
MS_LOG(ERROR) << "OneHot function error error_code[" << error_code << "]";
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;
}
int PadImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int PadImpl(void *cdata, int task_id) {
auto padKernel = reinterpret_cast<PadCPUKernel *>(cdata);
int error_code = padKernel->RunImpl(task_id);
if (error_code != NNACL_OK) {
@ -102,7 +102,7 @@ int PadCPUKernel::Run() {
auto output_data = reinterpret_cast<float *>(output->Data());
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) {
MS_LOG(ERROR) << "Pad run error, error_code[" << error_code << "]";
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;
}
int PoolingImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int PoolingImpl(void *cdata, int task_id) {
auto pooling = reinterpret_cast<PoolingCPUKernel *>(cdata);
auto error_code = pooling->RunImpl(task_id);
if (error_code != RET_OK) {
@ -94,7 +94,7 @@ int PoolingCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << 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) {
MS_LOG(ERROR) << "pooling error error_code[" << error_code << "]";
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 PowerImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int PowerImpl(void *cdata, int task_id) {
auto kernel = reinterpret_cast<PowerCPUKernel *>(cdata);
auto ret = kernel->RunImpl(task_id);
if (ret != RET_OK) {
@ -46,7 +46,7 @@ int PowerCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << 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) {
MS_LOG(ERROR) << "PowerCPUKernel error: " << ret;
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 {
int PReluRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int PReluRun(void *cdata, int task_id) {
auto PRelu = reinterpret_cast<PReluCPUKernel *>(cdata);
auto ret = PRelu->DoExcute(task_id);
if (ret != RET_OK) {
@ -135,7 +135,7 @@ int PReluCPUKernel::Run() {
auto negative_slope_tensor = in_tensors_.at(1);
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) {
MS_LOG(ERROR) << "PRelu Run error: error_code[" << ret << "]";
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;
}
int ReduceImpl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ReduceImpl(void *cdata, int task_id) {
auto reduce = reinterpret_cast<ReduceCPUKernel *>(cdata);
auto error_code = reduce->CallReduceUnit(task_id);
if (error_code != RET_OK) {
@ -125,7 +125,7 @@ int ReduceCPUKernel::Run() {
inner_size_ *= tmp_shape_[k];
}
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) {
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";
return RET_ERROR;
@ -145,7 +145,7 @@ int ReduceCPUKernel::Run() {
}
axis_size_ = tmp_shape_[last_reduce_axis];
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) {
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";
return RET_ERROR;

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

@ -38,7 +38,7 @@ int ResizeCPUKernel::Init() {
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 error_code = resize->RunImpl(task_id);
if (error_code != RET_OK) {
@ -94,7 +94,7 @@ int ResizeCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed.";
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) {
MS_LOG(ERROR) << "Resize run error, error_code[" << error_code << "]";
return RET_ERROR;

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

@ -100,7 +100,7 @@ int ReverseCPUKernel::Init() {
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 ret = g_kernel->DoReverse(task_id);
if (ret != RET_OK) {
@ -132,7 +132,7 @@ int ReverseCPUKernel::Run() {
}
in_ptr_ = reinterpret_cast<float *>(in_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) {
MS_LOG(ERROR) << "Reverse run error error_code[" << 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;
}
int ROIPoolingRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ROIPoolingRun(void *cdata, int task_id) {
auto Data = reinterpret_cast<ROIPoolingCPUKernel *>(cdata);
auto ret = Data->DoExecute(task_id);
if (ret != RET_OK) {
@ -91,7 +91,7 @@ int ROIPoolingCPUKernel::Run() {
in_ptr_ = reinterpret_cast<float *>(in_tensors_.front()->Data());
out_ptr_ = reinterpret_cast<float *>(out_tensors_.front()->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) {
MS_LOG(ERROR) << "ROIPooling error: error_code[" << 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;
}
int ScaleRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ScaleRun(void *cdata, int task_id) {
auto scale = reinterpret_cast<ScaleCPUKernel *>(cdata);
auto ret = scale->Scale(task_id);
if (ret != RET_OK) {
@ -162,7 +162,7 @@ int ScaleCPUKernel::Run() {
auto out_tensor = out_tensors_.front();
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) {
MS_LOG(ERROR) << "Scale error error_code[" << ret << "]";
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;
}
int ScatterNDRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ScatterNDRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ScatterNDCPUKernel *>(cdata);
auto ret = g_kernel->ScatterND(task_id);
if (ret != RET_OK) {
@ -153,7 +153,7 @@ int ScatterNDCPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << ret;
return ret;
}
ret = LiteBackendParallelLaunch(ScatterNDRun, this, thread_n_num_);
ret = ParallelLaunch(THREAD_POOL_DEFAULT, ScatterNDRun, this, thread_n_num_);
if (ret != RET_OK) {
MS_LOG(ERROR) << "ScatterND error error_code[" << ret << "]";
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 {
int SliceLaunch(int thread_id, LiteParallelGroupEnv *penv, void *cdata) {
int SliceLaunch(void *cdata, int task_id) {
if (cdata == nullptr) {
MS_LOG(ERROR) << "Input cdata is nullptr!";
return RET_NULL_PTR;
}
auto kernel = reinterpret_cast<SliceCPUKernel *>(cdata);
return kernel->SliceParallelRun(thread_id);
return kernel->SliceParallelRun(task_id);
}
} // namespace
@ -97,7 +97,7 @@ int SliceCPUKernel::Run() {
DoSliceNoParallel(input_data, output_data, param);
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) {
MS_LOG(ERROR) << "slice launch fail!ret: " << ret;
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;
}
int SpaceToDepthRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int SpaceToDepthRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<SpaceToDepthCPUKernel *>(cdata);
auto ret = g_kernel->SpaceToDepth(task_id);
if (ret != RET_OK) {
@ -93,7 +93,7 @@ int SpaceToDepthCPUKernel::Run() {
input_ptr_ = reinterpret_cast<float *>(in_tensors_[0]->Data());
output_ptr_ = reinterpret_cast<float *>(out_tensors_[0]->Data());
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) {
MS_LOG(ERROR) << "SpaceToDepth error error_code[" << 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;
}
int SparseToDenseRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int SparseToDenseRun(void *cdata, int task_id) {
auto s2ddata = reinterpret_cast<SparseToDenseCPUKernel *>(cdata);
auto ret = s2ddata->DoExcute(task_id);
if (ret != RET_OK) {
@ -70,7 +70,7 @@ int SparseToDenseCPUKernel::Run() {
std::vector<int> temp_shape = output0->shape();
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) {
MS_LOG(ERROR) << "SparseToDenseRun error: error_code[" << ret << "]";
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;
}
int SplitRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int SplitRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<SplitCPUKernel *>(cdata);
auto ret = g_kernel->Split(task_id);
if (ret != RET_OK) {
@ -83,7 +83,7 @@ int SplitCPUKernel::Run() {
for (int i = 0; i < param->num_split_; i++) {
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) {
MS_LOG(ERROR) << "Scale error error_code[" << ret << "]";
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;
}
int TransposeRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int TransposeRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<TransposeCPUKernel *>(cdata);
auto ret = g_kernel->TransposeParallel(task_id);
if (ret != RET_OK) {
@ -101,7 +101,7 @@ int TransposeCPUKernel::Run() {
in_shape_ = const_cast<int *>(in_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) {
MS_LOG(ERROR) << "Tranpose error error_code[" << 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;
}
int UnsqueezeRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int UnsqueezeRun(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<UnsqueezeCPUKernel *>(cdata);
auto ret = g_kernel->DoUnsqueeze(task_id);
if (ret != RET_OK) {
@ -73,7 +73,7 @@ int UnsqueezeCPUKernel::Run() {
}
in_ptr_ = reinterpret_cast<int8_t *>(in_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) {
MS_LOG(ERROR) << "UnsqueezeRun error error_code[" << 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;
}
int WhereRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int WhereRun(void *cdata, int task_id) {
auto wheredata = reinterpret_cast<WhereCPUKernel *>(cdata);
auto ret = wheredata->DoExcute(task_id);
if (ret != RET_OK) {
@ -79,7 +79,7 @@ int WhereCPUKernel::Run() {
MS_LOG(ERROR) << "Error, inputs' length are zero !!!";
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) {
MS_LOG(ERROR) << "WhereDwRun error: error_code[" << ret << "]";
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;
}
int ActivationGradRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ActivationGradRun(void *cdata, int task_id) {
auto activationGrad_kernel = reinterpret_cast<ActivationGradCPUKernel *>(cdata);
auto error_code = activationGrad_kernel->DoActivation(task_id);
if (error_code != RET_OK) {
@ -81,7 +81,7 @@ int ActivationGradRun(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
}
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) {
MS_LOG(ERROR) << "Activation function error error_code[" << error_code << "]";
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()),
static_cast<uint8_t *>(in_tensors_.at(1)->Data()), reinterpret_cast<uint8_t *>(input0_data_),
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(input1_data_);
return ret;
}
ret = LiteBackendParallelLaunch(AddInt8Run, this, thread_count_);
ret = ParallelLaunch(THREAD_POOL_DEFAULT, AddInt8Run, this, thread_count_);
return ret;
}
int AddInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int AddInt8Run(void *cdata, int task_id) {
auto add = reinterpret_cast<QuantizedAddCPUKernel *>(cdata);
add->DoExecute(task_id);
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;
};
int AddInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata);
int AddInt8Run(void *cdata, int task_id);
} // namespace mindspore::kernel
#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 {
int ArithmeticsInt8Launch(int thread_id, LiteParallelGroupEnv *penv, void *cdata) {
int ArithmeticsInt8Launch(void *cdata, int task_id) {
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) {
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 RET_OK;
@ -151,7 +151,7 @@ int ArithmeticInt8CPUKernel::Run() {
}
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_) {
context_->allocator->Free(tile_data0_);
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;
}
int ArithmeticSelfInt8Runs(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ArithmeticSelfInt8Runs(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<ArithmeticSelfInt8CPUKernel *>(cdata);
auto ret = g_kernel->DoArithmeticSelf(task_id);
if (ret != RET_OK) {
@ -104,7 +104,7 @@ int ArithmeticSelfInt8CPUKernel::Run() {
auto out_tensor = out_tensors_.at(0);
in_ptr_ = reinterpret_cast<int8_t *>(input_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) {
MS_LOG(ERROR) << "ArithmeticSelfRun error error_code[" << 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;
}
int BatchNormInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int BatchNormInt8Run(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<BatchnormInt8CPUKernel *>(cdata);
auto ret = g_kernel->DoExecute(task_id);
if (ret != RET_OK) {
@ -199,7 +199,7 @@ int BatchnormInt8CPUKernel::Run() {
in_addr_ = reinterpret_cast<int8_t *>(in_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) {
MS_LOG(ERROR) << "BatchnormRun error error_code[" << 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());
ret = LiteBackendParallelLaunch(ConcatInt8Run, this, thread_count_);
ret = ParallelLaunch(THREAD_POOL_DEFAULT, ConcatInt8Run, this, thread_count_);
return ret;
}
int ConcatInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ConcatInt8Run(void *cdata, int task_id) {
auto concat = reinterpret_cast<ConcatInt8CPUKernel *>(cdata);
concat->DoExecute(task_id);
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;
};
int ConcatInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata);
int ConcatInt8Run(void *cdata, int task_id);
} // namespace mindspore::kernel
#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;
}
int Convolution1x1Int8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int Convolution1x1Int8Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<Convolution1x1Int8CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id);
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_,
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) {
MS_LOG(ERROR) << "conv1x1 fp16 error error_code[" << error_code << "]";
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;
}
int Convolution3x3Int8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int Convolution3x3Int8Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<Convolution3x3Int8CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id);
if (error_code != RET_OK) {
@ -238,7 +238,7 @@ int Convolution3x3Int8CPUKernel::Run() {
auto input_addr = reinterpret_cast<int8_t *>(in_tensors_.at(kInputIndex)->Data());
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) {
MS_LOG(ERROR) << "conv3x3 int8 error error_code[" << error_code << "]";
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;
}
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 ret = conv_dw_int8->Execute(task_id);
if (ret != RET_OK) {
@ -164,7 +164,7 @@ int ConvolutionDepthwiseInt8CPUKernel::Run() {
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) {
MS_LOG(ERROR) << "ConvDwInt8Run error: error_code[" << ret << "]";
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;
}
int ConvolutionInt8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ConvolutionInt8Impl(void *cdata, int task_id) {
auto conv = reinterpret_cast<ConvolutionInt8CPUKernel *>(cdata);
auto error_code = conv->RunImpl(task_id);
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_,
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) {
MS_LOG(ERROR) << "conv int8 error error_code[" << error_code << "]";
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;
return ret;
}
ret = LiteBackendParallelLaunch(CropInt8Run, this, thread_count_);
ret = ParallelLaunch(THREAD_POOL_DEFAULT, CropInt8Run, this, thread_count_);
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);
crop->DoExecute(task_id);
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_;
};
int CropInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata);
int CropInt8Run(void *cdata, int task_id);
void PadOffset(int input_dim, CropParameter *crop_para);
} // 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;
}
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 ret = deconv_dw_int8->Execute(task_id);
if (ret != RET_OK) {
@ -196,7 +196,7 @@ int DeconvolutionDepthwiseInt8CPUKernel::Run() {
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) {
MS_LOG(ERROR) << "DeconvDwInt8Run error: error_code[" << ret << "]";
return RET_ERROR;

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

@ -216,7 +216,7 @@ void DeConvInt8CPUKernel::FreeRunBuf() {
return;
}
int DeConvInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int DeConvInt8Run(void *cdata, int task_id) {
auto deconv = reinterpret_cast<DeConvInt8CPUKernel *>(cdata);
auto error_code = deconv->DoDeconv(task_id);
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_,
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) {
MS_LOG(ERROR) << "deconv int8 run error! error_code[" << error_code << "]";
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;
}
int DivInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int DivInt8Run(void *cdata, int task_id) {
auto div_kernel = reinterpret_cast<DivInt8CPUKernel *>(cdata);
auto ret = div_kernel->DoExecute(task_id);
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_),
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_) {
context_->allocator->Free(tile0_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;
}
int FcInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int FcInt8Run(void *cdata, int task_id) {
auto fc = reinterpret_cast<FullconnectionInt8CPUKernel *>(cdata);
auto ret = fc->RunImpl(task_id);
if (ret != RET_OK) {
@ -137,7 +137,7 @@ int FullconnectionInt8CPUKernel::Run() {
auto input_ptr = reinterpret_cast<int8_t *>(in_tensors_[0]->Data());
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_);
LiteBackendParallelLaunch(FcInt8Run, this, thread_count_);
ParallelLaunch(THREAD_POOL_DEFAULT, FcInt8Run, this, thread_count_);
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;
}
int GatherNdInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int GatherNdInt8Run(void *cdata, int task_id) {
auto g_kernel = reinterpret_cast<GatherNdInt8CPUKernel *>(cdata);
auto ret = g_kernel->DoGatherNd(task_id);
if (ret != RET_OK) {
@ -132,7 +132,7 @@ int GatherNdInt8CPUKernel::Run() {
}
in_ptr_ = reinterpret_cast<int8_t *>(in_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) {
MS_LOG(ERROR) << "gatherNd error error_code[" << 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;
}
int GatherInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int GatherInt8Run(void *cdata, int task_id) {
auto gather_kernel = reinterpret_cast<GatherInt8CPUKernel *>(cdata);
auto error_code = gather_kernel->DoGather(task_id);
if (error_code != RET_OK) {
@ -127,7 +127,7 @@ int GatherInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare fail!ret: " << 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) {
MS_LOG(ERROR) << "Gather function error error_code[" << error_code << "]";
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;
}
int HswishInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int HswishInt8Run(void *cdata, int task_id) {
auto activation_kernel = reinterpret_cast<HswishInt8CPUKernel *>(cdata);
auto error_code = activation_kernel->DoActivation(task_id);
if (error_code != RET_OK) {
@ -94,7 +94,7 @@ int HswishInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed.";
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) {
MS_LOG(ERROR) << "HswishInt8Run function error error_code[" << error_code << "]";
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;
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) {
MS_LOG(ERROR) << "RunPreluParam failed. errorcode: ";
}
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);
prelu->DoExecute(task_id);
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:
LeakyReluQuantArg quant_prelu_parm_;
};
int PreluInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata);
int PreluInt8Run(void *cdata, int task_id);
} // namespace mindspore::kernel
#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;
}
int MatmulInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int MatmulInt8Run(void *cdata, int task_id) {
auto op = reinterpret_cast<MatmulInt8CPUKernel *>(cdata);
auto ret = op->RunImpl(task_id);
if (ret != RET_OK) {
@ -152,7 +152,7 @@ int MatmulInt8CPUKernel::Run() {
auto &q = quant_params_;
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_);
ret = LiteBackendParallelLaunch(MatmulInt8Run, this, thread_count_);
ret = ParallelLaunch(THREAD_POOL_DEFAULT, MatmulInt8Run, this, thread_count_);
if (ret != RET_OK) {
MS_LOG(ERROR) << "MatmulInt8Run error: [" << 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()),
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(input1_data_);
return ret;
}
ret = LiteBackendParallelLaunch(MulInt8Run, this, thread_count_);
ret = ParallelLaunch(THREAD_POOL_DEFAULT, MulInt8Run, this, thread_count_);
return ret;
}
int MulInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int MulInt8Run(void *cdata, int task_id) {
auto mul = reinterpret_cast<MulInt8CPUKernel *>(cdata);
mul->DoExecute(task_id);
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;
};
int MulInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata);
int MulInt8Run(void *cdata, int task_id);
} // namespace mindspore::kernel
#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_);
}
int PadInt8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int PadInt8Impl(void *cdata, int task_id) {
auto resize = reinterpret_cast<PadInt8CPUKernel *>(cdata);
auto error_code = resize->RunImpl(task_id);
if (error_code != RET_OK) {
@ -132,7 +132,7 @@ int PadInt8CPUKernel::Run() {
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));
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) {
MS_LOG(ERROR) << "Resize run error, error_code[" << error_code << "]";
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;
}
int PoolingInt8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int PoolingInt8Impl(void *cdata, int task_id) {
auto pooling = reinterpret_cast<PoolingInt8CPUKernel *>(cdata);
auto error_code = pooling->RunImpl(task_id);
if (error_code != RET_OK) {
@ -85,7 +85,7 @@ int PoolingInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed.";
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) {
MS_LOG(ERROR) << "poolingInt8 error error_code[" << error_code << "]";
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;
}
int PowerInt8Run(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int PowerInt8Run(void *cdata, int task_id) {
auto power_kernel = reinterpret_cast<PowerInt8CPUKernel *>(cdata);
auto ret = power_kernel->DoPower(task_id);
if (ret != RET_OK) {
@ -103,7 +103,7 @@ int PowerInt8CPUKernel::Run() {
MS_LOG(ERROR) << "Prepare failed.";
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) {
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;
}
int ReduceInt8Impl(int task_id, LiteParallelGroupEnv *penv, void *cdata) {
int ReduceInt8Impl(void *cdata, int task_id) {
auto reduce = reinterpret_cast<ReduceInt8CPUKernel *>(cdata);
auto error_code = reduce->CallReduceUnit(task_id);
if (error_code != RET_OK) {
@ -284,7 +284,7 @@ int ReduceInt8CPUKernel::Run() {
inner_size_ *= tmp_shape_[k];
}
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) {
FreeTmpBuffer();
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";
@ -321,7 +321,7 @@ int ReduceInt8CPUKernel::Run() {
axis_size_ = tmp_shape_[last_reduce_axis];
last_dst_data_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->Data());
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) {
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";
FreeTmpBuffer();

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