From 188bff3480257edaa1155e670c8d513f2b0efbcd Mon Sep 17 00:00:00 2001 From: ZhangMing <2778525216@qq.com> Date: Wed, 24 Dec 2025 18:25:01 +0800 Subject: [PATCH 1/6] add kernel to select memory type, KerneyKey.memory_type(scheduler.cc/1129) --> DSPKernel.out_mem_type(dsp_kernel.h/105) --> DSPAllocator.mem_type_(dsp_kernel.cc/56) Signed-off-by: ZhangMing <2778525216@qq.com> add memory copy kernel(storage_pass.h/.cc), support generate kernel config randomly and select kernel by config file(scheduler.cc) Signed-off-by: ZhangMing <2778525216@qq.com> storage_pass Signed-off-by: ZhangMing <2778525216@qq.com> benchmark supports generating kernel configuration files(mindspore-lite/tools/benchmark) Signed-off-by: ZhangMing <2778525216@qq.com> --- include/api/context.h | 16 + mindspore-lite/src/CMakeLists.txt | 4 + mindspore-lite/src/executor/kernel_exec.h | 31 +- mindspore-lite/src/litert/cxx_api/context.cc | 25 ++ mindspore-lite/src/litert/cxx_api/context.h | 2 + .../src/litert/cxx_api/converters.cc | 6 +- .../src/litert/cxx_api/converters.h | 2 +- .../src/litert/kernel/dsp/dsp_allocator.h | 6 +- .../src/litert/kernel/dsp/dsp_kernel.cc | 7 + .../src/litert/kernel/dsp/dsp_kernel.h | 20 +- mindspore-lite/src/litert/kernel_registry.cc | 52 ++- mindspore-lite/src/litert/kernel_registry.h | 23 +- mindspore-lite/src/litert/lite_session.cc | 1 + mindspore-lite/src/litert/scheduler.cc | 276 +++++++++++--- mindspore-lite/src/litert/scheduler.h | 72 ++++ mindspore-lite/src/litert/storage_pass.cc | 344 ++++++++++++++++++ mindspore-lite/src/litert/storage_pass.h | 40 ++ mindspore-lite/tools/benchmark/CMakeLists.txt | 5 +- .../tools/benchmark/benchmark_base.h | 54 ++- .../tools/benchmark/benchmark_unified_api.cc | 19 + .../tools/benchmark/kernel_config.cc | 85 +++++ .../tools/benchmark/kernel_config.h | 42 +++ .../tools/benchmark/run_benchmark.cc | 22 +- 23 files changed, 1098 insertions(+), 56 deletions(-) create mode 100644 mindspore-lite/src/litert/storage_pass.cc create mode 100644 mindspore-lite/src/litert/storage_pass.h create mode 100644 mindspore-lite/tools/benchmark/kernel_config.cc create mode 100644 mindspore-lite/tools/benchmark/kernel_config.h diff --git a/include/api/context.h b/include/api/context.h index fdcc0854..5601818a 100644 --- a/include/api/context.h +++ b/include/api/context.h @@ -163,6 +163,22 @@ class MS_API Context { /// \return Mutable reference of DeviceInfoContext vector in this context. std::vector> &MutableDeviceInfo(); + /// \brief Set the status whether to perform model inference or training in parallel. + /// + /// \param[in] is_enable: true, open kernel config; false, close kernel config. + /// \param[in] config_file: the config file path. + void SetEnableKernelConfig(bool is_enable, const std::string &config_file = ""); + + /// \brief Get the kernel config info file path. + /// + /// \return The kernel config info file path setting. + std::string GetKernelConfigFile() const; + + /// \brief Get the status whether to enable kernel config from file. + /// + /// \return Bool value that indicates whether enable kernel config from file. + bool GetKernelConfig() const; + private: std::shared_ptr data_; }; diff --git a/mindspore-lite/src/CMakeLists.txt b/mindspore-lite/src/CMakeLists.txt index be964557..84cd4841 100644 --- a/mindspore-lite/src/CMakeLists.txt +++ b/mindspore-lite/src/CMakeLists.txt @@ -149,6 +149,10 @@ set(LITE_SRC ${CMAKE_CURRENT_SOURCE_DIR}/infer/primitive_type.cc ) +if(TARGET_FT04 OR TARGET_FT78) + set(LITE_SRC ${LITE_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/litert/storage_pass.cc) +endif() + file(GLOB FORMAT_PASS_SRC "${CMAKE_CURRENT_SOURCE_DIR}/litert/pass/format_pass/*.cc") set(LITE_SRC ${LITE_SRC} ${FORMAT_PASS_SRC}) diff --git a/mindspore-lite/src/executor/kernel_exec.h b/mindspore-lite/src/executor/kernel_exec.h index 480cbc01..81e6ebc7 100644 --- a/mindspore-lite/src/executor/kernel_exec.h +++ b/mindspore-lite/src/executor/kernel_exec.h @@ -63,6 +63,28 @@ enum KERNEL_ARCH { }; static const char *const kBuiltin = "Builtin"; +int GetCoreIdByCoreMask(int core_mask) { +#ifdef MT_7004 + for (int i = 0; i < 4; ++i) { + if ((core_mask >> i) & 1) return i; + } +#endif +#ifdef FT_78NE + for (int i = 0; i < 8; ++i) { + if ((core_mask >> i) & 1) return i; + } +#endif + return -1; +} + +enum MEMORY_TYPE { + kShareMemory, // lite::dsp::MemType::SMC + kDDR, // lite::dsp::MemType::DDR + kPrivateMemory, // lite::dsp::MemType::L2 + kMemoryType_MIN = kShareMemory, + kMemoryType_MAX = kPrivateMemory +}; + struct KernelKey { KERNEL_ARCH arch = kCPU; TypeId data_type = kTypeUnknown; @@ -70,10 +92,13 @@ struct KernelKey { int type = 0; std::string kernel_arch; std::string provider{kBuiltin}; - + MEMORY_TYPE memory_type = kShareMemory; + int core_mask{0x1}; bool operator==(const KernelKey &dst) const { - return type == dst.type && kernel_arch == dst.kernel_arch && provider == dst.provider && arch == dst.arch && - data_type == dst.data_type && format == dst.format; + return type == dst.type && kernel_arch == dst.kernel_arch && + provider == dst.provider && arch == dst.arch && + data_type == dst.data_type && format == dst.format && + memory_type == dst.memory_type && core_mask == dst.core_mask; } }; diff --git a/mindspore-lite/src/litert/cxx_api/context.cc b/mindspore-lite/src/litert/cxx_api/context.cc index 435ab537..7ca24d92 100644 --- a/mindspore-lite/src/litert/cxx_api/context.cc +++ b/mindspore-lite/src/litert/cxx_api/context.cc @@ -247,6 +247,31 @@ bool Context::GetMultiModalHW() const { return data_->float_mode; } +void Context::SetEnableKernelConfig(bool is_enable, const std::string &config_file) { + if (data_ == nullptr) { + MS_LOG(ERROR) << "Invalid context."; + return; + } + data_->enable_kernel_config_ = is_enable; + data_->kernel_config_file_ = config_file; +} + +bool Context::GetKernelConfig() const { + if (data_ == nullptr) { + MS_LOG(ERROR) << "Invalid context."; + return false; + } + return data_->enable_kernel_config_; +} + +std::string Context::GetKernelConfigFile() const { + if (data_ == nullptr) { + MS_LOG(ERROR) << "Invalid context."; + return ""; + } + return data_->kernel_config_file_; +} + std::vector> &Context::MutableDeviceInfo() { static std::vector> empty{}; if (data_ == nullptr) { diff --git a/mindspore-lite/src/litert/cxx_api/context.h b/mindspore-lite/src/litert/cxx_api/context.h index 0923d1a4..a2425c07 100644 --- a/mindspore-lite/src/litert/cxx_api/context.h +++ b/mindspore-lite/src/litert/cxx_api/context.h @@ -41,6 +41,8 @@ struct Context::Data { DelegateMode delegate_mode_ = kNoDelegate; std::shared_ptr delegate = nullptr; bool float_mode = false; + bool enable_kernel_config_ = false; + std::string kernel_config_file_ = ""; }; struct DeviceInfoContext::Data { diff --git a/mindspore-lite/src/litert/cxx_api/converters.cc b/mindspore-lite/src/litert/cxx_api/converters.cc index 01ca00e1..7f4340e7 100644 --- a/mindspore-lite/src/litert/cxx_api/converters.cc +++ b/mindspore-lite/src/litert/cxx_api/converters.cc @@ -78,12 +78,14 @@ Status ContextUtils::AddAscendDevice(lite::InnerContext *inner_context, DeviceIn return kSuccess; } -Status ContextUtils::AddDspDevice(lite::InnerContext *inner_context, DeviceInfoContext *device) { +Status ContextUtils::AddDspDevice(lite::InnerContext *inner_context, DeviceInfoContext *device, bool enable_kernel_config, std::string kernel_config_file) { lite::DeviceInfo device_info; auto dsp_context = device->Cast(); device_info.dsp_device_info_ = {dsp_context->GetDeviceID()}; inner_context->device_list_.push_back( {lite::DT_DSP, device_info, dsp_context->GetProvider(), dsp_context->GetProviderDevice()}); + inner_context->enable_kernel_config_ = enable_kernel_config; + inner_context->kernel_config_file_ = kernel_config_file; return kSuccess; } @@ -171,7 +173,7 @@ std::shared_ptr ContextUtils::Convert(Context *context) { } else if (device->GetDeviceType() == kAscend) { ret = AddAscendDevice(inner_context.get(), device.get()); } else if (device->GetDeviceType() == kDSP) { - ret = AddDspDevice(inner_context.get(), device.get()); + ret = AddDspDevice(inner_context.get(), device.get(), context->GetKernelConfig(), context->GetKernelConfigFile()); } else if (device->GetDeviceType() == kCustomDevice) { ret = AddCustomDevice(inner_context.get(), device); } diff --git a/mindspore-lite/src/litert/cxx_api/converters.h b/mindspore-lite/src/litert/cxx_api/converters.h index b19d7c0e..c5e56571 100644 --- a/mindspore-lite/src/litert/cxx_api/converters.h +++ b/mindspore-lite/src/litert/cxx_api/converters.h @@ -45,7 +45,7 @@ class MS_API ContextUtils { lite::InnerContext *inner_context); static Status AddNpuDevice(bool enable_fp16, int frequency, lite::InnerContext *inner_context); static Status AddAscendDevice(lite::InnerContext *inner_context, DeviceInfoContext *device); - static Status AddDspDevice(lite::InnerContext *inner_context, DeviceInfoContext *device); + static Status AddDspDevice(lite::InnerContext *inner_context, DeviceInfoContext *device, bool enable_kernel_config, std::string kernel_config_file); static Status AddCustomDevice(lite::InnerContext *inner_context, const std::shared_ptr &device); static bool IsAffinityModeValid(int affinity_mode) { return affinity_mode >= lite::NO_BIND && affinity_mode <= lite::MID_CPU; diff --git a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h index 3cb2bae2..563af929 100644 --- a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h +++ b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h @@ -44,7 +44,7 @@ class DSPAllocator : public mindspore::Allocator { using Allocator::Malloc; void *Malloc(size_t size, MemType type) { return _Malloc(type, size); } - void *Malloc(size_t size) override { return _Malloc(MemType::DDR, size); } + void *Malloc(size_t size) override { return _Malloc(mem_type_, size); } void Free(void *ptr) override; int RefCount(void *ptr) override; @@ -55,6 +55,9 @@ class DSPAllocator : public mindspore::Allocator { void Clear(); MemType GetMemType(void *host_ptr); + void SetMemType(MemType mem_type) { mem_type_ = mem_type; }; + int32_t GetCoreId() { return core_id_; }; + void SetCoreId(int32_t core_id) { core_id_ = core_id; }; uint64_t GetDeviceMemPtr(void *buffer); void *Prepare(void *ptr) override { return ptr; } @@ -86,6 +89,7 @@ class DSPAllocator : public mindspore::Allocator { // 6 is empirical value int shift_factor_ = 6; bool lock_flag_ = true; + MemType mem_type_{MemType::DDR}; }; } // namespace mindspore::lite::dsp diff --git a/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.cc b/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.cc index 137e2efe..87613895 100644 --- a/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.cc +++ b/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.cc @@ -53,6 +53,13 @@ int DSPKernel::PreProcess() { auto *output = out_tensors_.at(i); CHECK_NULL_RETURN(output); CHECK_NULL_RETURN(output->allocator()); + auto dsp_allocator = reinterpret_cast(output->allocator().get()); + dsp_allocator->SetMemType(out_mem_type_); + dsp_allocator->SetCoreId(core_id_); + MS_LOG(DEBUG) << "MallocData begin, tensor_name: " + << output->tensor_name() + << ", memory: " << static_cast(out_mem_type_) + << ", core_id: " << static_cast(core_id_); ret = output->MallocData(); if (ret != RET_OK) { MS_LOG(ERROR) << "MallocData failed"; diff --git a/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h b/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h index 08d90787..9731e02d 100644 --- a/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h +++ b/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h @@ -65,6 +65,8 @@ class DSPKernel : public LiteKernel { virtual int CheckSpecs() { return RET_OK; } lite::dsp::MemType GetMemType() { return out_mem_type_; } void SetMemType(lite::dsp::MemType mem_type) { out_mem_type_ = mem_type; } + int32_t GetCoreId() { return core_id_; } + void SetCoreId(int32_t core_id) { core_id_ = core_id; } void SetKernelArg(const std::vector &kernel_args = {}) { kernel_args_ = kernel_args; } int InferShape() override; @@ -72,7 +74,7 @@ class DSPKernel : public LiteKernel { lite::dsp::DSPRuntime *dsp_runtime_; std::vector kernel_args_; lite::dsp::MemType out_mem_type_{lite::dsp::MemType::DDR}; - + int32_t core_id_{0}; private: lite::dsp::DSPRuntimeInnerWrapper dsp_runtime_wrapper_; }; @@ -102,6 +104,22 @@ kernel::LiteKernel *DSPKernelCreator(const std::vector &inputs, delete kernel; return nullptr; } + auto dsp_kernel = reinterpret_cast(kernel); + if (desc.memory_type == MEMORY_TYPE::kShareMemory) { + dsp_kernel->SetMemType(lite::dsp::MemType::SMC); + } else if (desc.memory_type == MEMORY_TYPE::kDDR) { + dsp_kernel->SetMemType(lite::dsp::MemType::DDR); + } else if (desc.memory_type == MEMORY_TYPE::kPrivateMemory) { + dsp_kernel->SetMemType(lite::dsp::MemType::L2); + } else { + MS_LOG(WARNING) << "Unknown memory type: " << static_cast(desc.memory_type) << ", using default SMC"; + dsp_kernel->SetMemType(lite::dsp::MemType::SMC); // 安全降级 + } + dsp_kernel->SetCoreId(GetCoreIdByCoreMask(desc.core_mask)); + MS_LOG(DEBUG) << "kernel " << opParameter->name_ + << " create success!" + << " memory type: " << static_cast(dsp_kernel->GetMemType()) + << " core id: " << static_cast(dsp_kernel->GetCoreId()); return kernel; } } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel_registry.cc b/mindspore-lite/src/litert/kernel_registry.cc index 2d6230a1..a7f9e48b 100644 --- a/mindspore-lite/src/litert/kernel_registry.cc +++ b/mindspore-lite/src/litert/kernel_registry.cc @@ -40,6 +40,7 @@ using mindspore::kernel::kBuiltin; using mindspore::kernel::kCPU; using mindspore::kernel::KERNEL_ARCH; +using mindspore::kernel::MEMORY_TYPE; using mindspore::kernel::KernelKey; namespace mindspore::lite { @@ -98,12 +99,16 @@ int KernelRegistry::GetCreatorFuncIndex(const kernel::KernelKey desc) { int device_index = static_cast(desc.arch) - kKernelArch_MIN; int dType_index = desc.data_type == kObjectTypeString ? 0 : static_cast(desc.data_type) - kNumberTypeBegin; int op_index = static_cast(desc.type); + int mType_index = desc.memory_type - kMemoryType_MIN; int op_type_length = op_type_length_; if (op_index >= PrimType_InnerOpMin && desc.type < PrimType_InnerOpMax) { op_type_length = inner_op_type_length_; op_index -= PrimType_InnerOpMin; } - int index = device_index * data_type_length_ * op_type_length + dType_index * op_type_length + op_index; + int index = device_index * data_type_length_ * memory_type_length_ * op_type_length + + dType_index * memory_type_length_ * op_type_length + + mType_index * op_type_length + + op_index; return index; } @@ -148,6 +153,51 @@ void KernelRegistry::RegKernel(KERNEL_ARCH arch, TypeId data_type, int op_type, } } +void KernelRegistry::RegKernel(KERNEL_ARCH arch, TypeId data_type, int op_type, MEMORY_TYPE memory_type, kernel::KernelCreator creator) { + CreatorArraysInit(); + KernelKey desc = {arch, data_type, NHWC, op_type}; + desc.memory_type = memory_type; + int index = GetCreatorFuncIndex(desc); + if (desc.type >= PrimType_MIN && desc.type < PrimType_MAX) { + if (index >= array_size_ || index < 0) { + MS_LOG(ERROR) << "invalid kernel key, arch " << desc.arch << ", data_type" << desc.data_type << ",op type " + << desc.type; + return; + } + if (creator_arrays_ != nullptr) { + creator_arrays_[index] = creator; + } + } else if (desc.type >= PrimType_InnerOpMin && desc.type < PrimType_InnerOpMax) { + MS_CHECK_TRUE_RET_VOID(index >= 0 && index < inner_op_array_size_); + if (inner_op_creator_arrays_ != nullptr) { + inner_op_creator_arrays_[index] = creator; + } + } +} + +void KernelRegistry::RegKernel(KERNEL_ARCH arch, TypeId data_type, int op_type, MEMORY_TYPE memory_type, int core_mask, kernel::KernelCreator creator) { + CreatorArraysInit(); + KernelKey desc = {arch, data_type, NHWC, op_type}; + desc.memory_type = memory_type; + desc.core_mask = core_mask; + int index = GetCreatorFuncIndex(desc); + if (desc.type >= PrimType_MIN && desc.type < PrimType_MAX) { + if (index >= array_size_ || index < 0) { + MS_LOG(ERROR) << "invalid kernel key, arch " << desc.arch << ", data_type" << desc.data_type << ",op type " + << desc.type; + return; + } + if (creator_arrays_ != nullptr) { + creator_arrays_[index] = creator; + } + } else if (desc.type >= PrimType_InnerOpMin && desc.type < PrimType_InnerOpMax) { + MS_CHECK_TRUE_RET_VOID(index >= 0 && index < inner_op_array_size_); + if (inner_op_creator_arrays_ != nullptr) { + inner_op_creator_arrays_[index] = creator; + } + } +} + KernelRegistry::~KernelRegistry() { KernelRegistry *instance = GetInstance(); std::unique_lock malloc_creator_array(instance->lock_); diff --git a/mindspore-lite/src/litert/kernel_registry.h b/mindspore-lite/src/litert/kernel_registry.h index 1715a0fc..ad9de666 100644 --- a/mindspore-lite/src/litert/kernel_registry.h +++ b/mindspore-lite/src/litert/kernel_registry.h @@ -27,6 +27,8 @@ using mindspore::kernel::kKernelArch_MAX; using mindspore::kernel::kKernelArch_MIN; +using mindspore::kernel::kMemoryType_MAX; +using mindspore::kernel::kMemoryType_MIN; using mindspore::schema::PrimitiveType_MAX; using mindspore::schema::PrimitiveType_MIN; @@ -41,6 +43,8 @@ class MS_API KernelRegistry { int GetCreatorFuncIndex(kernel::KernelKey desc); void RegKernel(kernel::KernelKey desc, kernel::KernelCreator creator); void RegKernel(kernel::KERNEL_ARCH arch, TypeId data_type, int type, kernel::KernelCreator creator); + void RegKernel(kernel::KERNEL_ARCH arch, TypeId data_type, int type, kernel::MEMORY_TYPE memory_type, kernel::KernelCreator creator); + void RegKernel(kernel::KERNEL_ARCH arch, TypeId data_type, int type, kernel::MEMORY_TYPE memory_type, int core_mask, kernel::KernelCreator creator); bool SupportKernel(const kernel::KernelKey &key); int GetKernelExec(const std::vector &in_tensors, const std::vector &out_tensors, const InnerContext *ctx, const mindspore::Context *ms_ctx, const kernel::KernelKey &key, @@ -55,7 +59,8 @@ class MS_API KernelRegistry { static const int device_type_length_{kKernelArch_MAX - kKernelArch_MIN + 1}; static const int data_type_length_{kNumberTypeEnd - kNumberTypeBegin + 1}; static const int op_type_length_{PrimitiveType_MAX - PrimitiveType_MIN + 1}; - static const int array_size_{device_type_length_ * data_type_length_ * op_type_length_}; + static const int memory_type_length_{kMemoryType_MAX - kMemoryType_MIN + 1}; + static const int array_size_{device_type_length_ * data_type_length_ * op_type_length_ * memory_type_length_}; kernel::KernelCreator *creator_arrays_ = nullptr; static const int inner_op_type_length_{PrimType_InnerOpMax - PrimType_InnerOpMin}; static const int inner_op_array_size_{device_type_length_ * data_type_length_ * inner_op_type_length_}; @@ -79,10 +84,26 @@ class KernelRegistrar { kernel::KernelCreator creator) { KernelRegistry::GetInstance()->RegKernel(arch, data_type, op_type, creator); } + + KernelRegistrar(const kernel::KERNEL_ARCH arch, const TypeId data_type, const int op_type, + const int memory_type, kernel::KernelCreator creator) { + KernelRegistry::GetInstance()->RegKernel(arch, data_type, op_type, memory_type, creator); + } + + KernelRegistrar(const kernel::KERNEL_ARCH arch, const TypeId data_type, const int op_type, + const int memory_type, const int core_mask, kernel::KernelCreator creator) { + KernelRegistry::GetInstance()->RegKernel(arch, data_type, op_type, memory_type, core_mask, creator); + } }; #define REG_KERNEL(arch, data_type, op_type, kernelCreater) \ static KernelRegistrar g_##arch##data_type##op_type##kernelReg(arch, data_type, op_type, kernelCreater); + +#define REG_DSP_KERNEL(arch, data_type, op_type, memory_type, kernelCreater) \ + static KernelRegistrar g_##arch##data_type##op_type##memory_type##kernelReg(arch, data_type, op_type, memory_type, kernelCreater); + +#define REG_DSP_KERNEL(arch, data_type, op_type, memory_type, core_mask, kernelCreater) \ + static KernelRegistrar g_##arch##data_type##op_type##memory_type##core_mask##kernelReg(arch, data_type, op_type, memory_type, core_mask, kernelCreater); } // namespace mindspore::lite #endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_REGISTRY_H_ diff --git a/mindspore-lite/src/litert/lite_session.cc b/mindspore-lite/src/litert/lite_session.cc index 77fc59e2..383ff02d 100644 --- a/mindspore-lite/src/litert/lite_session.cc +++ b/mindspore-lite/src/litert/lite_session.cc @@ -599,6 +599,7 @@ int LiteSession::CompileGraph(Model *model) { delegate_device_type_); scheduler.SetupSchedulerCb(std::move(sched_cb_)); scheduler.SetConfig(config_info_); + scheduler.SetKernelConfig(); ret = scheduler.Schedule(&kernels_); if (ret != RET_OK) { MS_LOG(ERROR) << "Schedule kernels failed: " << ret; diff --git a/mindspore-lite/src/litert/scheduler.cc b/mindspore-lite/src/litert/scheduler.cc index 117945e2..e0a1121f 100644 --- a/mindspore-lite/src/litert/scheduler.cc +++ b/mindspore-lite/src/litert/scheduler.cc @@ -21,6 +21,7 @@ #include #include #include +#include #include "src/tensorlist.h" #include "nnacl_c/partial_fusion_parameter.h" #include "include/errorcode.h" @@ -40,6 +41,9 @@ #include "src/common/context_util.h" #include "src/litert/infer_manager.h" #include "src/litert/runtime_pass.h" +#ifdef ENABLE_DSP +#include "src/litert/storage_pass.h" +#endif #include "src/litert/pass/format_pass/format_pass.h" #if !defined(AUTO_PARALLEL_CLIP) || !defined(RUNTIME_PASS_CLIP) #include "src/litert/sub_graph_split.h" @@ -462,6 +466,15 @@ int Scheduler::Schedule(std::vector *dst_kernels) { return ret; } shape_fusion_pass_->RestoreState(); + +#ifdef ENABLE_DSP + status = StoragePass(dst_kernels, src_tensors_, ms_context_); + if (status != RET_OK) { + MS_LOG(ERROR) << "storage pass failed."; + return RET_ERROR; + } +#endif + if (IsPrintDebug()) { MS_LOG(DEBUG) << "schedule kernels success."; for (auto subgraph : *dst_kernels) { @@ -1126,7 +1139,7 @@ int Scheduler::FindDspKernel(const std::vector &in_tensors, const std: } // support more data type like int32 - kernel::KernelKey dsp_desc{kernel::KERNEL_ARCH::kDSP, desc.data_type, NHWC, desc.type}; + kernel::KernelKey dsp_desc{kernel::KERNEL_ARCH::kDSP, desc.data_type, NHWC, desc.type, "dsp", "Builtin", kernel::MEMORY_TYPE::kShareMemory, 0x1}; // memory_type && core_id // weight dequant auto ret = WeightDecoder::DequantNode(op_parameter, in_tensors, kNumberTypeFloat32, src_model_->graph_.version_, context_->float_mode); @@ -1208,45 +1221,16 @@ int Scheduler::FindProviderKernel(const std::vector &in_tensors, const return RET_NOT_SUPPORT; } -kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in_tensors, - const std::vector &out_tensors, const LiteGraph::Node *node, - TypeId prefer_data_type) { - MS_ASSERT(node != nullptr); - // why we need this - TypeId data_type; - if (node->quant_type_ == schema::QuantType_QUANT_WEIGHT) { - if (in_tensors.front()->data_type() == kNumberTypeBool) { - data_type = kNumberTypeBool; - } else { - data_type = kNumberTypeFloat32; - } - } else { - data_type = GetFirstFp32Fp16OrInt8Type(in_tensors); - if (data_type == kTypeUnknown) { - MS_LOG(ERROR) << "GetFirstFp32Fp16OrInt8Type is unknown."; - return nullptr; - } - } - if (context_->float_mode) { - for (auto tensor : out_tensors) { - if (!tensor->quant_params().empty() && - (tensor->data_type() == kNumberTypeInt8 || tensor->data_type() == kNumberTypeUInt8)) { - data_type = kNumberTypeFloat32; - tensor->set_data_type(kNumberTypeFloat32); - } - } - } - kernel::KernelExec *kernel = nullptr; - auto status = FindProviderKernel(in_tensors, out_tensors, node, data_type, &kernel); - if (status == RET_OK && kernel != nullptr) { - return kernel; - } +int Scheduler::SelectKernelByDeviceList(const std::vector &in_tensors, + const std::vector &out_tensors, const LiteGraph::Node *node, + TypeId data_type, kernel::KernelExec **kernel, TypeId prefer_data_type) { + int status = RET_NOT_SUPPORT; MS_ASSERT(!node->output_indices_.empty()); OpParameter *op_parameter = op_parameters_[node->output_indices_.at(0)]; if (op_parameter == nullptr) { MS_LOG(ERROR) << "Can not find OpParameter!type: " << GetPrimitiveTypeName(node->primitive_, context_->get_schema_version()); - return nullptr; + return status; } #if (defined GPU_OPENCL) || (defined ENABLE_FP16) @@ -1261,7 +1245,7 @@ kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in if (dsp_priority && use_dsp_kernel) { status = FindDspKernel(in_tensors, out_tensors, op_parameter, desc, &kernel, prefer_data_type); if (status == RET_OK) { - return kernel; + return status; } else { MS_LOG(DEBUG) << "Get dsp op failed, scheduler to cpu: " << PrimitiveCurVersionTypeName(desc.type) << " " << node->name_; @@ -1272,7 +1256,7 @@ kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in op_parameter = op_parameters_[node->output_indices_.at(0)]; } else { MS_LOG(ERROR) << "Try repeat infer fail: " << node->name_; - return nullptr; + return RET_NOT_SUPPORT; } } } @@ -1285,7 +1269,7 @@ kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in if (gpu_priority && use_gpu_kernel) { status = FindGpuKernel(in_tensors, out_tensors, op_parameter, desc, &kernel, prefer_data_type); if (status == RET_OK) { - return kernel; + return status; } else { MS_LOG(DEBUG) << "Get gpu op failed, scheduler to cpu: " << PrimitiveCurVersionTypeName(desc.type) << " " << node->name_; @@ -1297,7 +1281,7 @@ kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in op_parameter->thread_num_ = kernel_thread_count; } else { MS_LOG(ERROR) << "Try repeat infer fail: " << node->name_; - return nullptr; + return RET_NOT_SUPPORT; } } } @@ -1308,7 +1292,7 @@ kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in ((is_train_session_ == false) || (sched_cb_ && sched_cb_->SchedFp16Kernel(node)))) { status = FindCpuKernel(in_tensors, out_tensors, op_parameter, desc, kNumberTypeFloat16, &kernel); if (status == RET_OK) { - return kernel; + return status; } else { MS_LOG(INFO) << "Get op failed, scheduler to CPU by node: " << node->name_ << ", prefer_data_type is " << (prefer_data_type == kNumberTypeFloat16 ? "fp16" : "unknown") << ", desc.type index:" << desc.type @@ -1321,7 +1305,7 @@ kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in op_parameter->thread_num_ = kernel_thread_count; } else { MS_LOG(ERROR) << "Try repeat infer fail: " << node->name_; - return nullptr; + return RET_NOT_SUPPORT; } } } @@ -1333,7 +1317,86 @@ kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in } status = FindCpuKernel(in_tensors, out_tensors, op_parameter, desc, kNumberTypeFloat32, &kernel); if (status == RET_OK) { - return kernel; + return status; + } else if (status == RET_ERROR) { + op_parameters_.erase(node->output_indices_.at(0)); + auto ret = InferNodeShape(node); + if (!(ret == RET_INFER_INVALID || ret == RET_OK)) { + MS_LOG(ERROR) << "Try repeat infer fail: " << node->name_; + } + } +#ifdef OP_INT8_CLIP + if (desc.data_type == kNumberTypeInt8) { + MS_LOG(ERROR) << unsupport_int8_log; + } +#endif + return status; +} + +int Scheduler::SelectKernelByConfigFile(const std::vector &in_tensors, + const std::vector &out_tensors, const LiteGraph::Node *node, + TypeId data_type, kernel::KernelExec **kernel, TypeId prefer_data_type) { + int status = RET_NOT_SUPPORT; + MS_ASSERT(!node->output_indices_.empty()); + OpParameter *op_parameter = op_parameters_[node->output_indices_.at(0)]; + if (op_parameter == nullptr) { + MS_LOG(ERROR) << "Can not find OpParameter!type: " + << GetPrimitiveTypeName(node->primitive_, context_->get_schema_version()); + return status; + } + + op_parameter->is_train_session_ = is_train_session_; + + if (kernel_info_.empty()) { + MS_LOG(ERROR) << "Kernel config parse error."; + return status; + } + const KernelInfo *kernel_info = nullptr; + for (const auto &kinfo : kernel_info_) { + if (kinfo.name == node->name_) { + kernel_info = &kinfo; + break; + } + } + if (kernel_info == nullptr) { + MS_LOG(ERROR) << "kernel name: " << node->name_ << " not found in kernel config file"; + return status; + } + kernel::KernelKey desc{kernel::KERNEL_ARCH::kCPU, data_type, NHWC, op_parameter->type_}; + +#ifdef ENABLE_DSP + bool dsp_priority = DeviceTypePriority(context_, DT_DSP, DT_CPU); + bool use_dsp_kernel = node->device_type_ == DT_DSP || node->device_type_ == kDefaultDeviceType; + if (dsp_priority && use_dsp_kernel) { + status = FindDspKernel(in_tensors, out_tensors, op_parameter, desc, &kernel, prefer_data_type); + if (status == RET_OK) { + kernel->desc().memory_type = kernel_info->memory_type; + kernel->desc().core_mask = kernel_info->core_mask; + return status; + } else { + MS_LOG(DEBUG) << "Get dsp op failed, scheduler to cpu: " << PrimitiveCurVersionTypeName(desc.type) << " " + << node->name_; + if (status == RET_ERROR) { + op_parameters_.erase(node->output_indices_.at(0)); + auto ret = InferNodeShape(node); + if (ret == RET_INFER_INVALID || ret == RET_OK) { + op_parameter = op_parameters_[node->output_indices_.at(0)]; + } else { + MS_LOG(ERROR) << "Try repeat infer fail: " << node->name_; + return RET_NOT_SUPPORT; + } + } + } + } +#endif + + if (data_type == kNumberTypeFloat16) { + MS_LOG(DEBUG) << "Get fp16 op failed, back to fp32 op."; + desc.data_type = kNumberTypeFloat32; + } + status = FindCpuKernel(in_tensors, out_tensors, op_parameter, desc, kNumberTypeFloat32, kernel); + if (status == RET_OK) { + return status; } else if (status == RET_ERROR) { op_parameters_.erase(node->output_indices_.at(0)); auto ret = InferNodeShape(node); @@ -1346,6 +1409,135 @@ kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in MS_LOG(ERROR) << unsupport_int8_log; } #endif + return status; +} + +int Scheduler::SelectKernelRandomly(const std::vector &in_tensors, + const std::vector &out_tensors, const LiteGraph::Node *node, + TypeId data_type, kernel::KernelExec **kernel, TypeId prefer_data_type) { + int status = RET_NOT_SUPPORT; + MS_ASSERT(!node->output_indices_.empty()); + OpParameter *op_parameter = op_parameters_[node->output_indices_.at(0)]; + if (op_parameter == nullptr) { + MS_LOG(ERROR) << "Can not find OpParameter!type: " + << GetPrimitiveTypeName(node->primitive_, context_->get_schema_version()); + return status; + } + + op_parameter->is_train_session_ = is_train_session_; + std::random_device random_device; + auto rng = std::mt19937(random_device()); + kernel::KernelKey desc{kernel::KERNEL_ARCH::kCPU, data_type, NHWC, op_parameter->type_}; + +#ifdef ENABLE_DSP + std::uniform_int_distribution<> generate_priority(false, true); + bool dsp_priority = generate_priority(rng); + bool use_dsp_kernel = node->device_type_ == DT_DSP || node->device_type_ == kDefaultDeviceType; + if (dsp_priority && use_dsp_kernel) { + status = FindDspKernel(in_tensors, out_tensors, op_parameter, desc, &kernel, prefer_data_type); + if (status == RET_OK) { + std::vector coremark; + std::vector all_mem_types = {kernel::MEMORY_TYPE::kShareMemory, + kernel::MEMORY_TYPE::kDDR, + kernel::MEMORY_TYPE::kPrivateMemory}; + #ifdef MT_7004 + coremask = {1, 3, 15}; + #endif + #ifdef FT_78NE + coremask = {1, 3, 15, 255}; + #endif + std::uniform_int_distribution<> generate_coremark(0, coremark.size() - 1); + std::uniform_int_distribution<> generate_memtype(0, all_mem_types.size() - 1); + kernel->desc().memory_type = all_mem_types[generate_memtype(rng)]; + kernel->desc().core_mask = coremark[generate_coremark(rng)]; + return status; + } else { + MS_LOG(DEBUG) << "Get dsp op failed, scheduler to cpu: " << PrimitiveCurVersionTypeName(desc.type) << " " + << node->name_; + if (status == RET_ERROR) { + op_parameters_.erase(node->output_indices_.at(0)); + auto ret = InferNodeShape(node); + if (ret == RET_INFER_INVALID || ret == RET_OK) { + op_parameter = op_parameters_[node->output_indices_.at(0)]; + } else { + MS_LOG(ERROR) << "Try repeat infer fail: " << node->name_; + return RET_NOT_SUPPORT; + } + } + } + } +#endif + + if (data_type == kNumberTypeFloat16) { + MS_LOG(DEBUG) << "Get fp16 op failed, back to fp32 op."; + desc.data_type = kNumberTypeFloat32; + } + status = FindCpuKernel(in_tensors, out_tensors, op_parameter, desc, kNumberTypeFloat32, kernel); + if (status == RET_OK) { + return status; + } else if (status == RET_ERROR) { + op_parameters_.erase(node->output_indices_.at(0)); + auto ret = InferNodeShape(node); + if (!(ret == RET_INFER_INVALID || ret == RET_OK)) { + MS_LOG(ERROR) << "Try repeat infer fail: " << node->name_; + } + } +#ifdef OP_INT8_CLIP + if (desc.data_type == kNumberTypeInt8) { + MS_LOG(ERROR) << unsupport_int8_log; + } +#endif + return status; +} + +kernel::KernelExec *Scheduler::FindBackendKernel(const std::vector &in_tensors, + const std::vector &out_tensors, const LiteGraph::Node *node, + TypeId prefer_data_type) { + MS_ASSERT(node != nullptr); + // why we need this + TypeId data_type; + if (node->quant_type_ == schema::QuantType_QUANT_WEIGHT) { + if (in_tensors.front()->data_type() == kNumberTypeBool) { + data_type = kNumberTypeBool; + } else { + data_type = kNumberTypeFloat32; + } + } else { + data_type = GetFirstFp32Fp16OrInt8Type(in_tensors); + if (data_type == kTypeUnknown) { + MS_LOG(ERROR) << "GetFirstFp32Fp16OrInt8Type is unknown."; + return nullptr; + } + } + if (context_->float_mode) { + for (auto tensor : out_tensors) { + if (!tensor->quant_params().empty() && + (tensor->data_type() == kNumberTypeInt8 || tensor->data_type() == kNumberTypeUInt8)) { + data_type = kNumberTypeFloat32; + tensor->set_data_type(kNumberTypeFloat32); + } + } + } + kernel::KernelExec *kernel = nullptr; + auto status = FindProviderKernel(in_tensors, out_tensors, node, data_type, &kernel); + if (status == RET_OK && kernel != nullptr) { + return kernel; + } + + if(context_ != nullptr) { + if (context_->enable_kernel_config_) { + if (context_->kernel_config_file_.empty()) { + status = SelectKernelRandomly(in_tensors, out_tensors, node, data_type, &kernel, prefer_data_type); + } else { + status = SelectKernelByConfigFile(in_tensors, out_tensors, node, data_type, &kernel, prefer_data_type); + } + } else { + status = SelectKernelByDeviceList(in_tensors, out_tensors, node, data_type, &kernel, prefer_data_type); + } + } + if (status == RET_OK && kernel != nullptr) { + return kernel; + } return nullptr; } diff --git a/mindspore-lite/src/litert/scheduler.h b/mindspore-lite/src/litert/scheduler.h index 8142119c..f844f41c 100644 --- a/mindspore-lite/src/litert/scheduler.h +++ b/mindspore-lite/src/litert/scheduler.h @@ -32,7 +32,21 @@ #include "include/api/delegate.h" #include "src/control_flow/control_flow_scheduler.h" #include "src/litert/runtime_shape_fusion_pass.h" +#include "src/common/file_utils.h" +#include +struct ModelTime { + double min; + double avg; + double max; +}; + +struct KernelInfo { + std::string name; + int arch; + int core_mask; + int memory_type; +}; namespace mindspore::lite { constexpr int kDefaultDeviceType = -1; class Scheduler { @@ -61,6 +75,51 @@ class Scheduler { void SetConfig(const std::map> *config_info) { config_info_ = config_info; } + void SetKernelConfig() { + if (context_->kernel_config_file_.empty() || !context_->enable_kernel_config_) { + MS_LOG(INFO) << "Kernel config file is empty or kernel config is disabled."; + return; + } + auto real_path = RealPath(context_->kernel_config_file_.c_str()); + std::ifstream ifs(real_path); + if (!ifs.good()) { + MS_LOG(ERROR) << "file: " << real_path << " is not exist"; + return; + } + if (!ifs.is_open()) { + MS_LOG(ERROR) << "file: " << real_path << " open failed"; + return; + } + + nlohmann::json kernel_config_json; + ifs >> kernel_config_json; + double best_avg = std::numeric_limits::max(); + + for (const auto &item : kernel_config_json) { + if (!item.contains("model_time") || !item["model_time"].contains("avg") || !item.contains("kernel_info")) { + MS_LOG(WARNING) << "Invalid kernel config item format"; + continue; + } + double temp_avg = item["model_time"]["avg"]; + if (temp_avg < best_avg) { + best_avg = temp_avg; + kernel_info_.clear(); + for (const auto &kernel : item["kernel_info"]) { + if (!kernel.contains("name") || !kernel.contains("arch") || !kernel.contains("core_mask") || + !kernel.contains("mem_type")) { + MS_LOG(WARNING) << "Invalid kernel info format"; + continue; + } + KernelInfo kinfo; + kinfo.name = kernel["name"]; + kinfo.arch = kernel["arch"]; + kinfo.core_mask = kernel["core_mask"]; + kinfo.mem_type = kernel["mem_type"]; + kernel_info_.push_back(kinfo); + } + } + } + } std::vector NonTailCallNodes(); private: @@ -99,6 +158,18 @@ class Scheduler { int FindProviderKernel(const std::vector &in_tensors, const std::vector &out_tensors, const LiteGraph::Node *node, TypeId data_type, kernel::KernelExec **kernel); + int SelectKernelByDeviceList(const std::vector &in_tensors, const std::vector &out_tensors, + const LiteGraph::Node *node, TypeId data_type, kernel::KernelExec **kernel, + TypeId prefer_data_type); + + int SelectKernelByConfigFile(const std::vector &in_tensors, const std::vector &out_tensors, + const LiteGraph::Node *node, TypeId data_type, kernel::KernelExec **kernel, + TypeId prefer_data_type); + + int SelectKernelRandomly(const std::vector &in_tensors, const std::vector &out_tensors, + const LiteGraph::Node *node, TypeId data_type, kernel::KernelExec **kernel, + TypeId prefer_data_type); + int InitKernels(std::vector &&dst_kernels); kernel::KernelExec *SchedulePartialToKernel(const lite::LiteGraph::Node *src_node); // schedule a partial node to a subgraph_kernel @@ -182,6 +253,7 @@ class Scheduler { const std::map> *config_info_ = nullptr; std::shared_ptr shape_fusion_pass_ = nullptr; std::vector infer_subgraph_index_; + std::vector kernel_info_; }; } // namespace mindspore::lite diff --git a/mindspore-lite/src/litert/storage_pass.cc b/mindspore-lite/src/litert/storage_pass.cc new file mode 100644 index 00000000..77a6cde5 --- /dev/null +++ b/mindspore-lite/src/litert/storage_pass.cc @@ -0,0 +1,344 @@ +#include "src/litert/storage_pass.h" +#include "mindspore-lite/include/registry/register_kernel.h" +#include "mindspore-lite/src/common/tensor_util.h" +#include "mindspore-lite/src/litert/kernel_exec_util.h" + +using MEMORY_TYPE = mindspore::kernel::MEMORY_TYPE; +using KernelKey = mindspore::kernel::KernelKey; + +namespace mindspore::lite { + +/** + * @brief 对子图进行存储优化。 + * + * 对传入的子图进行存储选择操作，并在不同存储类型的算子之间插入内存拷贝算子 。 + * + * @param subgraphs 子图的指针数组，每个子图是一个KernelExec的指针 + * @param tensors Tensor指针数组，存储子图中使用的Tensor + * @param ms_ctx MindSpore的上下文指针，包含执行环境信息 + * + * @return 操作结果，如果成功返回RET_OK，否则返回RET_ERROR + */ +STATUS StoragePass(std::vector *subgraphs, std::vector *tensors, + const mindspore::Context *ms_ctx) { + for (auto subgraph : *subgraphs) { + auto arch = subgraph->desc().arch; + if (arch == kernel::KERNEL_ARCH::kDelegate || arch == kernel::KERNEL_ARCH::kCPU) { + continue; // 跳过Delegate和CPU子图 + } + auto status = ProcessSubgraph(subgraph, tensors, ms_ctx); // 处理每个子图 + if (status != RET_OK) { + return status; + } + } + return RET_OK; +} + +/** + * @brief 处理图输入或常量张量 + * + * 根据给定的图、当前算子、内存类型、输入张量、张量列表、索引和MindSpore上下文，处理图输入或常量张量。 + * 如果内存类型不是DDR，则会插入内存复制算子。 + * + * @param graph 图指针，指向需要处理的子图 + * @param origin_kernel 当前算子指针 + * @param origin_memory_type 内存类型 + * @param in_tensor 输入张量指针 + * @param tensors 张量列表指针 + * @param index 索引 + * @param ms_ctx MindSpore上下文指针 + * + * @return 处理成功返回true，否则返回false + */ +bool HandleGraphInputOrConstTensor(kernel::SubGraphKernel *graph, kernel::KernelExec *origin_kernel, + MEMORY_TYPE origin_memory_type, Tensor *in_tensor, std::vector *tensors, + size_t index, const mindspore::Context *ms_ctx) { + bool is_ddr_type = origin_memory_type == MEMORY_TYPE::kDDR; + if (!is_ddr_type) { + std::string name = in_tensor->tensor_name() + "_memcpy_to_" + origin_kernel->name(); + auto mem_copy_kernel = InsertMemoryCopy(graph, origin_kernel, name, tensors, index, ms_ctx); + if (mem_copy_kernel == nullptr) { + MS_LOG(ERROR) << "InsertMemoryCopy failed."; + return false; + } + mem_copy_kernel->desc().core_mask = origin_kernel->desc().core_mask; + graph->SetInNodes(kernel::KernelExecUtil::SubgraphInputNodes(graph->nodes())); + graph->SetOutNodes(kernel::KernelExecUtil::SubgraphOutputNodes(graph->nodes())); + auto ret = graph->TopologicalSortNodes(); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Topological sort kernels failed."; + return false; + } + } + return true; +} + +/** + * @brief 处理非图输入或常量张量的输入 + * + * 处理输入张量不是图输入或常量张量的情况，通过插入内存拷贝算子（Memory Copy Kernel）来处理。 + * + * @param graph 子图指针，指向当前处理的子图。 + * @param origin_kernel 原始算子执行对象指针，指向原始算子执行对象。 + * @param in_kernel 输入算子执行对象指针，指向输入算子执行对象。 + * @param tensors 张量指针向量指针，指向包含所有张量的指针向量。 + * @param index 张量索引，指定需要处理的张量在tensors中的位置。 + * @param ms_ctx MindSpore上下文指针，指向MindSpore上下文对象。 + * + * @return 如果处理成功返回true，否则返回false。 + */ +bool HandleNonGraphInputOrConstTensor(kernel::SubGraphKernel *graph, kernel::KernelExec *origin_kernel, + kernel::KernelExec *in_kernel, std::vector *tensors, size_t index, + const mindspore::Context *ms_ctx) { + std::string name = in_kernel->name() + "_memcpy_to_" + origin_kernel->name(); + auto mem_copy_kernel = InsertMemoryCopy(graph, origin_kernel, name, tensors, index, ms_ctx); + if (mem_copy_kernel == nullptr) { + MS_LOG(ERROR) << "InsertMemoryCopy failed."; + return false; + } + if (origin_kernel->desc().memory_type == MEMORY_TYPE::kPrivateMemory) { + mem_copy_kernel->desc().core_mask = origin_kernel->desc().core_mask; + } else { + mem_copy_kernel->desc().core_mask = in_kernel->desc().core_mask; + } + + auto in_tensors = origin_kernel->in_tensors(); + for (size_t j = 0; j < in_tensors.size(); j++) { + auto in_tensor = in_tensors.at(j); + if (in_tensor->tensor_name() == in_kernel->name()) { + origin_kernel->set_in_tensor(mem_copy_kernel->out_tensors()[0], j); + } + } + graph->SetInNodes(kernel::KernelExecUtil::SubgraphInputNodes(graph->nodes())); + graph->SetOutNodes(kernel::KernelExecUtil::SubgraphOutputNodes(graph->nodes())); + auto ret = graph->TopologicalSortNodes(); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Topological sort kernels failed."; + return false; + } + return true; +} + +/** + * @brief 处理输入张量 + * + * 该函数用于处理输入张量，并根据张量的类型进行不同的处理。 + * + * @param graph 子图指针 + * @param origin_kernel 当前算子执行对象指针 + * @param in_kernels 输入算子执行对象指针数组 + * @param tensors 张量指针数组指针 + * @param origin_memory_type 内存类型 + * @param in_t 输入张量指针 + * @param ms_ctx MindSpore上下文指针 + * @param index 输入张量的索引 + * + * @return 如果处理成功，则返回true；否则返回false + */ +bool HandleInputTensors(kernel::SubGraphKernel *graph, kernel::KernelExec *origin_kernel, + std::vector in_kernels, std::vector *tensors, + MEMORY_TYPE origin_memory_type, Tensor *in_t, const mindspore::Context *ms_ctx, + const size_t &index) { + if (in_t->IsGraphInput() || in_t->IsConst()) { + if (!HandleGraphInputOrConstTensor(graph, origin_kernel, origin_memory_type, in_t, tensors, index, ms_ctx)) { + return false; + } + } else { + int in_kernel_index = -1; + for (size_t i = 0; i < in_kernels.size(); ++i) { + if (find(in_kernels[i]->out_tensors().begin(), in_kernels[i]->out_tensors().end(), in_t) != + in_kernels[i]->out_tensors().end()) { + in_kernel_index = i; + break; + } + } + if (in_kernel_index < 0) { + MS_LOG(ERROR) << "Can not find the kernel of input tensor: " << in_t->tensor_name(); + return false; + } + auto in_kernel = in_kernels.at(in_kernel_index); + bool need_copy = false; + MEMORY_TYPE in_memory_type = in_kernel->desc().memory_type; +#ifdef MT_7004 + KernelKey in_desc = in_kernel->desc(); + int in_core_mask = in_desc.core_mask; + int in_core_id = kernel::GetCoreIdByCoreMask(in_core_mask); + + KernelKey origin_desc = origin_kernel->desc(); + int origin_core_mask = origin_desc.core_mask; + int origin_core_id = kernel::GetCoreIdByCoreMask(origin_core_mask); + + bool is_mem_type_diff = origin_memory_type != in_memory_type; + bool is_am_mem_type_diff_core = origin_memory_type == MEMORY_TYPE::kPrivateMemory && + in_memory_type == MEMORY_TYPE::kPrivateMemory && + in_core_id != origin_core_id; + + need_copy = is_mem_type_diff || is_am_mem_type_diff_core; + +#elif defined(FT_78NE) + if (origin_memory_type == MEMORY_TYPE::kShareMemory) { + need_copy = in_memory_type != MEMORY_TYPE::kShareMemory; + } else if (origin_memory_type == MEMORY_TYPE::kPrivateMemory) { + need_copy = in_memory_type != MEMORY_TYPE::kPrivateMemory; + if (!need_copy) { + KernelKey in_desc = in_kernel->desc(); + int in_core_mask = in_desc.core_mask; + int in_core_id = kernel::GetCoreIdByCoreMask(in_core_mask); + + KernelKey origin_desc = origin_kernel->desc(); + int origin_core_mask = origin_desc.core_mask; + int origin_core_id = kernel::GetCoreIdByCoreMask(origin_core_mask); + + need_copy = in_core_id != origin_core_id; + } + } else if (origin_memory_type == MEMORY_TYPE::kDDR) { + need_copy = (in_memory_type == MEMORY_TYPE::kShareMemory) || (in_memory_type == MEMORY_TYPE::kPrivateMemory); + } +#endif + if (need_copy && !HandleNonGraphInputOrConstTensor(graph, origin_kernel, in_kernel, tensors, index, ms_ctx)) { + return false; + } + } + return true; +} + +/** + * @brief 处理算子函数 + * + * 处理传入的子图、原始算子、张量向量和上下文，插入内存拷贝操作，确保内存类型一致。 + * + * @param graph 子图指针 + * @param origin_kernel 当前算子指针 + * @param tensors 张量向量指针 + * @param ms_ctx 上下文指针 + * @return STATUS 状态码，RET_OK 表示成功，RET_ERROR 表示失败 + */ +STATUS ProcessKernel(kernel::SubGraphKernel *graph, kernel::KernelExec *origin_kernel, std::vector *tensors, + const mindspore::Context *ms_ctx) { + KernelKey origin_kernel_desc = origin_kernel->desc(); + MEMORY_TYPE origin_kernel_memory_type = origin_kernel_desc.memory_type; + auto in_kernels = origin_kernel->in_kernels(); + auto in_ts = origin_kernel->in_tensors(); + auto in_tensor_size = in_ts.size(); + for (size_t i = 0; i < in_tensor_size; i++) { + auto in_t = in_ts.at(i); + if (!HandleInputTensors(graph, origin_kernel, in_kernels, tensors, origin_kernel_memory_type, in_t, ms_ctx, i)) { + return RET_ERROR; + } + } + return RET_OK; +} + +/** + * @brief 处理子图 + * + * @param subgraph 子图指针 + * @param tensors 张量指针数组 + * @param ms_ctx MindSpore上下文指针 + * + * @return STATUS 状态码 + */ +STATUS ProcessSubgraph(kernel::KernelExec *subgraph, std::vector *tensors, const mindspore::Context *ms_ctx) { + auto graph = static_cast(subgraph); + auto kernels = graph->nodes(); + auto origin_kernel_size = kernels.size(); + for (size_t kernel_index = 0; kernel_index < origin_kernel_size; kernel_index++) { + kernel::KernelExec *origin_kernel = kernels.at(kernel_index); + auto status = ProcessKernel(graph, origin_kernel, tensors, ms_ctx); + if (status != RET_OK) { + return status; + } + } + return RET_OK; +} + +/** + * @brief 在子图中插入内存拷贝操作 + * + * 在给定的子图中，根据指定的索引，在原始算子操作后插入一个内存拷贝操作。 + * + * @param subgraph 子图指针，指向要插入内存拷贝操作的子图 + * @param origin_kernel 原始算子操作指针，指向要在其后插入内存拷贝操作的算子操作 + * @param name 内存拷贝操作的名称 + * @param all_tensors 所有张量的指针，用于存储新创建的内存拷贝张量 + * @param index 索引，指定在哪个输入张量后进行内存拷贝操作 + * @param ms_ctx MindSpore上下文指针，提供必要的上下文信息 + * + * @return 插入后的内存拷贝算子操作指针，如果插入失败则返回nullptr + */ +kernel::KernelExec *InsertMemoryCopy(kernel::SubGraphKernel *subgraph, kernel::KernelExec *origin_kernel, + std::string &name, std::vector *all_tensors, const size_t &index, + const mindspore::Context *ms_ctx) { + auto mem_copy_name = name; + auto in_tensor = origin_kernel->in_tensors().at(index); + auto out_tensor = new (std::nothrow) Tensor(in_tensor->data_type(), in_tensor->shape(), in_tensor->format()); + out_tensor->set_tensor_name(mem_copy_name); + auto mem_copy_kernel = CreateMemoryCopyFunc(in_tensor, out_tensor, mem_copy_name, ms_ctx); + if (mem_copy_kernel == nullptr) { + MS_LOG(ERROR) << "create memory copy kernel failed"; + return nullptr; + } + mem_copy_kernel->desc().memory_type = origin_kernel->desc().memory_type; + all_tensors->push_back(out_tensor); + subgraph->InsertInEdge(origin_kernel, mem_copy_kernel, index); + return mem_copy_kernel; +} + +/** + * @brief 创建一个内存拷贝算子的函数。 + * + * 根据输入和输出张量，以及MindSpore上下文，创建一个内存拷贝的函数。 + * + * @param in_tensor 输入张量。 + * @param out_tensor 输出张量。 + * @param name 函数名称。 + * @param ms_ctx MindSpore上下文指针。 + * + * @return 返回创建的KernelExec指针，如果创建失败则返回nullptr。 + */ +kernel::KernelExec *CreateMemoryCopyFunc(Tensor *in_tensor, Tensor *out_tensor, std::string &name, + const mindspore::Context *ms_ctx) { + std::vector in_tensors; + std::vector out_tensors; + in_tensors.push_back(in_tensor); + out_tensors.push_back(out_tensor); + auto ms_in_tensors = LiteTensorsToMSTensors(in_tensors); + auto ms_out_tensors = LiteTensorsToMSTensors(out_tensors); + + flatbuffers::FlatBufferBuilder fbb(1024); + // create custom kernel + auto val_offset = schema::CreateCustomDirect(fbb, "Custom_FT_MemoryCopy"); + flatbuffers::Offset primitive = + schema::CreatePrimitive(fbb, static_cast(PrimType::PrimType_Custom), val_offset.o); + fbb.Finish(primitive); + const mindspore::schema::Primitive *primitive_ptr = + flatbuffers::GetRoot(fbb.GetBufferPointer()); + auto data_type = in_tensor->data_type(); + auto prim_type = mindspore::schema::PrimitiveType::PrimitiveType_Custom; + std::string kernel_arch = "DSP"; + std::string provider = "FTMatrix"; + auto arch = kernel::KERNEL_ARCH::kDSP; + + kernel::KernelKey key{arch, data_type, NHWC, prim_type, kernel_arch, provider}; + registry::KernelDesc desc{static_cast(key.data_type), key.type, key.kernel_arch, key.provider}; + auto creator = registry::RegisterKernel::GetCreator(primitive_ptr, &desc); + if (creator == nullptr) { + MS_LOG(ERROR) << "creator memory copy kernel error"; + return nullptr; + } + + auto base_kernel = creator(ms_in_tensors, ms_out_tensors, primitive_ptr, ms_ctx); + if (base_kernel != nullptr) { + auto *kernel_exec = new (std::nothrow) kernel::KernelExec(base_kernel); + if (kernel_exec != nullptr) { + kernel::KernelKey tmp_key = key; + tmp_key.arch = kernel::KERNEL_ARCH::kDSP; + kernel_exec->set_desc(tmp_key); + kernel_exec->set_name(name); + MS_LOG(DEBUG) << "create " << name << " kernel success"; + return kernel_exec; + } + } + return nullptr; +} +} // namespace mindspore::lite \ No newline at end of file diff --git a/mindspore-lite/src/litert/storage_pass.h b/mindspore-lite/src/litert/storage_pass.h new file mode 100644 index 00000000..99997549 --- /dev/null +++ b/mindspore-lite/src/litert/storage_pass.h @@ -0,0 +1,40 @@ +#ifndef MINDSPORE_LITE_SRC_STORAGE_STORAGE_PASS_H_ +#define MINDSPORE_LITE_SRC_STORAGE_STORAGE_PASS_H_ + +#include +#include "src/executor/kernel_exec.h" +#include "src/executor/sub_graph_kernel.h" +#include "schema/ops_generated.h" +#include "schema/model_generated.h" + +namespace mindspore::lite { + +STATUS StoragePass(std::vector *subgraphs, std::vector *tensors, + const mindspore::Context *ms_ctx); + +kernel::KernelExec *InsertMemoryCopy(kernel::SubGraphKernel *subgraph, kernel::KernelExec *origin_kernel, + std::string &name, std::vector *all_tensors, const size_t &index, + const mindspore::Context *ms_ctx); + +kernel::KernelExec *CreateMemoryCopyFunc(Tensor *in_tensor, Tensor *out_tensor, std::string &name, + const mindspore::Context *ms_ctx); + +STATUS ProcessKernel(kernel::SubGraphKernel *graph, kernel::KernelExec *origin_kernel, std::vector *tensors, + const mindspore::Context *ms_ctx); + +STATUS ProcessSubgraph(kernel::KernelExec *subgraph, std::vector *tensors, const mindspore::Context *ms_ctx); + +bool HandleGraphInputOrConstTensor(kernel::SubGraphKernel *graph, kernel::KernelExec *origin_kernel, + kernel::MEMORY_TYPE origin_memory_type, Tensor *in_tensor, std::vector *tensors, + size_t index, const mindspore::Context *ms_ctx); + +bool HandleNonGraphInputOrConstTensor(kernel::SubGraphKernel *graph, kernel::KernelExec *origin_kernel, + kernel::KernelExec *in_kernel, std::vector *tensors, size_t index, + const mindspore::Context *ms_ctx); + +bool HandleInputTensors(kernel::SubGraphKernel *graph, kernel::KernelExec *origin_kernel, + std::vector in_kernels, std::vector *tensors, + kernel::MEMORY_TYPE origin_memory_type, Tensor *in_t, const mindspore::Context *ms_ctx, + const size_t &index); +} // namespace mindspore::lite +#endif // MINDSPORE_LITE_SRC_STORAGE_STORAGE_PASS_H_ \ No newline at end of file diff --git a/mindspore-lite/tools/benchmark/CMakeLists.txt b/mindspore-lite/tools/benchmark/CMakeLists.txt index 5a22fd12..4f29389c 100644 --- a/mindspore-lite/tools/benchmark/CMakeLists.txt +++ b/mindspore-lite/tools/benchmark/CMakeLists.txt @@ -58,6 +58,8 @@ else() endif() include_directories(${NNACL_DIR}/../) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) + set(COMMON_SRC ${CMAKE_CURRENT_SOURCE_DIR}/../common/flag_parser.cc ${CMAKE_CURRENT_SOURCE_DIR}/../common/string_util.cc @@ -93,7 +95,8 @@ set(BENCHMARK_SRC ${CMAKE_CURRENT_SOURCE_DIR}/main.cc ${CMAKE_CURRENT_SOURCE_DIR}/run_benchmark.cc ${CMAKE_CURRENT_SOURCE_DIR}/benchmark_base.cc - ${CMAKE_CURRENT_SOURCE_DIR}/benchmark_unified_api.cc) + ${CMAKE_CURRENT_SOURCE_DIR}/benchmark_unified_api.cc + ${CMAKE_CURRENT_SOURCE_DIR}/kernel_config.cc) if(MSLITE_ENABLE_CLOUD_FUSION_INFERENCE OR MSLITE_ENABLE_CLOUD_INFERENCE) set_property(SOURCE ${BENCHMARK_SRC} PROPERTY COMPILE_DEFINITIONS diff --git a/mindspore-lite/tools/benchmark/benchmark_base.h b/mindspore-lite/tools/benchmark/benchmark_base.h index cd156d56..e41f9b9b 100644 --- a/mindspore-lite/tools/benchmark/benchmark_base.h +++ b/mindspore-lite/tools/benchmark/benchmark_base.h @@ -42,7 +42,9 @@ #include "ir/dtype/type_id.h" #include "schema/model_generated.h" #include "nnacl_c/op_base.h" - +#ifdef ENABLE_DSP +#include "kernel_config.h" +#endif namespace mindspore::lite { #define BENCHMARK_LOG_ERROR(str) \ do { \ @@ -135,6 +137,10 @@ class MS_API BenchmarkFlags : public virtual FlagParser { AddFlag(&BenchmarkFlags::perf_profiling_, "perfProfiling", "Perf event profiling(only instructions statics enabled currently)", false); AddFlag(&BenchmarkFlags::perf_event_, "perfEvent", "CYCLE|CACHE|STALL", "CYCLE"); +#ifdef ENABLE_DSP + AddFlag(&BenchmarkFlags::run_benchmark_count_, "runBenchmarkCount", "run benchmark count", 0); + AddFlag(&BenchmarkFlags::kernel_config_file_, "kernelConfigFile", "Kernel config file", ""); +#endif // MarkAccuracy AddFlag(&BenchmarkFlags::benchmark_data_file_, "benchmarkDataFile", "Benchmark data file path", ""); AddFlag(&BenchmarkFlags::benchmark_data_type_, "benchmarkDataType", @@ -210,6 +216,11 @@ class MS_API BenchmarkFlags : public virtual FlagParser { bool enable_gl_texture_ = false; bool enable_parallel_ = false; int warm_up_loop_count_ = 3; +#ifdef ENABLE_DSP + int run_benchmark_count_ = 0; + bool enable_kernel_config_ = false; + std::string kernel_config_file_; +#endif // MarkAccuracy std::string benchmark_data_file_; std::string benchmark_data_type_ = "FLOAT"; @@ -249,6 +260,33 @@ class MS_API BenchmarkBase { int Init(); virtual int RunBenchmark() = 0; +#ifdef ENABLE_DSP + void GetKernelConfigApi(const std::string &filename) { + int start = filename.find_last_of("/"); + int end = filename.find_last_of("."); + std::string result_name = filename.substr(start + 1, end - start - 1); + kernel_config_ = new KernelConfig(result_name + ".json"); + } + + void DeleteKernelConfigApi() { + if (kernel_config_ != nullptr) { + delete kernel_config_; + kernel_config_ = nullptr; + } + } + + int GetRunBenchmarkCount() { + return flags_->run_benchmark_count_; + } + + bool IsEnableKernelConfig() { + if (flags_->run_benchmark_count_ > 0 && flags_->kernel_config_file_.empty()) { + flags_->enable_kernel_config_ = true; + } + return flags_->enable_kernel_config_; + } +#endif + protected: virtual int LoadInput() = 0; @@ -530,9 +568,21 @@ class MS_API BenchmarkBase { float op_cost_total_ = 0.0f; std::map> op_times_by_type_; std::map> op_times_by_name_; +#ifdef ENABLE_DSP + std::map op_start_times_by_name_; + std::map op_end_times_by_name_; + std::map>> op_input_shape_; + std::map> op_input_dtype_; + std::map op_arch_; + std::map op_custom_name_; + std::map op_core_mask_; + std::map op_mem_type_; + KernelConfig *kernel_config_; +#else std::map op_start_times_by_name_; +#endif std::mutex op_times_mutex_; -#ifndef BENCHMARK_CLIP_JSON + #ifndef BENCHMARK_CLIP_JSON // dump data nlohmann::json dump_cfg_json_; #endif diff --git a/mindspore-lite/tools/benchmark/benchmark_unified_api.cc b/mindspore-lite/tools/benchmark/benchmark_unified_api.cc index 722d7f74..05bd51df 100644 --- a/mindspore-lite/tools/benchmark/benchmark_unified_api.cc +++ b/mindspore-lite/tools/benchmark/benchmark_unified_api.cc @@ -534,6 +534,11 @@ int BenchmarkUnifiedApi::InitMSContext(const std::shared_ptr std::shared_ptr dsp_device_info = std::make_shared(); device_list.push_back(dsp_device_info); context->SetEnableParallel(flags_->enable_parallel_); + if (!flags_->kernel_config_file_.empty()) { + context->SetEnableKernelConfig(true, flags_->kernel_config_file_); + } else { + context->SetEnableKernelConfig(flags_->enable_kernel_config_); + } } // CPU priority is behind GPU and NPU @@ -544,6 +549,7 @@ int BenchmarkUnifiedApi::InitMSContext(const std::shared_ptr return RET_OK; } + #ifdef MSLITE_ENABLE_CLOUD_INFERENCE int BenchmarkUnifiedApi::CompareOutputForModelPool(std::vector *outputs) { if (outputs->empty()) { @@ -977,6 +983,19 @@ int BenchmarkUnifiedApi::MarkPerformance() { flags_->model_file_.substr(flags_->model_file_.find_last_of(DELIM_SLASH) + 1).c_str(), flags_->num_threads_, time_min / kFloatMSEC, time_max / kFloatMSEC, time_avg / kFloatMSEC); } + +#ifdef ENABLE_DSP + if (flags_->enable_kernel_config_) { + flags_->run_benchmark_count_--; + kernel_config_->GetKernelConfig(time_min / kFloatMSEC, time_avg / kFloatMSEC, time_max / kFloatMSEC, op_arch_, + op_core_mask_, op_mem_type_, flags_->run_benchmark_count_); + op_times_by_name_.clear(); + op_times_by_type_.clear(); + op_arch_.clear(); + op_core_mask_.clear(); + op_mem_type_.clear(); + } +#endif return RET_OK; } diff --git a/mindspore-lite/tools/benchmark/kernel_config.cc b/mindspore-lite/tools/benchmark/kernel_config.cc new file mode 100644 index 00000000..8ecd4b9b --- /dev/null +++ b/mindspore-lite/tools/benchmark/kernel_config.cc @@ -0,0 +1,85 @@ +#include "kernel_config.h" +#include + +namespace mindspore::lite { + +static const char *kDefaultKernelConfigFilename = "model.json"; + +void KernelConfig::OpenFile() { output_file_stream_.open(filename_, std::ofstream::out | std::ofstream::trunc); } + +KernelConfig::KernelConfig(const std::string &filename) { + filename_ = filename.empty() ? kDefaultKernelConfigFilename : filename; + OpenFile(); + StartLog(); +} + +KernelConfig::KernelConfig(const char *filename_cstr) { + std::string filename(filename_cstr); + filename_ = filename.empty() ? kDefaultKernelConfigFilename : filename; + OpenFile(); + StartLog(); +} + +KernelConfig::~KernelConfig() { + EndLog(); + output_file_stream_.close(); +} + +void KernelConfig::StartLog() { + output_file_stream_ << std::string( + R"JSON([ + )JSON"); +} + +void KernelConfig::EndLog() { + output_file_stream_ << std::string(R"JSON( +])JSON"); +} +void KernelConfig::GetKernelConfig(float min_time, float avg_time, float max_time, + const std::map &op_arch, + const std::map &op_core_mask, + const std::map &op_mem_type, int run_count) { + output_file_stream_ << string_format(std::string(R"JSON({ + "model_time": {"min": %.3f, "avg": %.3f, "max": %.3f}, + "kernel_info": [)JSON"), + min_time, avg_time, max_time); + size_t kernel_count = 0; + std::map result; + for (auto &iter : op_arch) { + auto arch = iter.second; + // delete pnna kernel + if (arch == 8) { + continue; + } + result[iter.first] = arch; + } + size_t result_size = result.size(); + for (auto &iter : result) { + auto kernel_name = iter.first; + ++kernel_count; + auto arch = op_arch.at(kernel_name); + auto core_mask = op_core_mask.at(kernel_name); + auto mem_type = op_mem_type.at(kernel_name); + auto is_last = (kernel_count == result_size); + if (!is_last) { + output_file_stream_ << string_format(std::string(R"JSON( + {"name": "%s","arch": %d,"core_mask": %d,"mem_type": %d},)JSON"), + kernel_name.c_str(), arch, core_mask, mem_type); + } else { + output_file_stream_ << string_format(std::string(R"JSON( + {"name": "%s","arch": %d,"core_mask": %d,"mem_type": %d})JSON"), + kernel_name.c_str(), arch, core_mask, mem_type); + } + } + if (run_count > 0) { + output_file_stream_ << (std::string(R"JSON( + ] + }, + )JSON")); + } else { + output_file_stream_ << (std::string(R"JSON( + ] + })JSON")); + } +} +} // namespace mindspore::lite \ No newline at end of file diff --git a/mindspore-lite/tools/benchmark/kernel_config.h b/mindspore-lite/tools/benchmark/kernel_config.h new file mode 100644 index 00000000..331b7f69 --- /dev/null +++ b/mindspore-lite/tools/benchmark/kernel_config.h @@ -0,0 +1,42 @@ +#ifndef MINDSPORE_LITE_TOOLS_BENCHMARK_KERNEL_CONFIG_H_ +#define MINDSPORE_LITE_TOOLS_BENCHMARK_KERNEL_CONFIG_H_ + +#include +#include +#include +#include +#include +#include "mindspore/lite/src/common/log.h" + +namespace mindspore::lite { + +class KernelConfig { + public: + KernelConfig(const std::string &filename); + KernelConfig(const char *filename); + ~KernelConfig(); + std::string filename() { return filename_; } + void GetKernelConfig(float min_time, float avg_time, float max_time, const std::map &op_arch, + const std::map &op_core_mask, const std::map &op_mem_type, + int run_count); + + template + std::string string_format(const std::string &format, Args... args) { + int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1; // Extra space for '\0' + auto size = static_cast(size_s); + auto buf = std::make_unique(size); + std::snprintf(buf.get(), size, format.c_str(), args...); + return std::string(buf.get(), size - 1); // exclude the '\0' + } + + private: + void OpenFile(); + void StartLog(); + void EndLog(); + + std::string filename_; + std::ofstream output_file_stream_; +}; +} // namespace mindspore::lite + +#endif // MINDSPORE_LITE_TOOLS_BENCHMARK_KERNEL_CONFIG_H_ \ No newline at end of file diff --git a/mindspore-lite/tools/benchmark/run_benchmark.cc b/mindspore-lite/tools/benchmark/run_benchmark.cc index c13d90dd..9487f823 100644 --- a/mindspore-lite/tools/benchmark/run_benchmark.cc +++ b/mindspore-lite/tools/benchmark/run_benchmark.cc @@ -73,7 +73,27 @@ int RunBenchmark(int argc, const char **argv) { } auto model_name = flags.model_file_.substr(flags.model_file_.find_last_of(DELIM_SLASH) + 1); - status = benchmark->RunBenchmark(); +#ifdef ENABLE_DSP + int run_benchmark_count = benchmark->GetRunBenchmarkCount(); + bool enable_kernel_config = benchmark->IsEnableKernelConfig(); + int run_count = 0; + if (enable_kernel_config) { + benchmark->GetKernelConfigApi(model_name); + run_count = run_benchmark_count; + } else { + run_count = 1; + } + for (int i = 0; i < run_count; i++) { +#endif + status = benchmark->RunBenchmark(); + +#ifdef ENABLE_DSP + } + if (enable_kernel_config) { + benchmark->DeleteKernelConfigApi(); + } +#endif + if (status != 0) { BENCHMARK_LOG_ERROR("Run Benchmark " << model_name << " Failed : " << status); delete benchmark; -- Gitee From 8110c51c5f165419fb79c801e2df0ae47a1058c5 Mon Sep 17 00:00:00 2001 From: ZhangMing <2778525216@qq.com> Date: Wed, 31 Dec 2025 20:37:55 +0800 Subject: [PATCH 2/6] support config kernel_config_file and run_benchmark_count by cfg file, Usage: ./benchmark --modelFile=your_model.ms --device=DSP --configFile=benchmark.cfg Signed-off-by: ZhangMing <2778525216@qq.com> --- .../src/litert/cxx_api/model/model_impl.cc | 13 ++++ .../src/litert/cxx_api/model/model_impl.h | 1 + .../tools/benchmark/benchmark_base.h | 8 +-- .../tools/benchmark/benchmark_unified_api.cc | 62 ++++++++++++++++--- .../tools/benchmark/benchmark_unified_api.h | 4 ++ 5 files changed, 75 insertions(+), 13 deletions(-) diff --git a/mindspore-lite/src/litert/cxx_api/model/model_impl.cc b/mindspore-lite/src/litert/cxx_api/model/model_impl.cc index 272c01dd..c9d9a1b8 100644 --- a/mindspore-lite/src/litert/cxx_api/model/model_impl.cc +++ b/mindspore-lite/src/litert/cxx_api/model/model_impl.cc @@ -415,6 +415,19 @@ Status ModelImpl::UpdateConfig(const std::string §ion, const std::pair lock(mutex_); + auto iter = config_info_.find(section); + if (iter == config_info_.end()) { + return ""; + } + auto elem_iter = iter->second.find(key); + if (elem_iter == iter->second.end()) { + return ""; + } + return elem_iter->second; +} + Status ModelImpl::Predict(const std::vector &inputs, std::vector *outputs, const MSKernelCallBack &before, const MSKernelCallBack &after) { std::lock_guard lock(mutex_); diff --git a/mindspore-lite/src/litert/cxx_api/model/model_impl.h b/mindspore-lite/src/litert/cxx_api/model/model_impl.h index f8943afc..e02d6ccf 100644 --- a/mindspore-lite/src/litert/cxx_api/model/model_impl.h +++ b/mindspore-lite/src/litert/cxx_api/model/model_impl.h @@ -85,6 +85,7 @@ class ModelImpl { Status LoadConfig(const std::string &config_path); Status UpdateConfig(const std::string §ion, const std::pair &config); + std::string GetConfig(const std::string §ion, const std::string &key); std::vector GetInputs(); std::vector GetOutputs(); std::vector GetGradients() const; diff --git a/mindspore-lite/tools/benchmark/benchmark_base.h b/mindspore-lite/tools/benchmark/benchmark_base.h index e41f9b9b..aaed109f 100644 --- a/mindspore-lite/tools/benchmark/benchmark_base.h +++ b/mindspore-lite/tools/benchmark/benchmark_base.h @@ -137,10 +137,10 @@ class MS_API BenchmarkFlags : public virtual FlagParser { AddFlag(&BenchmarkFlags::perf_profiling_, "perfProfiling", "Perf event profiling(only instructions statics enabled currently)", false); AddFlag(&BenchmarkFlags::perf_event_, "perfEvent", "CYCLE|CACHE|STALL", "CYCLE"); -#ifdef ENABLE_DSP - AddFlag(&BenchmarkFlags::run_benchmark_count_, "runBenchmarkCount", "run benchmark count", 0); - AddFlag(&BenchmarkFlags::kernel_config_file_, "kernelConfigFile", "Kernel config file", ""); -#endif +// #ifdef ENABLE_DSP +// AddFlag(&BenchmarkFlags::run_benchmark_count_, "runBenchmarkCount", "run benchmark count", 0); +// AddFlag(&BenchmarkFlags::kernel_config_file_, "kernelConfigFile", "Kernel config file", ""); +// #endif // MarkAccuracy AddFlag(&BenchmarkFlags::benchmark_data_file_, "benchmarkDataFile", "Benchmark data file path", ""); AddFlag(&BenchmarkFlags::benchmark_data_type_, "benchmarkDataType", diff --git a/mindspore-lite/tools/benchmark/benchmark_unified_api.cc b/mindspore-lite/tools/benchmark/benchmark_unified_api.cc index 05bd51df..6df541c7 100644 --- a/mindspore-lite/tools/benchmark/benchmark_unified_api.cc +++ b/mindspore-lite/tools/benchmark/benchmark_unified_api.cc @@ -1390,6 +1390,27 @@ int BenchmarkUnifiedApi::RunParallelBenchmark(std::shared_ptrkernel_config_file_ = ms_model_->impl()->GetConfig("benchmark", "kernel_config_file"); + MS_LOG(INFO) << "Kernel config file set to: " << kernel_config_file_; + std::string count_str = ms_model_->impl()->GetConfig("benchmark", "run_benchmark_count"); + flags_->run_benchmark_count_ = stoi(count_str); + MS_LOG(INFO) << "Benchmark will run " << count_str << " times"; +} +// 配置文件示例(benchmark.cfg) +/* +[benchmark] +kernel_config_file = ./model.json +run_benchmark_count = 10 +*/ + +// 使用方法 +/* +./benchmark --modelFile=your_model.ms --device=DSP --configFile=benchmark.cfg +*/ +#endif + int BenchmarkUnifiedApi::RunBenchmark() { auto start_prepare_time = GetTimeUs(); @@ -1414,6 +1435,38 @@ int BenchmarkUnifiedApi::RunBenchmark() { MS_LOG(INFO) << "start unified benchmark run"; std::cout << "start unified benchmark run" << std::endl; + // auto context = std::make_shared(); + // if (context == nullptr) { + // MS_LOG(ERROR) << "New context failed while running " << model_name.c_str(); + // std::cerr << "New context failed while running " << model_name.c_str() << std::endl; + // return RET_ERROR; + // } + + // auto status = InitMSContext(context); + // if (status != RET_OK) { + // MS_LOG(ERROR) << "InitMSContext failed while running " << model_name.c_str(); + // std::cout << "InitMSContext failed while running " << model_name.c_str(); + // return RET_ERROR; + // } + + // (void)UpdateDistributionName(context, &flags_->model_file_); + // (void)UpdateDistributionName(context, &flags_->benchmark_data_file_); + // (void)UpdateDistributionName(context, &flags_->config_file_); + + if (!flags_->config_file_.empty()) { + auto config_ret = ms_model_.LoadConfig(flags_->config_file_); + if (config_ret != kSuccess) { + MS_LOG(ERROR) << "ms_model_.LoadConfig failed while running ", model_name.c_str(); + std::cout << "ms_model_.LoadConfig failed while running ", model_name.c_str(); + } + } + + UpdateConfigInfo(); + +#ifdef ENABLE_DSP + LoadBenchmarkConfig(); // Load kernel_config_file and run_benchmark_count into flags_ +#endif + auto context = std::make_shared(); if (context == nullptr) { MS_LOG(ERROR) << "New context failed while running " << model_name.c_str(); @@ -1432,15 +1485,6 @@ int BenchmarkUnifiedApi::RunBenchmark() { (void)UpdateDistributionName(context, &flags_->benchmark_data_file_); (void)UpdateDistributionName(context, &flags_->config_file_); - if (!flags_->config_file_.empty()) { - auto config_ret = ms_model_.LoadConfig(flags_->config_file_); - if (config_ret != kSuccess) { - MS_LOG(ERROR) << "ms_model_.LoadConfig failed while running ", model_name.c_str(); - std::cout << "ms_model_.LoadConfig failed while running ", model_name.c_str(); - } - } - - UpdateConfigInfo(); #ifdef MSLITE_ENABLE_CLOUD_INFERENCE if (flags_->enable_parallel_predict_) { MS_CHECK_FALSE_MSG(RunParallelBenchmark(context) != RET_OK, RET_ERROR, "run model pool failed."); diff --git a/mindspore-lite/tools/benchmark/benchmark_unified_api.h b/mindspore-lite/tools/benchmark/benchmark_unified_api.h index 18b8229c..d0d76a4b 100644 --- a/mindspore-lite/tools/benchmark/benchmark_unified_api.h +++ b/mindspore-lite/tools/benchmark/benchmark_unified_api.h @@ -52,6 +52,10 @@ class MS_API BenchmarkUnifiedApi : public BenchmarkBase { virtual ~BenchmarkUnifiedApi(); +#ifdef ENABLE_DSP + void LoadBenchmarkConfig(); +#endif + int RunBenchmark() override; protected: -- Gitee From 48f3ae25587dbe10527fd9506d228519cb387ca5 Mon Sep 17 00:00:00 2001 From: ZhangMing <2778525216@qq.com> Date: Wed, 31 Dec 2025 21:08:43 +0800 Subject: [PATCH 3/6] convert mindspore::lite::dsp::MemType to mindspore::kernel::MEMORY_TYPE in dsp Signed-off-by: ZhangMing <2778525216@qq.com> --- .../src/litert/kernel/dsp/dsp_allocator.cc | 8 ++++---- .../src/litert/kernel/dsp/dsp_allocator.h | 15 ++++++++------- .../src/litert/kernel/dsp/dsp_kernel.h | 17 ++++------------- 3 files changed, 16 insertions(+), 24 deletions(-) diff --git a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.cc b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.cc index 56859933..932ed64e 100644 --- a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.cc +++ b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.cc @@ -40,7 +40,7 @@ void DSPAllocator::UnLock() { } } -void *DSPAllocator::MinimumFit(MemType mem_type, size_t size) { +void *DSPAllocator::MinimumFit(MEMORY_TYPE mem_type, size_t size) { auto iter = free_list_.lower_bound(size); while (iter != free_list_.end() && (iter->second->size_ >= size) && (iter->second->size_ < (size << shift_factor_))) { auto mem_buf = iter->second; @@ -58,7 +58,7 @@ void *DSPAllocator::MinimumFit(MemType mem_type, size_t size) { return nullptr; } -void *DSPAllocator::_Malloc(MemType mem_type, size_t size) { +void *DSPAllocator::_Malloc(MEMORY_TYPE mem_type, size_t size) { if (size > dsp_runtime_->GetMaxAllocSize()) { MS_LOG(ERROR) << "MallocData out of max_size, size: " << size; return nullptr; @@ -223,8 +223,8 @@ void DSPAllocator::Clear() { UnLock(); } -MemType DSPAllocator::GetMemType(void *host_ptr) { - MemType mem_type{MemType::DDR}; +MEMORY_TYPE DSPAllocator::GetMemType(void *host_ptr) { + MEMORY_TYPE mem_type{MEMORY_TYPE::kDDR}; Lock(); auto it = allocated_list_.find(host_ptr); if (it == allocated_list_.end()) { diff --git a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h index 563af929..2a04f5bd 100644 --- a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h +++ b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h @@ -27,6 +27,7 @@ #include "src/litert/inner_allocator.h" namespace mindspore::lite::dsp { +using MEMORY_TYPE = mindspore::kernel::MEMORY_TYPE; enum class MemType : char { SMC, DDR, DDR36BIT, L2 }; #define UNLOCK_AND_RETURN_NULL(condition, ptr) \ do { \ @@ -43,7 +44,7 @@ class DSPAllocator : public mindspore::Allocator { ~DSPAllocator() override; using Allocator::Malloc; - void *Malloc(size_t size, MemType type) { return _Malloc(type, size); } + void *Malloc(size_t size, MEMORY_TYPE type) { return _Malloc(type, size); } void *Malloc(size_t size) override { return _Malloc(mem_type_, size); } void Free(void *ptr) override; @@ -54,8 +55,8 @@ class DSPAllocator : public mindspore::Allocator { size_t TotalSize(); void Clear(); - MemType GetMemType(void *host_ptr); - void SetMemType(MemType mem_type) { mem_type_ = mem_type; }; + MEMORY_TYPE GetMemType(void *host_ptr); + void SetMemType(MEMORY_TYPE mem_type) { mem_type_ = mem_type; }; int32_t GetCoreId() { return core_id_; }; void SetCoreId(int32_t core_id) { core_id_ = core_id; }; uint64_t GetDeviceMemPtr(void *buffer); @@ -64,8 +65,8 @@ class DSPAllocator : public mindspore::Allocator { private: void Lock(); void UnLock(); - void *MinimumFit(MemType mem_type, size_t size); - void *_Malloc(MemType mem_type, size_t size = 0); + void *MinimumFit(MEMORY_TYPE mem_type, size_t size); + void *_Malloc(MEMORY_TYPE mem_type, size_t size = 0); template void ClearMemList(T *list); @@ -79,7 +80,7 @@ class DSPAllocator : public mindspore::Allocator { size_t size_{0}; uint64_t device_ptr_{0}; void *host_ptr_{nullptr}; - MemType mem_type_{MemType::DDR}; + MEMORY_TYPE mem_type_ {MEMORY_TYPE::kDDR}; }; // buf, membuf> @@ -89,7 +90,7 @@ class DSPAllocator : public mindspore::Allocator { // 6 is empirical value int shift_factor_ = 6; bool lock_flag_ = true; - MemType mem_type_{MemType::DDR}; + MEMORY_TYPE mem_type_ {MEMORY_TYPE::kDDR}; }; } // namespace mindspore::lite::dsp diff --git a/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h b/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h index 9731e02d..d6d2f2c1 100644 --- a/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h +++ b/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h @@ -63,8 +63,8 @@ class DSPKernel : public LiteKernel { bool MallocDataDone(); virtual int CheckSpecs() { return RET_OK; } - lite::dsp::MemType GetMemType() { return out_mem_type_; } - void SetMemType(lite::dsp::MemType mem_type) { out_mem_type_ = mem_type; } + MEMORY_TYPE GetMemType() { return out_mem_type_; } + void SetMemType(MEMORY_TYPE mem_type) { out_mem_type_ = mem_type; } int32_t GetCoreId() { return core_id_; } void SetCoreId(int32_t core_id) { core_id_ = core_id; } void SetKernelArg(const std::vector &kernel_args = {}) { kernel_args_ = kernel_args; } @@ -73,7 +73,7 @@ class DSPKernel : public LiteKernel { protected: lite::dsp::DSPRuntime *dsp_runtime_; std::vector kernel_args_; - lite::dsp::MemType out_mem_type_{lite::dsp::MemType::DDR}; + MEMORY_TYPE out_mem_type_{MEMORY_TYPE::kDDR}; int32_t core_id_{0}; private: lite::dsp::DSPRuntimeInnerWrapper dsp_runtime_wrapper_; @@ -105,16 +105,7 @@ kernel::LiteKernel *DSPKernelCreator(const std::vector &inputs, return nullptr; } auto dsp_kernel = reinterpret_cast(kernel); - if (desc.memory_type == MEMORY_TYPE::kShareMemory) { - dsp_kernel->SetMemType(lite::dsp::MemType::SMC); - } else if (desc.memory_type == MEMORY_TYPE::kDDR) { - dsp_kernel->SetMemType(lite::dsp::MemType::DDR); - } else if (desc.memory_type == MEMORY_TYPE::kPrivateMemory) { - dsp_kernel->SetMemType(lite::dsp::MemType::L2); - } else { - MS_LOG(WARNING) << "Unknown memory type: " << static_cast(desc.memory_type) << ", using default SMC"; - dsp_kernel->SetMemType(lite::dsp::MemType::SMC); // 安全降级 - } + dsp_kernel->SetMemType(desc.memory_type); dsp_kernel->SetCoreId(GetCoreIdByCoreMask(desc.core_mask)); MS_LOG(DEBUG) << "kernel " << opParameter->name_ << " create success!" -- Gitee From c75323e31797114afa4b6196807195bb9742730f Mon Sep 17 00:00:00 2001 From: ZhangMing <2778525216@qq.com> Date: Mon, 19 Jan 2026 21:44:02 +0800 Subject: [PATCH 4/6] baseline_debug Signed-off-by: ZhangMing <2778525216@qq.com> --- build.sh | 2 +- dsp_sdk | 1 + include/api/types.h | 6 + .../common/ops/populate/custom_populate.cc | 2 +- mindspore-lite/src/executor/kernel_exec.h | 28 ++- mindspore-lite/src/litert/cxx_api/context.cc | 8 + .../src/litert/cxx_api/model/model_impl.cc | 2 +- mindspore-lite/src/litert/infer_manager.cc | 8 +- mindspore-lite/src/litert/inner_context.h | 3 + .../src/litert/kernel/cpu/base/custom_base.cc | 10 +- .../src/litert/kernel/dsp/dsp_allocator.h | 1 + mindspore-lite/src/litert/kernel_registry.h | 11 +- mindspore-lite/src/litert/scheduler.cc | 32 ++-- mindspore-lite/src/litert/scheduler.h | 5 +- mindspore-lite/src/litert/storage_pass.cc | 43 ++--- .../tools/benchmark/benchmark_base.cc | 152 +++++++++++++++ .../tools/benchmark/benchmark_base.h | 18 +- .../tools/benchmark/benchmark_unified_api.cc | 173 ++++++++++-------- .../tools/benchmark/benchmark_unified_api.h | 4 - .../tools/benchmark/kernel_config.cc | 82 +++++++++ .../tools/benchmark/kernel_config.h | 1 + .../tools/benchmark/run_benchmark.cc | 14 +- 22 files changed, 434 insertions(+), 172 deletions(-) create mode 160000 dsp_sdk diff --git a/build.sh b/build.sh index 80bbf0f1..f63e597d 100755 --- a/build.sh +++ b/build.sh @@ -48,7 +48,7 @@ build_exit() exit 1 } -update_submodule +#update_submodule echo "---------------- MindSpore-Lite: build start ----------------" init_default_options process_options "$@" diff --git a/dsp_sdk b/dsp_sdk new file mode 160000 index 00000000..3fbb2903 --- /dev/null +++ b/dsp_sdk @@ -0,0 +1 @@ +Subproject commit 3fbb290365c4ae5b0becb3bb8c6ad4ddc88c541e diff --git a/include/api/types.h b/include/api/types.h index 25eb1ebf..2bc3223b 100644 --- a/include/api/types.h +++ b/include/api/types.h @@ -422,6 +422,12 @@ struct MSCallBackParam { std::string node_name; /**< node name argument */ std::string node_type; /**< node type argument */ double execute_time; /**< gpu execute time */ +#ifdef ENABLE_DSP + int arch{0x0}; + int core_mask{0x1}; + std::string custom_kernel_name{""}; + int mem_type{0}; +#endif }; /// \brief KernelCallBack defined the function pointer for callBack. diff --git a/mindspore-lite/src/common/ops/populate/custom_populate.cc b/mindspore-lite/src/common/ops/populate/custom_populate.cc index 85689387..e974efcc 100644 --- a/mindspore-lite/src/common/ops/populate/custom_populate.cc +++ b/mindspore-lite/src/common/ops/populate/custom_populate.cc @@ -185,7 +185,7 @@ OpParameter *CreateNpuOfflineModelParameter(const void *prim) { return nullptr; } memset(param, 0, sizeof(CustomParameter)); - param->op_parameter_.type_ = PrimType_Inner_ThirdPartyModel; + //param->op_parameter_.type_ = PrimType::PrimType_Inner_ThirdPartyModel; // The offline model only uses the attr_data [0] field, and other fields do not need to be assigned values. param->attr_data[0] = static_cast(const_cast(prim)); return reinterpret_cast(param); diff --git a/mindspore-lite/src/executor/kernel_exec.h b/mindspore-lite/src/executor/kernel_exec.h index 81e6ebc7..3fc024d5 100644 --- a/mindspore-lite/src/executor/kernel_exec.h +++ b/mindspore-lite/src/executor/kernel_exec.h @@ -62,21 +62,12 @@ enum KERNEL_ARCH { kKernelArch_MAX = kAPU }; static const char *const kBuiltin = "Builtin"; - -int GetCoreIdByCoreMask(int core_mask) { -#ifdef MT_7004 +inline int GetCoreIdByCoreMask(int core_mask) { for (int i = 0; i < 4; ++i) { if ((core_mask >> i) & 1) return i; } -#endif -#ifdef FT_78NE - for (int i = 0; i < 8; ++i) { - if ((core_mask >> i) & 1) return i; - } -#endif return -1; } - enum MEMORY_TYPE { kShareMemory, // lite::dsp::MemType::SMC kDDR, // lite::dsp::MemType::DDR @@ -144,9 +135,26 @@ class KernelExec { auto ret = DoExecute(); if (after != nullptr) { +#ifdef ENABLE_DSP + auto desc = this->desc(); + MSCallBackParam opInfo; + opInfo.node_name = this->name(); + opInfo.node_type = TypeName(type()); + opInfo.arch = static_cast(desc.arch); + opInfo.core_mask = desc.core_mask; + opInfo.mem_type = static_cast(desc.memory_type); + if (type() == schema::PrimitiveType_Custom) { + auto type = kernel_->GetAttr("type"); + opInfo.custom_kernel_name = type; + } + if (!after(this->in_tensors(), this->out_tensors(), opInfo)) { + MS_LOG(WARNING) << "run kernel after_callback failed, name: " << this->name(); + } +#else if (!after(this->in_tensors(), this->out_tensors(), {this->name(), TypeName(type())})) { MS_LOG(WARNING) << "run kernel after_callback failed, name: " << this->name(); } +#endif } return ret; } diff --git a/mindspore-lite/src/litert/cxx_api/context.cc b/mindspore-lite/src/litert/cxx_api/context.cc index 7ca24d92..81a3c6a1 100644 --- a/mindspore-lite/src/litert/cxx_api/context.cc +++ b/mindspore-lite/src/litert/cxx_api/context.cc @@ -254,6 +254,14 @@ void Context::SetEnableKernelConfig(bool is_enable, const std::string &config_fi } data_->enable_kernel_config_ = is_enable; data_->kernel_config_file_ = config_file; + if(is_enable) + MS_LOG(INFO) << "Context::data_->enable_kernel_config_ is true"; + else + MS_LOG(INFO) << "Context::data_->enable_kernel_config_ is false"; + if(!config_file.empty()) + MS_LOG(INFO) << "Context::data_->kernel_config_file_ is " << config_file; + else + MS_LOG(INFO) << "Context::data_->kernel_config_file_ is empty"; } bool Context::GetKernelConfig() const { diff --git a/mindspore-lite/src/litert/cxx_api/model/model_impl.cc b/mindspore-lite/src/litert/cxx_api/model/model_impl.cc index c9d9a1b8..972b0a77 100644 --- a/mindspore-lite/src/litert/cxx_api/model/model_impl.cc +++ b/mindspore-lite/src/litert/cxx_api/model/model_impl.cc @@ -420,7 +420,7 @@ std::string ModelImpl::GetConfig(const std::string §ion, const std::string & auto iter = config_info_.find(section); if (iter == config_info_.end()) { return ""; - } + } auto elem_iter = iter->second.find(key); if (elem_iter == iter->second.end()) { return ""; diff --git a/mindspore-lite/src/litert/infer_manager.cc b/mindspore-lite/src/litert/infer_manager.cc index 5aceef86..4e33d8df 100644 --- a/mindspore-lite/src/litert/infer_manager.cc +++ b/mindspore-lite/src/litert/infer_manager.cc @@ -189,10 +189,10 @@ int KernelInferShape(const std::vector &inputs, const std::vecto MS_LOG(ERROR) << "No input!"; return RET_ERROR; } - if (parameter->type_ == static_cast(PrimType_Inner_ThirdPartyModel)) { - MS_LOG(INFO) << "No need infer shape for PrimType_Inner_ThirdPartyModel."; - return RET_OK; - } + // if (parameter->type_ == static_cast(PrimType_Inner_ThirdPartyModel)) { + // MS_LOG(INFO) << "No need infer shape for PrimType_Inner_ThirdPartyModel."; + // return RET_OK; + // } std::vector in_tensors; std::vector out_tensors; int ret = GenerateInTensorC(inputs, &in_tensors, allocator); diff --git a/mindspore-lite/src/litert/inner_context.h b/mindspore-lite/src/litert/inner_context.h index 19f61ad8..cefbacd5 100644 --- a/mindspore-lite/src/litert/inner_context.h +++ b/mindspore-lite/src/litert/inner_context.h @@ -147,6 +147,9 @@ struct MS_API InnerContext { std::unordered_map> link_info_{}; const ExecEnv *GetExecEnv() const { return &exec_env_; } + bool enable_kernel_config_ = false; + std::string kernel_config_file_ = ""; + private: int IsValid(); bool IsAllDeviceTypeValid() const; diff --git a/mindspore-lite/src/litert/kernel/cpu/base/custom_base.cc b/mindspore-lite/src/litert/kernel/cpu/base/custom_base.cc index d5dcb57b..f4c19666 100644 --- a/mindspore-lite/src/litert/kernel/cpu/base/custom_base.cc +++ b/mindspore-lite/src/litert/kernel/cpu/base/custom_base.cc @@ -34,9 +34,9 @@ int CustomBaseCPUKernel::ReSize() { return RET_OK; } int CustomBaseCPUKernel::Run() { return RET_OK; } -REG_KERNEL(kCPU, kNumberTypeInt32, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) -REG_KERNEL(kCPU, kNumberTypeFloat32, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) -REG_KERNEL(kCPU, kNumberTypeInt8, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) -REG_KERNEL(kCPU, kNumberTypeUInt8, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) -REG_KERNEL(kCPU, kNumberTypeBool, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +// REG_KERNEL(kCPU, kNumberTypeInt32, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +// REG_KERNEL(kCPU, kNumberTypeFloat32, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +// REG_KERNEL(kCPU, kNumberTypeInt8, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +// REG_KERNEL(kCPU, kNumberTypeUInt8, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +// REG_KERNEL(kCPU, kNumberTypeBool, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h index 2a04f5bd..a14a2cb0 100644 --- a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h +++ b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h @@ -25,6 +25,7 @@ #include #include #include "src/litert/inner_allocator.h" +#include "src/executor/kernel_exec.h" namespace mindspore::lite::dsp { using MEMORY_TYPE = mindspore::kernel::MEMORY_TYPE; diff --git a/mindspore-lite/src/litert/kernel_registry.h b/mindspore-lite/src/litert/kernel_registry.h index ad9de666..a57ea9ed 100644 --- a/mindspore-lite/src/litert/kernel_registry.h +++ b/mindspore-lite/src/litert/kernel_registry.h @@ -78,7 +78,6 @@ class KernelRegistrar { KernelRegistrar(const kernel::KernelKey &desc, kernel::KernelCreator creator) { KernelRegistry::GetInstance()->RegKernel(desc, creator); } - ~KernelRegistrar() = default; KernelRegistrar(const kernel::KERNEL_ARCH arch, const TypeId data_type, const int op_type, kernel::KernelCreator creator) { @@ -86,21 +85,25 @@ class KernelRegistrar { } KernelRegistrar(const kernel::KERNEL_ARCH arch, const TypeId data_type, const int op_type, - const int memory_type, kernel::KernelCreator creator) { + const kernel::MEMORY_TYPE memory_type, kernel::KernelCreator creator) { KernelRegistry::GetInstance()->RegKernel(arch, data_type, op_type, memory_type, creator); } KernelRegistrar(const kernel::KERNEL_ARCH arch, const TypeId data_type, const int op_type, - const int memory_type, const int core_mask, kernel::KernelCreator creator) { + const kernel::MEMORY_TYPE memory_type, const int core_mask, kernel::KernelCreator creator) { KernelRegistry::GetInstance()->RegKernel(arch, data_type, op_type, memory_type, core_mask, creator); } + + ~KernelRegistrar() = default; }; #define REG_KERNEL(arch, data_type, op_type, kernelCreater) \ static KernelRegistrar g_##arch##data_type##op_type##kernelReg(arch, data_type, op_type, kernelCreater); +/* #define REG_DSP_KERNEL(arch, data_type, op_type, memory_type, kernelCreater) \ - static KernelRegistrar g_##arch##data_type##op_type##memory_type##kernelReg(arch, data_type, op_type, memory_type, kernelCreater); + static KernelRegistrar g_##arch##data_type##op_type##memory_type##kernelReg(arch, data_type, op_type, memory_type, kernelCreater); +*/ #define REG_DSP_KERNEL(arch, data_type, op_type, memory_type, core_mask, kernelCreater) \ static KernelRegistrar g_##arch##data_type##op_type##memory_type##core_mask##kernelReg(arch, data_type, op_type, memory_type, core_mask, kernelCreater); diff --git a/mindspore-lite/src/litert/scheduler.cc b/mindspore-lite/src/litert/scheduler.cc index e0a1121f..c12130f8 100644 --- a/mindspore-lite/src/litert/scheduler.cc +++ b/mindspore-lite/src/litert/scheduler.cc @@ -425,7 +425,9 @@ int Scheduler::Schedule(std::vector *dst_kernels) { << "TypeId(" << kernel->desc().data_type << "); " << "OpType(" << PrimitiveCurVersionTypeName(kernel->desc().type) << "); " << "format(" << kernel->desc().format << "); " - << "arch(" << kernel->desc().arch << ")"; + << "arch(" << kernel->desc().arch << ")" + << "mem_type(" << kernel->desc().memory_type<< ")" + << "core_mask(" << kernel->desc().core_mask<< ")"; } ret = CheckCpuValid(dst_kernels); if (ret != RET_OK) { @@ -1243,7 +1245,7 @@ int Scheduler::SelectKernelByDeviceList(const std::vector &in_tensors, bool dsp_priority = DeviceTypePriority(context_, DT_DSP, DT_CPU); bool use_dsp_kernel = node->device_type_ == DT_DSP || node->device_type_ == kDefaultDeviceType; if (dsp_priority && use_dsp_kernel) { - status = FindDspKernel(in_tensors, out_tensors, op_parameter, desc, &kernel, prefer_data_type); + status = FindDspKernel(in_tensors, out_tensors, op_parameter, desc, kernel, prefer_data_type); if (status == RET_OK) { return status; } else { @@ -1315,7 +1317,7 @@ int Scheduler::SelectKernelByDeviceList(const std::vector &in_tensors, MS_LOG(DEBUG) << "Get fp16 op failed, back to fp32 op."; desc.data_type = kNumberTypeFloat32; } - status = FindCpuKernel(in_tensors, out_tensors, op_parameter, desc, kNumberTypeFloat32, &kernel); + status = FindCpuKernel(in_tensors, out_tensors, op_parameter, desc, kNumberTypeFloat32, kernel); if (status == RET_OK) { return status; } else if (status == RET_ERROR) { @@ -1368,10 +1370,12 @@ int Scheduler::SelectKernelByConfigFile(const std::vector &in_tensors, bool dsp_priority = DeviceTypePriority(context_, DT_DSP, DT_CPU); bool use_dsp_kernel = node->device_type_ == DT_DSP || node->device_type_ == kDefaultDeviceType; if (dsp_priority && use_dsp_kernel) { - status = FindDspKernel(in_tensors, out_tensors, op_parameter, desc, &kernel, prefer_data_type); + status = FindDspKernel(in_tensors, out_tensors, op_parameter, desc, kernel, prefer_data_type); if (status == RET_OK) { - kernel->desc().memory_type = kernel_info->memory_type; - kernel->desc().core_mask = kernel_info->core_mask; + auto current_desc = (*kernel)->desc(); + current_desc.memory_type = kernel_info->memory_type; + current_desc.core_mask = kernel_info->core_mask; + (*kernel)->set_desc(current_desc); return status; } else { MS_LOG(DEBUG) << "Get dsp op failed, scheduler to cpu: " << PrimitiveCurVersionTypeName(desc.type) << " " @@ -1434,22 +1438,18 @@ int Scheduler::SelectKernelRandomly(const std::vector &in_tensors, bool dsp_priority = generate_priority(rng); bool use_dsp_kernel = node->device_type_ == DT_DSP || node->device_type_ == kDefaultDeviceType; if (dsp_priority && use_dsp_kernel) { - status = FindDspKernel(in_tensors, out_tensors, op_parameter, desc, &kernel, prefer_data_type); + status = FindDspKernel(in_tensors, out_tensors, op_parameter, desc, kernel, prefer_data_type); if (status == RET_OK) { - std::vector coremark; + std::vector coremark = {1, 3, 15}; std::vector all_mem_types = {kernel::MEMORY_TYPE::kShareMemory, kernel::MEMORY_TYPE::kDDR, kernel::MEMORY_TYPE::kPrivateMemory}; - #ifdef MT_7004 - coremask = {1, 3, 15}; - #endif - #ifdef FT_78NE - coremask = {1, 3, 15, 255}; - #endif std::uniform_int_distribution<> generate_coremark(0, coremark.size() - 1); std::uniform_int_distribution<> generate_memtype(0, all_mem_types.size() - 1); - kernel->desc().memory_type = all_mem_types[generate_memtype(rng)]; - kernel->desc().core_mask = coremark[generate_coremark(rng)]; + auto current_desc = (*kernel)->desc(); + current_desc.memory_type = all_mem_types[generate_memtype(rng)]; + current_desc.core_mask = coremark[generate_coremark(rng)]; + (*kernel)->set_desc(current_desc); return status; } else { MS_LOG(DEBUG) << "Get dsp op failed, scheduler to cpu: " << PrimitiveCurVersionTypeName(desc.type) << " " diff --git a/mindspore-lite/src/litert/scheduler.h b/mindspore-lite/src/litert/scheduler.h index f844f41c..a3fe0c16 100644 --- a/mindspore-lite/src/litert/scheduler.h +++ b/mindspore-lite/src/litert/scheduler.h @@ -35,6 +35,7 @@ #include "src/common/file_utils.h" #include +using MEMORY_TYPE = mindspore::kernel::MEMORY_TYPE; struct ModelTime { double min; double avg; @@ -45,7 +46,7 @@ struct KernelInfo { std::string name; int arch; int core_mask; - int memory_type; + MEMORY_TYPE memory_type; }; namespace mindspore::lite { constexpr int kDefaultDeviceType = -1; @@ -114,7 +115,7 @@ class Scheduler { kinfo.name = kernel["name"]; kinfo.arch = kernel["arch"]; kinfo.core_mask = kernel["core_mask"]; - kinfo.mem_type = kernel["mem_type"]; + kinfo.memory_type = kernel["mem_type"]; kernel_info_.push_back(kinfo); } } diff --git a/mindspore-lite/src/litert/storage_pass.cc b/mindspore-lite/src/litert/storage_pass.cc index 77a6cde5..deb5b313 100644 --- a/mindspore-lite/src/litert/storage_pass.cc +++ b/mindspore-lite/src/litert/storage_pass.cc @@ -61,7 +61,9 @@ bool HandleGraphInputOrConstTensor(kernel::SubGraphKernel *graph, kernel::Kernel MS_LOG(ERROR) << "InsertMemoryCopy failed."; return false; } - mem_copy_kernel->desc().core_mask = origin_kernel->desc().core_mask; + auto mem_copy_kernel_desc = mem_copy_kernel->desc(); + mem_copy_kernel_desc.core_mask = origin_kernel->desc().core_mask; + mem_copy_kernel->set_desc(mem_copy_kernel_desc); graph->SetInNodes(kernel::KernelExecUtil::SubgraphInputNodes(graph->nodes())); graph->SetOutNodes(kernel::KernelExecUtil::SubgraphOutputNodes(graph->nodes())); auto ret = graph->TopologicalSortNodes(); @@ -96,12 +98,13 @@ bool HandleNonGraphInputOrConstTensor(kernel::SubGraphKernel *graph, kernel::Ker MS_LOG(ERROR) << "InsertMemoryCopy failed."; return false; } - if (origin_kernel->desc().memory_type == MEMORY_TYPE::kPrivateMemory) { - mem_copy_kernel->desc().core_mask = origin_kernel->desc().core_mask; + auto origin_kernel_desc = origin_kernel->desc(); + if (origin_kernel_desc.memory_type == MEMORY_TYPE::kPrivateMemory) { + origin_kernel_desc.core_mask = origin_kernel->desc().core_mask; } else { - mem_copy_kernel->desc().core_mask = in_kernel->desc().core_mask; + origin_kernel_desc.core_mask = in_kernel->desc().core_mask; } - + origin_kernel->set_desc(origin_kernel_desc); auto in_tensors = origin_kernel->in_tensors(); for (size_t j = 0; j < in_tensors.size(); j++) { auto in_tensor = in_tensors.at(j); @@ -158,8 +161,9 @@ bool HandleInputTensors(kernel::SubGraphKernel *graph, kernel::KernelExec *origi } auto in_kernel = in_kernels.at(in_kernel_index); bool need_copy = false; - MEMORY_TYPE in_memory_type = in_kernel->desc().memory_type; -#ifdef MT_7004 + +#ifdef ENBALE_DSP + MEMORY_TYPE in_memory_type = in_kernel->desc().memory_type; KernelKey in_desc = in_kernel->desc(); int in_core_mask = in_desc.core_mask; int in_core_id = kernel::GetCoreIdByCoreMask(in_core_mask); @@ -174,27 +178,8 @@ bool HandleInputTensors(kernel::SubGraphKernel *graph, kernel::KernelExec *origi in_core_id != origin_core_id; need_copy = is_mem_type_diff || is_am_mem_type_diff_core; - -#elif defined(FT_78NE) - if (origin_memory_type == MEMORY_TYPE::kShareMemory) { - need_copy = in_memory_type != MEMORY_TYPE::kShareMemory; - } else if (origin_memory_type == MEMORY_TYPE::kPrivateMemory) { - need_copy = in_memory_type != MEMORY_TYPE::kPrivateMemory; - if (!need_copy) { - KernelKey in_desc = in_kernel->desc(); - int in_core_mask = in_desc.core_mask; - int in_core_id = kernel::GetCoreIdByCoreMask(in_core_mask); - - KernelKey origin_desc = origin_kernel->desc(); - int origin_core_mask = origin_desc.core_mask; - int origin_core_id = kernel::GetCoreIdByCoreMask(origin_core_mask); - - need_copy = in_core_id != origin_core_id; - } - } else if (origin_memory_type == MEMORY_TYPE::kDDR) { - need_copy = (in_memory_type == MEMORY_TYPE::kShareMemory) || (in_memory_type == MEMORY_TYPE::kPrivateMemory); - } #endif + if (need_copy && !HandleNonGraphInputOrConstTensor(graph, origin_kernel, in_kernel, tensors, index, ms_ctx)) { return false; } @@ -278,7 +263,9 @@ kernel::KernelExec *InsertMemoryCopy(kernel::SubGraphKernel *subgraph, kernel::K MS_LOG(ERROR) << "create memory copy kernel failed"; return nullptr; } - mem_copy_kernel->desc().memory_type = origin_kernel->desc().memory_type; + auto mem_copy_kernel_desc = mem_copy_kernel->desc(); + mem_copy_kernel_desc.memory_type = origin_kernel->desc().memory_type; + mem_copy_kernel->set_desc(mem_copy_kernel_desc); all_tensors->push_back(out_tensor); subgraph->InsertInEdge(origin_kernel, mem_copy_kernel, index); return mem_copy_kernel; diff --git a/mindspore-lite/tools/benchmark/benchmark_base.cc b/mindspore-lite/tools/benchmark/benchmark_base.cc index 333e77ff..b839da8a 100644 --- a/mindspore-lite/tools/benchmark/benchmark_base.cc +++ b/mindspore-lite/tools/benchmark/benchmark_base.cc @@ -606,6 +606,158 @@ int BenchmarkBase::Init() { return RET_OK; } +void BenchmarkBase::LoadBenchmarkConfig() { + std::string config_file_path = flags_->config_file_; + if (config_file_path.empty()) { + MS_LOG(WARNING) << "Config file path is empty, using default settings"; + return; + } + std::ifstream config_file(config_file_path); + if (!config_file.is_open()) { + MS_LOG(ERROR) << "Failed to open config file: " << config_file_path; + return; + } + + MS_LOG(INFO) << "Loading config file: " << config_file_path; + + std::string line; + bool in_benchmark_section = false; + std::string kernel_config_value; + std::string run_count_value; + + while (std::getline(config_file, line)) { + // 移除行尾的\r (处理Windows格式文件) + if (!line.empty() && line.back() == '\r') { + line.pop_back(); + } + + // 去除行首尾空格和制表符 + auto trim = [](std::string &str) { + // 删除首部空格 + size_t start = str.find_first_not_of(" \t\r\n"); + if (start == std::string::npos) { + str = ""; + return; + } + // 删除尾部空格 + size_t end = str.find_last_not_of(" \t\r\n"); + str = str.substr(start, end - start + 1); + }; + trim(line); + + MS_LOG(DEBUG) << "Processing line: \"" << line << "\""; + + // 跳过空行和注释 + if (line.empty() || line[0] == '#' || line[0] == ';') continue; + + // 处理节头 + if (line.front() == '[' && line.back() == ']') { + std::string section = line.substr(1, line.size() - 2); + trim(section); + + // 不区分大小写的节名比较 + std::string lower_section = section; + std::transform(lower_section.begin(), lower_section.end(), lower_section.begin(), ::tolower); + + MS_LOG(DEBUG) << "Found section: " << section << ", lowercased: " << lower_section; + in_benchmark_section = (lower_section == "benchmark"); + continue; + } + + // 仅处理benchmark节内的配置 + if (!in_benchmark_section) { + MS_LOG(DEBUG) << "Skipping line outside benchmark section: " << line; + continue; + } + + // 解析键值对 + size_t pos = line.find('='); + if (pos == std::string::npos) { + MS_LOG(DEBUG) << "Line has no '=' character: " << line; + continue; + } + + std::string key = line.substr(0, pos); + std::string value = line.substr(pos + 1); + trim(key); + trim(value); + + // 不区分大小写的键名比较 + std::string lower_key = key; + std::transform(lower_key.begin(), lower_key.end(), lower_key.begin(), ::tolower); + + MS_LOG(DEBUG) << "Found key-value pair: " << key << " = " << value; + + if (lower_key == "kernel_config_file") { + kernel_config_value = value; + MS_LOG(DEBUG) << "Set kernel_config_file to: " << kernel_config_value; + } else if (lower_key == "run_benchmark_count") { + run_count_value = value; + MS_LOG(DEBUG) << "Set run_benchmark_count to: " << run_count_value; + } + } + config_file.close(); + + MS_LOG(INFO) << "Finished parsing config file. kernel_config_value: \"" + << kernel_config_value << "\", run_count_value: \"" << run_count_value << "\""; + + // 4. 处理变量替换（${CURRENT_DIR}） + if (!kernel_config_value.empty()) { + // 替换${CURRENT_DIR}为实际路径 + char cwd[PATH_MAX]; + if (getcwd(cwd, sizeof(cwd)) != nullptr) { + size_t pos = 0; + std::string current_dir(cwd); + std::string placeholder = "${CURRENT_DIR}"; + + while ((pos = kernel_config_value.find(placeholder, pos)) != std::string::npos) { + kernel_config_value.replace(pos, placeholder.length(), current_dir); + pos += current_dir.length(); + } + MS_LOG(INFO) << "After variable replacement, kernel_config_file: " << kernel_config_value; + } else { + MS_LOG(WARNING) << "Failed to get current working directory"; + } + } else { + MS_LOG(WARNING) << "kernel_config_file not specified in config file"; + } + + flags_->kernel_config_file_ = kernel_config_value; + + int run_count = 1; // 默认值 + if (!run_count_value.empty()) { + try { + run_count = std::stoi(run_count_value); + if (run_count < 1) { + MS_LOG(WARNING) << "Invalid run count " << run_count_value + << ", using default value 1"; + run_count = 1; + } else { + MS_LOG(INFO) << "Using specified run count: " << run_count; + } + } catch (const std::exception &e) { + MS_LOG(WARNING) << "Invalid run count format: " << run_count_value + << ", error: " << e.what() + << ", using default value 1"; + } + } + flags_->run_benchmark_count_ = run_count; + + MS_LOG(INFO) << "Kernel config file set to: " << flags_->kernel_config_file_; + MS_LOG(INFO) << "Benchmark will run " << flags_->run_benchmark_count_ << " times"; +} +// 配置文件示例(benchmark.cfg) +/* +[benchmark] +kernel_config_file = ./model.json +run_benchmark_count = 10 +*/ + +// 使用方法 +/* +./benchmark --modelFile=your_model.ms --device=DSP --configFile=benchmark.cfg +*/ + int BenchmarkBase::PrintResult(const std::vector &title, const std::map> &result) { std::vector columnLenMax(kPrintColNum); diff --git a/mindspore-lite/tools/benchmark/benchmark_base.h b/mindspore-lite/tools/benchmark/benchmark_base.h index aaed109f..978c082a 100644 --- a/mindspore-lite/tools/benchmark/benchmark_base.h +++ b/mindspore-lite/tools/benchmark/benchmark_base.h @@ -42,9 +42,8 @@ #include "ir/dtype/type_id.h" #include "schema/model_generated.h" #include "nnacl_c/op_base.h" -#ifdef ENABLE_DSP #include "kernel_config.h" -#endif + namespace mindspore::lite { #define BENCHMARK_LOG_ERROR(str) \ do { \ @@ -137,10 +136,6 @@ class MS_API BenchmarkFlags : public virtual FlagParser { AddFlag(&BenchmarkFlags::perf_profiling_, "perfProfiling", "Perf event profiling(only instructions statics enabled currently)", false); AddFlag(&BenchmarkFlags::perf_event_, "perfEvent", "CYCLE|CACHE|STALL", "CYCLE"); -// #ifdef ENABLE_DSP -// AddFlag(&BenchmarkFlags::run_benchmark_count_, "runBenchmarkCount", "run benchmark count", 0); -// AddFlag(&BenchmarkFlags::kernel_config_file_, "kernelConfigFile", "Kernel config file", ""); -// #endif // MarkAccuracy AddFlag(&BenchmarkFlags::benchmark_data_file_, "benchmarkDataFile", "Benchmark data file path", ""); AddFlag(&BenchmarkFlags::benchmark_data_type_, "benchmarkDataType", @@ -216,11 +211,10 @@ class MS_API BenchmarkFlags : public virtual FlagParser { bool enable_gl_texture_ = false; bool enable_parallel_ = false; int warm_up_loop_count_ = 3; -#ifdef ENABLE_DSP + //Config int run_benchmark_count_ = 0; bool enable_kernel_config_ = false; std::string kernel_config_file_; -#endif // MarkAccuracy std::string benchmark_data_file_; std::string benchmark_data_type_ = "FLOAT"; @@ -260,7 +254,8 @@ class MS_API BenchmarkBase { int Init(); virtual int RunBenchmark() = 0; -#ifdef ENABLE_DSP + void LoadBenchmarkConfig(); + void GetKernelConfigApi(const std::string &filename) { int start = filename.find_last_of("/"); int end = filename.find_last_of("."); @@ -285,7 +280,6 @@ class MS_API BenchmarkBase { } return flags_->enable_kernel_config_; } -#endif protected: virtual int LoadInput() = 0; @@ -568,7 +562,6 @@ class MS_API BenchmarkBase { float op_cost_total_ = 0.0f; std::map> op_times_by_type_; std::map> op_times_by_name_; -#ifdef ENABLE_DSP std::map op_start_times_by_name_; std::map op_end_times_by_name_; std::map>> op_input_shape_; @@ -578,9 +571,6 @@ class MS_API BenchmarkBase { std::map op_core_mask_; std::map op_mem_type_; KernelConfig *kernel_config_; -#else - std::map op_start_times_by_name_; -#endif std::mutex op_times_mutex_; #ifndef BENCHMARK_CLIP_JSON // dump data diff --git a/mindspore-lite/tools/benchmark/benchmark_unified_api.cc b/mindspore-lite/tools/benchmark/benchmark_unified_api.cc index 6df541c7..0befd5ba 100644 --- a/mindspore-lite/tools/benchmark/benchmark_unified_api.cc +++ b/mindspore-lite/tools/benchmark/benchmark_unified_api.cc @@ -21,6 +21,11 @@ #include #include #include +#include +#include +#include +#include +#include #include #include #include @@ -482,21 +487,21 @@ void BenchmarkUnifiedApi::InitMSContextForAscend(const std::shared_ptrSetProvider(back_policy_env); - } -#ifdef ENABLE_CLOUD_FUSION_INFERENCE - if (flags_->device_id_ >= 0 && flags_->rank_id_ >= 0) { - ascend_device_info->SetDeviceID(flags_->device_id_); - ascend_device_info->SetRankID(flags_->rank_id_); - ascend_device_info->SetProvider("ge"); - } -#endif - device_list->push_back(ascend_device_info); +// std::shared_ptr ascend_device_info = std::make_shared(); +// ascend_device_info->SetDeviceID(device_id); +// ascend_device_info->SetProvider(flags_->provider_); +// auto back_policy_env = std::getenv("ASCEND_BACK_POLICY"); +// if (back_policy_env != nullptr) { +// ascend_device_info->SetProvider(back_policy_env); +// } +// #ifdef ENABLE_CLOUD_FUSION_INFERENCE +// if (flags_->device_id_ >= 0 && flags_->rank_id_ >= 0) { +// ascend_device_info->SetDeviceID(flags_->device_id_); +// ascend_device_info->SetRankID(flags_->rank_id_); +// ascend_device_info->SetProvider("ge"); +// } +// #endif +// device_list->push_back(ascend_device_info); } int BenchmarkUnifiedApi::InitMSContext(const std::shared_ptr &context) { @@ -983,12 +988,16 @@ int BenchmarkUnifiedApi::MarkPerformance() { flags_->model_file_.substr(flags_->model_file_.find_last_of(DELIM_SLASH) + 1).c_str(), flags_->num_threads_, time_min / kFloatMSEC, time_max / kFloatMSEC, time_avg / kFloatMSEC); } - #ifdef ENABLE_DSP - if (flags_->enable_kernel_config_) { - flags_->run_benchmark_count_--; + // If kernel config is enabled, always attempt to write model/kernel info. + if (flags_->enable_kernel_config_ && kernel_config_ != nullptr) { + // decrement remaining run count used to format JSON array entries correctly + if (flags_->run_benchmark_count_ > 0) { + flags_->run_benchmark_count_--; + } + // Ensure maps exist; GetKernelConfig handles empty maps by writing empty kernel_info kernel_config_->GetKernelConfig(time_min / kFloatMSEC, time_avg / kFloatMSEC, time_max / kFloatMSEC, op_arch_, - op_core_mask_, op_mem_type_, flags_->run_benchmark_count_); + op_core_mask_, op_mem_type_, flags_->run_benchmark_count_); op_times_by_name_.clear(); op_times_by_type_.clear(); op_arch_.clear(); @@ -1390,27 +1399,6 @@ int BenchmarkUnifiedApi::RunParallelBenchmark(std::shared_ptrkernel_config_file_ = ms_model_->impl()->GetConfig("benchmark", "kernel_config_file"); - MS_LOG(INFO) << "Kernel config file set to: " << kernel_config_file_; - std::string count_str = ms_model_->impl()->GetConfig("benchmark", "run_benchmark_count"); - flags_->run_benchmark_count_ = stoi(count_str); - MS_LOG(INFO) << "Benchmark will run " << count_str << " times"; -} -// 配置文件示例(benchmark.cfg) -/* -[benchmark] -kernel_config_file = ./model.json -run_benchmark_count = 10 -*/ - -// 使用方法 -/* -./benchmark --modelFile=your_model.ms --device=DSP --configFile=benchmark.cfg -*/ -#endif - int BenchmarkUnifiedApi::RunBenchmark() { auto start_prepare_time = GetTimeUs(); @@ -1435,38 +1423,6 @@ int BenchmarkUnifiedApi::RunBenchmark() { MS_LOG(INFO) << "start unified benchmark run"; std::cout << "start unified benchmark run" << std::endl; - // auto context = std::make_shared(); - // if (context == nullptr) { - // MS_LOG(ERROR) << "New context failed while running " << model_name.c_str(); - // std::cerr << "New context failed while running " << model_name.c_str() << std::endl; - // return RET_ERROR; - // } - - // auto status = InitMSContext(context); - // if (status != RET_OK) { - // MS_LOG(ERROR) << "InitMSContext failed while running " << model_name.c_str(); - // std::cout << "InitMSContext failed while running " << model_name.c_str(); - // return RET_ERROR; - // } - - // (void)UpdateDistributionName(context, &flags_->model_file_); - // (void)UpdateDistributionName(context, &flags_->benchmark_data_file_); - // (void)UpdateDistributionName(context, &flags_->config_file_); - - if (!flags_->config_file_.empty()) { - auto config_ret = ms_model_.LoadConfig(flags_->config_file_); - if (config_ret != kSuccess) { - MS_LOG(ERROR) << "ms_model_.LoadConfig failed while running ", model_name.c_str(); - std::cout << "ms_model_.LoadConfig failed while running ", model_name.c_str(); - } - } - - UpdateConfigInfo(); - -#ifdef ENABLE_DSP - LoadBenchmarkConfig(); // Load kernel_config_file and run_benchmark_count into flags_ -#endif - auto context = std::make_shared(); if (context == nullptr) { MS_LOG(ERROR) << "New context failed while running " << model_name.c_str(); @@ -1485,6 +1441,34 @@ int BenchmarkUnifiedApi::RunBenchmark() { (void)UpdateDistributionName(context, &flags_->benchmark_data_file_); (void)UpdateDistributionName(context, &flags_->config_file_); + if (!flags_->config_file_.empty()) { + auto config_ret = ms_model_.LoadConfig(flags_->config_file_); + if (config_ret != kSuccess) { + MS_LOG(ERROR) << "ms_model_.LoadConfig failed while running ", model_name.c_str(); + std::cout << "ms_model_.LoadConfig failed while running ", model_name.c_str(); + } + } + + UpdateConfigInfo(); + + // auto context = std::make_shared(); + // if (context == nullptr) { + // MS_LOG(ERROR) << "New context failed while running " << model_name.c_str(); + // std::cerr << "New context failed while running " << model_name.c_str() << std::endl; + // return RET_ERROR; + // } + + // auto status = InitMSContext(context); + // if (status != RET_OK) { + // MS_LOG(ERROR) << "InitMSContext failed while running " << model_name.c_str(); + // std::cout << "InitMSContext failed while running " << model_name.c_str(); + // return RET_ERROR; + // } + + // (void)UpdateDistributionName(context, &flags_->model_file_); + // (void)UpdateDistributionName(context, &flags_->benchmark_data_file_); + // (void)UpdateDistributionName(context, &flags_->config_file_); + #ifdef MSLITE_ENABLE_CLOUD_INFERENCE if (flags_->enable_parallel_predict_) { MS_CHECK_FALSE_MSG(RunParallelBenchmark(context) != RET_OK, RET_ERROR, "run model pool failed."); @@ -1611,6 +1595,26 @@ int BenchmarkUnifiedApi::InitTimeProfilingCallbackParameter() { op_times_by_type_[call_param.node_type].second += cost; op_times_by_name_[call_param.node_name].first++; op_times_by_name_[call_param.node_name].second += cost; +#ifdef ENABLE_DSP + if (!call_param.node_name.empty()) { + op_end_times_by_name_[call_param.node_name] = opEnd; + std::vector> in_shape; + std::vector in_dtype; + for (auto after_input : after_inputs) { + auto dtype = static_cast(after_input.DataType()); + in_shape.push_back(after_input.Shape()); + op_input_shape_[call_param.node_name] = in_shape; + in_dtype.push_back(dtype); + op_input_dtype_[call_param.node_name] = in_dtype; + } + op_arch_[call_param.node_name] = call_param.arch; + if (call_param.node_type == "Custom") { + op_custom_name_[call_param.node_name] = call_param.custom_kernel_name; + } + op_core_mask_[call_param.node_name] = call_param.core_mask; + op_mem_type_[call_param.node_name] = call_param.mem_type; + } +#endif } return true; }; @@ -1634,6 +1638,11 @@ int BenchmarkUnifiedApi::InitTimeProfilingCallbackParameter() { op_call_times_total_++; op_begin_ = GetTimeUs(); +#ifdef ENABLE_DSP + if (!call_param.node_name.empty()) { + op_start_times_by_name_[call_param.node_name] = op_begin_; + } +#endif return true; }; @@ -1659,6 +1668,26 @@ int BenchmarkUnifiedApi::InitTimeProfilingCallbackParameter() { op_times_by_type_[call_param.node_type].second += cost; op_times_by_name_[call_param.node_name].first++; op_times_by_name_[call_param.node_name].second += cost; +#ifdef ENABLE_DSP + if (!call_param.node_name.empty()) { + op_end_times_by_name_[call_param.node_name] = opEnd; + std::vector> in_shape; + std::vector in_dtype; + for (auto after_input : after_inputs) { + auto dtype = static_cast(after_input.DataType()); + in_shape.push_back(after_input.Shape()); + op_input_shape_[call_param.node_name] = in_shape; + in_dtype.push_back(dtype); + op_input_dtype_[call_param.node_name] = in_dtype; + } + op_arch_[call_param.node_name] = call_param.arch; + if (call_param.node_type == "Custom") { + op_custom_name_[call_param.node_name] = call_param.custom_kernel_name; + } + op_core_mask_[call_param.node_name] = call_param.core_mask; + op_mem_type_[call_param.node_name] = call_param.mem_type; + } +#endif return true; }; } diff --git a/mindspore-lite/tools/benchmark/benchmark_unified_api.h b/mindspore-lite/tools/benchmark/benchmark_unified_api.h index d0d76a4b..18b8229c 100644 --- a/mindspore-lite/tools/benchmark/benchmark_unified_api.h +++ b/mindspore-lite/tools/benchmark/benchmark_unified_api.h @@ -52,10 +52,6 @@ class MS_API BenchmarkUnifiedApi : public BenchmarkBase { virtual ~BenchmarkUnifiedApi(); -#ifdef ENABLE_DSP - void LoadBenchmarkConfig(); -#endif - int RunBenchmark() override; protected: diff --git a/mindspore-lite/tools/benchmark/kernel_config.cc b/mindspore-lite/tools/benchmark/kernel_config.cc index 8ecd4b9b..8446645c 100644 --- a/mindspore-lite/tools/benchmark/kernel_config.cc +++ b/mindspore-lite/tools/benchmark/kernel_config.cc @@ -35,14 +35,74 @@ void KernelConfig::EndLog() { output_file_stream_ << std::string(R"JSON( ])JSON"); } + +// void KernelConfig::GetKernelConfig(float min_time, float avg_time, float max_time, +// const std::map &op_arch, +// const std::map &op_core_mask, +// const std::map &op_mem_type, int run_count) { +// output_file_stream_ << string_format(std::string(R"JSON({ +// "model_time": {"min": %.3f, "avg": %.3f, "max": %.3f}, +// "kernel_info": [)JSON"), +// min_time, avg_time, max_time); + +// size_t kernel_count = 0; +// std::map result; +// for (auto &iter : op_arch) { +// auto arch = iter.second; +// // delete pnna kernel +// if (arch == 8) { +// continue; +// } +// result[iter.first] = arch; +// } +// size_t result_size = result.size(); +// for (auto &iter : result) { +// auto kernel_name = iter.first; +// ++kernel_count; +// auto arch = op_arch.at(kernel_name); +// auto core_mask = op_core_mask.at(kernel_name); +// auto mem_type = op_mem_type.at(kernel_name); +// auto is_last = (kernel_count == result_size); +// if (!is_last) { +// output_file_stream_ << string_format(std::string(R"JSON( +// {"name": "%s","arch": %d,"core_mask": %d,"mem_type": %d},)JSON"), +// kernel_name.c_str(), arch, core_mask, mem_type); +// } else { +// output_file_stream_ << string_format(std::string(R"JSON( +// {"name": "%s","arch": %d,"core_mask": %d,"mem_type": %d})JSON"), +// kernel_name.c_str(), arch, core_mask, mem_type); +// } +// } +// if (run_count > 0) { +// output_file_stream_ << (std::string(R"JSON( +// ] +// }, +// )JSON")); +// } else { +// output_file_stream_ << (std::string(R"JSON( +// ] +// })JSON")); +// } +// } + void KernelConfig::GetKernelConfig(float min_time, float avg_time, float max_time, const std::map &op_arch, const std::map &op_core_mask, const std::map &op_mem_type, int run_count) { + // 文件输出 output_file_stream_ << string_format(std::string(R"JSON({ "model_time": {"min": %.3f, "avg": %.3f, "max": %.3f}, "kernel_info": [)JSON"), min_time, avg_time, max_time); + + // 命令行输出 - 模型时间信息 + std::cout << "\n===== Kernel Configuration Summary =====" << std::endl; + std::cout << "Model Performance (ms):" << std::endl; + std::cout << " Min Time: " << std::fixed << std::setprecision(3) << min_time << " ms" << std::endl; + std::cout << " Avg Time: " << std::fixed << std::setprecision(3) << avg_time << " ms" << std::endl; + std::cout << " Max Time: " << std::fixed << std::setprecision(3) << max_time << " ms" << std::endl; + std::cout << "Kernel Details:" << std::endl; + size_t kernel_count = 0; std::map result; for (auto &iter : op_arch) { @@ -54,6 +114,12 @@ void KernelConfig::GetKernelConfig(float min_time, float avg_time, float max_tim result[iter.first] = arch; } size_t result_size = result.size(); + + // 如果没有内核信息，命令行输出提示 + if (result_size == 0) { + std::cout << " No kernel information available" << std::endl; + } + for (auto &iter : result) { auto kernel_name = iter.first; ++kernel_count; @@ -61,6 +127,15 @@ void KernelConfig::GetKernelConfig(float min_time, float avg_time, float max_tim auto core_mask = op_core_mask.at(kernel_name); auto mem_type = op_mem_type.at(kernel_name); auto is_last = (kernel_count == result_size); + + // 命令行输出 - 每个内核的详细信息 + std::cout << " [" << kernel_count << "/" << result_size << "] "; + std::cout << "Kernel: " << std::left << std::setw(30) << kernel_name; + std::cout << " Arch: " << std::setw(2) << arch; + std::cout << " CoreMask: 0x" << std::hex << std::setw(4) << std::setfill('0') << core_mask; + std::cout << std::dec << std::setfill(' ') << " MemType: " << std::setw(2) << mem_type << std::endl; + + // 文件输出 if (!is_last) { output_file_stream_ << string_format(std::string(R"JSON( {"name": "%s","arch": %d,"core_mask": %d,"mem_type": %d},)JSON"), @@ -71,6 +146,13 @@ void KernelConfig::GetKernelConfig(float min_time, float avg_time, float max_tim kernel_name.c_str(), arch, core_mask, mem_type); } } + + // 命令行输出 - 总结信息 + std::cout << "Total Kernels: " << result_size << std::endl; + std::cout << "Config saved to: " << filename_ << std::endl; + std::cout << "=========================================" << std::endl << std::endl; + + // 文件输出 - 结尾 if (run_count > 0) { output_file_stream_ << (std::string(R"JSON( ] diff --git a/mindspore-lite/tools/benchmark/kernel_config.h b/mindspore-lite/tools/benchmark/kernel_config.h index 331b7f69..ea4dbabf 100644 --- a/mindspore-lite/tools/benchmark/kernel_config.h +++ b/mindspore-lite/tools/benchmark/kernel_config.h @@ -3,6 +3,7 @@ #include #include +#include #include #include #include diff --git a/mindspore-lite/tools/benchmark/run_benchmark.cc b/mindspore-lite/tools/benchmark/run_benchmark.cc index 9487f823..3ecca038 100644 --- a/mindspore-lite/tools/benchmark/run_benchmark.cc +++ b/mindspore-lite/tools/benchmark/run_benchmark.cc @@ -71,28 +71,22 @@ int RunBenchmark(int argc, const char **argv) { delete benchmark; return RET_ERROR; } + + benchmark->LoadBenchmarkConfig(); // from .cfg load kernel_config_file and run_benchmark_count into flags_ auto model_name = flags.model_file_.substr(flags.model_file_.find_last_of(DELIM_SLASH) + 1); -#ifdef ENABLE_DSP int run_benchmark_count = benchmark->GetRunBenchmarkCount(); bool enable_kernel_config = benchmark->IsEnableKernelConfig(); - int run_count = 0; if (enable_kernel_config) { benchmark->GetKernelConfigApi(model_name); - run_count = run_benchmark_count; - } else { - run_count = 1; } - for (int i = 0; i < run_count; i++) { -#endif + for (int i = 0; i < run_benchmark_count; i++) { status = benchmark->RunBenchmark(); - -#ifdef ENABLE_DSP } + if (enable_kernel_config) { benchmark->DeleteKernelConfigApi(); } -#endif if (status != 0) { BENCHMARK_LOG_ERROR("Run Benchmark " << model_name << " Failed : " << status); -- Gitee From 52e3585d7cec097f25630228ad8c134339852673 Mon Sep 17 00:00:00 2001 From: ZhangMing <2778525216@qq.com> Date: Thu, 22 Jan 2026 23:18:55 +0800 Subject: [PATCH 5/6] baseline debug: add REG_DSP_KERNEL for ft04 and enbale running without .cfg Signed-off-by: ZhangMing <2778525216@qq.com> --- mindspore | 2 +- .../common/ops/populate/custom_populate.cc | 2 +- mindspore-lite/src/litert/infer_manager.cc | 8 ++-- .../src/litert/kernel/cpu/base/custom_base.cc | 10 ++-- .../litert/kernel/dsp/ft04/applymomentum.cc | 12 ++++- .../src/litert/kernel/dsp/ft04/assert.cc | 8 +++- .../src/litert/kernel/dsp/ft04/div.cc | 24 ++++++++-- .../src/litert/kernel/dsp/ft04/exp.cc | 24 ++++++++-- .../src/litert/kernel/dsp/ft04/ft04_add.cc | 24 ++++++++-- .../src/litert/kernel/dsp/ft04/linspace.cc | 12 ++++- .../litert/kernel/dsp/ft04/matmulfusion.cc | 24 ++++++++-- .../src/litert/kernel/dsp/ft04/mul.cc | 24 ++++++++-- .../litert/kernel/dsp/ft04/ragged_range.cc | 20 ++++++-- .../src/litert/kernel/dsp/ft04/range.cc | 20 ++++++-- .../src/litert/kernel/dsp/ft04/sub.cc | 24 ++++++++-- mindspore-lite/src/litert/kernel_registry.h | 6 +-- .../tools/benchmark/benchmark_base.h | 2 +- .../tools/benchmark/benchmark_unified_api.cc | 48 ++++++------------- .../tools/benchmark/kernel_config.h | 2 +- .../tools/benchmark/run_benchmark.cc | 9 ++-- 20 files changed, 208 insertions(+), 97 deletions(-) diff --git a/mindspore b/mindspore index 2365375a..11c2221d 160000 --- a/mindspore +++ b/mindspore @@ -1 +1 @@ -Subproject commit 2365375a9d84065f7354601cb3b48ececb477bc8 +Subproject commit 11c2221d8727a31284580892c2db4d1964740c96 diff --git a/mindspore-lite/src/common/ops/populate/custom_populate.cc b/mindspore-lite/src/common/ops/populate/custom_populate.cc index 3142ed2a..9e12be6c 100644 --- a/mindspore-lite/src/common/ops/populate/custom_populate.cc +++ b/mindspore-lite/src/common/ops/populate/custom_populate.cc @@ -185,7 +185,7 @@ OpParameter *CreateNpuOfflineModelParameter(const void *prim) { return nullptr; } memset(param, 0, sizeof(CustomParameter)); - //param->op_parameter_.type_ = PrimType::PrimType_Inner_ThirdPartyModel; + param->op_parameter_.type_ = PrimType::PrimType_Inner_ThirdPartyModel; // The offline model only uses the attr_data [0] field, and other fields do not need to be assigned values. param->attr_data[0] = static_cast(const_cast(prim)); return reinterpret_cast(param); diff --git a/mindspore-lite/src/litert/infer_manager.cc b/mindspore-lite/src/litert/infer_manager.cc index 4e33d8df..5aceef86 100644 --- a/mindspore-lite/src/litert/infer_manager.cc +++ b/mindspore-lite/src/litert/infer_manager.cc @@ -189,10 +189,10 @@ int KernelInferShape(const std::vector &inputs, const std::vecto MS_LOG(ERROR) << "No input!"; return RET_ERROR; } - // if (parameter->type_ == static_cast(PrimType_Inner_ThirdPartyModel)) { - // MS_LOG(INFO) << "No need infer shape for PrimType_Inner_ThirdPartyModel."; - // return RET_OK; - // } + if (parameter->type_ == static_cast(PrimType_Inner_ThirdPartyModel)) { + MS_LOG(INFO) << "No need infer shape for PrimType_Inner_ThirdPartyModel."; + return RET_OK; + } std::vector in_tensors; std::vector out_tensors; int ret = GenerateInTensorC(inputs, &in_tensors, allocator); diff --git a/mindspore-lite/src/litert/kernel/cpu/base/custom_base.cc b/mindspore-lite/src/litert/kernel/cpu/base/custom_base.cc index f4c19666..d5dcb57b 100644 --- a/mindspore-lite/src/litert/kernel/cpu/base/custom_base.cc +++ b/mindspore-lite/src/litert/kernel/cpu/base/custom_base.cc @@ -34,9 +34,9 @@ int CustomBaseCPUKernel::ReSize() { return RET_OK; } int CustomBaseCPUKernel::Run() { return RET_OK; } -// REG_KERNEL(kCPU, kNumberTypeInt32, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) -// REG_KERNEL(kCPU, kNumberTypeFloat32, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) -// REG_KERNEL(kCPU, kNumberTypeInt8, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) -// REG_KERNEL(kCPU, kNumberTypeUInt8, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) -// REG_KERNEL(kCPU, kNumberTypeBool, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +REG_KERNEL(kCPU, kNumberTypeInt32, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +REG_KERNEL(kCPU, kNumberTypeFloat32, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +REG_KERNEL(kCPU, kNumberTypeInt8, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +REG_KERNEL(kCPU, kNumberTypeUInt8, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) +REG_KERNEL(kCPU, kNumberTypeBool, PrimType_Inner_ThirdPartyModel, LiteKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/applymomentum.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/applymomentum.cc index ce2bcfa5..2ffee648 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/applymomentum.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/applymomentum.cc @@ -26,6 +26,9 @@ #include "src/litert/kernel_registry.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -197,6 +200,11 @@ int ApplyMomentumDSPKernel::Run() { return RET_OK; } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_ApplyMomentum, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_ApplyMomentum, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_ApplyMomentum, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_ApplyMomentum, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_ApplyMomentum, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_ApplyMomentum, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_ApplyMomentum, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_ApplyMomentum, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/assert.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/assert.cc index 32e9835f..92d68762 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/assert.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/assert.cc @@ -20,6 +20,9 @@ #include "src/litert/kernel_registry.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -70,6 +73,9 @@ int AssertDSPKernel::Run() { return RunInt(); } -REG_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_Assert, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_Assert, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_Assert, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_Assert, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/div.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/div.cc index d88b8e40..9423773f 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/div.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/div.cc @@ -22,6 +22,9 @@ #include "src/litert/kernel_registry.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -102,9 +105,20 @@ int DivDSPKernel::Run() { return RET_OK; } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_DivFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_DivFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_DivFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_DivFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_DivFusion, DSPKernelCreator) +//register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_DivFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_DivFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_DivFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_DivFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_DivFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_DivFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_DivFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_DivFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_DivFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_DivFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_DivFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_DivFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_DivFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_DivFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_DivFusion, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/exp.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/exp.cc index aef12c9d..02ce9c97 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/exp.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/exp.cc @@ -24,6 +24,9 @@ #include "src/litert/kernel_registry.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -116,9 +119,20 @@ int ExpDSPKernel::Run() { return RET_OK; } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_ExpFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_ExpFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_ExpFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_ExpFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_ExpFusion, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_ExpFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_ExpFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_ExpFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_ExpFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_ExpFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_ExpFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_ExpFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_ExpFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_ExpFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_ExpFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_ExpFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_ExpFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_ExpFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_ExpFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_ExpFusion, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/ft04_add.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/ft04_add.cc index 89b5e55a..63f1608b 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/ft04_add.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/ft04_add.cc @@ -22,6 +22,9 @@ #include "src/litert/kernel_registry.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -47,9 +50,20 @@ int AddFT04DSPKernel::Prepare() { return RET_OK; } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_AddFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_AddFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_AddFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_AddFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_AddFusion, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_AddFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_AddFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_AddFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_AddFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_AddFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_AddFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_AddFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_AddFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_AddFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_AddFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_AddFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_AddFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_AddFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_AddFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_AddFusion, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/linspace.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/linspace.cc index 1434ad83..0a0df167 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/linspace.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/linspace.cc @@ -23,6 +23,9 @@ #include "schema/inner/model_generated.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -100,7 +103,12 @@ int LinspaceDSPKernel::Run() { return RET_OK; } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_LinSpace, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_LinSpace, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_LinSpace, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_LinSpace, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_LinSpace, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_LinSpace, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_LinSpace, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_LinSpace, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/matmulfusion.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/matmulfusion.cc index 602507e0..66f15838 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/matmulfusion.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/matmulfusion.cc @@ -22,6 +22,9 @@ #include "src/litert/kernel/cpu/nnacl_c/matmul_parameter.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -172,10 +175,21 @@ int MatMulFusionDSPKernel::Run() { return RET_OK; } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_MatMulFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_MatMulFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_MatMulFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_MatMulFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_MatMulFusion, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_MatMulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_MatMulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_MatMulFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_MatMulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_MatMulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_MatMulFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_MatMulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_MatMulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_MatMulFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_MatMulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_MatMulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_MatMulFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_MatMulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_MatMulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_MatMulFusion, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/mul.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/mul.cc index ba979717..7b08333a 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/mul.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/mul.cc @@ -22,6 +22,9 @@ #include "src/litert/kernel_registry.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -102,9 +105,20 @@ int MulDSPKernel::Run() { return RET_OK; } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_MulFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_MulFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_MulFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_MulFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_MulFusion, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_MulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_MulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_MulFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_MulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_MulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_MulFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_MulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_MulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_MulFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_MulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_MulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_MulFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_MulFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_MulFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_MulFusion, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/ragged_range.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/ragged_range.cc index 1acc8965..5b111870 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/ragged_range.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/ragged_range.cc @@ -22,6 +22,9 @@ #include "schema/inner/model_generated.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -124,9 +127,18 @@ int RaggedRangeDSPKernel::Run() { } } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_RaggedRange, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_RaggedRange, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_RaggedRange, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_RaggedRange, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_RaggedRange, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_RaggedRange, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_RaggedRange, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_RaggedRange, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_RaggedRange, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_RaggedRange, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_RaggedRange, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_RaggedRange, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_RaggedRange, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_RaggedRange, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_RaggedRange, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_RaggedRange, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/range.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/range.cc index b33bf153..db2d98a1 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/range.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/range.cc @@ -23,6 +23,9 @@ #include "src/litert/kernel_registry.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -110,8 +113,17 @@ int RangeDSPKernel::Run() { return RET_OK; } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_Range, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_Range, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_Range, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_Range, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_Range, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_Range, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_Range, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_Range, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_Range, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_Range, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_Range, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_Range, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_Range, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_Range, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_Range, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_Range, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/sub.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/sub.cc index 1b254325..88b87f42 100644 --- a/mindspore-lite/src/litert/kernel/dsp/ft04/sub.cc +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/sub.cc @@ -22,6 +22,9 @@ #include "src/litert/kernel_registry.h" using mindspore::kernel::KERNEL_ARCH::kDSP; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kShareMemory; +using mindspore::kernel::MEMORY_TYPE::kPrivateMemory; using mindspore::lite::KernelRegistrar; using mindspore::lite::RET_ERROR; using mindspore::lite::RET_OK; @@ -102,9 +105,20 @@ int SubDSPKernel::Run() { return RET_OK; } -REG_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_SubFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_SubFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_SubFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_SubFusion, DSPKernelCreator) -REG_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_SubFusion, DSPKernelCreator) +// register DSP kernels for different memory types +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_SubFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_SubFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat32, PrimitiveType_SubFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_SubFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_SubFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt16, PrimitiveType_SubFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_SubFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_SubFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeInt32, PrimitiveType_SubFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_SubFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_SubFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeComplex64, PrimitiveType_SubFusion, kPrivateMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_SubFusion, kShareMemory, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_SubFusion, kDDR, DSPKernelCreator) +REG_DSP_KERNEL(kDSP, kNumberTypeFloat16, PrimitiveType_SubFusion, kPrivateMemory, DSPKernelCreator) } // namespace mindspore::kernel diff --git a/mindspore-lite/src/litert/kernel_registry.h b/mindspore-lite/src/litert/kernel_registry.h index a57ea9ed..4d125784 100644 --- a/mindspore-lite/src/litert/kernel_registry.h +++ b/mindspore-lite/src/litert/kernel_registry.h @@ -100,13 +100,9 @@ class KernelRegistrar { #define REG_KERNEL(arch, data_type, op_type, kernelCreater) \ static KernelRegistrar g_##arch##data_type##op_type##kernelReg(arch, data_type, op_type, kernelCreater); -/* + #define REG_DSP_KERNEL(arch, data_type, op_type, memory_type, kernelCreater) \ static KernelRegistrar g_##arch##data_type##op_type##memory_type##kernelReg(arch, data_type, op_type, memory_type, kernelCreater); -*/ - -#define REG_DSP_KERNEL(arch, data_type, op_type, memory_type, core_mask, kernelCreater) \ - static KernelRegistrar g_##arch##data_type##op_type##memory_type##core_mask##kernelReg(arch, data_type, op_type, memory_type, core_mask, kernelCreater); } // namespace mindspore::lite #endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_REGISTRY_H_ diff --git a/mindspore-lite/tools/benchmark/benchmark_base.h b/mindspore-lite/tools/benchmark/benchmark_base.h index 978c082a..360f95ce 100644 --- a/mindspore-lite/tools/benchmark/benchmark_base.h +++ b/mindspore-lite/tools/benchmark/benchmark_base.h @@ -214,7 +214,7 @@ class MS_API BenchmarkFlags : public virtual FlagParser { //Config int run_benchmark_count_ = 0; bool enable_kernel_config_ = false; - std::string kernel_config_file_; + std::string kernel_config_file_ = ""; // MarkAccuracy std::string benchmark_data_file_; std::string benchmark_data_type_ = "FLOAT"; diff --git a/mindspore-lite/tools/benchmark/benchmark_unified_api.cc b/mindspore-lite/tools/benchmark/benchmark_unified_api.cc index 0befd5ba..0f94ebcb 100644 --- a/mindspore-lite/tools/benchmark/benchmark_unified_api.cc +++ b/mindspore-lite/tools/benchmark/benchmark_unified_api.cc @@ -487,21 +487,21 @@ void BenchmarkUnifiedApi::InitMSContextForAscend(const std::shared_ptrSetProvider(back_policy_env); -// } -// #ifdef ENABLE_CLOUD_FUSION_INFERENCE -// if (flags_->device_id_ >= 0 && flags_->rank_id_ >= 0) { -// ascend_device_info->SetDeviceID(flags_->device_id_); -// ascend_device_info->SetRankID(flags_->rank_id_); -// ascend_device_info->SetProvider("ge"); -// } -// #endif -// device_list->push_back(ascend_device_info); + std::shared_ptr ascend_device_info = std::make_shared(); + ascend_device_info->SetDeviceID(device_id); + ascend_device_info->SetProvider(flags_->provider_); + auto back_policy_env = std::getenv("ASCEND_BACK_POLICY"); + if (back_policy_env != nullptr) { + ascend_device_info->SetProvider(back_policy_env); + } +#ifdef ENABLE_CLOUD_FUSION_INFERENCE + if (flags_->device_id_ >= 0 && flags_->rank_id_ >= 0) { + ascend_device_info->SetDeviceID(flags_->device_id_); + ascend_device_info->SetRankID(flags_->rank_id_); + ascend_device_info->SetProvider("ge"); + } +#endif + device_list->push_back(ascend_device_info); } int BenchmarkUnifiedApi::InitMSContext(const std::shared_ptr &context) { @@ -1451,24 +1451,6 @@ int BenchmarkUnifiedApi::RunBenchmark() { UpdateConfigInfo(); - // auto context = std::make_shared(); - // if (context == nullptr) { - // MS_LOG(ERROR) << "New context failed while running " << model_name.c_str(); - // std::cerr << "New context failed while running " << model_name.c_str() << std::endl; - // return RET_ERROR; - // } - - // auto status = InitMSContext(context); - // if (status != RET_OK) { - // MS_LOG(ERROR) << "InitMSContext failed while running " << model_name.c_str(); - // std::cout << "InitMSContext failed while running " << model_name.c_str(); - // return RET_ERROR; - // } - - // (void)UpdateDistributionName(context, &flags_->model_file_); - // (void)UpdateDistributionName(context, &flags_->benchmark_data_file_); - // (void)UpdateDistributionName(context, &flags_->config_file_); - #ifdef MSLITE_ENABLE_CLOUD_INFERENCE if (flags_->enable_parallel_predict_) { MS_CHECK_FALSE_MSG(RunParallelBenchmark(context) != RET_OK, RET_ERROR, "run model pool failed."); diff --git a/mindspore-lite/tools/benchmark/kernel_config.h b/mindspore-lite/tools/benchmark/kernel_config.h index ea4dbabf..c2e36ec1 100644 --- a/mindspore-lite/tools/benchmark/kernel_config.h +++ b/mindspore-lite/tools/benchmark/kernel_config.h @@ -7,7 +7,7 @@ #include #include #include -#include "mindspore/lite/src/common/log.h" +#include "mindspore-lite/src/common/log.h" namespace mindspore::lite { diff --git a/mindspore-lite/tools/benchmark/run_benchmark.cc b/mindspore-lite/tools/benchmark/run_benchmark.cc index 3ecca038..5083fddf 100644 --- a/mindspore-lite/tools/benchmark/run_benchmark.cc +++ b/mindspore-lite/tools/benchmark/run_benchmark.cc @@ -71,8 +71,9 @@ int RunBenchmark(int argc, const char **argv) { delete benchmark; return RET_ERROR; } - - benchmark->LoadBenchmarkConfig(); // from .cfg load kernel_config_file and run_benchmark_count into flags_ +#ifdef ENABLE_DSP + if(!flags.config_file_.empty()) + benchmark->LoadBenchmarkConfig(); // from benchmark.cfg load kernel_config_file and run_benchmark_count into flags auto model_name = flags.model_file_.substr(flags.model_file_.find_last_of(DELIM_SLASH) + 1); int run_benchmark_count = benchmark->GetRunBenchmarkCount(); @@ -87,7 +88,9 @@ int RunBenchmark(int argc, const char **argv) { if (enable_kernel_config) { benchmark->DeleteKernelConfigApi(); } - +#else + status = benchmark->RunBenchmark(); +#endif if (status != 0) { BENCHMARK_LOG_ERROR("Run Benchmark " << model_name << " Failed : " << status); delete benchmark; -- Gitee From 63239b63c46287c9c87223e303df37a3421744f0 Mon Sep 17 00:00:00 2001 From: ZhangMing <2778525216@qq.com> Date: Fri, 23 Jan 2026 22:28:22 +0800 Subject: [PATCH 6/6] support custom_memory_copy and custom_memory_copy_infer for FT04 and FT78 Signed-off-by: ZhangMing <2778525216@qq.com> --- .../src/litert/kernel/dsp/dsp_allocator.h | 1 + .../src/litert/kernel/dsp/dsp_kernel.h | 1 + .../dsp/ft04/custom/custom_memory_copy.cc | 51 +++++++++++++++++++ .../dsp/ft04/custom/custom_memory_copy.h | 45 ++++++++++++++++ .../dsp/ft78/custom/custom_memory_copy.cc | 51 +++++++++++++++++++ .../dsp/ft78/custom/custom_memory_copy.h | 45 ++++++++++++++++ .../dsp/infer/custom_memory_copy_infer.cc | 47 +++++++++++++++++ .../dsp/infer/custom_memory_copy_infer.h | 33 ++++++++++++ 8 files changed, 274 insertions(+) create mode 100644 mindspore-lite/src/litert/kernel/dsp/ft04/custom/custom_memory_copy.cc create mode 100644 mindspore-lite/src/litert/kernel/dsp/ft04/custom/custom_memory_copy.h create mode 100644 mindspore-lite/src/litert/kernel/dsp/ft78/custom/custom_memory_copy.cc create mode 100644 mindspore-lite/src/litert/kernel/dsp/ft78/custom/custom_memory_copy.h create mode 100644 mindspore-lite/tools/converter/adapter/dsp/infer/custom_memory_copy_infer.cc create mode 100644 mindspore-lite/tools/converter/adapter/dsp/infer/custom_memory_copy_infer.h diff --git a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h index a14a2cb0..9744f533 100644 --- a/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h +++ b/mindspore-lite/src/litert/kernel/dsp/dsp_allocator.h @@ -60,6 +60,7 @@ class DSPAllocator : public mindspore::Allocator { void SetMemType(MEMORY_TYPE mem_type) { mem_type_ = mem_type; }; int32_t GetCoreId() { return core_id_; }; void SetCoreId(int32_t core_id) { core_id_ = core_id; }; + uint32_t GetCoreMask() { return 1U << core_id_; }; uint64_t GetDeviceMemPtr(void *buffer); void *Prepare(void *ptr) override { return ptr; } diff --git a/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h b/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h index d4446706..c4417f4e 100644 --- a/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h +++ b/mindspore-lite/src/litert/kernel/dsp/dsp_kernel.h @@ -69,6 +69,7 @@ class DSPKernel : public LiteKernel { void SetCoreId(int32_t core_id) { core_id_ = core_id; } void SetKernelArg(const std::vector &kernel_args = {}) { kernel_args_ = kernel_args; } int InferShape() override; + int GetCoreMask() {return core_mask_; } void SetCoreMask(int core_mask) { core_mask_ = core_mask; } void SetKernelName(const std::string &kernel_name) { kernel_name_ = kernel_name; } diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/custom/custom_memory_copy.cc b/mindspore-lite/src/litert/kernel/dsp/ft04/custom/custom_memory_copy.cc new file mode 100644 index 00000000..b57c22f1 --- /dev/null +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/custom/custom_memory_copy.cc @@ -0,0 +1,51 @@ +/** + * 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 "src/litert/kernel/dsp/ft04/custom/custom_memory_copy.h" +#include +#include "src/common/utils.h" + +namespace mindspore::lite { +const auto kComplex64 = DataType::kNumberTypeComplex64; +const auto kFloat32 = DataType::kNumberTypeFloat32; + +// Prepare will be called during graph compilation +int CustomMemoryCopyKernel::Prepare() { + allocator_ = dsp_runtime_->GetAllocator(); + std::string kernel_name = "custom_Memory_Copy"; + MS_LOG(DEBUG) << kernel_name << " Init Done!"; + return kSuccess; +} + +int CustomMemoryCopyKernel::Run() { + int ret = -1; + kernel_name_ = "FT04_datatrans"; + auto input_device_ptr = allocator_->GetDeviceMemPtr(in_tensors_.front()->data()); + auto output_device_ptr = allocator_->GetDeviceMemPtr(out_tensors_.front()->data()); + auto Size = (uint64_t)(out_tensors_.front()->Size()); + SetKernelArg({input_device_ptr, output_device_ptr, Size}); + ret = dsp_runtime_->RunKernel(kernel_name_, kernel_args_, allocator_->GetCoreMask()); + if (ret != kSuccess) { + MS_LOG(ERROR) << this->name() << " Run failed! "; + return kLiteError; + } + MS_LOG(DEBUG) << this->name() << " Run success! "; + return kSuccess; +} + +REGISTER_CUSTOM_KERNEL(DSP, FTMatrix, kFloat32, Custom_FT_MemoryCopy, CustomKernelCreator) +REGISTER_CUSTOM_KERNEL(DSP, FTMatrix, kComplex64, Custom_FT_MemoryCopy, CustomKernelCreator) +} // namespace mindspore \ No newline at end of file diff --git a/mindspore-lite/src/litert/kernel/dsp/ft04/custom/custom_memory_copy.h b/mindspore-lite/src/litert/kernel/dsp/ft04/custom/custom_memory_copy.h new file mode 100644 index 00000000..5df10fa8 --- /dev/null +++ b/mindspore-lite/src/litert/kernel/dsp/ft04/custom/custom_memory_copy.h @@ -0,0 +1,45 @@ +/** + * Copyright 2025 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_CUSTOM_KERNEL_MEMORY_COPY_H_ +#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_CUSTOM_KERNEL_MEMORY_COPY_H_ + +#include +#include +#include +#include +#include +#include "include/registry/register_kernel_interface.h" +#include "include/registry/register_kernel.h" +#include "include/errorcode.h" +#include "src/litert/kernel/dsp/custom_kernel.h" + +namespace mindspore::lite { + +class CustomMemoryCopyKernel : public CustomKernel { + public: + using CustomKernel::CustomKernel; + ~CustomMemoryCopyKernel() override = default;; + int Prepare() override; + int Run() override; + + private: + std::string kernel_name_ = ""; + std::shared_ptr allocator_{}; +}; + +} // namespace mindspore::lite +#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_CUSTOM_KERNEL_MEMORY_COPY_H_ diff --git a/mindspore-lite/src/litert/kernel/dsp/ft78/custom/custom_memory_copy.cc b/mindspore-lite/src/litert/kernel/dsp/ft78/custom/custom_memory_copy.cc new file mode 100644 index 00000000..915d5e72 --- /dev/null +++ b/mindspore-lite/src/litert/kernel/dsp/ft78/custom/custom_memory_copy.cc @@ -0,0 +1,51 @@ +/** + * 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 "src/litert/kernel/dsp/ft04/custom/custom_memory_copy.h" +#include +#include "src/common/utils.h" + +namespace mindspore::lite { +const auto kComplex64 = DataType::kNumberTypeComplex64; +const auto kFloat32 = DataType::kNumberTypeFloat32; + +// Prepare will be called during graph compilation +int CustomMemoryCopyKernel::Prepare() { + allocator_ = dsp_runtime_->GetAllocator(); + std::string kernel_name = "custom_Memory_Copy"; + MS_LOG(DEBUG) << kernel_name << " Init Done!"; + return kSuccess; +} + +int CustomMemoryCopyKernel::Run() { + int ret = -1; + kernel_name_ = "FT78_datatrans"; + auto input_device_ptr = allocator_->GetDeviceMemPtr(in_tensors_.front()->data()); + auto output_device_ptr = allocator_->GetDeviceMemPtr(out_tensors_.front()->data()); + auto Size = (uint64_t)(out_tensors_.front()->Size()); + SetKernelArg({input_device_ptr, output_device_ptr, Size}); + ret = dsp_runtime_->RunKernel(kernel_name_, kernel_args_, allocator_->GetCoreMask()); + if (ret != kSuccess) { + MS_LOG(ERROR) << this->name() << " Run failed! "; + return kLiteError; + } + MS_LOG(DEBUG) << this->name() << " Run success! "; + return kSuccess; +} + +REGISTER_CUSTOM_KERNEL(DSP, FTMatrix, kFloat32, Custom_FT_MemoryCopy, CustomKernelCreator) +REGISTER_CUSTOM_KERNEL(DSP, FTMatrix, kComplex64, Custom_FT_MemoryCopy, CustomKernelCreator) +} // namespace mindspore \ No newline at end of file diff --git a/mindspore-lite/src/litert/kernel/dsp/ft78/custom/custom_memory_copy.h b/mindspore-lite/src/litert/kernel/dsp/ft78/custom/custom_memory_copy.h new file mode 100644 index 00000000..5df10fa8 --- /dev/null +++ b/mindspore-lite/src/litert/kernel/dsp/ft78/custom/custom_memory_copy.h @@ -0,0 +1,45 @@ +/** + * Copyright 2025 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_CUSTOM_KERNEL_MEMORY_COPY_H_ +#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_CUSTOM_KERNEL_MEMORY_COPY_H_ + +#include +#include +#include +#include +#include +#include "include/registry/register_kernel_interface.h" +#include "include/registry/register_kernel.h" +#include "include/errorcode.h" +#include "src/litert/kernel/dsp/custom_kernel.h" + +namespace mindspore::lite { + +class CustomMemoryCopyKernel : public CustomKernel { + public: + using CustomKernel::CustomKernel; + ~CustomMemoryCopyKernel() override = default;; + int Prepare() override; + int Run() override; + + private: + std::string kernel_name_ = ""; + std::shared_ptr allocator_{}; +}; + +} // namespace mindspore::lite +#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_CUSTOM_KERNEL_MEMORY_COPY_H_ diff --git a/mindspore-lite/tools/converter/adapter/dsp/infer/custom_memory_copy_infer.cc b/mindspore-lite/tools/converter/adapter/dsp/infer/custom_memory_copy_infer.cc new file mode 100644 index 00000000..1625e846 --- /dev/null +++ b/mindspore-lite/tools/converter/adapter/dsp/infer/custom_memory_copy_infer.cc @@ -0,0 +1,47 @@ +/** + * Copyright 2025 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 "tools/converter/adapter/dsp/infer/custom_memory_copy_infer.h" +#include +#include +#include "include/api/status.h" +#include "include/registry/register_kernel_interface.h" +#include "tools/converter/adapter/dsp/infer/custom_common.h" + +namespace mindspore::lite { + +Status CustomMemoryCopyInfer::Infer(std::vector *inputs, std::vector *outputs, + const schema::Primitive *primitive) { + // if (inputs->size() != 1 || outputs->size() != 1) { + // return kLiteInferInvalid; + // } + outputs->front().SetFormat(outputs->front().format()); + outputs->front().SetDataType(outputs->front().DataType()); + auto ret = common::CheckIsDynamicShape(*inputs); + if (ret == kLiteInferInvalid) { + outputs->front().SetShape({-1}); // shape{-1} shows that shape need to be inferred when running. + return kLiteInferInvalid; + } else if (ret != kSuccess) { + return kLiteError; + } + auto input_shape = inputs->front().Shape(); + outputs->front().SetShape(inputs->front().Shape()); + return kSuccess; +} + +std::shared_ptr CustomMemoryCopyInferCreator() { return std::make_shared(); } +REGISTER_CUSTOM_KERNEL_INTERFACE(FTMatrix, Custom_FT_MemoryCopy, CustomMemoryCopyInferCreator) +} // namespace mindspore::lite \ No newline at end of file diff --git a/mindspore-lite/tools/converter/adapter/dsp/infer/custom_memory_copy_infer.h b/mindspore-lite/tools/converter/adapter/dsp/infer/custom_memory_copy_infer.h new file mode 100644 index 00000000..2af0d9ac --- /dev/null +++ b/mindspore-lite/tools/converter/adapter/dsp/infer/custom_memory_copy_infer.h @@ -0,0 +1,33 @@ +/** + * Copyright 2025 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_TOOLS_CONVERTER_ADAPTER_DSP_INFER_CUSTOM_MEMORY_COPY_INFER_H +#define MINDSPORE_LITE_TOOLS_CONVERTER_ADAPTER_DSP_INFER_CUSTOM_MEMORY_COPY_INFER_H + +#include "tools/converter/adapter/dsp/infer/custom_infer.h" +#include +#include + +namespace mindspore::lite { +class CustomMemoryCopyInfer : public CustomInterface { + public: + CustomMemoryCopyInfer() = default; + ~CustomMemoryCopyInfer() = default; + Status Infer(std::vector *inputs, std::vector *outputs, + const mindspore::schema::Primitive *primitive) override; +}; +} // namespace mindspore::lite +#endif // MINDSPORE_LITE_TOOLS_CONVERTER_ADAPTER_DSP_INFER_CUSTOM_MEMORY_COPY_INFER_H -- Gitee