From 1f4f62636c80a575a76470c5414dac4729f518f3 Mon Sep 17 00:00:00 2001 From: yangruoqi713 Date: Wed, 2 Jun 2021 17:21:38 +0800 Subject: [PATCH] [MSLITE][DEVELOP] add delegate api for third_party AI framework --- .../kernel_compiler/cpu/nnacl/fp32/pad_fp32.c | 3 +- mindspore/lite/include/context.h | 3 +- mindspore/lite/include/delegate.h | 60 +++++++++ mindspore/lite/include/kernel.h | 4 +- mindspore/lite/include/lite_utils.h | 5 + mindspore/lite/src/CMakeLists.txt | 1 + mindspore/lite/src/delegate/delegate.cc | 37 ++++++ mindspore/lite/src/executor.h | 4 +- mindspore/lite/src/inner_kernel.h | 2 +- mindspore/lite/src/lite_kernel.h | 53 +++++--- mindspore/lite/src/lite_mindrt.cc | 23 ++-- mindspore/lite/src/lite_mindrt.h | 3 +- mindspore/lite/src/lite_session.cc | 61 ++++++---- mindspore/lite/src/lite_session.h | 2 + mindspore/lite/src/mindrt_executor.cc | 6 +- mindspore/lite/src/mindrt_executor.h | 14 +-- .../src/runtime/agent/npu/npu_executor.cc | 2 +- .../lite/src/runtime/agent/npu/npu_executor.h | 2 +- .../runtime/agent/npu/subgraph_npu_kernel.cc | 2 +- .../src/runtime/gpu/opencl/opencl_executor.h | 2 +- .../kernel/arm/fp16/activation_fp16.cc | 31 ++++- .../arm/fp16/convolution_delegate_fp16.cc | 8 -- .../kernel/arm/fp16/deconvolution_fp16.cc | 7 -- .../kernel/arm/fp16/quant_dtype_cast_fp16.cc | 50 ++++++-- .../runtime/kernel/arm/fp16/reduce_fp16.cc | 26 +++- .../arm/fp32/convolution_delegate_fp32.cc | 8 -- .../kernel/arm/fp32/deconvolution_fp32.cc | 7 -- .../src/runtime/kernel/arm/fp32_grad/adam.cc | 8 -- .../kernel/arm/fp32_grad/apply_momentum.cc | 8 -- .../kernel/arm/fp32_grad/arithmetic_grad.cc | 8 -- .../arm/fp32_grad/arithmetic_self_grad.cc | 8 -- .../runtime/kernel/arm/fp32_grad/assign.cc | 8 -- .../runtime/kernel/arm/fp32_grad/bias_grad.cc | 8 -- .../runtime/kernel/arm/fp32_grad/bn_grad.cc | 7 -- .../kernel/arm/fp32_grad/convolution.cc | 8 -- .../arm/fp32_grad/convolution_grad_filter.cc | 8 -- .../fp32_grad/deconvolution_grad_filter.cc | 8 -- .../runtime/kernel/arm/fp32_grad/dropout.cc | 7 -- .../kernel/arm/fp32_grad/dropout_grad.cc | 7 -- .../runtime/kernel/arm/fp32_grad/neg_grad.cc | 8 -- .../kernel/arm/fp32_grad/pooling_grad.cc | 8 -- .../kernel/arm/fp32_grad/power_grad.cc | 8 -- .../src/runtime/kernel/arm/fp32_grad/sgd.cc | 9 -- .../sigmoid_cross_entropy_with_logits.cc | 7 -- .../sigmoid_cross_entropy_with_logits_grad.cc | 7 -- .../kernel/arm/fp32_grad/smooth_l1_loss.cc | 7 -- .../arm/fp32_grad/smooth_l1_loss_grad.cc | 7 -- .../softmax_cross_entropy_with_logits.cc | 7 -- .../kernel/arm/fp32_grad/softmax_grad.cc | 7 -- .../kernel/arm/int8/activation_int8.cc | 7 -- .../kernel/arm/int8/arithmetic_int8.cc | 7 -- .../arm/int8/convolution_int8_creator.cc | 7 -- .../kernel/arm/int8/deconvolution_int8.cc | 7 -- .../kernel/arm/string/extract_feature.cc | 7 -- .../kernel/arm/string/hashtable_lookup.cc | 7 -- .../runtime/kernel/arm/string/normalize.cc | 7 -- .../src/runtime/kernel/arm/string/predict.cc | 7 -- .../lite/src/runtime/parallel_executor.cc | 4 +- .../lite/src/runtime/parallel_executor.h | 2 +- mindspore/lite/src/scheduler.cc | 114 +++++++++++++++--- mindspore/lite/src/scheduler.h | 22 +++- .../kernel/arm/common/strided_slice_tests.cc | 24 +++- .../kernel/arm/fp16/reduce_fp16_tests.cc | 2 + .../kernel/arm/fp32/activation_fp32_test.cc | 21 +++- .../kernel/arm/fp32/batchnorm_fp32_tests.cc | 15 ++- .../fp32/convolution_depthwise_fp32_tests.cc | 7 +- .../runtime/kernel/arm/fp32/cumsum_tests.cc | 28 +++-- .../kernel/arm/fp32/l2norm_fp32_test.cc | 2 + .../arm/fp32/lsh_projection_fp32_tests.cc | 12 +- .../kernel/arm/fp32/lstm_fp32_tests.cc | 10 +- .../fp32/non_max_suppression_fp32_tests.cc | 2 + .../kernel/arm/fp32/one_hot_fp32_test.cc | 2 + .../runtime/kernel/arm/fp32/pad_fp32_test.cc | 2 + .../kernel/arm/fp32/reduce_fp32_tests.cc | 2 + .../arm/fp32/resize_bilinear_fp32_tests.cc | 2 + .../resize_nearest_neighbor_fp32_tests.cc | 2 + .../arm/fp32/reverse_sequence_fp32_tests.cc | 12 +- .../kernel/arm/fp32/scale_fp32_tests.cc | 2 + .../runtime/kernel/arm/fp32/softmax_tests.cc | 4 +- .../arm/fp32/space_to_depth_fp32_tests.cc | 6 +- .../arm/fp32/sparse_to_dense_fp32_tests.cc | 25 +++- .../arm/fp32/strided_slice_fp32_tests.cc | 35 ++++-- .../kernel/arm/fp32/tile_fp32_tests.cc | 12 +- .../kernel/arm/fp32/topk_fp32_tests.cc | 4 +- .../kernel/arm/fp32/transpose_fp32_tests.cc | 17 ++- .../kernel/arm/fp32/uniform_real_fp32_test.cc | 4 +- .../kernel/arm/fp32/unique_fp32_tests.cc | 4 +- .../kernel/arm/fp32/unstack_fp32_tests.cc | 8 +- .../fp32_grad/arithmetic_grad_fp32_tests.cc | 68 +++++++++-- .../arm/fp32_grad/bias_grad_fp32_tests.cc | 10 +- .../kernel/arm/fp32_grad/bn_grad_fp32_test.cc | 8 +- .../fp32_grad/convolution_grad_fp32_tests.cc | 17 +++ .../deconvolution_grad_fp32_tests.cc | 13 +- .../arm/fp32_grad/pooling_grad_fp32_tests.cc | 44 ++++--- .../softmax_crossentropy_fp32_tests.cc | 5 +- .../runtime/kernel/arm/int8/add_int8_tests.cc | 4 +- .../arm/int8/arithmetic_self_int8_tests.cc | 80 +++++++++--- .../kernel/arm/int8/batchnorm_int8_test.cc | 10 +- .../kernel/arm/int8/concat_int8_tests.cc | 15 ++- .../kernel/arm/int8/crop_int8_tests.cc | 50 ++++++-- .../kernel/arm/int8/gatherNd_int8_test.cc | 5 +- .../kernel/arm/int8/gather_int8_test.cc | 5 +- .../kernel/arm/int8/hswish_int8_tests.cc | 4 +- .../kernel/arm/int8/l2_norm_int8_tests.cc | 4 +- .../runtime/kernel/arm/int8/mul_int8_tests.cc | 25 +++- .../kernel/arm/int8/power_int8_tests.cc | 10 +- .../kernel/arm/int8/prelu_int8_tests.cc | 5 +- .../kernel/arm/int8/quant_dtype_cast_tests.cc | 10 +- .../kernel/arm/int8/reduce_int8_tests.cc | 2 + .../kernel/arm/int8/relux_int8_tests.cc | 8 +- .../kernel/arm/int8/reshape_int8_tests.cc | 10 +- .../arm/int8/resize_bilinear_int8_tests.cc | 2 + .../resize_nearest_neighbor_int8_tests.cc | 2 + .../src/runtime/kernel/arm/int8/scale_int8.cc | 2 + .../kernel/arm/int8/sigmoid_int8_tests.cc | 4 +- .../kernel/arm/int8/slice_int8_tests.cc | 32 +++-- .../kernel/arm/int8/softmax_int8_tests.cc | 5 +- .../arm/int8/space_to_batch_int8_tests.cc | 4 +- .../kernel/arm/int8/split_int8_tests.cc | 5 +- .../kernel/arm/int8/squeeze_int8_tests.cc | 5 +- .../runtime/kernel/arm/int8/sub_int_tests.cc | 8 +- .../kernel/arm/int8/topk_int8_tests.cc | 4 +- .../kernel/arm/int8/unsqueeze_int8_tests.cc | 5 +- .../ut/src/runtime/kernel/opencl/common.cc | 12 ++ .../fusion/constant_folding_fusion.cc | 6 + 125 files changed, 1055 insertions(+), 511 deletions(-) create mode 100644 mindspore/lite/include/delegate.h create mode 100644 mindspore/lite/src/delegate/delegate.cc diff --git a/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/pad_fp32.c b/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/pad_fp32.c index 7552d3ed7d7..ee8cb6677d3 100644 --- a/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/pad_fp32.c +++ b/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/pad_fp32.c @@ -38,7 +38,8 @@ int TransOut2InputDimIndex(int out_dim_index, int left_pad, int in_dim, int offs if (out_dim_index < left_pad) { // left pad const int index_sum = left_pad + offset - 1; - return MSMAX(index_sum - out_dim_index, offset); + int in_index = MSMAX(index_sum - out_dim_index, offset); + return MSMIN(in_index, in_dim - 1); } out_dim_index -= left_pad; if (out_dim_index < in_dim) { diff --git a/mindspore/lite/include/context.h b/mindspore/lite/include/context.h index 0d736e951c5..35d74d92243 100644 --- a/mindspore/lite/include/context.h +++ b/mindspore/lite/include/context.h @@ -1,5 +1,5 @@ /** - * Copyright 2020 Huawei Technologies Co., Ltd + * Copyright 2020-2021 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. @@ -66,6 +66,7 @@ struct Context { #else DeviceContextVector device_list_; #endif // NOT_USE_STL + DelegatePtr delegate = nullptr; }; } // namespace mindspore::lite #endif // MINDSPORE_LITE_INCLUDE_CONTEXT_H_ diff --git a/mindspore/lite/include/delegate.h b/mindspore/lite/include/delegate.h new file mode 100644 index 00000000000..c477cf81382 --- /dev/null +++ b/mindspore/lite/include/delegate.h @@ -0,0 +1,60 @@ +/** + * Copyright 2021 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 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_DELEGATE_DELEGATE_H_ +#define MINDSPORE_LITE_DELEGATE_DELEGATE_H_ + +#include +#include +#include "include/ms_tensor.h" +#include "include/context.h" +#include "include/kernel.h" + +namespace mindspore { +using KernelIter = std::vector::iterator; +class DelegateModel { + public: + DelegateModel(std::vector *kernels, + std::map primitives) + : kernels_(kernels), primitives_(primitives) {} + + ~DelegateModel() = default; + + const schema::Primitive *GetPrimitive(kernel::Kernel *kernel); + + KernelIter BeginKernelIterator(); + + KernelIter EndKernelIterator(); + + KernelIter Replace(KernelIter from, KernelIter end, kernel::Kernel *graph_kernel); + + protected: + std::vector *kernels_; + std::map primitives_; +}; + +class Delegate { + public: + Delegate() = default; + + virtual ~Delegate() = default; + + virtual int Init() = 0; + + virtual int Build(DelegateModel *model) = 0; +}; +} // namespace mindspore +#endif // MINDSPORE_LITE_DELEGATE_DELEGATE_H_ diff --git a/mindspore/lite/include/kernel.h b/mindspore/lite/include/kernel.h index 5fa4b70dbb7..a684ec09c4d 100644 --- a/mindspore/lite/include/kernel.h +++ b/mindspore/lite/include/kernel.h @@ -19,8 +19,10 @@ #include #include #include +#include "schema/model_generated.h" #include "include/lite_utils.h" #include "src/common/log_adapter.h" +#include "include/context.h" namespace mindspore::kernel { class Kernel { @@ -43,7 +45,7 @@ class Kernel { virtual int ReSize() = 0; - virtual schema::PrimitiveType type() { return type_; } + virtual schema::PrimitiveType type() const { return type_; } virtual void set_inputs(const std::vector &in_tensors) { this->inputs_ = in_tensors; } virtual void set_input(mindspore::tensor::MSTensor *in_tensor, int index) { diff --git a/mindspore/lite/include/lite_utils.h b/mindspore/lite/include/lite_utils.h index 38a74b229fc..b7efb54b1f5 100644 --- a/mindspore/lite/include/lite_utils.h +++ b/mindspore/lite/include/lite_utils.h @@ -604,6 +604,8 @@ using TensorPtrVector = Vector; using Uint32Vector = Vector; class Allocator; using AllocatorPtr = void *; +class Delegate; +using DelegatePtr = void *; using DeviceContextVector = Vector; using KernelCallBack = void (*)(void *, void *); #else @@ -613,6 +615,9 @@ using KernelCallBack = void (*)(void *, void *); class Allocator; using AllocatorPtr = std::shared_ptr; +class Delegate; +using DelegatePtr = std::shared_ptr; + using TensorPtrVector = std::vector; using Uint32Vector = std::vector; template diff --git a/mindspore/lite/src/CMakeLists.txt b/mindspore/lite/src/CMakeLists.txt index f842afc9d83..6db52ab4452 100644 --- a/mindspore/lite/src/CMakeLists.txt +++ b/mindspore/lite/src/CMakeLists.txt @@ -52,6 +52,7 @@ set(LITE_SRC ${CMAKE_CURRENT_SOURCE_DIR}/common/prim_util.cc ${CMAKE_CURRENT_SOURCE_DIR}/common/tensor_util.cc ${CMAKE_CURRENT_SOURCE_DIR}/common/dynamic_library_loader.cc + ${CMAKE_CURRENT_SOURCE_DIR}/delegate/delegate.cc ${CMAKE_CURRENT_SOURCE_DIR}/common/quant_utils.cc ${CMAKE_CURRENT_SOURCE_DIR}/runtime/inner_allocator.cc ${CMAKE_CURRENT_SOURCE_DIR}/runtime/infer_manager.cc diff --git a/mindspore/lite/src/delegate/delegate.cc b/mindspore/lite/src/delegate/delegate.cc new file mode 100644 index 00000000000..70f54a34e57 --- /dev/null +++ b/mindspore/lite/src/delegate/delegate.cc @@ -0,0 +1,37 @@ +/** + * Copyright 2021 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "include/delegate.h" +namespace mindspore { +const schema::Primitive *DelegateModel::GetPrimitive(kernel::Kernel *kernel) { + if (primitives_.find(kernel) != primitives_.end()) { + return primitives_[kernel]; + } else { + return nullptr; + } +} + +KernelIter DelegateModel::BeginKernelIterator() { return kernels_->begin(); } + +KernelIter DelegateModel::EndKernelIterator() { return kernels_->end(); } + +KernelIter DelegateModel::Replace(KernelIter from, KernelIter end, kernel::Kernel *graph_kernel) { + int insert_index = from - BeginKernelIterator(); + kernels_->erase(from, end); + kernels_->insert(BeginKernelIterator() + insert_index, graph_kernel); + return BeginKernelIterator() + insert_index + 1; +} +} // namespace mindspore diff --git a/mindspore/lite/src/executor.h b/mindspore/lite/src/executor.h index 804051519d6..6f2a1a92f87 100644 --- a/mindspore/lite/src/executor.h +++ b/mindspore/lite/src/executor.h @@ -29,8 +29,8 @@ class Executor { virtual ~Executor() = default; virtual int Prepare(const std::vector &kernels, const std::vector &inputs, - const std::vector &outputs) { - ctx_ = static_cast(kernels[0]->Context()); + const std::vector &outputs, const lite::InnerContext *ctx) { + ctx_ = ctx; return RET_OK; } diff --git a/mindspore/lite/src/inner_kernel.h b/mindspore/lite/src/inner_kernel.h index f494934f0fd..d91218f584b 100644 --- a/mindspore/lite/src/inner_kernel.h +++ b/mindspore/lite/src/inner_kernel.h @@ -130,7 +130,7 @@ class InnerKernel : public Kernel { return true; } - schema::PrimitiveType type() override { + schema::PrimitiveType type() const override { return (this->op_parameter_ != nullptr) ? schema::PrimitiveType(this->op_parameter_->type_) : schema::PrimitiveType_NONE; } diff --git a/mindspore/lite/src/lite_kernel.h b/mindspore/lite/src/lite_kernel.h index 5c7d92df78c..cb6cc54cb8d 100644 --- a/mindspore/lite/src/lite_kernel.h +++ b/mindspore/lite/src/lite_kernel.h @@ -34,9 +34,10 @@ #include "include/context.h" #include "include/kernel.h" #include "src/inner_kernel.h" +#include "include/delegate.h" namespace mindspore::kernel { -enum KERNEL_ARCH { kCPU, kGPU, kAPU, kNPU, kCustom, kKernelArch_MIN = kCPU, kKernelArch_MAX = kNPU }; +enum KERNEL_ARCH { kCPU, kGPU, kAPU, kNPU, kCustom, kDelegate, kKernelArch_MIN = kCPU, kKernelArch_MAX = kDelegate }; static const char *const kBuiltin = "Builtin"; struct KernelKey { @@ -45,6 +46,7 @@ struct KernelKey { int type; std::string kernel_arch; std::string provider{kBuiltin}; + std::shared_ptr delegate = nullptr; bool operator<(const KernelKey &dst) const { if (provider != dst.provider) { @@ -125,7 +127,13 @@ class LiteKernel { return kernel_->Prepare(); } - virtual int Init() { return mindspore::lite::RET_OK; } + virtual int Init() { + MS_ASSERT(kernel_ != nullptr); + if (desc_.provider == kBuiltin) { + return std::static_pointer_cast(kernel_)->Init(); + } + return mindspore::lite::RET_OK; + } virtual int ReSize() { MS_ASSERT(kernel_ != nullptr); @@ -136,7 +144,10 @@ class LiteKernel { OpParameter *op_parameter() const { MS_ASSERT(kernel_ != nullptr); - return std::static_pointer_cast(kernel_)->op_parameter(); + if (desc_.provider == kBuiltin) { + return std::static_pointer_cast(kernel_)->op_parameter(); + } + return nullptr; } std::string name() const { @@ -151,32 +162,49 @@ class LiteKernel { virtual int Train() { MS_ASSERT(kernel_ != nullptr); - return std::static_pointer_cast(kernel_)->Train(); + if (desc_.provider == kBuiltin) { + return std::static_pointer_cast(kernel_)->Train(); + } + return mindspore::lite::RET_OK; } virtual bool IsTrain() const { MS_ASSERT(kernel_ != nullptr); - return std::static_pointer_cast(kernel_)->IsTrain(); + if (desc_.provider == kBuiltin) { + return std::static_pointer_cast(kernel_)->IsTrain(); + } + return false; } virtual int Eval() { MS_ASSERT(kernel_ != nullptr); - return std::static_pointer_cast(kernel_)->Eval(); + if (desc_.provider == kBuiltin) { + return std::static_pointer_cast(kernel_)->Eval(); + } + return mindspore::lite::RET_OK; } virtual bool IsEval() const { MS_ASSERT(kernel_ != nullptr); - return std::static_pointer_cast(kernel_)->IsEval(); + if (desc_.provider == kBuiltin) { + return std::static_pointer_cast(kernel_)->IsEval(); + } + return false; } virtual void set_trainable(bool trainable = true) { MS_ASSERT(kernel_ != nullptr); - std::static_pointer_cast(kernel_)->set_trainable(trainable); + if (desc_.provider == kBuiltin) { + std::static_pointer_cast(kernel_)->set_trainable(trainable); + } } virtual bool is_trainable() const { MS_ASSERT(kernel_ != nullptr); - return std::static_pointer_cast(kernel_)->is_trainable(); + if (desc_.provider == kBuiltin) { + return std::static_pointer_cast(kernel_)->is_trainable(); + } + return false; } void set_is_model_output(bool is_model_output) { this->is_model_output_ = is_model_output; } @@ -330,13 +358,6 @@ kernel::InnerKernel *LiteKernelCreator(const std::vector &inputs free(parameter); return nullptr; } - - auto ret = kernel->Init(); - if (ret != lite::RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << parameter->name_; - delete kernel; - return nullptr; - } return kernel; } } // namespace mindspore::kernel diff --git a/mindspore/lite/src/lite_mindrt.cc b/mindspore/lite/src/lite_mindrt.cc index f3aec1ce625..05db2fbc29d 100644 --- a/mindspore/lite/src/lite_mindrt.cc +++ b/mindspore/lite/src/lite_mindrt.cc @@ -91,11 +91,15 @@ void LiteOpActor::IsolateInputData(std::vector> *ac int ref_count = 0; /* set op input for calculate */ - for (auto in_node : reinterpret_cast(kernel_)->in_nodes()) { - for (size_t node_in_index = 0; node_in_index < in_node->in_tensors().size(); node_in_index++) { - if (old_tensor == in_node->in_tensors()[node_in_index]) { - in_node->set_in_tensor(new_tensor, node_in_index); - ref_count++; + if (kernel_->desc().delegate != nullptr) { + ref_count++; + } else { + for (auto in_node : reinterpret_cast(kernel_)->in_nodes()) { + for (size_t node_in_index = 0; node_in_index < in_node->in_tensors().size(); node_in_index++) { + if (old_tensor == in_node->in_tensors()[node_in_index]) { + in_node->set_in_tensor(new_tensor, node_in_index); + ref_count++; + } } } } @@ -162,6 +166,10 @@ int LiteOpActor::CompileArrowThroughOutputKernels() { } int LiteOpActor::CompileArrowThroughPartialCall() { + if (kernel_->desc().delegate != nullptr) { + MS_LOG(INFO) << "kernel is delegate subgraph kernel."; + return RET_OK; + } auto *subgraph_kernel = reinterpret_cast(kernel_); if (subgraph_kernel == nullptr) { MS_LOG(INFO) << "kernel is not subgraph kernel, no partial call."; @@ -330,10 +338,11 @@ int LiteOpActor::PrepareOutputData() { return RET_OK; } -std::vector> CreateOpActor(const std::vector &kernels) { +std::vector> CreateOpActor(const std::vector &kernels, + const lite::InnerContext *ctx) { std::vector> actors; std::unordered_map partial_map{}; - auto thread_pool = kernels[0]->Context()->thread_pool_; + auto thread_pool = ctx->thread_pool_; if (thread_pool == nullptr) { MS_LOG(ERROR) << "thread pool is nullptr"; return actors; diff --git a/mindspore/lite/src/lite_mindrt.h b/mindspore/lite/src/lite_mindrt.h index 697679cd9cc..9de49171450 100644 --- a/mindspore/lite/src/lite_mindrt.h +++ b/mindspore/lite/src/lite_mindrt.h @@ -185,6 +185,7 @@ class LiteSwitchOpActor : public LiteOpActor { int MindrtInit(bool subgraph_split = false); void MindrtTerminate(const std::vector> &); -std::vector> CreateOpActor(const std::vector &kernels); +std::vector> CreateOpActor(const std::vector &kernels, + const lite::InnerContext *ctx); } // namespace mindspore::lite #endif // MINDSPORE_LITE_SRC_LITE_MINDRT_H_ diff --git a/mindspore/lite/src/lite_session.cc b/mindspore/lite/src/lite_session.cc index 3ffd9ce34e6..d60a1b6420a 100644 --- a/mindspore/lite/src/lite_session.cc +++ b/mindspore/lite/src/lite_session.cc @@ -383,6 +383,21 @@ void LiteSession::IsolateOutputTensor() { /* set new tensor for calculate */ for (auto subgraph : kernels_) { + /* subgraph input and output */ + for (size_t i = 0; i < subgraph->in_tensors().size(); i++) { + if (subgraph->in_tensors()[i] == src_tensor) { + subgraph->set_in_tensor(new_tensor, i); + } + } + for (size_t i = 0; i < subgraph->out_tensors().size(); i++) { + if (subgraph->out_tensors()[i] == src_tensor) { + subgraph->set_out_tensor(new_tensor, i); + } + } + + if (subgraph->desc().delegate != nullptr) { + continue; + } /* node input and output */ auto nodes = reinterpret_cast(subgraph)->nodes(); for (size_t i = 0; i < nodes.size(); i++) { @@ -398,18 +413,6 @@ void LiteSession::IsolateOutputTensor() { } } } - - /* subgraph input and output */ - for (size_t i = 0; i < subgraph->in_tensors().size(); i++) { - if (subgraph->in_tensors()[i] == src_tensor) { - subgraph->set_in_tensor(new_tensor, i); - } - } - for (size_t i = 0; i < subgraph->out_tensors().size(); i++) { - if (subgraph->out_tensors()[i] == src_tensor) { - subgraph->set_out_tensor(new_tensor, i); - } - } } } return; @@ -450,6 +453,9 @@ bool LiteSession::IfUseMindrtExecutor() { #endif for (auto kernel : kernels_) { + if (kernel->desc().delegate != nullptr) { + continue; + } auto sub_graph = reinterpret_cast(kernel); if (sub_graph->nodes()[0]->type() == schema::PrimitiveType_Merge) { use_mindrt_run = false; /* control-flow model */ @@ -489,9 +495,9 @@ int LiteSession::CompileGraph(Model *model) { } // scheduler kernels #if SUPPORT_NPU - Scheduler scheduler(context_, model, &tensors_, is_train_session_, npu_manager_, npu_pass_manager_); + Scheduler scheduler(context_, model, &tensors_, is_train_session_, npu_manager_, npu_pass_manager_, delegate_); #else - Scheduler scheduler(context_, model, &tensors_, is_train_session_); + Scheduler scheduler(context_, model, &tensors_, is_train_session_, delegate_); #endif ret = scheduler.Schedule(&kernels_); if (ret != RET_OK) { @@ -529,14 +535,13 @@ int LiteSession::CompileGraph(Model *model) { #ifdef ENABLE_MINDRT } #endif - - if (nullptr == executor_) { + if (executor_ == nullptr) { MS_LOG(ERROR) << "New Executor failed"; is_running_.store(false); return RET_ERROR; } - ret = executor_->Prepare(this->kernels_, this->inputs_, this->outputs_); + ret = executor_->Prepare(this->kernels_, this->inputs_, this->outputs_, context_); if (ret != RET_OK) { MS_LOG(ERROR) << "Prepare executor failed: " << ret; is_running_.store(false); @@ -555,10 +560,14 @@ int LiteSession::PrepareKernels(Model *model, bool use_mindrt_run) { // find in_kernels and out_kernels for subgraphs for (auto kernel : this->kernels_) { kernel->FindInoutKernels(this->kernels_); - auto sub_graph = reinterpret_cast(kernel); - MS_ASSERT(sub_graph != nullptr); - auto kernel_in_subgraph = sub_graph->nodes(); - all_kernels.insert(all_kernels.end(), kernel_in_subgraph.begin(), kernel_in_subgraph.end()); + if (kernel->desc().delegate != nullptr) { + all_kernels.push_back(kernel); + } else { + auto sub_graph = reinterpret_cast(kernel); + MS_ASSERT(sub_graph != nullptr); + auto kernel_in_subgraph = sub_graph->nodes(); + all_kernels.insert(all_kernels.end(), kernel_in_subgraph.begin(), kernel_in_subgraph.end()); + } } if (!use_mindrt_run) { @@ -646,6 +655,16 @@ int LiteSession::Init(const Context *context) { is_running_.store(false); return ret; } + if (context->delegate != nullptr) { + delegate_ = context->delegate; + } + if (delegate_ != nullptr) { + auto delegate_ret = delegate_->Init(); + if (delegate_ret != RET_OK) { + MS_LOG(ERROR) << "Delegate init failed"; + return RET_ERROR; + } + } ret = KernelRegistry::GetInstance()->Init(); if (ret != RET_OK) { MS_LOG(ERROR) << "KernelRegistry Init Failed."; diff --git a/mindspore/lite/src/lite_session.h b/mindspore/lite/src/lite_session.h index 04adfa81e17..7ec7ebe48be 100644 --- a/mindspore/lite/src/lite_session.h +++ b/mindspore/lite/src/lite_session.h @@ -31,6 +31,7 @@ #include "src/executor.h" #include "src/tensor.h" #include "src/tensorlist.h" +#include "include/delegate.h" #if SUPPORT_NPU #include "src/runtime/agent/npu/npu_manager.h" #include "src/runtime/agent/npu/optimizer/npu_pass_manager.h" @@ -150,6 +151,7 @@ class LiteSession : public session::LiteSession { #elif GPU_VULKAN gpu::GpuRuntimeWrapper *vk_runtime_wrap_{nullptr}; #endif + std::shared_ptr delegate_ = nullptr; }; } // namespace lite } // namespace mindspore diff --git a/mindspore/lite/src/mindrt_executor.cc b/mindspore/lite/src/mindrt_executor.cc index 1caf5ba9533..22eba968941 100644 --- a/mindspore/lite/src/mindrt_executor.cc +++ b/mindspore/lite/src/mindrt_executor.cc @@ -76,15 +76,15 @@ int MindrtExecutor::Resize(const std::vector &inp } int MindrtExecutor::Prepare(const std::vector &kernels, const std::vector &inputs, - const std::vector &outputs) { + const std::vector &outputs, const lite::InnerContext *ctx) { MS_ASSERT(kernels.size() != 0); - auto ret = MindrtInit(kernels[0]->Context()->enable_parallel_); + auto ret = MindrtInit(ctx->enable_parallel_); if (ret != RET_OK) { MS_LOG(ERROR) << "MindrtInit failed"; return ret; } - op_actors_ = CreateOpActor(kernels); + op_actors_ = CreateOpActor(kernels, ctx); if (op_actors_.size() != kernels.size()) { MS_LOG(ERROR) << "CreateOpActor failed"; return RET_ERROR; diff --git a/mindspore/lite/src/mindrt_executor.h b/mindspore/lite/src/mindrt_executor.h index a721c85de07..92c141bcc32 100644 --- a/mindspore/lite/src/mindrt_executor.h +++ b/mindspore/lite/src/mindrt_executor.h @@ -32,15 +32,15 @@ class MindrtExecutor : public Executor { explicit MindrtExecutor(std::unordered_map *output_map) : output_tensor_map_(output_map) {} virtual ~MindrtExecutor() { MindrtTerminate(op_actors_); } - virtual int Prepare(const std::vector &kernels, const std::vector &inputs, - const std::vector &outputs); + int Prepare(const std::vector &kernels, const std::vector &inputs, + const std::vector &outputs, const lite::InnerContext *ctx) override; - virtual int Run(const std::vector &in_tensors, const std::vector &out_tensors, - const std::vector &kernels, mindspore::Allocator *allocator = nullptr, - const KernelCallBack &before = nullptr, const KernelCallBack &after = nullptr); + int Run(const std::vector &in_tensors, const std::vector &out_tensors, + const std::vector &kernels, mindspore::Allocator *allocator = nullptr, + const KernelCallBack &before = nullptr, const KernelCallBack &after = nullptr) override; - virtual int Resize(const std::vector &inputs, - const std::vector> &dims); + int Resize(const std::vector &inputs, + const std::vector> &dims) override; private: void TransferGraphOutput(); diff --git a/mindspore/lite/src/runtime/agent/npu/npu_executor.cc b/mindspore/lite/src/runtime/agent/npu/npu_executor.cc index e36c35e818b..7d24d80ea0e 100644 --- a/mindspore/lite/src/runtime/agent/npu/npu_executor.cc +++ b/mindspore/lite/src/runtime/agent/npu/npu_executor.cc @@ -33,7 +33,7 @@ NPUExecutor::~NPUExecutor() { } int NPUExecutor::Prepare(const std::vector &kernels, const std::vector &inputs, - const std::vector &outputs) { + const std::vector &outputs, const lite::InnerContext *ctx) { MS_ASSERT(npu_manager_ != nullptr); this->client_ = npu_manager_->GetClient(model_name_); if (this->client_ == nullptr) { diff --git a/mindspore/lite/src/runtime/agent/npu/npu_executor.h b/mindspore/lite/src/runtime/agent/npu/npu_executor.h index 46eb6c0c7b4..849fa90bffa 100644 --- a/mindspore/lite/src/runtime/agent/npu/npu_executor.h +++ b/mindspore/lite/src/runtime/agent/npu/npu_executor.h @@ -34,7 +34,7 @@ class NPUExecutor : public Executor { : model_name_(model_name), npu_manager_(npu_manager) {} ~NPUExecutor() override; int Prepare(const std::vector &kernels, const std::vector &inputs, - const std::vector &outputs) override; + const std::vector &outputs, const lite::InnerContext *ctx) override; int Run(const std::vector &in_tensors, const std::vector &out_tensors, const std::vector &in_kernels, const std::vector &kernels, diff --git a/mindspore/lite/src/runtime/agent/npu/subgraph_npu_kernel.cc b/mindspore/lite/src/runtime/agent/npu/subgraph_npu_kernel.cc index 991057dccb1..15a26e549c4 100644 --- a/mindspore/lite/src/runtime/agent/npu/subgraph_npu_kernel.cc +++ b/mindspore/lite/src/runtime/agent/npu/subgraph_npu_kernel.cc @@ -219,7 +219,7 @@ int SubGraphNpuKernel::Init() { } int SubGraphNpuKernel::Prepare() { - if (executor_->Prepare(nodes_, in_tensors(), out_tensors()) != RET_OK) { + if (executor_->Prepare(nodes_, in_tensors(), out_tensors(), nullptr) != RET_OK) { MS_LOG(ERROR) << "NPU executor prepare failed."; return RET_ERROR; } diff --git a/mindspore/lite/src/runtime/gpu/opencl/opencl_executor.h b/mindspore/lite/src/runtime/gpu/opencl/opencl_executor.h index 1eda4207747..6120c603b9a 100644 --- a/mindspore/lite/src/runtime/gpu/opencl/opencl_executor.h +++ b/mindspore/lite/src/runtime/gpu/opencl/opencl_executor.h @@ -32,7 +32,7 @@ class OpenCLExecutor : public Executor { ~OpenCLExecutor() override = default; int Prepare(const std::vector &kernels, const std::vector &inputs, - const std::vector &outputs) override { + const std::vector &outputs, const lite::InnerContext *ctx) override { return RET_OK; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/activation_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/activation_fp16.cc index ba9dc431797..8bff3a5d232 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/activation_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/activation_fp16.cc @@ -109,5 +109,34 @@ int ActivationFp16CPUKernel::Run() { return RET_OK; } -REG_KERNEL(kCPU, kNumberTypeFloat16, PrimitiveType_Activation, LiteKernelCreator) +/* creator func */ +kernel::InnerKernel *CpuActivationFp16KernelCreator(const std::vector &inputs, + const std::vector &outputs, + OpParameter *opParameter, const lite::Context *ctx, + const kernel::KernelKey &desc) { + MS_ASSERT(opParameter != nullptr); + MS_ASSERT(desc.type == schema::PrimitiveType_Activation); + + auto act_param = reinterpret_cast(opParameter); + auto type = act_param->type_; + if (type != schema::ActivationType_RELU && type != schema::ActivationType_RELU6 && + type != schema::ActivationType_LEAKY_RELU && type != schema::ActivationType_SIGMOID && + type != schema::ActivationType_TANH && type != schema::ActivationType_HSWISH && + type != schema::ActivationType_SWISH && type != schema::ActivationType_HARD_TANH) { + MS_LOG(ERROR) << "Activation fp16 not support type: " << type; + return nullptr; + } + + kernel::InnerKernel *kernel = nullptr; + kernel = new (std::nothrow) + kernel::ActivationFp16CPUKernel(opParameter, inputs, outputs, static_cast(ctx)); + if (kernel == nullptr) { + MS_LOG(DEBUG) << "Create activation fp16 kernel failed."; + free(opParameter); + return nullptr; + } + return kernel; +} + +REG_KERNEL(kCPU, kNumberTypeFloat16, PrimitiveType_Activation, CpuActivationFp16KernelCreator) } // namespace mindspore::kernel diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_delegate_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_delegate_fp16.cc index 684790b916a..1172782bc5b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_delegate_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_delegate_fp16.cc @@ -213,14 +213,6 @@ kernel::InnerKernel *CpuConvFp16KernelCreator(const std::vector free(opParameter); return nullptr; } - - auto ret = kernel->Init(); - if (ret != RET_OK) { - MS_LOG(INFO) << "Init fp16 kernel failed, name: " << opParameter->name_ - << ", type: " << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc index a05eee862b1..e348fedf87a 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc @@ -255,13 +255,6 @@ kernel::InnerKernel *CpuDeConvFp16KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << op_parameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(op_parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/quant_dtype_cast_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/quant_dtype_cast_fp16.cc index 832aa6bcfff..c2dc7adbc7f 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/quant_dtype_cast_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/quant_dtype_cast_fp16.cc @@ -175,26 +175,54 @@ int QuantDTypeCastFp16CPUKernel::Run() { kernel::InnerKernel *CpuQuantDTypeCastFp16KernelCreator(const std::vector &inputs, const std::vector &outputs, - OpParameter *opParameter, const lite::InnerContext *ctx, + OpParameter *opParameter, const lite::Context *ctx, const kernel::KernelKey &desc) { + MS_ASSERT(opParameter != nullptr); + MS_ASSERT(desc.type == schema::PrimitiveType_Conv2DFusion); + if (opParameter == nullptr) { - MS_LOG(ERROR) << "Input opParameter is nullptr!"; + MS_LOG(ERROR) << "opParameter is nullptr!"; return nullptr; } - auto *kernel = new (std::nothrow) QuantDTypeCastFp16CPUKernel(opParameter, inputs, outputs, ctx); + auto in_tensor = inputs.front(); + auto out_tensor = outputs.front(); + auto param = reinterpret_cast(opParameter); + if (param->dstT == kNumberTypeInt8) { + if (in_tensor->data_type() != kNumberTypeFloat16 || out_tensor->data_type() != kNumberTypeInt8) { + MS_LOG(ERROR) << "param data type and tensor data type do not match."; + return nullptr; + } + } else if (param->srcT == kNumberTypeInt8) { + if (in_tensor->data_type() != kNumberTypeInt8 || out_tensor->data_type() != kNumberTypeFloat16) { + MS_LOG(ERROR) << "param data type and tensor data type do not match."; + return nullptr; + } + } else if (param->dstT == kNumberTypeUInt8) { + if (in_tensor->data_type() != kNumberTypeFloat16 || out_tensor->data_type() != kNumberTypeUInt8) { + MS_LOG(ERROR) << "param data type and tensor data type do not match."; + return nullptr; + } + } else if (param->srcT == kNumberTypeUInt8) { + if (in_tensor->data_type() != kNumberTypeUInt8 || out_tensor->data_type() != kNumberTypeFloat16) { + MS_LOG(ERROR) << "param data type and tensor data type do not match."; + return nullptr; + } + } else { + MS_LOG(ERROR) << "param data type not supported:" + << " src: " << param->srcT << " dst: " << param->dstT; + return nullptr; + } + + kernel::InnerKernel *kernel = nullptr; + kernel = new (std::nothrow) + QuantDTypeCastFp16CPUKernel(opParameter, inputs, outputs, static_cast(ctx)); if (kernel == nullptr) { MS_LOG(ERROR) << "new QuantDTypeCastFp16CPUKernel fail!"; free(opParameter); return nullptr; } - auto ret = kernel->Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed! name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } -REG_KERNEL(kCPU, kNumberTypeFloat16, PrimitiveType_QuantDTypeCast, LiteKernelCreator) + +REG_KERNEL(kCPU, kNumberTypeFloat16, PrimitiveType_QuantDTypeCast, CpuQuantDTypeCastFp16KernelCreator) } // namespace mindspore::kernel diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/reduce_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/reduce_fp16.cc index f827e435efe..89c11ae4df1 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/reduce_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/reduce_fp16.cc @@ -142,5 +142,29 @@ int ReduceFp16CPUKernel::MallocTmpBuffer() { return RET_OK; } -REG_KERNEL(kCPU, kNumberTypeFloat16, PrimitiveType_ReduceFusion, LiteKernelCreator) +/* creator func */ +kernel::InnerKernel *CpuReduceFp16KernelCreator(const std::vector &inputs, + const std::vector &outputs, OpParameter *opParameter, + const lite::Context *ctx, const kernel::KernelKey &desc) { + MS_ASSERT(opParameter != nullptr); + MS_ASSERT(desc.type == schema::PrimitiveType_ReduceFusion); + + auto reduce_param = reinterpret_cast(opParameter); + if (reduce_param->mode_ != ReduceMode_ReduceMean && reduce_param->mode_ != ReduceMode_ReduceMax) { + MS_LOG(ERROR) << "Reduce unsupported reduce mode: " << reduce_param->mode_; + return nullptr; + } + + kernel::InnerKernel *kernel = nullptr; + kernel = new (std::nothrow) + kernel::ReduceFp16CPUKernel(opParameter, inputs, outputs, static_cast(ctx)); + if (kernel == nullptr) { + MS_LOG(DEBUG) << "Create reduce fp16 kernel failed."; + free(opParameter); + return nullptr; + } + return kernel; +} + +REG_KERNEL(kCPU, kNumberTypeFloat16, PrimitiveType_ReduceFusion, CpuReduceFp16KernelCreator) } // namespace mindspore::kernel diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_delegate_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_delegate_fp32.cc index e7173aeba62..caf7fc13b54 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_delegate_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_delegate_fp32.cc @@ -282,14 +282,6 @@ kernel::InnerKernel *CpuConvFp32KernelCreator(const std::vector free(op_parameter); return nullptr; } - - auto ret = kernel->Init(); - if (ret != RET_OK && ret != RET_INFER_INVALID) { - MS_LOG(ERROR) << "Init kernel failed, name: " << op_parameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(op_parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc index f0e41b0ce87..afece07417b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc @@ -269,13 +269,6 @@ kernel::InnerKernel *CpuDeConvFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << op_parameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(op_parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/adam.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/adam.cc index 13aa9acf3cf..f6a9cddacd7 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/adam.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/adam.cc @@ -153,14 +153,6 @@ kernel::InnerKernel *CpuAdamFp32KernelCreator(const std::vector free(opParameter); return nullptr; } - - auto ret = kernel->Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/apply_momentum.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/apply_momentum.cc index cdbfc46c11d..7ce8099cf19 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/apply_momentum.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/apply_momentum.cc @@ -129,14 +129,6 @@ kernel::InnerKernel *CpuApplyMomentumFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/arithmetic_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/arithmetic_grad.cc index d2d1dd7ea8e..c27c5672c75 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/arithmetic_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/arithmetic_grad.cc @@ -249,14 +249,6 @@ kernel::InnerKernel *CpuArithmeticGradFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/arithmetic_self_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/arithmetic_self_grad.cc index 03935a935d1..95a231f84d1 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/arithmetic_self_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/arithmetic_self_grad.cc @@ -105,14 +105,6 @@ kernel::InnerKernel *CpuArithmeticSelfGradFp32KernelCreator(const std::vector
  • Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << param->name_ - << ", type: " << schema::EnumNamePrimitiveType(static_cast(param->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/assign.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/assign.cc index b578b9feb3f..d6d05741940 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/assign.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/assign.cc @@ -79,14 +79,6 @@ kernel::InnerKernel *CpuAssignFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bias_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bias_grad.cc index e0a3700d2bc..f20f443d767 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bias_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bias_grad.cc @@ -102,14 +102,6 @@ kernel::InnerKernel *CpuBiasGradFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bn_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bn_grad.cc index 5393de4d13f..b9a51815727 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bn_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bn_grad.cc @@ -173,13 +173,6 @@ kernel::InnerKernel *CpuBNGradFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution.cc index 6fd968de535..c011bf62231 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution.cc @@ -189,14 +189,6 @@ kernel::InnerKernel *CpuConvTrainFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } } // namespace mindspore::kernel diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_filter.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_filter.cc index 9ed8154f12a..7ab83bd52a9 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_filter.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_filter.cc @@ -218,14 +218,6 @@ kernel::InnerKernel *CpuConvGradFilterFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_filter.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_filter.cc index 64a6d0dca05..0922916a5ef 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_filter.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_filter.cc @@ -144,14 +144,6 @@ kernel::InnerKernel *CpuDeConvGradFilterFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/dropout.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/dropout.cc index e372a2dc2dd..630b7d98e35 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/dropout.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/dropout.cc @@ -125,13 +125,6 @@ kernel::InnerKernel *CpuDropoutFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - delete kernel; - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/dropout_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/dropout_grad.cc index bacd7951573..c1a721139c9 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/dropout_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/dropout_grad.cc @@ -107,13 +107,6 @@ kernel::InnerKernel *CpuDropoutGradFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - delete kernel; - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/neg_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/neg_grad.cc index 7d3cafde2e6..104591c206b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/neg_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/neg_grad.cc @@ -79,14 +79,6 @@ kernel::InnerKernel *CpuNegGradFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << param->name_ - << ", type: " << schema::EnumNamePrimitiveType(static_cast(param->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/pooling_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/pooling_grad.cc index 12edef4de2c..bba43f91b10 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/pooling_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/pooling_grad.cc @@ -120,14 +120,6 @@ kernel::InnerKernel *CpuPoolingGradFp32KernelCreator(const std::vectorInit(); - if (RET_OK != ret) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/power_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/power_grad.cc index c6d2f3ae6a8..d69dfacdaaf 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/power_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/power_grad.cc @@ -96,14 +96,6 @@ kernel::InnerKernel *CpuPowerGradFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sgd.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sgd.cc index fa32e1f8378..1192bd15f3a 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sgd.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sgd.cc @@ -209,15 +209,6 @@ kernel::InnerKernel *CpuSgdFp32KernelCreator(const std::vector & free(opParameter); return nullptr; } - - auto ret = kernel->Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } - return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sigmoid_cross_entropy_with_logits.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sigmoid_cross_entropy_with_logits.cc index 62b84554e2e..297d7096c0b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sigmoid_cross_entropy_with_logits.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sigmoid_cross_entropy_with_logits.cc @@ -83,13 +83,6 @@ kernel::InnerKernel *CpuSigmoidCrossEntropyWithLogitsFp32KernelCreator(const std MS_LOG(ERROR) << "new SigmoidCrossEntropyWithLogits failed"; return nullptr; } - auto ret = kernel->Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sigmoid_cross_entropy_with_logits_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sigmoid_cross_entropy_with_logits_grad.cc index 5b926f7dbbd..97510a57c19 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sigmoid_cross_entropy_with_logits_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sigmoid_cross_entropy_with_logits_grad.cc @@ -83,13 +83,6 @@ kernel::InnerKernel *CpuSigmoidCrossEntropyWithLogitsGradFp32KernelCreator(const MS_LOG(ERROR) << "new SigmoidCrossEntropyWithLogitsGradWithLogitsCPUKernel failed"; return nullptr; } - auto ret = kernel->Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/smooth_l1_loss.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/smooth_l1_loss.cc index e61caccb7df..9d2e6f25472 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/smooth_l1_loss.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/smooth_l1_loss.cc @@ -94,13 +94,6 @@ kernel::InnerKernel *CpuSmoothL1LossFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/smooth_l1_loss_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/smooth_l1_loss_grad.cc index 4017f6b8b06..f031f752acb 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/smooth_l1_loss_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/smooth_l1_loss_grad.cc @@ -91,13 +91,6 @@ kernel::InnerKernel *CpuSmoothL1LossGradFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_cross_entropy_with_logits.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_cross_entropy_with_logits.cc index 8b8dbd4aa45..dac58f8d855 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_cross_entropy_with_logits.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_cross_entropy_with_logits.cc @@ -138,13 +138,6 @@ kernel::InnerKernel *CpuSoftmaxCrossEntropyFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_grad.cc index fd8a2e66904..3e0e7bfc60d 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_grad.cc @@ -100,13 +100,6 @@ kernel::InnerKernel *CpuSoftmaxGradFp32KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(opParameter->type_)); - delete kernel; - return nullptr; - } return kernel; } } // namespace mindspore::kernel diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/activation_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/activation_int8.cc index f13cb51c029..2600bb11b67 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/activation_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/activation_int8.cc @@ -73,13 +73,6 @@ kernel::InnerKernel *CpuActivationInt8KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << parameter->name_ - << ", type: " << schema::EnumNamePrimitiveType(static_cast(parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc index e2f990fec92..33f3a4e5400 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc @@ -181,13 +181,6 @@ kernel::InnerKernel *CpuArithmeticInt8KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << parameter->name_ - << ", type: " << schema::EnumNamePrimitiveType(static_cast(parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/convolution_int8_creator.cc b/mindspore/lite/src/runtime/kernel/arm/int8/convolution_int8_creator.cc index ac893bec588..8c85311d17e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/convolution_int8_creator.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/convolution_int8_creator.cc @@ -129,13 +129,6 @@ kernel::InnerKernel *CpuConvInt8KernelCreator(const std::vector free(op_parameter); return nullptr; } - auto ret = kernel->Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << op_parameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(op_parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/deconvolution_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/deconvolution_int8.cc index 7aaeb7c8019..10c1de57cae 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/deconvolution_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/deconvolution_int8.cc @@ -303,13 +303,6 @@ kernel::InnerKernel *CpuDeConvInt8KernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << op_parameter->name_ << ", type: " - << schema::EnumNamePrimitiveType(static_cast(op_parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/string/extract_feature.cc b/mindspore/lite/src/runtime/kernel/arm/string/extract_feature.cc index 3458f5b908b..0cd95185d32 100644 --- a/mindspore/lite/src/runtime/kernel/arm/string/extract_feature.cc +++ b/mindspore/lite/src/runtime/kernel/arm/string/extract_feature.cc @@ -81,13 +81,6 @@ kernel::InnerKernel *CpuExtractFeatureKernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << parameter->name_ - << ", type: " << schema::EnumNamePrimitiveType(static_cast(parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/string/hashtable_lookup.cc b/mindspore/lite/src/runtime/kernel/arm/string/hashtable_lookup.cc index 290f9ffc032..13a9a32a1c1 100644 --- a/mindspore/lite/src/runtime/kernel/arm/string/hashtable_lookup.cc +++ b/mindspore/lite/src/runtime/kernel/arm/string/hashtable_lookup.cc @@ -80,13 +80,6 @@ kernel::InnerKernel *CpuHashtableLookupKernelCreator(const std::vectorInit(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << parameter->name_ - << ", type: " << schema::EnumNamePrimitiveType(static_cast(parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/string/normalize.cc b/mindspore/lite/src/runtime/kernel/arm/string/normalize.cc index db67fc6c55d..b370323cf6e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/string/normalize.cc +++ b/mindspore/lite/src/runtime/kernel/arm/string/normalize.cc @@ -148,13 +148,6 @@ kernel::InnerKernel *CpuNormalizeKernelCreator(const std::vector free(parameter); return nullptr; } - auto ret = kernel->Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << parameter->name_ - << ", type: " << schema::EnumNamePrimitiveType(static_cast(parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/kernel/arm/string/predict.cc b/mindspore/lite/src/runtime/kernel/arm/string/predict.cc index e4c1924947a..18928bb257f 100644 --- a/mindspore/lite/src/runtime/kernel/arm/string/predict.cc +++ b/mindspore/lite/src/runtime/kernel/arm/string/predict.cc @@ -109,13 +109,6 @@ kernel::InnerKernel *CpuPredictKernelCreator(const std::vector & free(parameter); return nullptr; } - auto ret = kernel->Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init kernel failed, name: " << parameter->name_ - << ", type: " << schema::EnumNamePrimitiveType(static_cast(parameter->type_)); - delete kernel; - return nullptr; - } return kernel; } diff --git a/mindspore/lite/src/runtime/parallel_executor.cc b/mindspore/lite/src/runtime/parallel_executor.cc index 1e75d1df42f..1214155fea2 100644 --- a/mindspore/lite/src/runtime/parallel_executor.cc +++ b/mindspore/lite/src/runtime/parallel_executor.cc @@ -21,7 +21,8 @@ namespace mindspore::lite { ParallelExecutor::~ParallelExecutor() { delete thread_pool_; } int ParallelExecutor::Prepare(const std::vector &kernels, - const std::vector &inputs, const std::vector &outputs) { + const std::vector &inputs, const std::vector &outputs, + const lite::InnerContext *ctx) { thread_pool_ = InterThreadPool::CreateThreadPool(1, max_thread_num_); if (thread_pool_ == nullptr) { MS_LOG(ERROR) << "Memory error: fail to new ThreadPool"; @@ -39,7 +40,6 @@ static int RunKernel(void *data, int index, float lhs_scale, float rhs_scale) { MS_LOG(ERROR) << "run kernel failed, name: " << kernel->name(); return 0; } - return 0; } diff --git a/mindspore/lite/src/runtime/parallel_executor.h b/mindspore/lite/src/runtime/parallel_executor.h index 7cce7511ebb..4e96262a229 100644 --- a/mindspore/lite/src/runtime/parallel_executor.h +++ b/mindspore/lite/src/runtime/parallel_executor.h @@ -33,7 +33,7 @@ class ParallelExecutor : public Executor { ~ParallelExecutor() override; int Prepare(const std::vector &kernels, const std::vector &inputs, - const std::vector &outputs) override; + const std::vector &outputs, const lite::InnerContext *ctx) override; int Run(const std::vector &in_tensors, const std::vector &out_tensors, const std::vector &kernels, mindspore::Allocator *allocator = nullptr, diff --git a/mindspore/lite/src/scheduler.cc b/mindspore/lite/src/scheduler.cc index 50bb5ddbd1d..9d9bc2ad8da 100644 --- a/mindspore/lite/src/scheduler.cc +++ b/mindspore/lite/src/scheduler.cc @@ -103,13 +103,27 @@ int Scheduler::Schedule(std::vector *dst_kernels) { MS_LOG(ERROR) << "Schedule main subgraph to kernels failed."; return ret; } + if (delegate_ != nullptr) { + ret = ReplaceDelegateKernels(dst_kernels); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Repalce delegate kernels failed."; + return ret; + } + } FindAllInoutKernels(*dst_kernels); + // origin kernel init + for (size_t i = 0; i < dst_kernels->size(); i++) { + ret = (*dst_kernels)[i]->Init(); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Kernel " << (*dst_kernels)[i]->name() << " Init failed."; + return ret; + } + } ret = RunPass(dst_kernels); if (ret != RET_OK) { MS_LOG(ERROR) << "Schedule run pass failed."; return ret; } - auto src_kernel = *dst_kernels; dst_kernels->clear(); std::map is_kernel_finish; @@ -122,6 +136,61 @@ int Scheduler::Schedule(std::vector *dst_kernels) { return RET_OK; } +int Scheduler::ReplaceDelegateKernels(std::vector *dst_kernels) { + std::vector kernels; + for (size_t i = 0; i < dst_kernels->size(); i++) { + kernels.push_back((*dst_kernels)[i]->kernel()); + } + DelegateModel *model = new (std::nothrow) DelegateModel(&kernels, primitives_); + if (model == nullptr) { + MS_LOG(ERROR) << "New delegate model failed."; + return RET_NULL_PTR; + } + auto ret = delegate_->Build(model); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Delegate prepare kernels failed."; + return ret; + } + + auto src_kernels = *dst_kernels; + dst_kernels->clear(); + std::map delegate_support; + for (auto kernel : src_kernels) { + delegate_support[kernel] = true; + } + for (auto kernel : kernels) { + size_t index = 0; + for (; index < src_kernels.size(); index++) { + if (kernel == src_kernels[index]->kernel()) { + // Kernels that the delegate does not support keep the original backend + dst_kernels->push_back(src_kernels[index]); + delegate_support[src_kernels[index]] = false; + break; + } + } + if (index == src_kernels.size()) { + // New liteKernel to save delegate subgraph + std::shared_ptr shared_kernel(kernel); + auto lite_kernel = new (std::nothrow) kernel::LiteKernel(shared_kernel); + if (lite_kernel == nullptr) { + MS_LOG(ERROR) << "New LiteKernel for delegate subgraph failed."; + return RET_NULL_PTR; + } + kernel::KernelKey delegate_desc{ + kernel::kDelegate, kernel->inputs()[0]->data_type(), schema::PrimitiveType_NONE, "", "", delegate_}; + lite_kernel->set_desc(delegate_desc); + dst_kernels->push_back(lite_kernel); + } + } + // Release the cpu kernel that has been replace by delegate subgraph + for (auto kernel : src_kernels) { + if (delegate_support[kernel] == true) { + delete kernel; + } + } + return RET_OK; +} + void Scheduler::FindNodeInoutTensors(const lite::Model::Node &node, std::vector *inputs, std::vector *outputs) { MS_ASSERT(inputs != nullptr); @@ -393,7 +462,7 @@ int Scheduler::FindCpuKernel(const std::vector &in_tensors, const std: RestoreTensorData(&restored_origin_tensors); } return ret; -} // namespace mindspore::lite +} int Scheduler::FindGpuKernel(const std::vector &in_tensors, const std::vector &out_tensors, OpParameter *op_parameter, const kernel::KernelKey &desc, kernel::LiteKernel **kernel) { @@ -610,6 +679,13 @@ kernel::LiteKernel *Scheduler::SchedulePartialToKernel(const lite::Model::Node * MS_LOG(ERROR) << "Schedule partial failed, name: " << src_node->name_; return nullptr; } + for (auto kernel : sub_kernels) { + ret = kernel->Init(); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Schedule partial kernel init failed, name: " << kernel->name(); + return nullptr; + } + } FindAllInoutKernels(sub_kernels); ret = RunPass(&sub_kernels); @@ -667,6 +743,7 @@ int Scheduler::ScheduleSubGraphToKernels(size_t subgraph_index, std::vectorset_is_model_output(IsContain(graph_output_node_indexes_, size_t(node_index))); dst_kernels->emplace_back(kernel); + primitives_.emplace(kernel->kernel(), static_cast(primitive)); } if (in_tensors != nullptr) { std::transform(subgraph->input_indices_.begin(), subgraph->input_indices_.end(), std::back_inserter(*in_tensors), @@ -791,25 +868,34 @@ int Scheduler::ConstructSubGraphs(std::vector src_kernel, head_kernels.push_back(head_kernel); - auto cur_sub_graph_type = mindspore::lite::Scheduler::GetKernelSubGraphType(head_kernels[0]); - auto sub_kernels = FindAllSubGraphKernels(head_kernels, is_kernel_finish); - auto subgraph = CreateSubGraphKernel(sub_kernels, nullptr, nullptr, cur_sub_graph_type); - if (subgraph == nullptr) { - MS_LOG(ERROR) << "Create SubGraphKernel failed"; - return RET_ERROR; + auto subgraph_delegate = head_kernel->desc().delegate; + if (subgraph_delegate != nullptr) { + dst_kernel->emplace_back(head_kernel); + (*is_kernel_finish)[head_kernel] = true; + } else { + auto cur_sub_graph_type = mindspore::lite::Scheduler::GetKernelSubGraphType(head_kernels[0]); + auto sub_kernels = FindAllSubGraphKernels(head_kernels, is_kernel_finish); + auto subgraph = CreateSubGraphKernel(sub_kernels, nullptr, nullptr, cur_sub_graph_type); + if (subgraph == nullptr) { + MS_LOG(ERROR) << "Create SubGraphKernel failed"; + return RET_ERROR; + } + dst_kernel->emplace_back(subgraph); } - dst_kernel->emplace_back(subgraph); } /* end when all kernel converted */ for (auto *subgraph : *dst_kernel) { - auto ret = subgraph->Init(); - if (ret != RET_OK) { - MS_LOG(ERROR) << "Init SubGraph failed: " << ret; - return ret; + auto subgraph_delegate = subgraph->desc().delegate; + if (subgraph_delegate == nullptr) { + auto ret = subgraph->Init(); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Init SubGraph failed: " << ret; + return ret; + } } } return RET_OK; -} // namespace mindspore::lite +} bool Scheduler::MergeOpIsReady(const kernel::LiteKernel *kernel, std::map is_kernel_finish) { diff --git a/mindspore/lite/src/scheduler.h b/mindspore/lite/src/scheduler.h index 835194cb339..2c6649d439e 100644 --- a/mindspore/lite/src/scheduler.h +++ b/mindspore/lite/src/scheduler.h @@ -19,6 +19,7 @@ #include #include +#include #include #include "src/sub_graph_kernel.h" #include "src/inner_context.h" @@ -26,21 +27,29 @@ #if SUPPORT_NPU #include "src/runtime/agent/npu/optimizer/npu_pass_manager.h" #endif +#include "include/delegate.h" namespace mindspore::lite { class Scheduler { public: - Scheduler(const InnerContext *ctx, Model *src_model, std::vector *src_tensors, bool is_train_session) - : context_(ctx), src_model_(src_model), src_tensors_(src_tensors), is_train_session_(is_train_session) {} + Scheduler(const InnerContext *ctx, Model *src_model, std::vector *src_tensors, bool is_train_session, + std::shared_ptr delegate = nullptr) + : context_(ctx), + src_model_(src_model), + src_tensors_(src_tensors), + is_train_session_(is_train_session), + delegate_(delegate) {} #if SUPPORT_NPU Scheduler(const InnerContext *ctx, Model *src_model, std::vector *src_tensors, bool is_train_session, - NPUManager *npu_manager = nullptr, NPUPassManager *npu_pass_manager = nullptr) + NPUManager *npu_manager = nullptr, NPUPassManager *npu_pass_manager = nullptr, + std::shared_ptr delegate = nullptr) : context_(ctx), src_model_(src_model), src_tensors_(src_tensors), npu_manager_(npu_manager), npu_pass_manager_(npu_pass_manager), - is_train_session_(is_train_session) {} + is_train_session_(is_train_session), + delegate_(delegate) {} #endif ~Scheduler() = default; @@ -71,6 +80,9 @@ class Scheduler { int FindProviderKernel(const std::vector &in_tensors, const std::vector &out_tensors, const Model::Node *node, TypeId data_type, kernel::LiteKernel **kernel); + + int ReplaceDelegateKernels(std::vector *dst_kernels); + // schedule a partial node to a subgraph_kernel kernel::LiteKernel *SchedulePartialToKernel(const lite::Model::Node *src_node); // schedule a node to a kernel @@ -120,6 +132,8 @@ class Scheduler { std::vector graph_output_node_indexes_; std::map op_parameters_; bool is_train_session_ = false; + std::map primitives_; + std::shared_ptr delegate_ = nullptr; }; } // namespace mindspore::lite diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/common/strided_slice_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/common/strided_slice_tests.cc index 52d4eb1fa11..92c893e8d54 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/common/strided_slice_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/common/strided_slice_tests.cc @@ -78,7 +78,9 @@ TEST_F(TestStridedSlice, StridedSlice) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[2] = {0.2390374, 0.05051243}; ASSERT_NEAR(output_data[0], expect[0], 0.001); @@ -120,7 +122,9 @@ TEST_F(TestStridedSlice, 7d) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[2] = {0.92039955, 0.49574447}; ASSERT_NEAR(output_data[0], expect[0], 0.001); @@ -163,7 +167,9 @@ TEST_F(TestStridedSlice, 8d) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect[4] = {-9, -7}; for (unsigned int i = 0; i < sizeof(expect); ++i) { @@ -206,7 +212,9 @@ TEST_F(TestStridedSlice, FastRun7d) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[4] = {0.92039955, 0.49574447, 0.02647042, 0.4566604}; ASSERT_NEAR(output_data[0], expect[0], 0.001); @@ -251,7 +259,9 @@ TEST_F(TestStridedSlice, FastRun7dSingleThread) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[4] = {0.92039955, 0.49574447, 0.02647042, 0.4566604}; ASSERT_NEAR(output_data[0], expect[0], 0.001); @@ -295,7 +305,9 @@ TEST_F(TestStridedSlice, StridedSliceInt8) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect[4] = {-6, -5, 7, 8}; for (unsigned int i = 0; i < sizeof(expect); ++i) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp16/reduce_fp16_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp16/reduce_fp16_tests.cc index e6188622f43..fc62e9964d4 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp16/reduce_fp16_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp16/reduce_fp16_tests.cc @@ -76,6 +76,8 @@ void TestReduceFp16::Prepare(const std::vector &input_shape, const std::vec ASSERT_NE(creator_, nullptr); kernel_ = creator_(inputs_, outputs_, reinterpret_cast(¶m_), &ctx_, desc); ASSERT_NE(kernel_, nullptr); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } TEST_F(TestReduceFp16, Mean) { float in[96] = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/activation_fp32_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/activation_fp32_test.cc index acf2b57611f..d6baa4b45fc 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/activation_fp32_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/activation_fp32_test.cc @@ -128,7 +128,10 @@ TEST_F(TestActivationFp32, HSwishFp32) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector expect_output = {-0, -0.33333334, -0.33333334, 0, 0.6666667, 5, 6, 7}; ASSERT_EQ(0, CompareOutputData(output.data(), expect_output.data(), 8, 0.00001)); @@ -171,7 +174,10 @@ TEST_F(TestActivationFp32, HardTanh1) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector expect_output = {-1.0, -1.0, -0.5, 0.0, 0.5, 1.0, 1.0, 1.0}; ASSERT_EQ(0, CompareOutputData(output.data(), expect_output.data(), 8, 0.00001)); @@ -214,7 +220,10 @@ TEST_F(TestActivationFp32, HardTanh2) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector expect_output = {-2.0, -2.0, -1.0, 0.0, 1.0, 2.0, 2.0, 2.0}; ASSERT_EQ(0, CompareOutputData(output.data(), expect_output.data(), 8, 0.00001)); @@ -255,8 +264,10 @@ TEST_F(TestActivationFp32, Softplus) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - auto ret = kernel->Run(); - ASSERT_EQ(0, ret); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector expect_output = {1.3132616, 2.1269281, 3.0485871, 4.0181499, 5.0067153, 0.31326169, 6.0024757, 7.0009117, 0.0000453989, 0.0000000002, 20.00000000, 30.00000000, 14.0000000, 0.69314718}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/batchnorm_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/batchnorm_fp32_tests.cc index 7129b2570fe..06a31c349a2 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/batchnorm_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/batchnorm_fp32_tests.cc @@ -61,7 +61,10 @@ TEST_F(TestBatchnormFp32, BNTest) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < output0_tensor.ElementsNum(); i++) { @@ -116,7 +119,10 @@ TEST_F(TestBatchnormFp32, FusedBNTest) { ASSERT_EQ(lite::RET_OK, ctx.Init()); auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < output0.ElementsNum(); i++) { @@ -166,7 +172,10 @@ TEST_F(TestBatchnormFp32, easyTest) { ASSERT_EQ(lite::RET_OK, ctx.Init()); auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < output0.ElementsNum(); i++) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32_tests.cc index b963e6c0201..7bb7793f2ae 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32_tests.cc @@ -119,7 +119,10 @@ TEST_F(TestConvolutionDwFp32, ConvDwFp32Accuracy) { auto *kernel = creator(inputs, outputs, reinterpret_cast(conv_param), ctx, desc); ASSERT_NE(kernel, nullptr); // op run - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::cout << "==================output data=================" << std::endl; auto output_ptr = reinterpret_cast(outputs[0]->MutableData()); @@ -169,6 +172,8 @@ TEST_F(TestConvolutionDwFp32, ConvDwFp32Performance) { ASSERT_NE(creator, nullptr); auto *kernel = creator(inputs, outputs, reinterpret_cast(conv_param), ctx, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); /* running warm up */ for (int i = 0; i < 3; i++) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/cumsum_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/cumsum_tests.cc index 8d465f63edf..c33a08e1e31 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/cumsum_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/cumsum_tests.cc @@ -54,7 +54,9 @@ TEST_F(TestCumsum, TestThread1) { auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); EXPECT_NEAR(1.0f, output_data0[0], 0.000001); EXPECT_NEAR(1.0f, output_data0[1], 0.000001); @@ -106,7 +108,9 @@ TEST_F(TestCumsum, TestExclusive) { auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); EXPECT_NEAR(0.0f, output_data0[0], 0.000001); EXPECT_NEAR(0.0f, output_data0[1], 0.000001); @@ -158,7 +162,9 @@ TEST_F(TestCumsum, TestReverse) { auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); EXPECT_NEAR(6.0f, output_data0[0], 0.000001); EXPECT_NEAR(6.0f, output_data0[1], 0.000001); @@ -210,7 +216,9 @@ TEST_F(TestCumsum, TestReverseExclusive) { auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); EXPECT_NEAR(5.0f, output_data0[0], 0.000001); EXPECT_NEAR(5.0f, output_data0[1], 0.000001); @@ -263,7 +271,9 @@ TEST_F(TestCumsum, TestIntRank2) { auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); EXPECT_EQ(1, output_data0[0]); EXPECT_EQ(3, output_data0[1]); @@ -309,7 +319,9 @@ TEST_F(TestCumsum, TestIntRank2Thread2) { auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); EXPECT_EQ(1, output_data0[0]); EXPECT_EQ(3, output_data0[1]); @@ -356,7 +368,9 @@ TEST_F(TestCumsum, TestIntRank2Thread4) { auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); EXPECT_EQ(1, output_data0[0]); EXPECT_EQ(3, output_data0[1]); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/l2norm_fp32_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/l2norm_fp32_test.cc index 3e2aff5a89d..40d22f6c4b5 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/l2norm_fp32_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/l2norm_fp32_test.cc @@ -71,6 +71,8 @@ void TestL2NormFp32::Init(const std::vector &input_shape, const std::vector ASSERT_NE(creator_, nullptr); kernel_ = creator_(inputs_, outputs_, reinterpret_cast(¶m_), &ctx_, desc); ASSERT_NE(kernel_, nullptr); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } // 2thread all axis no_activation diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lsh_projection_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lsh_projection_fp32_tests.cc index bef7e28a8b3..0f20496c75f 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lsh_projection_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lsh_projection_fp32_tests.cc @@ -66,7 +66,9 @@ TEST_F(TestLshProjectionFp32, Dense1DInputs) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); std::vector except_result = {0, 0, 0, 1, 0, 0}; @@ -106,7 +108,9 @@ TEST_F(TestLshProjectionFp32, Sparse1DInputs) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); std::vector except_result = {0, 5, 8}; @@ -150,7 +154,9 @@ TEST_F(TestLshProjectionFp32, Sparse3DInputs) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); std::vector except_result = {2, 5, 9}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc index 5d2ac26c370..506d332cf96 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc @@ -156,7 +156,10 @@ TEST_F(LstmFp32, LstmForwardFp32Accuracy) { auto *kernel = creator(inputs, outputs, reinterpret_cast(lstm_param), ctx, desc); ASSERT_NE(kernel, nullptr); // op run - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::cout << "==================output data=================" << std::endl; std::vector output0_data = {-0.0702, 0.1225, 0.0876, -0.0357, -0.0227, -0.2294, @@ -304,7 +307,10 @@ TEST_F(LstmFp32, LstmBackwardFp32Accuracy) { auto *kernel = creator(inputs, outputs, reinterpret_cast(lstm_param), ctx, desc); ASSERT_NE(kernel, nullptr); // op run - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::cout << "==================output data=================" << std::endl; std::vector output0_data = {-0.2922, -0.1416, 0.0077, -0.0422, -0.0585, 0.2061, -0.2385, -0.0146, diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/non_max_suppression_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/non_max_suppression_fp32_tests.cc index a2f39a0705f..ff755e844ad 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/non_max_suppression_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/non_max_suppression_fp32_tests.cc @@ -88,6 +88,8 @@ void TestNMSFp32::Init(const std::vector &box_tensor_shape, float *box_data ASSERT_NE(creator_, nullptr); kernel_ = creator_(inputs_, outputs_, reinterpret_cast(¶m_), &ctx_, desc_); ASSERT_NE(kernel_, nullptr); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } TEST_F(TestNMSFp32, TestCase1) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/one_hot_fp32_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/one_hot_fp32_test.cc index 47a3976bdb2..28ec87d393e 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/one_hot_fp32_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/one_hot_fp32_test.cc @@ -75,6 +75,8 @@ void TestOneHotFp32::Prepare(const std::vector &indices_shape, int *indices ctx_.Init(); creator_ = lite::KernelRegistry::GetInstance()->GetCreator(desc); kernel_ = creator_(inputs_, outputs_, reinterpret_cast(param_), &ctx_, desc); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } // 3 3 axis -1 -> 3 3 4 diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/pad_fp32_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/pad_fp32_test.cc index c3fcc52a97e..f148f2e9714 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/pad_fp32_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/pad_fp32_test.cc @@ -90,6 +90,8 @@ void TestPadFp32::Prepare(const std::vector &input_shape, const std::vector ASSERT_NE(creator_, nullptr); kernel_ = creator_(inputs_, outputs_, reinterpret_cast(¶m_), &ctx_, desc); ASSERT_NE(kernel_, nullptr); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } TEST_F(TestPadFp32, TestPad1) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/reduce_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/reduce_fp32_tests.cc index 69e055bce3a..ecf39d5b49d 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/reduce_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/reduce_fp32_tests.cc @@ -89,6 +89,8 @@ void TestReduceFp32::Prepare(const std::vector &in_shape, const std::vector } ctx_->thread_num_ = thread_num_; kernel_ = creator_(inputs, outputs, reinterpret_cast(¶m_), ctx_, desc_); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } TEST_F(TestReduceFp32, Mean1) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_bilinear_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_bilinear_fp32_tests.cc index 00842bedb9f..73893d1fbb5 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_bilinear_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_bilinear_fp32_tests.cc @@ -71,6 +71,8 @@ void TestResizeBilinearFp32::Prepare(const std::vector &input_shape, const ASSERT_NE(creator_, nullptr); kernel_ = creator_(inputs_, outputs_, reinterpret_cast(¶m_), &ctx_, desc); ASSERT_NE(kernel_, nullptr); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } // 1*1 -> 1*1 diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_nearest_neighbor_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_nearest_neighbor_fp32_tests.cc index 6a4493f7f27..111a5ce0e31 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_nearest_neighbor_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_nearest_neighbor_fp32_tests.cc @@ -66,6 +66,8 @@ void TestResizeNearestNeighborFp32::Prepare(const std::vector &input_shape, ASSERT_NE(creator_, nullptr); kernel_ = creator_(inputs_, outputs_, reinterpret_cast(¶m_), &ctx_, desc); ASSERT_NE(kernel_, nullptr); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } // 1*1 -> 1*1 TEST_F(TestResizeNearestNeighborFp32, ResizeNearestNeighborTest1) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/reverse_sequence_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/reverse_sequence_fp32_tests.cc index 6329f04ebb2..554793f7c37 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/reverse_sequence_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/reverse_sequence_fp32_tests.cc @@ -54,7 +54,9 @@ TEST_F(TestReverseSequenceFp32, BatchLessSeq) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[] = {2, 3, 0, 1, 4, 5, 6, 7, 12, 13, 10, 11, 8, 9, 14, 15, 22, 23, 20, 21, 18, 19, 16, 17, @@ -98,7 +100,9 @@ TEST_F(TestReverseSequenceFp32, BatchGreaterSeq) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[] = {8, 9, 18, 19, 20, 21, 14, 15, 0, 1, 10, 11, 12, 13, 6, 7, 16, 17, 2, 3, 4, 5, 22, 23, @@ -142,7 +146,9 @@ TEST_F(TestReverseSequenceFp32, BatchSeqNotAdjacent) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[] = {2, 3, 0, 1, 4, 5, 6, 7, 10, 11, 8, 9, 12, 13, 14, 15, 18, 19, 16, 17, 20, 21, 22, 23, diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/scale_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/scale_fp32_tests.cc index 88c2c1ab086..6415f5f4864 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/scale_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/scale_fp32_tests.cc @@ -91,6 +91,8 @@ void TestScaleFp32::Prepare(const std::vector &input_shape, const std::vect ASSERT_NE(creator_, nullptr); kernel_ = creator_(inputs_, outputs_, reinterpret_cast(¶m_), &ctx_, desc_); ASSERT_NE(kernel_, nullptr); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } TEST_F(TestScaleFp32, ScaleNoAct) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/softmax_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/softmax_tests.cc index c2b1ab53963..f345e1a482f 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/softmax_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/softmax_tests.cc @@ -46,7 +46,9 @@ TEST_F(TestSoftmaxFp32, 001) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[] = {0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/space_to_depth_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/space_to_depth_fp32_tests.cc index e12582968d9..a611a90559e 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/space_to_depth_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/space_to_depth_fp32_tests.cc @@ -82,8 +82,10 @@ TEST_F(SpaceToDepthTestFp32, SpaceToDepthTest2) { auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc); ASSERT_NE(creator, nullptr); auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); - ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); for (int i = 0; i < out_size; ++i) { std::cout << output[i] << " "; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/sparse_to_dense_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/sparse_to_dense_fp32_tests.cc index 3be0d52ebb0..aab1a3d139a 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/sparse_to_dense_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/sparse_to_dense_fp32_tests.cc @@ -91,7 +91,10 @@ TEST_F(TestSparseToDenseFp32, SparseToDense_test1) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, @@ -174,7 +177,10 @@ TEST_F(TestSparseToDenseFp32, SparseToDense_test2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, @@ -257,7 +263,10 @@ TEST_F(TestSparseToDenseFp32, SparseToDense_test3) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {0, 1, 0, 1, 1, 0, 0, 0, 0, 0}; PrintData("output data", output, output_size); @@ -338,7 +347,10 @@ TEST_F(TestSparseToDenseFp32, SparseToDense_test4) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {0, 0, 0, 0, 0, 1, 0, 0, 0, 0}; PrintData("output data", output, output_size); @@ -419,7 +431,10 @@ TEST_F(TestSparseToDenseFp32, SparseToDense_test5) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/strided_slice_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/strided_slice_fp32_tests.cc index 0282a5d3fac..97bd90661a8 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/strided_slice_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/strided_slice_fp32_tests.cc @@ -159,7 +159,10 @@ TEST_F(TestStridedSliceFp32, StridedSlice3) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(strided_slice_param), ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); delete ctx; ASSERT_EQ(0, CompareOutputData(output_data, correct, 2, 0.000001)); @@ -209,7 +212,10 @@ TEST_F(TestStridedSliceFp32, StridedSlice4) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(strided_slice_param), ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); delete ctx; ASSERT_EQ(0, CompareOutputData(output_data, correct, 4, 0.000001)); @@ -266,7 +272,10 @@ TEST_F(TestStridedSliceFp32, StridedSlice5) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(strided_slice_param), ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); delete ctx; ASSERT_EQ(0, CompareOutputData(output_data, correct, 12, 0.000001)); @@ -323,7 +332,10 @@ TEST_F(TestStridedSliceFp32, StridedSlice6) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(strided_slice_param), ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); delete ctx; ASSERT_EQ(0, CompareOutputData(output_data, correct, 8, 0.000001)); @@ -372,7 +384,10 @@ TEST_F(TestStridedSliceFp32, StridedSlice7) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(strided_slice_param), ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); delete ctx; ASSERT_EQ(0, CompareOutputData(output_data, correct, 1, 0.000001)); @@ -429,7 +444,10 @@ TEST_F(TestStridedSliceFp32, StridedSlice8) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(strided_slice_param), ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); delete ctx; ASSERT_EQ(0, CompareOutputData(output_data, correct, 5, 0.000001)); @@ -579,7 +597,10 @@ TEST_F(TestStridedSliceFp32, StridedSlice9) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(strided_slice_param), ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); delete ctx; ASSERT_EQ(0, CompareOutputData(output_data, correct, 490, 0.000001)); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/tile_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/tile_fp32_tests.cc index d059201c23c..317e0d96815 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/tile_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/tile_fp32_tests.cc @@ -56,7 +56,9 @@ TEST_F(TestTileFp32, Tile) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[] = {1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4}; @@ -101,7 +103,9 @@ TEST_F(TestTileFp32, SimpleTile1) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), context, desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[] = {1, 2, 3, 4, 1, 2, 3, 4}; @@ -146,7 +150,9 @@ TEST_F(TestTileFp32, SimpleTile2) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), context, desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect[] = {1, 2, 1, 2, 3, 4, 3, 4}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/topk_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/topk_fp32_tests.cc index 6d5bbe1ef1d..041acc41bb9 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/topk_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/topk_fp32_tests.cc @@ -51,7 +51,9 @@ TEST_F(TestTopKFp32, TopK) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect0[] = {3, 2, 6, 5, 9, 8, 12, 11}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/transpose_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/transpose_fp32_tests.cc index d9d03c0c89a..84ae8b09a1b 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/transpose_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/transpose_fp32_tests.cc @@ -56,8 +56,11 @@ TEST_F(TestTransposeFp32, 10D) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(param), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); + float expect[24] = {1, 5, 9, 13, 17, 21, 2, 6, 10, 14, 18, 22, 3, 7, 11, 15, 19, 23, 4, 8, 12, 16, 20, 24}; for (int i = 0; i < 24; ++i) { ASSERT_NEAR(out[i], expect[i], 0.001); @@ -94,8 +97,11 @@ TEST_F(TestTransposeFp32, 10DSingleThread) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(param), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); + float expect[24] = {1, 5, 9, 13, 17, 21, 2, 6, 10, 14, 18, 22, 3, 7, 11, 15, 19, 23, 4, 8, 12, 16, 20, 24}; for (int i = 0; i < 24; ++i) { ASSERT_NEAR(out[i], expect[i], 0.001); @@ -239,8 +245,11 @@ TEST_F(TestTransposeFp32, TransposeFp32_test5) { /* 1x2x3x2x2 */ auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc); ASSERT_NE(creator, nullptr); auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(param), &ctx, desc); - ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); + for (int i = 0; i < 24; ++i) { std::cout << output[i] << " "; } diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/uniform_real_fp32_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/uniform_real_fp32_test.cc index 7bc238d9984..8785609f5b4 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/uniform_real_fp32_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/uniform_real_fp32_test.cc @@ -46,7 +46,9 @@ TEST_F(TestUniformRealFp32, UniformReal) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); EXPECT_NEAR(0.138693, output_data0[0], 0.000001); EXPECT_NEAR(0.511552, output_data0[1], 0.000001); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/unique_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/unique_fp32_tests.cc index 843c49c4604..0e08c127e46 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/unique_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/unique_fp32_tests.cc @@ -50,7 +50,9 @@ TEST_F(TestUniqueFp32, Unique) { auto kernel = creator(inputs, outputs, ¶meter, ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect0[] = {1, 2, 4, 7, 8}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/unstack_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/unstack_fp32_tests.cc index 82809e68c41..b9bf1252360 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/unstack_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/unstack_fp32_tests.cc @@ -56,7 +56,9 @@ TEST_F(TestUnstackFp32, Unstack) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect0[] = {1, 2, 9, 10, 17, 18}; @@ -104,7 +106,9 @@ TEST_F(TestUnstackFp32, Unstack2) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); EXPECT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); float expect0[] = {1, 2, 3, 4, 5, 6, 7, 8}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/arithmetic_grad_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/arithmetic_grad_fp32_tests.cc index ce5982ff4fa..b0874ee18fd 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/arithmetic_grad_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/arithmetic_grad_fp32_tests.cc @@ -212,7 +212,10 @@ TEST_F(TestArithmeticGradFp32, TestAddGradFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[1]->MutableData()); printf("==================output data=================\n"); @@ -254,7 +257,10 @@ TEST_F(TestArithmeticGradFp32, TestAddGrad2Fp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[0]->MutableData()); printf("==================output data=================\n"); @@ -298,7 +304,10 @@ TEST_F(TestArithmeticGradFp32, TestAddGrad3Fp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[0]->MutableData()); printf("==================output data=================\n"); @@ -343,7 +352,10 @@ TEST_F(TestArithmeticGradFp32, TestSubGradFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[1]->MutableData()); printf("==================output data=================\n"); @@ -388,7 +400,10 @@ TEST_F(TestArithmeticGradFp32, TestSubGrad2Fp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[0]->MutableData()); printf("==================output data=================\n"); @@ -431,6 +446,9 @@ TEST_F(TestArithmeticGradFp32, TestMulGradFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + int loop_count = 1000; auto time_start = mindspore::lite::GetTimeUs(); for (int i = 0; i < loop_count; i++) { @@ -483,7 +501,10 @@ TEST_F(TestArithmeticGradFp32, TestMulGrad2Fp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[0]->MutableData()); printf("==================output data=================\n"); @@ -527,7 +548,10 @@ TEST_F(TestArithmeticGradFp32, TestMulGrad3Fp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[1]->MutableData()); printf("==================output data=================\n"); @@ -571,7 +595,10 @@ TEST_F(TestArithmeticGradFp32, TestMulGrad4Fp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[0]->MutableData()); printf("==================output data=================\n"); @@ -615,7 +642,10 @@ TEST_F(TestArithmeticGradFp32, TestDivGradFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[1]->MutableData()); printf("==================output data=================\n"); @@ -659,7 +689,10 @@ TEST_F(TestArithmeticGradFp32, TestDivGrad2Fp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[0]->MutableData()); printf("==================output data=================\n"); @@ -704,7 +737,10 @@ TEST_F(TestArithmeticGradFp32, TestDivGrad3Fp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[1]->MutableData()); printf("==================output data=================\n"); @@ -748,7 +784,10 @@ TEST_F(TestArithmeticGradFp32, Test3DDivGrad2Fp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[1]->MutableData()); printf("==================output data=================\n"); @@ -830,7 +869,10 @@ TEST_F(TestArithmeticGradFp32, TestMaximumGradBroadcastFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); float *output_ptr = reinterpret_cast(outputs[1]->MutableData()); printf("==================output data=================\n"); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bias_grad_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bias_grad_fp32_tests.cc index b7c130c7db5..a1c05d2bb96 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bias_grad_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bias_grad_fp32_tests.cc @@ -59,7 +59,10 @@ TEST_F(TestBiasGradFp32, BiasGradFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(bias_param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < 7; i++) { @@ -108,7 +111,10 @@ TEST_F(TestBiasGradFp32, BiasGrad2DFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(bias_param), &ctx, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < 20; i++) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bn_grad_fp32_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bn_grad_fp32_test.cc index 67e17984706..3be96222300 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bn_grad_fp32_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bn_grad_fp32_test.cc @@ -88,7 +88,10 @@ TEST_F(TestBNGradFp32, BNGradFp32) { ASSERT_NE(kernel_obj, nullptr); mindspore::kernel::InnerKernel::AllocWorkspace(kernel_obj->workspace_size()); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); std::cout << "==========dx==========\n"; auto dx = reinterpret_cast(outputs[0]->MutableData()); for (int i = 0; i < 7; i++) std::cout << dx[i] << " "; @@ -189,6 +192,9 @@ TEST_F(TestBNGradFp32, BNTtrainFp32) { float *curr_mean = reinterpret_cast(mean_tensor.MutableData()); float *curr_var = reinterpret_cast(var_tensor.MutableData()); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + kernel_obj->Train(); kernel_obj->set_trainable(true); kernel_obj->Run(); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/convolution_grad_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/convolution_grad_fp32_tests.cc index ec152061cb3..ec419dbe3d7 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/convolution_grad_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/convolution_grad_fp32_tests.cc @@ -119,6 +119,9 @@ TEST_F(TestConvolutionGradFp32, ConvFp32FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -196,6 +199,8 @@ TEST_F(TestConvolutionGradFp32, ConvFp32InputGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop @@ -272,6 +277,8 @@ TEST_F(TestConvolutionGradFp32, ConvFp32GroupFilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); kernel->Run(); @@ -345,6 +352,8 @@ TEST_F(TestConvolutionGradFp32, ConvFp32GroupInputGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -420,6 +429,8 @@ TEST_F(TestConvolutionGradFp32, ConvFp32GroupDilationFilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop @@ -496,6 +507,8 @@ TEST_F(TestConvolutionGradFp32, ConvFp32GroupDilationInputGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); int loop_count = 100; @@ -673,6 +686,8 @@ TEST_F(TestConvolutionGradFp32, ConvFp32Dilation2Group2Stride2FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop @@ -780,6 +795,8 @@ TEST_F(TestConvolutionGradFp32, ConvGroup2Dilation2Stride2) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_fp32_tests.cc index 5d8f447fab5..15d9f4f8168 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_fp32_tests.cc @@ -98,6 +98,8 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop @@ -204,6 +206,8 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); for (int i = 0; i < 3; i++) { } @@ -310,6 +314,8 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2Group3FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop @@ -413,6 +419,8 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2Group3Stride1FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop @@ -519,6 +527,8 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2Group2Stride2FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop @@ -628,7 +638,8 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2Group12Stride2FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc); ASSERT_NE(kernel, nullptr); - + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); mindspore::kernel::InnerKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/pooling_grad_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/pooling_grad_fp32_tests.cc index 2e425d33615..045cf96eafa 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/pooling_grad_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/pooling_grad_fp32_tests.cc @@ -160,7 +160,10 @@ TEST_F(TestPoolingGradFp32, AvgPoolingKernelGradFp32) { auto kernel_obj = creator(inputs, outputs, reinterpret_cast(pooling_param), &context, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < 20; i++) { @@ -229,7 +232,10 @@ TEST_F(TestPoolingGradFp32, AvgPoolingBatchGradFp32) { auto kernel_obj = creator(inputs, outputs, reinterpret_cast(pooling_param), &context, desc); ASSERT_NE(kernel_obj, nullptr); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < 20; i++) { @@ -297,9 +303,10 @@ TEST_F(TestPoolingGradFp32, AvgPoolGradStride2Fp32) { auto kernel = pool_creator(inputs, outputs, reinterpret_cast(pool), &context, pool_desc); ASSERT_NE(kernel, nullptr); - kernel->Init(); - - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::string output_path = "./test_data/pooling/avgpoolgradfp32_s2_dx_3_28_28_3.bin"; auto res = CompareRelativeOutput(out_data, output_path); @@ -364,9 +371,10 @@ TEST_F(TestPoolingGradFp32, AvgPoolGradStride3Fp32) { auto kernel = pool_creator(inputs, outputs, reinterpret_cast(pool), &context, pool_desc); ASSERT_NE(kernel, nullptr); - kernel->Init(); - - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::string output_path = "./test_data/pooling/avgpoolgradfp32_s3_dx_3_28_28_3.bin"; auto res = CompareRelativeOutput(out_data, output_path); @@ -498,9 +506,10 @@ TEST_F(TestPoolingGradFp32, MaxPoolGradBatchFp32) { maxpool_creator(maxpool_inputs, maxpool_outputs, reinterpret_cast(maxpool), &context, maxpool_desc); ASSERT_NE(kernel, nullptr); - kernel->Init(); - - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::string output_path = "./test_data/pooling/maxpoolgradfp32_1_xgrad_3_28_28_3.bin"; auto res = CompareRelativeOutput(out_data, output_path); @@ -576,9 +585,10 @@ TEST_F(TestPoolingGradFp32, MaxPoolGradStride2Fp32) { maxpool_creator(maxpool_inputs, maxpool_outputs, reinterpret_cast(maxpool), &context, maxpool_desc); ASSERT_NE(kernel, nullptr); - kernel->Init(); - - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::string output_path = "./test_data/pooling/maxpoolgradfp32_s2_xgrad_3_28_28_3.bin"; auto res = CompareRelativeOutput(out_data, output_path); @@ -654,8 +664,10 @@ TEST_F(TestPoolingGradFp32, MaxPoolGradStride3Fp32) { maxpool_creator(maxpool_inputs, maxpool_outputs, reinterpret_cast(maxpool), &context, maxpool_desc); ASSERT_NE(kernel, nullptr); - kernel->Init(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::string output_path = "./test_data/pooling/maxpoolgradfp32_s3_xgrad_3_28_28_3.bin"; auto res = CompareRelativeOutput(out_data, output_path); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/softmax_crossentropy_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/softmax_crossentropy_fp32_tests.cc index 45eddb998ef..c0d581c064b 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/softmax_crossentropy_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/softmax_crossentropy_fp32_tests.cc @@ -77,7 +77,10 @@ TEST_F(TestSoftmaxCrossEntropyFp32, SoftmaxCrossEntropyFp32) { auto kernel_obj = creator(inputs, outputs, reinterpret_cast(sce_param), &context, desc); ASSERT_NE(kernel_obj, nullptr); mindspore::kernel::InnerKernel::AllocWorkspace(kernel_obj->workspace_size()); - kernel_obj->Run(); + auto ret = kernel_obj->Init(); + EXPECT_EQ(0, ret); + ret = kernel_obj->Run(); + EXPECT_EQ(0, ret); printf("==================total loss=================\n"); std::cout << loss[0] << " ," << std::endl; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/add_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/add_int8_tests.cc index 367cc225064..0259e128e45 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/add_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/add_int8_tests.cc @@ -60,7 +60,9 @@ TEST_F(TestQuantizedAdd, Add) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[10] = {-64, 76, 13, -13, -64, 76, 13, -13, -64, 76}; // -0.5 0.6 0.1 -0.1 diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/arithmetic_self_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/arithmetic_self_int8_tests.cc index 32d10e79d8f..4d6a9da7de9 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/arithmetic_self_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/arithmetic_self_int8_tests.cc @@ -74,7 +74,10 @@ TEST_F(TestArithmeticSelfInt8, floor_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; PrintData("output data", output, output_size); @@ -133,7 +136,10 @@ TEST_F(TestArithmeticSelfInt8, floor_quant1_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {0, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6}; PrintData("output data", output, output_size); @@ -192,7 +198,10 @@ TEST_F(TestArithmeticSelfInt8, round_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; PrintData("output data", output, output_size); @@ -251,7 +260,10 @@ TEST_F(TestArithmeticSelfInt8, round_quant1_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 7}; PrintData("output data", output, output_size); @@ -310,7 +322,10 @@ TEST_F(TestArithmeticSelfInt8, ceil_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; PrintData("output data", output, output_size); @@ -369,7 +384,10 @@ TEST_F(TestArithmeticSelfInt8, ceil_quant1_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6, 7}; PrintData("output data", output, output_size); @@ -428,7 +446,10 @@ TEST_F(TestArithmeticSelfInt8, abs_quant0_thread0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; PrintData("output data", output, output_size); @@ -487,7 +508,10 @@ TEST_F(TestArithmeticSelfInt8, abs_quant1_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6}; PrintData("output data", output, output_size); @@ -546,7 +570,10 @@ TEST_F(TestArithmeticSelfInt8, sin_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 1, 0, -1}; PrintData("output data", output, output_size); @@ -605,7 +632,10 @@ TEST_F(TestArithmeticSelfInt8, cos_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 0, -1, -1}; PrintData("output data", output, output_size); @@ -664,7 +694,10 @@ TEST_F(TestArithmeticSelfInt8, log_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2}; PrintData("output data", output, output_size); @@ -723,7 +756,10 @@ TEST_F(TestArithmeticSelfInt8, sqrt_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3}; PrintData("output data", output, output_size); @@ -782,7 +818,10 @@ TEST_F(TestArithmeticSelfInt8, rsqrt_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0}; PrintData("output data", output, output_size); @@ -841,7 +880,10 @@ TEST_F(TestArithmeticSelfInt8, square_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 127}; PrintData("output data", output, output_size); @@ -900,7 +942,10 @@ TEST_F(TestArithmeticSelfInt8, square_quant1_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 4, 7, 11, 16, 21, 28, 35, 43, 52, 62}; PrintData("output data", output, output_size); @@ -959,7 +1004,10 @@ TEST_F(TestArithmeticSelfInt8, logical_not_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1}; PrintData("output data", output, output_size); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/batchnorm_int8_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/batchnorm_int8_test.cc index dd767d3dd03..cba98f87bc0 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/batchnorm_int8_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/batchnorm_int8_test.cc @@ -108,7 +108,10 @@ TEST_F(TestBatchnormInt8, FusedTest) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < output0_tensor.ElementsNum(); i++) { @@ -188,7 +191,10 @@ TEST_F(TestBatchnormInt8, BNTest) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < output0_tensor.ElementsNum(); i++) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/concat_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/concat_int8_tests.cc index ba3e37265c1..8dd21ef7226 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/concat_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/concat_int8_tests.cc @@ -87,7 +87,10 @@ TEST_F(TestConcatInt8, Concat1_axis0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; PrintData("output data", output, input1.size() + input2.size()); @@ -158,7 +161,10 @@ TEST_F(TestConcatInt8, Concat1_axis1_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {10, 11, 12, 13, 14, 15, 30, 31, 20, 21, 22, 23, 24, 25, 32, 33}; PrintData("output data", output, input1.size() + input2.size()); @@ -230,7 +236,10 @@ TEST_F(TestConcatInt8, Concat1_axis1_thread2_quant1) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {5, 6, 6, 7, 7, 8, 15, 16, 10, 11, 11, 12, 12, 13, 16, 17}; PrintData("output data", output, input1.size() + input2.size()); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/crop_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/crop_int8_tests.cc index 573387ef4f3..1eba29da776 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/crop_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/crop_int8_tests.cc @@ -79,7 +79,10 @@ TEST_F(TestCropInt8, crop_1d_axis0_offset0_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {2, 3, 4, 5, 6, 7, 8}; PrintData("output data", output, output_size); @@ -142,7 +145,10 @@ TEST_F(TestCropInt8, crop_2d_axis1_offset0_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16}; PrintData("output data", output, output_size); @@ -205,7 +211,10 @@ TEST_F(TestCropInt8, crop_3d_axis1_offset0_quant0_thread0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {4, 8}; PrintData("output data", output, output_size); @@ -269,7 +278,10 @@ TEST_F(TestCropInt8, crop_3d_axis1_offset0_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {4, 6, 8, 10, 12, 14, 16, 20, 22, 24, 26, 28, 30, 32}; PrintData("output data", output, output_size); @@ -332,7 +344,10 @@ TEST_F(TestCropInt8, crop_4d_axis0_offset0_quant0_thread0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {16}; PrintData("output data", output, output_size); @@ -395,7 +410,10 @@ TEST_F(TestCropInt8, crop_4d_axis1_offset0_quant0_thread0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {8, 16}; PrintData("output data", output, output_size); @@ -461,7 +479,10 @@ TEST_F(TestCropInt8, crop_4d_axis1_offset1_quant0_thread0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {13, 14, 15, 16}; PrintData("output data", output, output_size); @@ -527,7 +548,10 @@ TEST_F(TestCropInt8, crop_4d_axis1_offset1_quant1_thread0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {7, 7, 8, 8}; PrintData("output data", output, output_size); @@ -592,7 +616,10 @@ TEST_F(TestCropInt8, crop_4d_axis0_offset0_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {40, 44, 48, 52, 56, 60, 64}; PrintData("output data", output, output_size); @@ -657,7 +684,10 @@ TEST_F(TestCropInt8, crop_4d_axis0_offset0_quant0_thread3) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {40, 44, 48, 52, 56, 60, 64}; PrintData("output data", output, output_size); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/gatherNd_int8_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/gatherNd_int8_test.cc index e90ba614bc6..ad188904116 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/gatherNd_int8_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/gatherNd_int8_test.cc @@ -83,7 +83,10 @@ TEST_F(TestGatherNdInt8, GatherNdTest) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < output0_tensor.ElementsNum(); i++) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/gather_int8_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/gather_int8_test.cc index 4a1f9939974..2e597a8ef63 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/gather_int8_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/gather_int8_test.cc @@ -81,7 +81,10 @@ TEST_F(TestGatherInt8, GatherTest) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), &ctx, desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); printf("==================output data=================\n"); for (int i = 0; i < output0_tensor.ElementsNum(); i++) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/hswish_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/hswish_int8_tests.cc index cd38f70528b..2bd3cb06831 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/hswish_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/hswish_int8_tests.cc @@ -61,7 +61,9 @@ TEST_F(TestHSwishInt8, HSwish) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect[8] = {-52, -52, -57, -52, 7, 25, 37, 101}; // 0, 0, -0.208333, 0, 2.29167, 3, 3.5, 6 diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/l2_norm_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/l2_norm_int8_tests.cc index cf6339502a6..62edf4232db 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/l2_norm_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/l2_norm_int8_tests.cc @@ -60,7 +60,9 @@ TEST_F(TestL2NormInt8, norm) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶m_), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect[10] = {-93, -70, -47, -23, 0, 15, 38, 53, 61, 91}; for (int i = 0; i < 10; ++i) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/mul_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/mul_int8_tests.cc index 61d2b2a0a14..8a9d79c0511 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/mul_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/mul_int8_tests.cc @@ -86,7 +86,10 @@ TEST_F(TestMulInt8, Mul_quant0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 4, 3, 8, 5, 12, 21, 32, 27, 40, 33, 48}; PrintData("output data", output, input1.size()); @@ -156,7 +159,10 @@ TEST_F(TestMulInt8, Mul_quant0_thread0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}; PrintData("output data", output, input1.size()); @@ -226,7 +232,10 @@ TEST_F(TestMulInt8, Mul_quant1) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 2, 4, 3, 6, 11, 16, 14, 20, 17, 24}; PrintData("output data", output, input1.size()); @@ -296,7 +305,10 @@ TEST_F(TestMulInt8, Mul_quant1_thread1) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 2, 4, 3, 6, 11, 16, 14, 20, 17, 24}; PrintData("output data", output, input1.size()); @@ -366,7 +378,10 @@ TEST_F(TestMulInt8, test) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 4, 9, 16, 25, 36, 7, 16, 27, 40, 55, 72}; PrintData("output data", output, input1.size()); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/power_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/power_int8_tests.cc index 55d03016e3e..2db66dd87af 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/power_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/power_int8_tests.cc @@ -75,7 +75,10 @@ TEST_F(TestPowerInt8, PowerInt8) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), ctx.get(), desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {-112, -65, 15, 127}; ASSERT_EQ(0, CompareOutputData(output.data(), except_result.data(), input.size(), 0.000001)); @@ -143,7 +146,10 @@ TEST_F(TestPowerInt8, normal) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), ctx.get(), desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {-99, 95, 124, -14}; ASSERT_EQ(0, CompareOutputData(output.data(), except_result.data(), input.size(), 0.000001)); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/prelu_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/prelu_int8_tests.cc index c095f2561e2..5d10fd5f7e8 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/prelu_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/prelu_int8_tests.cc @@ -79,7 +79,10 @@ TEST_F(TestPreluInt8, prelu_1) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, -1, 3, 4, 5, 6, 7, -2}; PrintData("output data", output, output_size); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/quant_dtype_cast_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/quant_dtype_cast_tests.cc index bff9bca8969..f76c54dd052 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/quant_dtype_cast_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/quant_dtype_cast_tests.cc @@ -70,7 +70,10 @@ TEST_F(QuantDTypeCastTestFp32, QuantDTypeCastTest1) { ASSERT_NE(creator, nullptr); auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(¶m), &ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); for (int i = 0; i < out_size; ++i) { std::cout << output[i] << " "; @@ -116,7 +119,10 @@ TEST_F(QuantDTypeCastTestFp32, QuantDTypeCastTest2) { ASSERT_NE(creator, nullptr); auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(¶m), &ctx, desc); ASSERT_NE(kernel, nullptr); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); for (int i = 0; i < out_size; ++i) { std::cout << output[i] << " "; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/reduce_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/reduce_int8_tests.cc index 2c327358bab..2b37adcb41a 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/reduce_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/reduce_int8_tests.cc @@ -82,6 +82,8 @@ void TestReduceInt8::Prepare(const std::vector &in_shape, const std::vector ctx_.thread_num_ = thread_num_; ASSERT_EQ(lite::RET_OK, ctx_.Init()); kernel_ = creator_(inputs, outputs, reinterpret_cast(¶m_), &ctx_, desc_); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } TEST_F(TestReduceInt8, Mean) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/relux_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/relux_int8_tests.cc index 167013bceda..98afb8a669e 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/relux_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/relux_int8_tests.cc @@ -59,7 +59,9 @@ TEST_F(TestReluXInt8, Relu) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[4] = {0, 26, 0, 90}; // @@ -103,7 +105,9 @@ TEST_F(TestReluXInt8, Relu6) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); // 0.0f, 0.0f, 1.25f, 3.0f, 4.5f, 6.0f, 6.0f, 6.0f diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/reshape_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/reshape_int8_tests.cc index 2d889043b28..0a36dd79615 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/reshape_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/reshape_int8_tests.cc @@ -75,7 +75,10 @@ TEST_F(TestReshapeInt8, reshape_quant0) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25}; PrintData("output data", output, input1.size()); @@ -134,7 +137,10 @@ TEST_F(TestReshapeInt8, reshape_quant1_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {6, 7, 7, 8, 8, 9, 11, 12, 12, 13, 13, 14}; PrintData("output data", output, input1.size()); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/resize_bilinear_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/resize_bilinear_int8_tests.cc index a8ad0fb57d6..1456c90ae38 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/resize_bilinear_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/resize_bilinear_int8_tests.cc @@ -80,6 +80,8 @@ void TestResizeBilinearInt8::Prepare(const std::vector &in_shape, const std ctx_.thread_num_ = thread_num; ASSERT_EQ(lite::RET_OK, ctx_.Init()); kernel_ = creator_(inputs, outputs, reinterpret_cast(¶m_), &ctx_, desc_); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } TEST_F(TestResizeBilinearInt8, Bilinear0) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/resize_nearest_neighbor_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/resize_nearest_neighbor_int8_tests.cc index 1e577c41367..0ada23c4524 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/resize_nearest_neighbor_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/resize_nearest_neighbor_int8_tests.cc @@ -75,6 +75,8 @@ void TestResizeNearestNeighborInt8::Prepare(const std::vector &in_shape, co ctx_.thread_num_ = thread_num; ASSERT_EQ(lite::RET_OK, ctx_.Init()); kernel_ = creator_(inputs, outputs, reinterpret_cast(¶m_), &ctx_, desc_); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } void TestResizeNearestNeighborInt8::TearDown() { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/scale_int8.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/scale_int8.cc index f4138c8a533..64fc09845bf 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/scale_int8.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/scale_int8.cc @@ -95,6 +95,8 @@ void TestScaleInt8::Prepare(const std::vector &in_shape, int8_t *input_data ctx_.thread_num_ = thread_num_; ASSERT_EQ(lite::RET_OK, ctx_.Init()); kernel_ = creator_(inputs, outputs, reinterpret_cast(¶m_), &ctx_, desc_); + auto ret = kernel_->Init(); + EXPECT_EQ(0, ret); } TEST_F(TestScaleInt8, scale1) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/sigmoid_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/sigmoid_int8_tests.cc index 9bddfae9fd4..9fd1024f6be 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/sigmoid_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/sigmoid_int8_tests.cc @@ -58,7 +58,9 @@ TEST_F(TestSigmoidInt8, Sigmoid) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect[8] = {1, 1, 1, 1, 1, 1, 1, 1}; // 0, 0, -0.208333, 0, 2.29167, 3, 3.5, 6 diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/slice_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/slice_int8_tests.cc index d73466114d0..195ff30621d 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/slice_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/slice_int8_tests.cc @@ -62,7 +62,9 @@ TEST_F(TestSliceInt8, SliceInt8) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[12] = {16, 45, 67, -49, -115, 106, -98, 119, 103, 81, -114, 68}; @@ -112,7 +114,9 @@ TEST_F(TestSliceInt8, Slice5D) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[12] = {16, 45, 67, -49, -115, 106, -98, 119, 103, 81, -114, 68}; @@ -162,7 +166,9 @@ TEST_F(TestSliceInt8, Slice6D) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[12] = {16, 45, 67, -49, -115, 106, -98, 119, 103, 81, -114, 68}; @@ -212,7 +218,9 @@ TEST_F(TestSliceInt8, Slice7D) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[12] = {16, 45, 67, -49, -115, 106, -98, 119, 103, 81, -114, 68}; @@ -263,7 +271,9 @@ TEST_F(TestSliceInt8, Slice8D) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[12] = {16, 45, 67, -49, -115, 106, -98, 119, 103, 81, -114, 68}; @@ -314,7 +324,9 @@ TEST_F(TestSliceInt8, SliceDiffQuantArgs) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[12] = {8, 23, 34, -25, -58, 53, -49, 60, 52, 41, -57, 34}; @@ -367,7 +379,9 @@ TEST_F(TestSliceInt8, SliceSingleThread) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[12] = {16, 45, 67, -49, -115, 106, -98, 119, 103, 81, -114, 68}; @@ -419,7 +433,9 @@ TEST_F(TestSliceInt8, Slice4Thread) { ASSERT_EQ(lite::RET_OK, ctx->Init()); auto kernel = creator(inputs, outputs, reinterpret_cast(parameter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[12] = {16, 45, 67, -49, -115, 106, -98, 119, 103, 81, -114, 68}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/softmax_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/softmax_int8_tests.cc index dce28f289db..1f746960ab2 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/softmax_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/softmax_int8_tests.cc @@ -79,7 +79,10 @@ TEST_F(TestSoftmaxInt8, SoftmaxInt8) { auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast(&op_param), ctx.get(), desc); ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor.shape(); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {-126, -126, -124, -124, -123, -124, -116, -116, 122, 122, 112, 112, -127, -127, -127, -127, -59, -59, -61, -59, 58, 58, 59, 58}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/space_to_batch_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/space_to_batch_int8_tests.cc index 9bfd0de740f..96deb532e4e 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/space_to_batch_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/space_to_batch_int8_tests.cc @@ -45,7 +45,9 @@ TEST_F(SpaceToBatchTestInt8, test1) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect[] = {0, 0, 0, 4, 0, 0, 3, 0, 0, 2, 0, 0, 1, 0, 0, 0}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/split_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/split_int8_tests.cc index 87b222a9205..4be6a75d889 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/split_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/split_int8_tests.cc @@ -91,7 +91,10 @@ TEST_F(TestSplitInt8, Split_quant0_thread2) { auto output2_tensor_shape = output2_tensor->shape(); ASSERT_EQ(output1_tensor_shape, output1_shape); ASSERT_EQ(output2_tensor_shape, output2_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result1 = {1, 2, 7, 8}; std::vector except_result2 = {3, 4, 5, 6, 9, 10, 11, 12}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/squeeze_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/squeeze_int8_tests.cc index 8e3facdbcde..395ac993592 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/squeeze_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/squeeze_int8_tests.cc @@ -75,7 +75,10 @@ TEST_F(TestSqueezeInt8, Squeeze_1d_axis0_offset0_quant0_thread2) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 3, 4, 5, 6, 7, 8}; PrintData("output data", output, output_size); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/sub_int_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/sub_int_tests.cc index 4ccd6a976cd..fab5700a36f 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/sub_int_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/sub_int_tests.cc @@ -62,7 +62,9 @@ TEST_F(TestSubInt8, SubInt8) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[10] = {81, 73, 88, -106, 35, 75, 54, 127, -39, 49}; @@ -109,7 +111,9 @@ TEST_F(TestSubInt8, SubInt8T2) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), ctx.get(), desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[10] = {0, 0, 0, 0, 0, 5, 5, 5, 5, 5}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/topk_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/topk_int8_tests.cc index 32c8829dcf4..246078b8c40 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/topk_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/topk_int8_tests.cc @@ -49,7 +49,9 @@ TEST_F(TestTopKInt8, TopK) { auto kernel = creator(inputs, outputs, reinterpret_cast(¶meter), nullptr, desc); ASSERT_NE(kernel, nullptr); - auto ret = kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); EXPECT_EQ(0, ret); int8_t expect0[] = {3, 2, 6, 5, 9, 8, 12, 11}; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/unsqueeze_int8_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/unsqueeze_int8_tests.cc index 5a39b6a8de0..910a74f3f8b 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/unsqueeze_int8_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/unsqueeze_int8_tests.cc @@ -77,7 +77,10 @@ TEST_F(TestUnsqueezeInt8, Unsqueeze_1) { ASSERT_NE(kernel, nullptr); auto output_tensor_shape = output0_tensor->shape(); ASSERT_EQ(output_tensor_shape, output_shape); - kernel->Run(); + auto ret = kernel->Init(); + EXPECT_EQ(0, ret); + ret = kernel->Run(); + EXPECT_EQ(0, ret); std::vector except_result = {1, 2, 3, 4, 5, 6, 7, 8}; PrintData("output data", output, output_size); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/opencl/common.cc b/mindspore/lite/test/ut/src/runtime/kernel/opencl/common.cc index 1188175c1ff..3b4c545d9ae 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/opencl/common.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/opencl/common.cc @@ -119,6 +119,12 @@ void TestMain(const std::vector &input_infos, const std::vec free(op_parameter); FAIL(); } + auto ret = inner_kernel->Init(); + if (ret != RET_OK) { + std::cerr << "kernel init failed."; + free(op_parameter); + FAIL(); + } std::shared_ptr shared_kernel(inner_kernel); auto *kernel = new (std::nothrow) kernel::LiteKernel(shared_kernel); if (kernel == nullptr) { @@ -278,6 +284,12 @@ void TestMain(const std::vector &input_infos, std::tupleInit(); + if (ret != RET_OK) { + std::cerr << "kernel init failed."; + free(op_parameter); + FAIL(); + } inner_kernel->set_registry_data_type(key.data_type); std::shared_ptr shared_kernel(inner_kernel); auto *kernel = new (std::nothrow) kernel::LiteKernel(shared_kernel); diff --git a/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc b/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc index 02587eb027b..47d592d9afc 100644 --- a/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc @@ -179,6 +179,12 @@ kernel::LiteKernel *GetLiteKernel(std::vector inputs, std::vectorInit(); + if (ret != lite::RET_OK) { + MS_LOG(ERROR) << "init failed."; + free(parameter); + return nullptr; + } return lite_kernel; }