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

!10269 npu solve memory leak 

From: @yeyunpeng2020
Reviewed-by: 
Signed-off-by:
This commit is contained in:
mindspore-ci-bot 2020-12-21 22:42:13 +08:00 committed by Gitee
parent c6aa54ee0e 7d61b0f826
commit 8c7b616992
48 changed files with 497 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -30,6 +30,7 @@
#include "src/runtime/kernel/arm/base/dequant.h"
#if SUPPORT_NPU
#include "src/runtime/agent/npu/npu_manager.h"
#include "src/runtime/agent/npu/optimizer/npu_pass_manager.h"
#endif
namespace mindspore {
@ -366,7 +367,7 @@ int LiteSession::CompileGraph(Model *model) {
return ret;
}
// scheduler kernels
Scheduler scheduler(context_, model, tensors_);
Scheduler scheduler(context_, model, &tensors_);
ret = scheduler.Schedule(&kernels_);
if (ret != RET_OK) {
MS_LOG(ERROR) << "Schedule kernels failed: " << ret;
@ -537,6 +538,10 @@ LiteSession::~LiteSession() {
delete this->context_;
delete this->executor_;
this->executor_ = nullptr;
#if SUPPORT_NPU
mindspore::lite::NPUPassManager::GetInstance()->Clear();
mindspore::lite::NPUManager::GetInstance()->Reset();
#endif
is_running_.store(false);
}

3
mindspore/lite/src/runtime/agent/npu/CMakeLists.txt
View File

@ -1,9 +1,8 @@
include_directories(${DDK_PATH})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/kernel)
file(GLOB_RECURSE NPU_RUNTIME_SRC
${CMAKE_CURRENT_SOURCE_DIR}/*.cc
${CMAKE_CURRENT_SOURCE_DIR}/../../kernel/npu/*.cc
${CMAKE_CURRENT_SOURCE_DIR}/optimizer/*.cc
)
add_library(hiai SHARED IMPORTED)
set_target_properties(hiai PROPERTIES IMPORTED_LOCATION

24
mindspore/lite/src/runtime/agent/npu/npu_executor.cc
View File

@ -17,6 +17,7 @@
#include "src/runtime/agent/npu/npu_executor.h"
#include "include/errorcode.h"
#include "src/runtime/agent/npu/npu_manager.h"
#include "nnacl/pack.h"
namespace mindspore::lite {
int NPUExecutor::Prepare(const std::vector<kernel::LiteKernel *> &kernels) {
this->client_ = mindspore::lite::NPUManager::GetInstance()->GetClient(model_name_);
@ -32,6 +33,7 @@ int NPUExecutor::Prepare(const std::vector<kernel::LiteKernel *> &kernels) {
}
int NPUExecutor::Run(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
const std::vector<kernel::LiteKernel *> &out_kernels,
const std::vector<kernel::LiteKernel *> &kernels, Allocator *allocator,
const KernelCallBack &before, const KernelCallBack &after) {
hiai::AiContext context;
@ -63,14 +65,32 @@ int NPUExecutor::Run(const std::vector<Tensor *> &in_tensors, const std::vector<
return RET_ERROR;
}
// For the output kernel of the entire model, and the format is nchw, the output tensor needs to be nchw TO nhwc.
std::vector<Tensor *> trans_tensors;
for (auto kernel : out_kernels) {
if (kernel->out_kernels().empty() && npu_trans_nodes.find(kernel->Type()) != npu_trans_nodes.end()) {
for (int i = 0; i < kernel->out_tensors().size(); ++i) {
trans_tensors.push_back(kernel->out_tensors()[i]);
}
}
}
for (int i = 0; i < npu_output_tensors_.size(); ++i) {
void *data = out_tensors[i]->MutableData();
if (data == nullptr) {
MS_LOG(ERROR) << "Malloc buffer failed.";
return RET_ERROR;
}
memcpy(data, npu_output_tensors_[i]->GetBuffer(), npu_output_tensors_[i]->GetSize());
out_tensors[i]->ResetRefCount();
if (std::find(trans_tensors.begin(), trans_tensors.end(), out_tensors[i]) != trans_tensors.end()) {
// Change data&tensor shape nc->nh
PackNCHWToNHWCFp32(npu_output_tensors_[i]->GetBuffer(), data, out_tensors[i]->Batch(),
out_tensors[i]->Width() * out_tensors[i]->Height(), out_tensors[i]->Channel());
out_tensors[i]->set_shape({out_tensors[i]->shape()[0], out_tensors[i]->shape()[2], out_tensors[i]->shape()[3],
out_tensors[i]->shape()[1]});
} else {
memcpy(data, npu_output_tensors_[i]->GetBuffer(), npu_output_tensors_[i]->GetSize());
out_tensors[i]->ResetRefCount();
}
}
return RET_OK;
}

5
mindspore/lite/src/runtime/agent/npu/npu_executor.h
View File

@ -32,8 +32,9 @@ class NPUExecutor : public Executor {
int Prepare(const std::vector<kernel::LiteKernel *> &kernels) override;
int Run(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
const std::vector<kernel::LiteKernel *> &kernels, Allocator *allocator = nullptr,
const KernelCallBack &before = nullptr, const KernelCallBack &after = nullptr);
const std::vector<kernel::LiteKernel *> &out_kernels, const std::vector<kernel::LiteKernel *> &kernels,
Allocator *allocator = nullptr, const KernelCallBack &before = nullptr,
const KernelCallBack &after = nullptr);
private:
int GetIOTensorVec();

144
mindspore/lite/src/runtime/agent/npu/npu_manager.cc
View File

@ -55,6 +55,26 @@ bool NPUManager::CheckEMUIVersion() {
return true;
}
void NPUManager::Reset() {
index_ = 0;
domi::HiaiIrBuild ir_build;
for (const auto &model_map : models_) {
auto model = model_map.second;
if (!model->is_freed) {
ir_build.ReleaseModelBuff(*model->model_buffer_data_);
model->model_buffer_data_ = nullptr;
model->is_freed = true;
model->desc_.reset();
model->desc_ = nullptr;
}
}
models_.clear();
for (auto client : clients_) {
client.reset();
}
clients_.clear();
}
bool NPUManager::CheckDDKVersion() {
auto client = std::make_shared<hiai::AiModelMngerClient>();
if (client->GetVersion() != nullptr) {
@ -104,54 +124,102 @@ bool NPUManager::IsKirinChip() {
return false;
}
int NPUManager::AddModel(void *model_buf, uint32_t size, const std::string &model_name, int frequency) {
hiai::MemBuffer *buffer = mc_builder_->InputMemBufferCreate(model_buf, size);
if (buffer == nullptr) {
MS_LOG(ERROR) << "MemBuffer is null.";
return RET_ERROR;
}
int NPUManager::AddModel(domi::ModelBufferData *model_buffer_data, const std::string &model_name, int frequency) {
auto model = new SubGraphModel(index_, model_name, model_buffer_data, frequency);
auto desc = std::make_shared<hiai::AiModelDescription>(model_name, frequency, 0, 0, 0);
desc->SetModelBuffer(buffer->GetMemBufferData(), buffer->GetMemBufferSize());
model_desc_.push_back(desc);
mc_builder_->MemBufferDestroy(buffer);
model_map_.insert({model_name, index_});
model->desc_ = desc;
models_.insert({model_name, model});
index_++;
return RET_OK;
}
int NPUManager::LoadOMModel() {
for (int i = 0; i < index_ / MAX_MODEL_NUM + 1; i++) {
auto client = std::make_shared<hiai::AiModelMngerClient>();
if (client == nullptr) {
MS_LOG(ERROR) << "NPU client is nullptr.";
return RET_ERROR;
}
int ret = client->Init(nullptr);
if (ret != hiai::AI_SUCCESS) {
MS_LOG(ERROR) << "NPU client init failed. code is " << ret;
return RET_ERROR;
}
mc_builder_ = std::make_shared<hiai::AiModelBuilder>(client);
vector<std::shared_ptr<hiai::AiModelDescription>> desc(model_desc_.begin() + i * MAX_MODEL_NUM,
((i + 1) * MAX_MODEL_NUM > index_)
? model_desc_.begin() + index_
: model_desc_.begin() + (i + 1) * MAX_MODEL_NUM);
ret = client->Load(desc);
if (ret != hiai::AI_SUCCESS) {
MS_LOG(ERROR) << "Client load model failed." << ret;
return RET_ERROR;
}
clients_.push_back(client);
std::shared_ptr<hiai::AiModelMngerClient> NPUManager::CreateAiModelMngerClient() {
auto client = std::make_shared<hiai::AiModelMngerClient>();
if (client == nullptr) {
MS_LOG(ERROR) << "NPU client is nullptr.";
return nullptr;
}
int ret = client->Init(nullptr);
if (ret != hiai::AI_SUCCESS) {
MS_LOG(ERROR) << "NPU client init failed. code is " << ret;
return nullptr;
}
return client;
}
int NPUManager::LoadOMModel() {
std::vector<std::shared_ptr<hiai::AiModelDescription>> models_desc;
std::shared_ptr<hiai::AiModelMngerClient> client = nullptr;
std::shared_ptr<hiai::AiModelBuilder> mc_builder = nullptr;
int total = 0;
for (const auto &model_map : models_) {
if (total % MAX_MODEL_NUM == 0) {
client = CreateAiModelMngerClient();
if (client == nullptr) {
MS_LOG(ERROR) << "Create Client failed.";
return RET_ERROR;
}
mc_builder = std::make_shared<hiai::AiModelBuilder>(client);
if (mc_builder == nullptr) {
MS_LOG(ERROR) << "Create AiModelBuilder failed.";
return RET_ERROR;
}
}
total++;
auto model = model_map.second;
if (model->is_loaded && model->is_freed) {
continue;
}
models_desc.push_back(model->desc_);
auto buffer = mc_builder->InputMemBufferCreate(model->model_buffer_data_->data, model->model_buffer_data_->length);
if (buffer == nullptr) {
MS_LOG(ERROR) << "NPU input memory buffer create failed.";
return RET_ERROR;
}
model->desc_->SetModelBuffer(model->model_buffer_data_->data, model->model_buffer_data_->length);
if (models_desc.size() == MAX_MODEL_NUM) {
auto ret = LoadModel(client, models_desc);
if (ret != RET_ERROR) {
MS_LOG(ERROR) << "Client load model failed.";
return RET_ERROR;
}
models_desc.clear();
}
}
if (!models_desc.empty()) {
auto ret = LoadModel(client, models_desc);
if (ret != RET_OK) {
MS_LOG(ERROR) << "Client load model failed.";
return RET_ERROR;
}
models_desc.clear();
}
return RET_OK;
}
std::shared_ptr<hiai::AiModelMngerClient> NPUManager::GetClient(const std::string &model_name) {
return clients_[model_map_[model_name] / MAX_MODEL_NUM];
return models_[model_name]->client_;
}
int NPUManager::index() const { return index_; }
int NPUManager::LoadModel(const std::shared_ptr<hiai::AiModelMngerClient> &client,
std::vector<std::shared_ptr<hiai::AiModelDescription>> desc_list) {
auto ret = client->Load(desc_list);
if (ret != hiai::AI_SUCCESS) {
MS_LOG(ERROR) << "Client load model failed." << ret;
return RET_ERROR;
}
for (const auto &desc : desc_list) {
MS_LOG(ERROR) << desc->GetName();
auto it = models_.find(desc->GetName());
it->second->is_loaded = true;
it->second->client_ = client;
}
this->clients_.push_back(client);
return RET_OK;
}
} // namespace mindspore::lite

40
mindspore/lite/src/runtime/agent/npu/npu_manager.h
View File

@ -18,9 +18,11 @@
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_MANAGER_H_
#include <string>
#include <memory>
#include <utility>
#include <vector>
#include <unordered_map>
#include <set>
#include "include/hiai_ir_build.h"
#include "schema/model_generated.h"
#include "include/HiAiModelManagerService.h"
@ -29,17 +31,34 @@ static std::set<mindspore::schema::PrimitiveType> npu_trans_nodes = {
schema::PrimitiveType_Conv2D, schema::PrimitiveType_DeConv2D,
schema::PrimitiveType_DepthwiseConv2D, schema::PrimitiveType_DeDepthwiseConv2D,
schema::PrimitiveType_Resize, schema::PrimitiveType_Pooling};
struct SubGraphModel {
public:
SubGraphModel(int index, std::string model_name, domi::ModelBufferData *model_buffer_data, int frequency)
: index_(index), model_name_(std::move(model_name)), model_buffer_data_(model_buffer_data) {
std::cout << model_name;
}
bool is_freed = false;
bool is_loaded = false;
int index_;
std::string model_name_;
domi::ModelBufferData *model_buffer_data_;
std::shared_ptr<hiai::AiModelMngerClient> client_;
std::shared_ptr<hiai::AiModelDescription> desc_;
};
class NPUManager {
public:
static NPUManager *GetInstance() {
static NPUManager npuManager;
return &npuManager;
static NPUManager manager;
return &manager;
}
~NPUManager() { Reset(); }
bool IsSupportNPU();
// provide to subgraph to add model.
int AddModel(void *model_buf, uint32_t size, const std::string &model_name, int frequency);
int AddModel(domi::ModelBufferData *model_buffer_data, const std::string &model_name, int frequency);
// scheduler to load om model.
int LoadOMModel();
@ -49,6 +68,11 @@ class NPUManager {
int index() const;
void Reset();
int LoadModel(const std::shared_ptr<hiai::AiModelMngerClient> &client,
std::vector<std::shared_ptr<hiai::AiModelDescription>> desc_list);
private:
bool IsKirinChip();
@ -58,16 +82,12 @@ class NPUManager {
int CompareVersion(const std::string &version1, const std::string &version2);
std::shared_ptr<hiai::AiModelMngerClient> CreateAiModelMngerClient();
private:
int index_ = 0;
std::unordered_map<std::string, SubGraphModel *> models_;
std::vector<std::shared_ptr<hiai::AiModelMngerClient>> clients_;
std::vector<std::shared_ptr<hiai::AiModelDescription>> model_desc_;
std::shared_ptr<hiai::AiModelBuilder> mc_builder_ = nullptr;
std::unordered_map<std::string, int> model_map_;
};
} // namespace mindspore::lite

19
mindspore/lite/src/runtime/agent/npu/npu_add_transform_pass.cc → mindspore/lite/src/runtime/agent/npu/optimizer/npu_add_transform_pass.cc
View File

@ -13,8 +13,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "src/runtime/agent/npu/npu_add_transform_pass.h"
#include "src/runtime/agent/npu/npu_pass_utils.h"
#include "src/runtime/agent/npu/optimizer/npu_add_transform_pass.h"
#include "src/runtime/agent/npu/optimizer/npu_pass_utils.h"
namespace mindspore::lite {
using kernel::KERNEL_ARCH::kNPU;
int NPUAddTransformPass::UpdateNH2NCTransNodePreKernel(kernel::LiteKernel *kernel, kernel::LiteKernel *trans_kernel,
@ -56,9 +56,11 @@ int NPUAddTransformPass::InsertNode(const InnerContext *context, std::vector<ker
auto nh2nc_name = kernel->name() + "_nh2nc_" + std::to_string(total++);
auto *nh2nc_kernel = NPUPassUtils::CreateNhwc2NchwKernel(kernel->out_tensors(), nh2nc_tensors, context, nh2nc_name);
all_kernels->push_back(nh2nc_kernel);
insert_primitive_.push_back(nh2nc_kernel->GetPrimitive());
auto nc2nh_name = kernel->name() + "_nc2nh_" + std::to_string(total++);
auto *nc2nh_kernel = NPUPassUtils::CreateNchw2NhwcKernel(nh2nc_tensors, nc2nh_tensors, context, nc2nh_name);
all_kernels->push_back(nc2nh_kernel);
insert_primitive_.push_back(nc2nh_kernel->GetPrimitive());
NPUPassUtils::UpdateKernel(nh2nc_kernel, {kernel}, {nc2nh_kernel}, kernel->out_tensors(), nh2nc_tensors);
NPUPassUtils::UpdateKernel(nc2nh_kernel, {nh2nc_kernel}, {out_kernel}, nh2nc_tensors, nc2nh_tensors);
UpdateNH2NCTransNodePreKernel(kernel, nh2nc_kernel, out_kernel);
@ -91,12 +93,11 @@ int NPUAddTransformPass::UpdateNC2NHTransNodeAfterKernel(kernel::LiteKernel *ker
return RET_OK;
}
int NPUAddTransformPass::Run(const InnerContext *context, std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors) {
if (context->IsNpuEnabled()) {
int NPUAddTransformPass::Run() {
if (context_->IsNpuEnabled()) {
std::vector<kernel::LiteKernel *> new_kernels;
for (auto it = all_kernels->begin(); it != all_kernels->end(); it++) {
for (auto it = all_kernels_->begin(); it != all_kernels_->end(); it++) {
auto kernel = *it;
new_kernels.push_back(kernel);
if (kernel->desc().arch != kNPU) {
@ -110,14 +111,14 @@ int NPUAddTransformPass::Run(const InnerContext *context, std::vector<kernel::Li
}
}
if (kernel->out_kernels().size() != sum) {
InsertNode(context, it, &new_kernels, all_tensors);
InsertNode(context_, it, &new_kernels, all_tensors_);
}
}
}
all_kernels->clear();
all_kernels_->clear();
for (int i = 0; i < new_kernels.size(); i++) {
all_kernels->push_back(new_kernels[i]);
all_kernels_->push_back(new_kernels[i]);
}
}
return RET_OK;

29
mindspore/lite/src/runtime/agent/npu/npu_add_transform_pass.h → mindspore/lite/src/runtime/agent/npu/optimizer/npu_add_transform_pass.h
View File

@ -14,16 +14,29 @@
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_ADD_TRANSFORM_PASS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_ADD_TRANSFORM_PASS_H_
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_ADD_TRANSFORM_PASS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_ADD_TRANSFORM_PASS_H_
#include <vector>
#include "src/lite_kernel.h"
#include "src/ops/primitive_c.h"
#include "src/runtime/agent/npu/optimizer/npu_base_pass.h"
namespace mindspore::lite {
class NPUAddTransformPass {
class NPUAddTransformPass : public NPUBasePass {
public:
int Run(const InnerContext *context, std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors);
explicit NPUAddTransformPass(const InnerContext *context, std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors) {
context_ = context;
all_kernels_ = all_kernels;
all_tensors_ = all_tensors;
name_ = "NPUConcatTransformPass";
}
~NPUAddTransformPass() override {
for (auto primitive : insert_primitive_) {
delete primitive;
}
insert_primitive_.clear();
}
int Run() override;
private:
int UpdateNH2NCTransNodePreKernel(kernel::LiteKernel *kernel, kernel::LiteKernel *trans_kernel,
@ -37,6 +50,10 @@ class NPUAddTransformPass {
private:
int total = 0;
const InnerContext *context_;
std::vector<kernel::LiteKernel *> *all_kernels_;
std::vector<const PrimitiveC *> insert_primitive_;
std::vector<Tensor *> *all_tensors_;
};
} // namespace mindspore::lite
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_ADD_TRANSFORM_PASS_H_
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_ADD_TRANSFORM_PASS_H_

34
mindspore/lite/src/runtime/agent/npu/optimizer/npu_base_pass.h Normal file
View File

@ -0,0 +1,34 @@
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_BASE_PASS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_BASE_PASS_H_
#include <string>
namespace mindspore::lite {
class NPUBasePass {
public:
virtual int Run() = 0;
virtual ~NPUBasePass() = default;
std::string name() { return name_; }
protected:
std::string name_;
};
} // namespace mindspore::lite
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_BASE_PASS_H_

19
mindspore/lite/src/runtime/agent/npu/npu_concat_transform_pass.cc → mindspore/lite/src/runtime/agent/npu/optimizer/npu_concat_transform_pass.cc
View File

@ -13,8 +13,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "src/runtime/agent/npu/npu_concat_transform_pass.h"
#include "src/runtime/agent/npu/npu_pass_utils.h"
#include "src/runtime/agent/npu/optimizer/npu_concat_transform_pass.h"
#include "src/runtime/agent/npu/optimizer/npu_pass_utils.h"
namespace mindspore::lite {
using kernel::KERNEL_ARCH::kNPU;
int NPUConcatTransformPass::UpdateNH2NCTransNodePreKernel(kernel::LiteKernel *kernel, kernel::LiteKernel *trans_kernel,
@ -54,9 +54,11 @@ int NPUConcatTransformPass::InsertNode(const InnerContext *context, std::vector<
auto nh2nc_name = kernel->name() + "_nh2nc_" + std::to_string(total++);
auto *nh2nc_kernel = NPUPassUtils::CreateNhwc2NchwKernel(kernel->out_tensors(), nh2nc_tensors, context, nh2nc_name);
all_kernels->push_back(nh2nc_kernel);
insert_primitive_.push_back(nh2nc_kernel->GetPrimitive());
auto nc2nh_name = kernel->name() + "_nc2nh_" + std::to_string(total++);
auto *nc2nh_kernel = NPUPassUtils::CreateNchw2NhwcKernel(nh2nc_tensors, nc2nh_tensors, context, nc2nh_name);
all_kernels->push_back(nc2nh_kernel);
insert_primitive_.push_back(nc2nh_kernel->GetPrimitive());
NPUPassUtils::UpdateKernel(nh2nc_kernel, {kernel}, {nc2nh_kernel}, kernel->out_tensors(), nh2nc_tensors);
NPUPassUtils::UpdateKernel(nc2nh_kernel, {nh2nc_kernel}, {out_kernel}, nh2nc_tensors, nc2nh_tensors);
UpdateNH2NCTransNodePreKernel(kernel, nh2nc_kernel, out_kernel);
@ -90,12 +92,11 @@ int NPUConcatTransformPass::UpdateNC2NHTransNodeAfterKernel(kernel::LiteKernel *
return RET_OK;
}
int NPUConcatTransformPass::Run(const InnerContext *context, std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors) {
if (context->IsNpuEnabled()) {
int NPUConcatTransformPass::Run() {
if (context_->IsNpuEnabled()) {
std::vector<kernel::LiteKernel *> new_kernels;
for (auto it = all_kernels->begin(); it != all_kernels->end(); it++) {
for (auto it = all_kernels_->begin(); it != all_kernels_->end(); it++) {
auto kernel = *it;
if (kernel->desc().arch != kNPU) {
new_kernels.push_back(kernel);
@ -109,15 +110,15 @@ int NPUConcatTransformPass::Run(const InnerContext *context, std::vector<kernel:
}
}
if (kernel->out_kernels().size() != sum) {
InsertNode(context, it, &new_kernels, all_tensors);
InsertNode(context_, it, &new_kernels, all_tensors_);
}
}
new_kernels.push_back(kernel);
}
all_kernels->clear();
all_kernels_->clear();
for (int i = 0; i < new_kernels.size(); i++) {
all_kernels->push_back(new_kernels[i]);
all_kernels_->push_back(new_kernels[i]);
}
}
return RET_OK;

29
mindspore/lite/src/runtime/agent/npu/npu_concat_transform_pass.h → mindspore/lite/src/runtime/agent/npu/optimizer/npu_concat_transform_pass.h
View File

@ -14,16 +14,29 @@
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_CONCAT_TRANSFORM_PASS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_CONCAT_TRANSFORM_PASS_H_
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_CONCAT_TRANSFORM_PASS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_CONCAT_TRANSFORM_PASS_H_
#include <vector>
#include "src/lite_kernel.h"
#include "src/ops/primitive_c.h"
#include "src/runtime/agent/npu/optimizer/npu_base_pass.h"
namespace mindspore::lite {
class NPUConcatTransformPass {
class NPUConcatTransformPass : public NPUBasePass {
public:
int Run(const InnerContext *context, std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors);
explicit NPUConcatTransformPass(const InnerContext *context, std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors) {
context_ = context;
all_kernels_ = all_kernels;
all_tensors_ = all_tensors;
name_ = "NPUConcatTransformPass";
}
~NPUConcatTransformPass() override {
for (auto primitive : insert_primitive_) {
delete primitive;
}
insert_primitive_.clear();
}
int Run() override;
private:
int UpdateNH2NCTransNodePreKernel(kernel::LiteKernel *kernel, kernel::LiteKernel *trans_kernel,
@ -37,6 +50,10 @@ class NPUConcatTransformPass {
private:
int total = 0;
const InnerContext *context_;
std::vector<kernel::LiteKernel *> *all_kernels_;
std::vector<Tensor *> *all_tensors_;
std::vector<const PrimitiveC *> insert_primitive_;
};
} // namespace mindspore::lite
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_CONCAT_TRANSFORM_PASS_H_
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_CONCAT_TRANSFORM_PASS_H_

4
mindspore/lite/src/runtime/agent/npu/npu_fusion_pass.cc → mindspore/lite/src/runtime/agent/npu/optimizer/npu_fusion_pass.cc
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "src/runtime/agent/npu/npu_fusion_pass.h"
#include "src/runtime/agent/npu/optimizer/npu_fusion_pass.h"
#include <vector>
#include "src/lite_kernel.h"
#include "nnacl/concat_parameter.h"
@ -198,7 +198,7 @@ int NPUFusionPass::FormatFusion(kernel::LiteKernel *kernel) {
return RET_OK;
}
int NPUFusionPass::Fusion() {
int NPUFusionPass::Run() {
for (auto kernel : *kernels) {
switch (kernel->Type()) {
case schema::PrimitiveType_Concat:

20
mindspore/lite/src/runtime/agent/npu/npu_fusion_pass.h → mindspore/lite/src/runtime/agent/npu/optimizer/npu_fusion_pass.h
View File

@ -14,17 +14,23 @@
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_FUSION_PASS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_FUSION_PASS_H_
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_FUSION_PASS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_FUSION_PASS_H_
#include <vector>
#include "src/lite_kernel.h"
#include "src/ops/primitive_c.h"
#include "src/runtime/agent/npu/optimizer/npu_base_pass.h"
namespace mindspore::lite {
class NPUFusionPass {
class NPUFusionPass : public NPUBasePass {
public:
explicit NPUFusionPass(std::vector<kernel::LiteKernel *> *dst_kernels) { kernels = dst_kernels; }
~NPUFusionPass() = default;
int Fusion();
explicit NPUFusionPass(std::vector<kernel::LiteKernel *> *dst_kernels) {
kernels = dst_kernels;
name_ = "NPUFusionPass";
}
~NPUFusionPass() override = default;
int Run() override;
protected:
int ConcatFusion(kernel::LiteKernel *kernel);
@ -37,4 +43,4 @@ class NPUFusionPass {
std::vector<kernel::LiteKernel *> *kernels;
};
} // namespace mindspore::lite
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_FUSION_PASS_H_
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_FUSION_PASS_H_

39
mindspore/lite/src/runtime/agent/npu/optimizer/npu_pass_manager.cc Normal file
View File

@ -0,0 +1,39 @@
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "src/runtime/agent/npu/optimizer/npu_pass_manager.h"
#include "include/errorcode.h"
#include "src/common/log_adapter.h"
namespace mindspore::lite {
void NPUPassManager::AddPass(NPUBasePass *pass) { all_pass_.push_back(pass); }
int NPUPassManager::Run() {
for (auto pass : all_pass_) {
auto ret = pass->Run();
if (ret != RET_OK) {
MS_LOG(ERROR) << "NPU Pass Run failed. Pass name is:" << pass->name();
return ret;
}
}
return RET_OK;
}
void NPUPassManager::Clear() {
for (auto pass : all_pass_) {
delete pass;
}
all_pass_.clear();
}
} // namespace mindspore::lite

41
mindspore/lite/src/runtime/agent/npu/optimizer/npu_pass_manager.h Normal file
View File

@ -0,0 +1,41 @@
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_PASS_MANAGER_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_PASS_MANAGER_H_
#include <vector>
#include "src/runtime/agent/npu/optimizer/npu_base_pass.h"
namespace mindspore::lite {
class NPUPassManager {
public:
static NPUPassManager *GetInstance() {
static NPUPassManager pass_manager;
return &pass_manager;
}
~NPUPassManager() { Clear(); }
void AddPass(NPUBasePass *pass);
int Run();
void Clear();
private:
std::vector<NPUBasePass *> all_pass_;
};
} // namespace mindspore::lite
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_PASS_MANAGER_H_

6
mindspore/lite/src/runtime/agent/npu/npu_pass_utils.cc → mindspore/lite/src/runtime/agent/npu/optimizer/npu_pass_utils.cc
View File

@ -17,7 +17,7 @@
#include "src/kernel_registry.h"
#include "src/ops/nhwc2nchw.h"
#include "src/ops/nchw2nhwc.h"
#include "src/runtime/agent/npu/npu_pass_utils.h"
#include "src/runtime/agent/npu/optimizer/npu_pass_utils.h"
namespace mindspore::lite {
using kernel::KERNEL_ARCH::kCPU;
using kernel::KERNEL_ARCH::kNPU;
@ -34,7 +34,7 @@ PrimitiveC *NPUPassUtils::CreateNchw2NhwcPrimitive() {
}
auto primitive_buf = reinterpret_cast<char *>(malloc(fbb.GetSize()));
if (primitive_buf == nullptr) {
MS_LOG(ERROR) << "Malloc primitive_buf_ failed.";
MS_LOG(ERROR) << "Malloc primitive buffer failed.";
fbb.Clear();
return nullptr;
}
@ -58,7 +58,7 @@ PrimitiveC *NPUPassUtils::CreateNhwc2NchwPrimitive() {
}
auto primitive_buf = reinterpret_cast<char *>(malloc(fbb.GetSize()));
if (primitive_buf == nullptr) {
MS_LOG(ERROR) << "Malloc primitive_buf_ failed.";
MS_LOG(ERROR) << "Malloc primitive buffer failed.";
fbb.Clear();
return nullptr;
}

6
mindspore/lite/src/runtime/agent/npu/npu_pass_utils.h → mindspore/lite/src/runtime/agent/npu/optimizer/npu_pass_utils.h
View File

@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_PASS_UTILS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_PASS_UTILS_H_
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_PASS_UTILS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_PASS_UTILS_H_
#include <vector>
#include <string>
#include "src/ops/primitive_c.h"
@ -41,4 +41,4 @@ class NPUPassUtils {
static PrimitiveC *CreateNhwc2NchwPrimitive();
};
} // namespace mindspore::lite
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_PASS_UTILS_H_
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_PASS_UTILS_H_

25
mindspore/lite/src/runtime/agent/npu/npu_transform_pass.cc → mindspore/lite/src/runtime/agent/npu/optimizer/npu_transform_pass.cc
View File

@ -13,11 +13,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "src/runtime/agent/npu/npu_transform_pass.h"
#include "src/runtime/agent/npu/optimizer/npu_transform_pass.h"
#include <vector>
#include "src/lite_kernel.h"
#include "src/runtime/agent/npu/npu_manager.h"
#include "src/runtime/agent/npu/npu_pass_utils.h"
#include "src/runtime/agent/npu/optimizer/npu_pass_utils.h"
namespace mindspore::lite {
using kernel::KERNEL_ARCH::kCPU;
using kernel::KERNEL_ARCH::kNPU;
@ -77,6 +77,7 @@ int NPUTransformPass::InsertPreNode(const InnerContext *context, std::vector<ker
NPUPassUtils::CreateNhwc2NchwKernel({kernel->in_tensors()[0]}, pre_trans_out_tensors, context, name);
// Insert Nhwc2Nchw into the front of the current queue
all_kernels->push_back(pre_trans_kernel);
insert_primitive_.push_back(pre_trans_kernel->GetPrimitive());
// Replace the output kernel of the previous node
std::vector<kernel::LiteKernel *> pre_trans_in_kernel;
if (is_input_kernel) {
@ -99,6 +100,10 @@ int NPUTransformPass::InsertPostNode(const InnerContext *context, std::vector<ke
std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors) {
auto kernel = *it;
// Model output does not insert operator
if (kernel->out_kernels().empty()) {
return RET_OK;
}
// Single output multiple references
for (int i = 0; i < kernel->out_kernels().size(); i++) {
auto next_kernel = kernel->out_kernels().at(i);
@ -118,6 +123,7 @@ int NPUTransformPass::InsertPostNode(const InnerContext *context, std::vector<ke
// Replace the input tensor of the next node
NPUPassUtils::UpdateKernel(post_trans_kernel, {kernel}, {next_kernel}, kernel->out_tensors(),
post_trans_out_tensors);
insert_primitive_.push_back(post_trans_kernel->GetPrimitive());
// Directly insert in the back, will not affect the topological sort
all_kernels->push_back(post_trans_kernel);
UpdateNC2NHTransNodePreKernel(kernel, post_trans_kernel, next_kernel);
@ -171,28 +177,27 @@ int NPUTransformPass::UpdateNC2NHTransNodeAfterKernel(kernel::LiteKernel *kernel
return RET_OK;
}
int NPUTransformPass::FormatTransformPass(const InnerContext *context, std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors) {
if (context->IsNpuEnabled()) {
int NPUTransformPass::Run() {
if (context_->IsNpuEnabled()) {
std::vector<kernel::LiteKernel *> new_kernels;
for (auto it = all_kernels->begin(); it != all_kernels->end(); it++) {
for (auto it = all_kernels_->begin(); it != all_kernels_->end(); it++) {
auto kernel = *it;
if (kernel->desc().arch != kNPU) {
new_kernels.push_back(kernel);
continue;
}
if (npu_trans_nodes.find(kernel->Type()) != npu_trans_nodes.end()) {
InsertPreNode(context, it, &new_kernels, all_tensors);
InsertPreNode(context_, it, &new_kernels, all_tensors_);
new_kernels.push_back(kernel);
InsertPostNode(context, it, &new_kernels, all_tensors);
InsertPostNode(context_, it, &new_kernels, all_tensors_);
} else {
new_kernels.push_back(kernel);
}
}
all_kernels->clear();
all_kernels_->clear();
for (int i = 0; i < new_kernels.size(); i++) {
all_kernels->push_back(new_kernels[i]);
all_kernels_->push_back(new_kernels[i]);
}
}
return RET_OK;

30
mindspore/lite/src/runtime/agent/npu/npu_transform_pass.h → mindspore/lite/src/runtime/agent/npu/optimizer/npu_transform_pass.h
View File

@ -14,16 +14,30 @@
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_TRANSFORM_PASS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_TRANSFORM_PASS_H_
#ifndef MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_TRANSFORM_PASS_H_
#define MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_TRANSFORM_PASS_H_
#include <vector>
#include "src/lite_kernel.h"
#include "src/ops/primitive_c.h"
#include "src/runtime/agent/npu/optimizer/npu_base_pass.h"
namespace mindspore::lite {
class NPUTransformPass {
class NPUTransformPass : public NPUBasePass {
public:
int FormatTransformPass(const InnerContext *context, std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors);
int Run() override;
explicit NPUTransformPass(const InnerContext *context, std::vector<kernel::LiteKernel *> *all_kernels,
std::vector<Tensor *> *all_tensors) {
context_ = context;
all_kernels_ = all_kernels;
all_tensors_ = all_tensors;
name_ = "NPUTransformPass";
}
~NPUTransformPass() override {
for (auto primitive : insert_primitive_) {
delete primitive;
}
insert_primitive_.clear();
}
private:
int UpdateNH2NCTransNodePreKernel(kernel::LiteKernel *kernel, kernel::LiteKernel *trans_kernel,
@ -46,6 +60,10 @@ class NPUTransformPass {
private:
int total = 0;
const InnerContext *context_;
std::vector<kernel::LiteKernel *> *all_kernels_;
std::vector<Tensor *> *all_tensors_;
std::vector<const PrimitiveC *> insert_primitive_;
};
} // namespace mindspore::lite
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_NPU_TRANSFORM_PASS_H_
#endif // MINDSPORE_LITE_SRC_RUNTIME_AGENT_NPU_OPTIMIZER_NPU_TRANSFORM_PASS_H_

14
mindspore/lite/src/runtime/agent/npu/subgraph_npu_kernel.cc
View File

@ -70,7 +70,7 @@ domi::ModelBufferData *SubGraphNpuKernel::BuildIRModel() {
}
int SubGraphNpuKernel::Run() {
return reinterpret_cast<lite::NPUExecutor *>(this->executor_)->Run(in_tensors_, out_tensors_, nodes_);
return reinterpret_cast<lite::NPUExecutor *>(this->executor_)->Run(in_tensors_, out_tensors_, out_kernels_, nodes_);
}
int SubGraphNpuKernel::BuildNPUInputOp() {
@ -159,17 +159,17 @@ int SubGraphNpuKernel::BuildNPUOutputOp() {
std::string SubGraphNpuKernel::GetOMModelName() { return this->name_ + ".om"; }
int SubGraphNpuKernel::Init() {
if (!isCompiled_) {
model_buffer_data_ = BuildIRModel();
if (model_buffer_data_ == nullptr) {
if (!is_compiled_) {
auto model_buffer_data = BuildIRModel();
if (model_buffer_data == nullptr) {
MS_LOG(ERROR) << "Build IR model failed.";
return RET_ERROR;
}
name_ = "kNpuSubGraph" + std::to_string(mindspore::lite::NPUManager::GetInstance()->index());
mindspore::lite::NPUManager::GetInstance()->AddModel(model_buffer_data_->data, model_buffer_data_->length,
GetOMModelName(), context_->GetNpuInfo().frequency_);
mindspore::lite::NPUManager::GetInstance()->AddModel(model_buffer_data, GetOMModelName(),
context_->GetNpuInfo().frequency_);
executor_ = new (std::nothrow) mindspore::lite::NPUExecutor(GetOMModelName());
@ -177,7 +177,7 @@ int SubGraphNpuKernel::Init() {
MS_LOG(ERROR) << "Create NPUExecutor failed.";
return RET_ERROR;
}
isCompiled_ = true;
is_compiled_ = true;
}
return RET_OK;
}

4
mindspore/lite/src/runtime/agent/npu/subgraph_npu_kernel.h
View File

@ -69,9 +69,7 @@ class SubGraphNpuKernel : public SubGraphKernel {
std::string GetOMModelName();
private:
bool isCompiled_ = false;
domi::ModelBufferData *model_buffer_data_;
bool is_compiled_ = false;
std::vector<ge::Operator> subgraph_input_op_;

13
mindspore/lite/src/runtime/kernel/npu/arithmetic_npu.cc
View File

@ -42,21 +42,14 @@ using mindspore::schema::PrimitiveType_Sub;
namespace mindspore::kernel {
int ArithmeticNPUKernel::IsSupport(const std::vector<lite::Tensor *> &inputs,
const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter) {
if (primitive_->Type() == PrimitiveType_Mul || primitive_->Type() == PrimitiveType_Div) {
if (primitive_->Type() == PrimitiveType_Mul || primitive_->Type() == PrimitiveType_Div ||
primitive_->Type() == PrimitiveType_Add || primitive_->Type() == PrimitiveType_Sub) {
if (inputs[0]->shape() != inputs[1]->shape()) {
MS_LOG(WARNING) << "For the two inputs, the corresponding dimensions must have the same value."
MS_LOG(WARNING) << name_ << " for the two inputs, the corresponding dimensions must have the same value."
<< " shape 1 is:" << inputs[0]->shape() << " shape 2 is:" << inputs[1]->shape();
return RET_ERROR;
}
}
if (primitive_->Type() == PrimitiveType_Add || primitive_->Type() == PrimitiveType_Sub) {
if (inputs[0]->shape().size() != inputs[1]->shape().size()) {
MS_LOG(WARNING)
<< "For the two inputs, the corresponding dimensions must have the same value, or one of them is 1."
<< " shape 1 is:" << inputs[0]->shape() << " shape 2 is:" << inputs[1]->shape();
return RET_ERROR;
}
}
return RET_OK;
}

4
mindspore/lite/src/runtime/kernel/npu/cast_npu.cc
View File

@ -35,8 +35,8 @@ int CastNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, const
return RET_ERROR;
}
op_->set_input_x(*npu_inputs[0]);
op_->set_attr_dst_dtype(lite::ConverterToNPUDataType(dst_type_));
op_->set_attr_src_dtype(lite::ConverterToNPUDataType(src_type_));
op_->set_attr_dst_dtype(lite::ConverterToNPUDataType(static_cast<TypeId>(cast_parameter_->dst_type_)));
op_->set_attr_src_dtype(lite::ConverterToNPUDataType(static_cast<TypeId>(cast_parameter_->src_type_)));
return RET_OK;
}

7
mindspore/lite/src/runtime/kernel/npu/cast_npu.h
View File

@ -27,9 +27,7 @@ class CastNPUKernel : public NPUKernel {
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {
auto cast_parameter = reinterpret_cast<CastParameter *>(parameter);
dst_type_ = static_cast<TypeId>(cast_parameter->dst_type_);
src_type_ = static_cast<TypeId>(cast_parameter->src_type_);
cast_parameter_ = reinterpret_cast<CastParameter *>(parameter);
}
~CastNPUKernel() override;
@ -41,8 +39,7 @@ class CastNPUKernel : public NPUKernel {
private:
hiai::op::CastT *op_ = nullptr;
TypeId dst_type_;
TypeId src_type_;
CastParameter *cast_parameter_;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_CAST_NPU_H_

2
mindspore/lite/src/runtime/kernel/npu/convolution_base_npu.h
View File

@ -18,8 +18,8 @@
#include <vector>
#include <memory>
#include "src/runtime/kernel/npu/npu_kernel.h"
#include "include/graph/op/all_ops.h"
#include "src/runtime/kernel/npu/transpose_base_npu.h"
#include "nnacl/conv_parameter.h"
namespace mindspore::kernel {

2
mindspore/lite/src/runtime/kernel/npu/convolution_npu.cc
View File

@ -30,7 +30,7 @@ int ConvolutionNPUKernel::IsSupport(const std::vector<lite::Tensor *> &inputs,
int ConvolutionNPUKernel::SetConvParam() {
conv_->set_attr_strides(ge::AttrValue::LIST_INT({conv_param_->stride_h_, conv_param_->stride_w_}));
conv_->set_attr_dilations(ge::AttrValue::LIST_INT({conv_param_->dilation_h_, conv_param_->dilation_w_}));
conv_->set_attr_groups(1);
conv_->set_attr_groups(conv_param_->group_);
if (conv_param_->pad_mode_ == Pad_Same) {
conv_->set_attr_pad_mode(ge::AttrValue::STR{"SAME"});

2
mindspore/lite/src/runtime/kernel/npu/gather_npu.cc
View File

@ -41,7 +41,7 @@ int GatherNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, con
op_->set_input_x(*npu_inputs[0]);
op_->set_input_indices(*npu_inputs[1]);
op_->set_attr_axis(axis_);
op_->set_attr_axis(gather_parameter_->axis_);
return RET_OK;
}

5
mindspore/lite/src/runtime/kernel/npu/gather_npu.h
View File

@ -27,8 +27,7 @@ class GatherNPUKernel : public NPUKernel {
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {
auto gather_parameter = reinterpret_cast<GatherParameter *>(parameter);
axis_ = gather_parameter->axis_;
gather_parameter_ = reinterpret_cast<GatherParameter *>(parameter);
}
~GatherNPUKernel() override;
@ -40,7 +39,7 @@ class GatherNPUKernel : public NPUKernel {
private:
hiai::op::GatherV2D *op_ = nullptr;
int axis_;
GatherParameter *gather_parameter_;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_GATHER_NPU_H_

4
mindspore/lite/src/runtime/kernel/npu/matmul_npu.cc
View File

@ -33,8 +33,8 @@ int MatMulNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, con
op_->set_input_x1(*npu_inputs[0]);
op_->set_input_x2(*npu_inputs[1]);
op_->set_attr_transpose_x1(a_transpose_);
op_->set_attr_transpose_x2(b_transpose_);
op_->set_attr_transpose_x1(matmul_parameter_->a_transpose_);
op_->set_attr_transpose_x2(matmul_parameter_->b_transpose_);
return RET_OK;
}

7
mindspore/lite/src/runtime/kernel/npu/matmul_npu.h
View File

@ -28,9 +28,7 @@ class MatMulNPUKernel : public NPUKernel {
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {
auto matmul_parameter = reinterpret_cast<MatMulParameter *>(parameter);
a_transpose_ = matmul_parameter->a_transpose_;
b_transpose_ = matmul_parameter->b_transpose_;
matmul_parameter_ = reinterpret_cast<MatMulParameter *>(parameter);
}
~MatMulNPUKernel() override;
@ -42,8 +40,7 @@ class MatMulNPUKernel : public NPUKernel {
private:
hiai::op::MatMul *op_ = nullptr;
bool a_transpose_ = false;
bool b_transpose_ = false;
MatMulParameter *matmul_parameter_;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_MATMUL_NPU_H_

5
mindspore/lite/src/runtime/kernel/npu/npu_kernel.h
View File

@ -53,6 +53,11 @@ kernel::LiteKernel *NPUKernelCreator(const std::vector<lite::Tensor *> &inputs,
const std::vector<lite::Tensor *> &outputs, OpParameter *opParameter,
const lite::InnerContext *ctx, const kernel::KernelKey &desc,
const mindspore::lite::PrimitiveC *primitive) {
if (!primitive->infer_flag()) {
MS_LOG(ERROR) << "NPU does not support runtime inference shape";
return nullptr;
}
auto *kernel = new (std::nothrow) T(opParameter, inputs, outputs, ctx, primitive);
if (kernel == nullptr) {
MS_LOG(ERROR) << "kernel " << opParameter->name_ << "is nullptr.";

8
mindspore/lite/src/runtime/kernel/npu/pad_npu.cc
View File

@ -25,7 +25,7 @@ using mindspore::schema::PrimitiveType_Pad;
namespace mindspore::kernel {
int PadNPUKernel::IsSupport(const std::vector<lite::Tensor *> &inputs, const std::vector<lite::Tensor *> &outputs,
OpParameter *opParameter) {
if (padding_mode_ != schema::PaddingMode_CONSTANT) {
if (pad_->GetPaddingMode() != schema::PaddingMode_CONSTANT) {
MS_LOG(WARNING) << "NPU only support CONSTANT padding mode";
return RET_ERROR;
}
@ -39,16 +39,16 @@ int PadNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, const
MS_LOG(ERROR) << name_ << " op is nullptr";
return RET_ERROR;
}
int size = static_cast<int>(paddings_.size() / 2);
int size = static_cast<int>(pad_->GetPaddings().size() / 2);
ge::TensorDesc padding_tensor_desc(ge::Shape({size, 2}), ge::FORMAT_NCHW, ge::DT_INT32);
ge::TensorPtr padding_tensor = std::make_shared<hiai::Tensor>(padding_tensor_desc);
padding_tensor->SetData(reinterpret_cast<uint8_t *>(paddings_.data()), size * sizeof(int));
padding_tensor->SetData(reinterpret_cast<uint8_t *>(pad_->GetPaddings().data()), size * sizeof(int));
auto paddings = new hiai::op::Const(name_ + "paddings");
paddings->set_attr_value(padding_tensor);
ge::TensorDesc constant_values_tensor_desc(ge::Shape({1}), ge::FORMAT_NCHW, ge::DT_FLOAT);
ge::TensorPtr constant_values_tensor = std::make_shared<hiai::Tensor>(constant_values_tensor_desc);
vector<float> constant_values_data_value = {constant_value_};
vector<float> constant_values_data_value = {pad_->GetConstantValue()};
constant_values_tensor->SetData(reinterpret_cast<uint8_t *>(constant_values_data_value.data()), 1 * sizeof(float));
auto constant = new hiai::op::Const(name_ + "constant");
constant->set_attr_value(constant_values_tensor);

9
mindspore/lite/src/runtime/kernel/npu/pad_npu.h
View File

@ -28,10 +28,7 @@ class PadNPUKernel : public NPUKernel {
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {
auto pad = reinterpret_cast<const mindspore::lite::Pad *>(primitive);
constant_value_ = pad->GetConstantValue();
paddings_ = pad->GetPaddings();
padding_mode_ = pad->GetPaddingMode();
pad_ = reinterpret_cast<const mindspore::lite::Pad *>(primitive);
}
~PadNPUKernel() override;
@ -43,9 +40,7 @@ class PadNPUKernel : public NPUKernel {
private:
hiai::op::PadV2 *op_ = nullptr;
std::vector<int> paddings_;
int padding_mode_;
float constant_value_;
const mindspore::lite::Pad *pad_;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_PAD_NPU_H_

16
mindspore/lite/src/runtime/kernel/npu/resize_npu.cc
View File

@ -27,8 +27,9 @@ using mindspore::schema::PrimitiveType_Resize;
namespace mindspore::kernel {
int ResizeNPUKernel::IsSupport(const std::vector<lite::Tensor *> &inputs, const std::vector<lite::Tensor *> &outputs,
OpParameter *opParameter) {
if (method_ != schema::ResizeMethod_LINEAR || method_ == schema::ResizeMethod_NEAREST) {
MS_LOG(WARNING) << "Unsupported resize method type:" << method_;
if (resize_parameter_->method_ != schema::ResizeMethod_LINEAR ||
resize_parameter_->method_ == schema::ResizeMethod_NEAREST) {
MS_LOG(WARNING) << "Unsupported resize method type:" << resize_parameter_->method_;
return RET_ERROR;
}
return RET_OK;
@ -38,20 +39,21 @@ int ResizeNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, con
const std::vector<ge::Operator *> &npu_inputs) {
ge::TensorDesc sizeTensorDesc(ge::Shape({2}), ge::FORMAT_NCHW, ge::DT_INT32);
ge::TensorPtr sizeTensor = std::make_shared<hiai::Tensor>(sizeTensorDesc);
vector<int32_t> dataValue = {static_cast<int32_t>(new_height_), static_cast<int32_t>(new_width_)};
vector<int32_t> dataValue = {static_cast<int32_t>(resize_parameter_->new_height_),
static_cast<int32_t>(resize_parameter_->new_width_)};
sizeTensor->SetData(reinterpret_cast<uint8_t *>(dataValue.data()), 2 * sizeof(int32_t));
auto out_size = new (std::nothrow) hiai::op::Const(name_ + "_size");
out_size->set_attr_value(sizeTensor);
if (method_ == schema::ResizeMethod_LINEAR) {
if (resize_parameter_->method_ == schema::ResizeMethod_LINEAR) {
auto op = new (std::nothrow) hiai::op::ResizeBilinearV2(name_);
if (op == nullptr) {
MS_LOG(ERROR) << " op is nullptr.";
return RET_ERROR;
}
op->set_attr_align_corners(align_corners_);
op->set_attr_align_corners(resize_parameter_->align_corners_);
op->set_input_x(*npu_inputs[0]);
op->set_input_size(*out_size);
op->set_attr_half_pixel_centers(preserve_aspect_ratio_);
op->set_attr_half_pixel_centers(resize_parameter_->preserve_aspect_ratio_);
op_ = op;
} else {
auto op = new (std::nothrow) hiai::op::ResizeNearestNeighborV2(name_);
@ -59,7 +61,7 @@ int ResizeNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, con
MS_LOG(ERROR) << " op is nullptr.";
return RET_ERROR;
}
op->set_attr_align_corners(align_corners_);
op->set_attr_align_corners(resize_parameter_->align_corners_);
op->set_input_x(*npu_inputs[0]);
op->set_input_size(*out_size);
op_ = op;

14
mindspore/lite/src/runtime/kernel/npu/resize_npu.h
View File

@ -22,7 +22,6 @@
#include "nnacl/arithmetic_common.h"
#include "src/runtime/kernel/npu/npu_kernel.h"
#include "include/graph/op/all_ops.h"
#include "src/runtime/kernel/npu/transpose_base_npu.h"
namespace mindspore::kernel {
class ResizeNPUKernel : public NPUKernel {
public:
@ -30,12 +29,7 @@ class ResizeNPUKernel : public NPUKernel {
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {
auto resize_parameter = reinterpret_cast<ResizeParameter *>(parameter);
method_ = resize_parameter->method_;
new_height_ = resize_parameter->new_height_;
new_width_ = resize_parameter->new_width_;
align_corners_ = resize_parameter->align_corners_;
preserve_aspect_ratio_ = resize_parameter->preserve_aspect_ratio_;
resize_parameter_ = reinterpret_cast<ResizeParameter *>(parameter);
}
~ResizeNPUKernel() override;
@ -48,11 +42,7 @@ class ResizeNPUKernel : public NPUKernel {
private:
ge::Operator *op_ = nullptr;
int method_;
int64_t new_height_;
int64_t new_width_;
bool align_corners_;
bool preserve_aspect_ratio_;
ResizeParameter *resize_parameter_;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_RESIZE_NPU_H_

2
mindspore/lite/src/runtime/kernel/npu/scale_npu.cc
View File

@ -34,7 +34,7 @@ int ScaleNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, cons
MS_LOG(ERROR) << name_ << " op is nullptr";
return RET_ERROR;
}
op_->set_attr_axis(this->axis_);
op_->set_attr_axis(scale_parameter_->axis_);
op_->set_input_x(*npu_inputs[0]);
op_->set_input_scale(*npu_inputs[1]);
op_->set_input_bias(*npu_inputs[2]);

4
mindspore/lite/src/runtime/kernel/npu/scale_npu.h
View File

@ -27,7 +27,7 @@ class ScaleNPUKernel : public NPUKernel {
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {
axis_ = reinterpret_cast<ScaleParameter *>(parameter)->axis_;
scale_parameter_ = reinterpret_cast<ScaleParameter *>(parameter);
}
~ScaleNPUKernel() override;
@ -39,7 +39,7 @@ class ScaleNPUKernel : public NPUKernel {
private:
hiai::op::Scale *op_ = nullptr;
int axis_;
ScaleParameter *scale_parameter_;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_Scale_NPU_H_

4
mindspore/lite/src/runtime/kernel/npu/softmax_npu.cc
View File

@ -35,10 +35,10 @@ int SoftmaxNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs,
MS_LOG(ERROR) << name_ << " op is nullptr";
return RET_ERROR;
}
if (axis_ == -1) {
if (softmax_parameter_->axis_ == -1) {
op_->set_attr_axis(inputs[0]->shape().size() - 1);
} else {
op_->set_attr_axis(axis_);
op_->set_attr_axis(softmax_parameter_->axis_);
}
op_->set_input_x(*npu_inputs[0]);
return RET_OK;

5
mindspore/lite/src/runtime/kernel/npu/softmax_npu.h
View File

@ -27,8 +27,7 @@ class SoftmaxNPUKernel : public NPUKernel {
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {
auto softmax_parameter = reinterpret_cast<SoftmaxParameter *>(parameter);
axis_ = softmax_parameter->axis_;
softmax_parameter_ = reinterpret_cast<SoftmaxParameter *>(parameter);
}
~SoftmaxNPUKernel() override;
@ -40,7 +39,7 @@ class SoftmaxNPUKernel : public NPUKernel {
private:
hiai::op::Softmax *op_ = nullptr;
int axis_;
SoftmaxParameter *softmax_parameter_;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_SOFTMAX_NPU_H_

10
mindspore/lite/src/runtime/kernel/npu/split_npu.cc
View File

@ -35,25 +35,25 @@ int SplitNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs, cons
MS_LOG(ERROR) << name_ << " op is nullptr";
return RET_ERROR;
}
int size = size_splits_.size();
int size = split_->size_splits().size();
ge::TensorDesc size_splits_tensor_desc(ge::Shape({size}), ge::FORMAT_NCHW, ge::DT_INT32);
ge::TensorPtr size_splits_tensor = std::make_shared<hiai::Tensor>(size_splits_tensor_desc);
size_splits_tensor->SetData(reinterpret_cast<uint8_t *>(size_splits_.data()), size * sizeof(int));
size_splits_tensor->SetData(reinterpret_cast<uint8_t *>(split_->size_splits().data()), size * sizeof(int));
auto size_splits = new hiai::op::Const(name_ + "_size");
size_splits->set_attr_value(size_splits_tensor);
ge::TensorDesc split_dim_tensor_desc(ge::Shape({1}), ge::FORMAT_NCHW, ge::DT_INT32);
ge::TensorPtr split_dim_tensor = std::make_shared<hiai::Tensor>(split_dim_tensor_desc);
vector<int32_t> split_dim_data_value = {split_dim_};
vector<int32_t> split_dim_data_value = {split_->GetSplitDim()};
split_dim_tensor->SetData(reinterpret_cast<uint8_t *>(split_dim_data_value.data()), 1 * sizeof(int));
auto split_dim = new hiai::op::Const(name_ + "_dim");
split_dim->set_attr_value(split_dim_tensor);
op_->set_input_x(*npu_inputs[0]);
op_->set_attr_num_split(num_split_);
op_->set_attr_num_split(split_->GetNumberSplit());
op_->set_input_split_dim(*split_dim);
op_->set_input_size_splits(*size_splits);
op_->create_dynamic_output_y(num_split_);
op_->create_dynamic_output_y(split_->GetNumberSplit());
return RET_OK;
}

9
mindspore/lite/src/runtime/kernel/npu/split_npu.h
View File

@ -27,10 +27,7 @@ class SplitNPUKernel : public NPUKernel {
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {
auto split = reinterpret_cast<const mindspore::lite::Split *>(primitive);
num_split_ = split->GetNumberSplit();
size_splits_ = split->GetSizeSplit();
split_dim_ = split->GetSplitDim();
split_ = reinterpret_cast<const mindspore::lite::Split *>(primitive);
}
~SplitNPUKernel() override;
@ -42,9 +39,7 @@ class SplitNPUKernel : public NPUKernel {
private:
hiai::op::SplitV *op_ = nullptr;
int num_split_;
std::vector<int> size_splits_;
int split_dim_;
const mindspore::lite::Split *split_;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_SPLIT_NPU_H_

10
mindspore/lite/src/runtime/kernel/npu/strided_slice_npu.cc
View File

@ -59,11 +59,11 @@ int StridedSliceNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &input
} else {
op_->set_input_strides(*npu_inputs[3]);
}
op_->set_attr_begin_mask(begin_mask_);
op_->set_attr_ellipsis_mask(ellipsis_mask_);
op_->set_attr_end_mask(end_mask_);
op_->set_attr_shrink_axis_mask(shrink_axis_mask_);
op_->set_attr_new_axis_mask(new_axis_mask_);
op_->set_attr_begin_mask(strided_slice_->GetBeginMask());
op_->set_attr_ellipsis_mask(strided_slice_->GetEllipsisMask());
op_->set_attr_end_mask(strided_slice_->GetEndMask());
op_->set_attr_shrink_axis_mask(strided_slice_->GetShrinkAxisMask());
op_->set_attr_new_axis_mask(strided_slice_->GetNewAxisMask());
return RET_OK;
}

13
mindspore/lite/src/runtime/kernel/npu/strided_slice_npu.h
View File

@ -28,12 +28,7 @@ class StridedSliceNPUKernel : public NPUKernel {
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {
auto strided_slice = reinterpret_cast<const mindspore::lite::StridedSlice *>(primitive);
begin_mask_ = strided_slice->GetBeginMask();
end_mask_ = strided_slice->GetEndMask();
ellipsis_mask_ = strided_slice->GetEllipsisMask();
new_axis_mask_ = strided_slice->GetNewAxisMask();
shrink_axis_mask_ = strided_slice->GetShrinkAxisMask();
strided_slice_ = reinterpret_cast<const mindspore::lite::StridedSlice *>(primitive);
}
~StridedSliceNPUKernel() override;
@ -45,11 +40,7 @@ class StridedSliceNPUKernel : public NPUKernel {
private:
hiai::op::StridedSlice *op_ = nullptr;
int begin_mask_;
int end_mask_;
int ellipsis_mask_;
int new_axis_mask_;
int shrink_axis_mask_;
const mindspore::lite::StridedSlice *strided_slice_;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_STRIDEDSLICE_NPU_H_

54
mindspore/lite/src/runtime/kernel/npu/transpose_base_npu.cc
View File

@ -1,54 +0,0 @@
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "src/runtime/kernel/npu/transpose_base_npu.h"
namespace mindspore::kernel {
TransposeBaseNPUKernel::~TransposeBaseNPUKernel() {
if (pre_trans_ != nullptr) {
delete pre_trans_;
pre_trans_ = nullptr;
}
if (post_trans_ != nullptr) {
delete post_trans_;
post_trans_ = nullptr;
}
}
int TransposeBaseNPUKernel::SetPreTranspose(const ge::Operator *input) {
// input permute: NHWC -> NCHW
pre_trans_ = new (std::nothrow) hiai::op::Permute(name_ + "_pre_transpose");
if (pre_trans_ == nullptr) {
MS_LOG(ERROR) << "New pre transpose npu operator (NHWC -> NCHW) for op " << name_ << " failed.";
return RET_ERROR;
}
pre_trans_->set_input_x(*input);
pre_trans_->set_attr_order(ge::AttrValue::LIST_INT({0, 3, 1, 2}));
return RET_OK;
}
int TransposeBaseNPUKernel::SetPostTranspose(const ge::Operator *input) {
// permute: NCHW -> NHWC
post_trans_ = new (std::nothrow) hiai::op::Permute(name_ + "_post_transpose");
if (post_trans_ == nullptr) {
MS_LOG(ERROR) << "New post transpose operator (NCHW -> NHWC) for op " << name_ << " failed.";
return RET_ERROR;
}
post_trans_->set_input_x(*input);
post_trans_->set_attr_order(ge::AttrValue::LIST_INT({0, 2, 3, 1}));
return RET_OK;
}
} // namespace mindspore::kernel

41
mindspore/lite/src/runtime/kernel/npu/transpose_base_npu.h
View File

@ -1,41 +0,0 @@
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_TRANSPOSE_BASE_H_
#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_TRANSPOSE_BASE_H_
#include <vector>
#include "include/graph/op/all_ops.h"
#include "include/graph/compatible/all_ops.h"
#include "src/runtime/kernel/npu/npu_kernel.h"
#include "nnacl/op_base.h"
namespace mindspore::kernel {
class TransposeBaseNPUKernel : public NPUKernel {
public:
TransposeBaseNPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
const mindspore::lite::PrimitiveC *primitive)
: NPUKernel(parameter, inputs, outputs, ctx, primitive) {}
~TransposeBaseNPUKernel() override;
protected:
int SetPreTranspose(const ge::Operator *input);
int SetPostTranspose(const ge::Operator *input);
hiai::op::Permute *pre_trans_ = nullptr;
hiai::op::Permute *post_trans_ = nullptr;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_NPU_TRANSPOSE_BASE_H_

4
mindspore/lite/src/runtime/kernel/npu/transpose_npu.cc
View File

@ -30,7 +30,7 @@ int TransposeNPUKernel::IsSupport(const std::vector<lite::Tensor *> &inputs, con
MS_LOG(ERROR) << "Unsupported conjugate transpose.";
return RET_ERROR;
}
return RET_OK;
return RET_ERROR;
}
int TransposeNPUKernel::SetNPUInputs(const std::vector<lite::Tensor *> &inputs,
@ -57,6 +57,4 @@ TransposeNPUKernel::~TransposeNPUKernel() {
}
REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_Transpose, NPUKernelCreator<TransposeNPUKernel>)
// REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_Nhwc2Nchw, NPUKernelCreator<TransposeNPUKernel>)
// REG_KERNEL(kNPU, kNumberTypeFloat32, PrimitiveType_Nchw2Nhwc, NPUKernelCreator<TransposeNPUKernel>)
} // namespace mindspore::kernel

56
mindspore/lite/src/scheduler.cc
View File

@ -34,10 +34,11 @@
#if SUPPORT_NPU
#include "src/runtime/agent/npu/subgraph_npu_kernel.h"
#include "src/runtime/agent/npu/npu_manager.h"
#include "src/runtime/agent/npu/npu_transform_pass.h"
#include "src/runtime/agent/npu/npu_fusion_pass.h"
#include "src/runtime/agent/npu/npu_add_transform_pass.h"
#include "src/runtime/agent/npu/npu_concat_transform_pass.h"
#include "src/runtime/agent/npu/optimizer/npu_pass_manager.h"
#include "src/runtime/agent/npu/optimizer/npu_transform_pass.h"
#include "src/runtime/agent/npu/optimizer/npu_fusion_pass.h"
#include "src/runtime/agent/npu/optimizer/npu_add_transform_pass.h"
#include "src/runtime/agent/npu/optimizer/npu_concat_transform_pass.h"
#endif
namespace mindspore::lite {
using kernel::KERNEL_ARCH::kCPU;
@ -89,12 +90,12 @@ void Scheduler::FindNodeInoutTensors(const lite::Model::Node &node, std::vector<
auto in_size = node.input_indices_.size();
inputs->reserve(in_size);
for (size_t j = 0; j < in_size; ++j) {
inputs->emplace_back(src_tensors_.at(node.input_indices_[j]));
inputs->emplace_back(src_tensors_->at(node.input_indices_[j]));
}
auto out_size = node.output_indices_.size();
outputs->reserve(out_size);
for (size_t j = 0; j < out_size; ++j) {
outputs->emplace_back(src_tensors_.at(node.output_indices_[j]));
outputs->emplace_back(src_tensors_->at(node.output_indices_[j]));
}
}
@ -303,11 +304,11 @@ int Scheduler::ScheduleSubGraphToKernels(size_t subgraph_index, std::vector<kern
}
if (in_tensors != nullptr) {
std::transform(subgraph->input_indices_.begin(), subgraph->input_indices_.end(), std::back_inserter(*in_tensors),
[&](const uint32_t index) { return this->src_tensors_.at(index); });
[&](const uint32_t index) { return this->src_tensors_->at(index); });
}
if (out_tensors != nullptr) {
std::transform(subgraph->output_indices_.begin(), subgraph->output_indices_.end(), std::back_inserter(*out_tensors),
[&](const uint32_t index) { return this->src_tensors_.at(index); });
[&](const uint32_t index) { return this->src_tensors_->at(index); });
}
return RET_OK;
}
@ -567,37 +568,16 @@ void Scheduler::FindAllInoutKernels(const std::vector<kernel::LiteKernel *> &ker
int Scheduler::RunPass(std::vector<kernel::LiteKernel *> *dst_kernels) {
int ret = RET_OK;
#if SUPPORT_NPU
auto transform_pass = new NPUTransformPass;
ret = transform_pass->FormatTransformPass(context_, dst_kernels, &src_tensors_);
delete transform_pass;
if (ret != RET_OK) {
MS_LOG(ERROR) << "Run npu format transform pass failed.";
return ret;
}
auto add_format_pass = new NPUAddTransformPass;
ret = add_format_pass->Run(context_, dst_kernels, &src_tensors_);
if (ret != RET_OK) {
MS_LOG(ERROR) << "Run npu add op insert transform pass failed.";
return ret;
}
delete add_format_pass;
auto concat_format_pass = new NPUConcatTransformPass;
ret = concat_format_pass->Run(context_, dst_kernels, &src_tensors_);
if (ret != RET_OK) {
MS_LOG(ERROR) << "Run npu concat op insert transform pass failed.";
return ret;
}
delete concat_format_pass;
auto transform_pass = new NPUTransformPass(context_, dst_kernels, src_tensors_);
mindspore::lite::NPUPassManager::GetInstance()->AddPass(transform_pass);
auto add_format_pass = new NPUAddTransformPass(context_, dst_kernels, src_tensors_);
mindspore::lite::NPUPassManager::GetInstance()->AddPass(add_format_pass);
auto concat_format_pass = new NPUConcatTransformPass(context_, dst_kernels, src_tensors_);
mindspore::lite::NPUPassManager::GetInstance()->AddPass(concat_format_pass);
auto fusion_pass = new NPUFusionPass(dst_kernels);
ret = fusion_pass->Fusion();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Run npu fussion transform pass failed.";
return ret;
}
delete fusion_pass;
mindspore::lite::NPUPassManager::GetInstance()->AddPass(fusion_pass);
ret = mindspore::lite::NPUPassManager::GetInstance()->Run();
#endif
return ret;
}

6
mindspore/lite/src/scheduler.h
View File

@ -28,8 +28,8 @@
namespace mindspore::lite {
class Scheduler {
public:
Scheduler(const InnerContext *ctx, Model *src_model, std::vector<Tensor *> src_tensors)
: context_(ctx), src_model_(src_model), src_tensors_(std::move(src_tensors)) {}
Scheduler(const InnerContext *ctx, Model *src_model, std::vector<Tensor *> *src_tensors)
: context_(ctx), src_model_(src_model), src_tensors_(src_tensors) {}
~Scheduler() = default;
int Schedule(std::vector<kernel::LiteKernel *> *dst_kernels);
@ -85,7 +85,7 @@ class Scheduler {
protected:
const InnerContext *context_ = nullptr;
Model *src_model_ = nullptr;
std::vector<Tensor *> src_tensors_;
std::vector<Tensor *> *src_tensors_;
std::vector<size_t> graph_output_node_indexes_;
};
} // namespace mindspore::lite