m53297601
/
mindspore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

!3833 rewrite op register func

Browse Source 
Merge pull request !3833 from fuzhiye/mindspore
pull/3833/MERGE
mindspore-ci-bot 5 years ago committed by Gitee
parent 5a3b557354 3a70fd23ce
commit 5338128283
110 changed files with 1788 additions and 1657 deletions
Show Stats Download Patch File Download Diff File

16
mindspore/lite/src/kernel_factory.cc
Unescape View File

@ -43,19 +43,11 @@ LiteKernel *KernelFactory::GetKernel(const std::vector<tensor::Tensor *> &inputs
MS_LOG(ERROR) << "PopulateParameter return nullptr, type: " << schema::EnumNamePrimitiveType(primitive->Type());
return nullptr;
}
auto creator = KernelRegistry::GetInstance()->GetKernelCreator(key);
auto creator = KernelRegistry::GetInstance()->GetCreator(key);
if (creator != nullptr) {
auto *kernel = creator(inputs, outputs, parameter, ctx, key);
if (kernel != nullptr) {
return kernel;
} else {
MS_LOG(ERROR) << "Creator kernel failed for " << schema::EnumNamePrimitiveType(key.type);
return nullptr;
}
} else {
MS_LOG(ERROR) << "Can not find OpCreator for " << schema::EnumNamePrimitiveType(key.type);
return nullptr;
auto kernel = creator(inputs, outputs, parameter, ctx, key);
return kernel;
}
return nullptr;
}
} // namespace mindspore::lite

1
mindspore/lite/src/kernel_factory.h
Unescape View File

@ -38,4 +38,3 @@ class KernelFactory {
} // namespace mindspore::lite
#endif // MINDSPORE_LITE_SRC_KERNEL_FACTORY_H_

94
mindspore/lite/src/kernel_registry.cc
Unescape View File

@ -13,47 +13,105 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "src/kernel_registry.h"
#include "include/errorcode.h"
#include "ir/dtype/type_id.h"
#ifdef ENABLE_ARM64
#include <asm/hwcap.h>
#include "common/utils.h"
#include "utils/log_adapter.h"
#include "src/runtime/kernel/arm/opclib/optimized_kernel.h"
#endif
using mindspore::kernel::kCPU;
using mindspore::kernel::KERNEL_ARCH;
using mindspore::kernel::KernelCreator;
using mindspore::kernel::KernelKey;
using mindspore::kernel::KERNEL_ARCH;
using mindspore::kernel::kKernelArch_MAX;
using mindspore::kernel::kKernelArch_MIN;
using mindspore::schema::PrimitiveType_MAX;
using mindspore::schema::PrimitiveType_MIN;
namespace mindspore::lite {
KernelRegistry::KernelRegistry() {}
KernelRegistry::~KernelRegistry() {}
KernelRegistry::~KernelRegistry() { FreeCreatorArray(); }
KernelRegistry *KernelRegistry::GetInstance() {
static KernelRegistry instance;
return &instance;
}
KernelCreator KernelRegistry::GetKernelCreator(const KernelKey &desc) {
auto it = creators.find(desc);
if (it != creators.end()) {
return it->second;
int KernelRegistry::Init() {
lock_.lock();
if (creator_arrays_ != nullptr) {
lock_.unlock();
return RET_OK;
}
device_type_length_ = kKernelArch_MAX - kKernelArch_MIN;
data_type_length_ = kNumberTypeEnd - kNumberTypeBegin;
op_type_length_ = PrimitiveType_MAX - PrimitiveType_MIN;
// malloc an array contain creator functions of kernel
auto total_len = device_type_length_ * data_type_length_ * op_type_length_;
creator_arrays_ = (kernel::KernelCreator *)malloc(total_len * sizeof(kernel::KernelCreator));
if (creator_arrays_ == nullptr) {
MS_LOG(ERROR) << "malloc creator_arrays_ failed.";
lock_.unlock();
return RET_ERROR;
}
for (int i = 0; i < total_len; ++i) {
creator_arrays_[i] = nullptr;
}
#ifdef ENABLE_ARM64
void *optimized_lib_handler = OptimizeModule::GetInstance()->optimized_op_handler_;
if (optimized_lib_handler != nullptr) {
MS_LOG(INFO) << "load optimize lib success.";
} else {
MS_LOG(INFO) << "load optimize lib failed.";
}
#endif
lock_.unlock();
return RET_OK;
}
void KernelRegistry::FreeCreatorArray() {
if (creator_arrays_ != nullptr) {
free(creator_arrays_);
creator_arrays_ = nullptr;
}
}
// if not find, use cpu kernel
KernelKey cpuDesc {kernel::KERNEL_ARCH::kCPU, desc.type};
it = creators.find(cpuDesc);
if (it != creators.end()) {
return it->second;
kernel::KernelCreator KernelRegistry::GetCreator(const KernelKey &desc) {
int index = GetCreatorFuncIndex(desc);
auto it = creator_arrays_[index];
if (it != nullptr) {
return it;
}
return nullptr;
}
void KernelRegistry::RegKernel(const KernelKey desc, KernelCreator creator) { creators[desc] = creator; }
int KernelRegistry::GetCreatorFuncIndex(const kernel::KernelKey desc) {
int index;
int device_index = static_cast<int>(desc.arch);
int dType_index = static_cast<int>(desc.data_type);
int op_index = static_cast<int>(desc.type);
index = device_index * data_type_length_ * op_type_length_ + dType_index * op_type_length_ + op_index;
return index;
}
void KernelRegistry::RegKernel(const KERNEL_ARCH arch, const schema::PrimitiveType type, KernelCreator creator) {
KernelKey desc = {arch, type};
creators[desc] = creator;
void KernelRegistry::RegKernel(const KernelKey desc, kernel::KernelCreator creator) {
int index = GetCreatorFuncIndex(desc);
creator_arrays_[index] = creator;
}
void KernelRegistry::RegKernel(const KERNEL_ARCH arch, const TypeId data_type, const schema::PrimitiveType op_type,
kernel::KernelCreator creator) {
KernelKey desc = {arch, data_type, op_type};
int index = GetCreatorFuncIndex(desc);
creator_arrays_[index] = creator;
}
bool KernelRegistry::Merge(const std::unordered_map<KernelKey, KernelCreator> &newCreators) { return false; }
const std::map<KernelKey, KernelCreator> &KernelRegistry::GetKernelCreators() { return creators; }
const kernel::KernelCreator *KernelRegistry::GetCreatorArrays() { return creator_arrays_; }
} // namespace mindspore::lite

28
mindspore/lite/src/kernel_registry.h
Unescape View File

@ -30,16 +30,22 @@ class KernelRegistry {
virtual ~KernelRegistry();
static KernelRegistry *GetInstance();
virtual kernel::KernelCreator GetKernelCreator(const kernel::KernelKey &desc);
const std::map<kernel::KernelKey, kernel::KernelCreator> &GetKernelCreators();
int Init();
void FreeCreatorArray();
virtual kernel::KernelCreator GetCreator(const kernel::KernelKey &desc);
const kernel::KernelCreator *GetCreatorArrays();
int GetCreatorFuncIndex(const kernel::KernelKey desc);
void RegKernel(const kernel::KernelKey desc, kernel::KernelCreator creator);
void RegKernel(const kernel::KERNEL_ARCH arch, const schema::PrimitiveType type, kernel::KernelCreator creator);
void RegKernel(const kernel::KERNEL_ARCH arch, const TypeId data_type, const schema::PrimitiveType type,
kernel::KernelCreator creator);
bool Merge(const std::unordered_map<kernel::KernelKey, kernel::KernelCreator> &newCreators);
protected:
std::map<kernel::KernelKey, kernel::KernelCreator> creators;
kernel::KernelCreator *creator_arrays_ = nullptr;
int device_type_length_;
int data_type_length_;
int op_type_length_;
std::mutex lock_;
};
class KernelRegistrar {
@ -48,14 +54,14 @@ class KernelRegistrar {
KernelRegistry::GetInstance()->RegKernel(desc, creator);
}
KernelRegistrar(const kernel::KERNEL_ARCH arch, const schema::PrimitiveType type, kernel::KernelCreator creator) {
KernelRegistry::GetInstance()->RegKernel(arch, type, creator);
KernelRegistrar(const kernel::KERNEL_ARCH arch, const TypeId data_type, const schema::PrimitiveType op_type,
kernel::KernelCreator creator) {
KernelRegistry::GetInstance()->RegKernel(arch, data_type, op_type, creator);
}
};
#define REG_KERNEL(arch, type, kernelCreater) \
static KernelRegistrar g_##arch##type##kernelReg(arch, type, kernelCreater);
#define REG_KERNEL(arch, data_type, op_type, kernelCreater) \
static KernelRegistrar g_##arch##data_type##op_type##kernelReg(arch, data_type, op_type, kernelCreater);
} // namespace mindspore::lite
#endif // MINDSPORE_LITE_SRC_KERNEL_REGISTRY_H_

8
mindspore/lite/src/lite_kernel.h
Unescape View File

@ -18,7 +18,7 @@
#define MINDSPORE_LITE_SRC_LITE_KERNEL_H_
#include <vector>
#include <string>
#ifdef ENABLE_FP16
#ifdef ENABLE_ARM
#include <arm_neon.h>
#endif
#include "src/runtime/kernel/arm/opclib/op_base.h"
@ -35,14 +35,17 @@ using FLOAT_t = float;
// using mindspore::kernel::AddressPtr;
namespace mindspore::kernel {
enum KERNEL_ARCH { kCPU, kGPU, kNPU, kInferShape };
enum KERNEL_ARCH { kCPU, kGPU, kNPU, kKernelArch_MIN = kCPU, kKernelArch_MAX = kNPU };
struct KernelKey {
KERNEL_ARCH arch;
TypeId data_type;
schema::PrimitiveType type;
bool operator<(const KernelKey &dst) const {
if (arch != dst.arch) {
return arch < dst.arch;
} else if (data_type != dst.data_type) {
return data_type < dst.data_type;
} else {
return type < dst.type;
}
@ -179,4 +182,3 @@ class LiteKernelUtil {
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_LITE_KERNEL_H_

8
mindspore/lite/src/lite_session.cc
Unescape View File

@ -24,6 +24,7 @@
#include "src/executor.h"
#include "src/common/utils.h"
#include "src/common/graph_util.h"
#include "src/kernel_registry.h"
#if SUPPORT_GPU
#include "src/runtime/opencl/opencl_runtime.h"
#endif
@ -197,7 +198,11 @@ void LiteSession::Init(Context *context) {
this->context->deviceCtx.type = context->deviceCtx.type;
this->context->allocator = std::make_shared<DefaultAllocator>();
ConfigThreadPool(context->cpuBindMode, context->threadNum);
auto ret = KernelRegistry::GetInstance()->Init();
if (ret != RET_OK) {
MS_LOG(ERROR) << "KernelRegistry Init Failed.";
return;
}
#if SUPPORT_GPU
if (context->deviceCtx.type == DT_GPU) {
auto opencl_runtime = lite::opencl::OpenCLRuntime::GetInstance();
@ -228,6 +233,7 @@ LiteSession::~LiteSession() {
delete kernel;
}
}
std::vector<mindspore::tensor::MSTensor *> LiteSession::GetInputsByName(std::string name) {
return input_map[name];
}

8
mindspore/lite/src/runtime/kernel/arm/CMakeLists.txt
Unescape View File

@ -25,13 +25,5 @@ if (PLATFORM_ARM32)
set(KERNEL_SRC ${KERNEL_SRC} ${ASSEMBLY_SRC})
endif()
if (ENABLE_FP16)
file(GLOB FP6_SRC
${CMAKE_CURRENT_SOURCE_DIR}/fp16/*.cc
${CMAKE_CURRENT_SOURCE_DIR}/opclib/fp16/*.cc
)
set(KERNEL_SRC ${KERNEL_SRC} ${FP6_SRC})
endif ()
add_library(cpu_kernel_mid_ OBJECT ${KERNEL_SRC})
add_subdirectory(opclib)

58
mindspore/lite/src/runtime/kernel/arm/base/concat_base.cc
Unescape View File

@ -36,7 +36,8 @@ int ConcatBaseCPUKernel::Init() {
kernel::LiteKernel *CpuConcatInt8KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx) {
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {
if (opParameter == nullptr) {
MS_LOG(ERROR) << "Input opParameter is nullptr!";
return nullptr;
@ -47,12 +48,20 @@ kernel::LiteKernel *CpuConcatInt8KernelCreator(const std::vector<lite::tensor::T
MS_LOG(ERROR) << "new ConcatCPUKernel fail!";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
kernel::LiteKernel *CpuConcatFp32OrInt32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
kernel::LiteKernel *CpuConcatInt32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx) {
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {
if (opParameter == nullptr) {
MS_LOG(ERROR) << "Input opParameter is nullptr!";
return nullptr;
@ -63,33 +72,28 @@ kernel::LiteKernel *CpuConcatFp32OrInt32KernelCreator(const std::vector<lite::te
MS_LOG(ERROR) << "new ConcatCPUKernel fail!";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
kernel::LiteKernel *CpuConcatKernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter,
const lite::Context *ctx, const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Concat);
auto input_tensor = inputs.at(kInputIndex);
auto data_type = input_tensor->data_type();
kernel::LiteKernel *kernel = nullptr;
switch (data_type) {
case kNumberTypeInt8:
case kNumberTypeUInt8:
kernel = CpuConcatInt8KernelCreator(inputs, outputs, opParameter, ctx);
break;
case kNumberTypeInt32:
case kNumberTypeFloat32:
kernel = CpuConcatFp32OrInt32KernelCreator(inputs, outputs, opParameter, ctx);
break;
default:
break;
kernel::LiteKernel *CpuConcatFp32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {;
if (opParameter == nullptr) {
MS_LOG(ERROR) << "Input opParameter is nullptr!";
return nullptr;
}
MS_ASSERT(desc.type == schema::PrimitiveType_Concat);
auto *kernel = new(std::nothrow) ConcatCPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "kernel is nullptr.";
MS_LOG(ERROR) << "new ConcatCPUKernel fail!";
return nullptr;
}
auto ret = kernel->Init();
@ -102,6 +106,8 @@ kernel::LiteKernel *CpuConcatKernelCreator(const std::vector<lite::tensor::Tenso
return kernel;
}
REG_KERNEL(kCPU, PrimitiveType_Concat, CpuConcatKernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt8, PrimitiveType_Concat, CpuConcatInt8KernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt32, PrimitiveType_Concat, CpuConcatInt32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Concat, CpuConcatFp32KernelCreator)
} // namespace mindspore::kernel

370
mindspore/lite/src/runtime/kernel/arm/base/convolution_base.cc
View File

File diff suppressed because it is too large Load Diff

1
mindspore/lite/src/runtime/kernel/arm/base/convolution_base.h
Unescape View File

@ -28,7 +28,6 @@
#include "src/lite_kernel.h"
#include "include/context.h"
#include "src/runtime/kernel/arm/base/layout_transform.h"
#include "src/runtime/kernel/arm/opclib/optimized_kernel.h"
using mindspore::lite::Context;
using mindspore::schema::PadMode;

60
mindspore/lite/src/runtime/kernel/arm/base/fullconnection_base.cc
Unescape View File

@ -32,39 +32,38 @@ int FullconnectionBaseCPUKernel::Init() {
return RET_OK;
}
kernel::LiteKernel *CpuFullConnectionKernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const lite::Context *ctx,
const kernel::KernelKey &desc) {
kernel::LiteKernel *CpuFullConnectionInt8KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const lite::Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Concat);
auto input_tensor = inputs.at(kInputIndex);
auto data_type = input_tensor->data_type();
kernel::LiteKernel *kernel = nullptr;
switch (data_type) {
case kNumberTypeInt8:
case kNumberTypeUInt8: {
kernel = new (std::nothrow) FullconnectionInt8CPUKernel(opParameter, inputs, outputs, ctx);
if (!kernel) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
break;
}
case kNumberTypeFloat32: {
kernel = new (std::nothrow) FullconnectionCPUKernel(opParameter, inputs, outputs, ctx);
if (!kernel) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
break;
}
default:
break;
auto kernel = new (std::nothrow) FullconnectionInt8CPUKernel(opParameter, inputs, outputs, ctx);
if (!kernel) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
kernel::LiteKernel *CpuFullConnectionFp32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const lite::Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Concat);
auto kernel = new (std::nothrow) FullconnectionCPUKernel(opParameter, inputs, outputs, ctx);
if (!kernel) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
@ -75,5 +74,6 @@ kernel::LiteKernel *CpuFullConnectionKernelCreator(const std::vector<lite::tenso
return kernel;
}
REG_KERNEL(kCPU, PrimitiveType_FullConnection, CpuFullConnectionKernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt8, PrimitiveType_FullConnection, CpuFullConnectionInt8KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_FullConnection, CpuFullConnectionFp32KernelCreator)
} // namespace mindspore::kernel

1
mindspore/lite/src/runtime/kernel/arm/base/layout_transform.cc
Unescape View File

@ -15,6 +15,7 @@
*/
#include "src/runtime/kernel/arm/base/layout_transform.h"
#include "mindspore/core/utils/log_adapter.h"
using mindspore::schema::Format;
namespace mindspore::kernel {

3
mindspore/lite/src/runtime/kernel/arm/base/layout_transform.h
Unescape View File

@ -21,7 +21,8 @@
#include <arm_neon.h>
#endif
#include "src/runtime/kernel/arm/opclib/pack.h"
#include "src/ir/tensor.h"
#include "ir/dtype/type_id.h"
#include "schema/ops_generated.h"
namespace mindspore::kernel {
typedef void (*LayoutConvertor)(const void *src, void *dst, int batch, int plane, int channel);

41
mindspore/lite/src/runtime/kernel/arm/base/pad.cc
Unescape View File

@ -32,11 +32,20 @@ kernel::LiteKernel *CpuPadInt8KernelCreator(const std::vector<lite::tensor::Tens
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const lite::Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Pad);
auto *kernel = new (std::nothrow) PadInt8CPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "new PadCPUKernel failed.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
@ -44,38 +53,13 @@ kernel::LiteKernel *CpuPadFp32KernelCreator(const std::vector<lite::tensor::Tens
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const lite::Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Pad);
auto *kernel = new (std::nothrow) PadCPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "new PadCPUKernel failed.";
return nullptr;
}
return kernel;
}
kernel::LiteKernel *CpuPadKernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs, OpParameter *opParameter,
const lite::Context *ctx, const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Concat);
auto input_tensor = inputs.at(kInputIndex);
auto data_type = input_tensor->data_type();
kernel::LiteKernel *kernel = nullptr;
switch (data_type) {
case kNumberTypeInt8:
kernel = CpuPadInt8KernelCreator(inputs, outputs, opParameter, ctx, desc);
break;
case kNumberTypeFloat32:
kernel = CpuPadFp32KernelCreator(inputs, outputs, opParameter, ctx, desc);
break;
default:
break;
}
if (kernel == nullptr) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
@ -86,5 +70,6 @@ kernel::LiteKernel *CpuPadKernelCreator(const std::vector<lite::tensor::Tensor *
return kernel;
}
REG_KERNEL(kCPU, PrimitiveType_Pad, CpuPadKernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt8, PrimitiveType_Pad, CpuPadInt8KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Pad, CpuPadFp32KernelCreator)
} // namespace mindspore::kernel

44
mindspore/lite/src/runtime/kernel/arm/base/pooling_base.cc
Unescape View File

@ -81,7 +81,8 @@ int PoolingBaseCPUKernel::Init() {
kernel::LiteKernel *CpuPoolingInt8KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx) {
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {
if (opParameter == nullptr) {
MS_LOG(ERROR) << "Input opParameter is nullptr!";
return nullptr;
@ -92,12 +93,20 @@ kernel::LiteKernel *CpuPoolingInt8KernelCreator(const std::vector<lite::tensor::
MS_LOG(ERROR) << "new PoolingInt8CPUKernel fail!";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
kernel::LiteKernel *CpuPoolingFp32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx) {
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {
if (opParameter == nullptr) {
MS_LOG(ERROR) << "Input opParameter is nullptr!";
return nullptr;
@ -108,34 +117,6 @@ kernel::LiteKernel *CpuPoolingFp32KernelCreator(const std::vector<lite::tensor::
MS_LOG(ERROR) << "new PoolingCPUKernel fail!";
return nullptr;
}
return kernel;
}
kernel::LiteKernel *CpuPoolingKernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const lite::Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Pooing);
auto input_tensor = inputs.at(kInputIndex);
auto data_type = input_tensor->data_type();
kernel::LiteKernel *kernel = nullptr;
switch (data_type) {
case kNumberTypeInt8:
case kNumberTypeUInt8:
kernel = CpuPoolingInt8KernelCreator(inputs, outputs, opParameter, ctx);
break;
case kNumberTypeFloat32:
kernel = CpuPoolingFp32KernelCreator(inputs, outputs, opParameter, ctx);
break;
default:
break;
}
if (kernel == nullptr) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
@ -146,5 +127,6 @@ kernel::LiteKernel *CpuPoolingKernelCreator(const std::vector<lite::tensor::Tens
return kernel;
}
REG_KERNEL(kCPU, PrimitiveType_Pooling, CpuPoolingKernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt8, PrimitiveType_Pooling, CpuPoolingInt8KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Pooling, CpuPoolingFp32KernelCreator)
} // namespace mindspore::kernel

69
mindspore/lite/src/runtime/kernel/arm/base/reshape_base.cc
Unescape View File

@ -35,60 +35,64 @@ int ReshapeBaseCPUKernel::Init() {
kernel::LiteKernel *CpuReshapeInt8KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx) {
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {
if (opParameter == nullptr) {
MS_LOG(ERROR) << "Input opParameter is nullptr!";
return nullptr;
}
MS_ASSERT(desc.type == schema::PrimitiveType_Concat);
auto *kernel = new(std::nothrow) ReshapeInt8CPUKernel(opParameter, inputs, outputs, ctx);
MS_ASSERT(desc.type == schema::PrimitiveType_Reshape);
auto *kernel = new (std::nothrow) ReshapeInt8CPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "new ConcatCPUKernel fail!";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
kernel::LiteKernel *CpuReshapeFp32OrInt32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx) {
kernel::LiteKernel *CpuReshapeInt32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {
if (opParameter == nullptr) {
MS_LOG(ERROR) << "Input opParameter is nullptr!";
return nullptr;
}
MS_ASSERT(desc.type == schema::PrimitiveType_Concat);
auto *kernel = new(std::nothrow) ReshapeCPUKernel(opParameter, inputs, outputs, ctx);
MS_ASSERT(desc.type == schema::PrimitiveType_Reshape);
auto *kernel = new (std::nothrow) ReshapeCPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "new ConcatCPUKernel fail!";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
kernel::LiteKernel *CpuReshapeKernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const lite::Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Concat);
auto input_tensor = inputs.at(kInputIndex);
auto data_type = input_tensor->data_type();
kernel::LiteKernel *kernel = nullptr;
switch (data_type) {
case kNumberTypeInt8:
case kNumberTypeUInt8:
kernel = CpuReshapeInt8KernelCreator(inputs, outputs, opParameter, ctx);
break;
case kNumberTypeInt32:
case kNumberTypeFloat32:
kernel = CpuReshapeFp32OrInt32KernelCreator(inputs, outputs, opParameter, ctx);
break;
default:
break;
kernel::LiteKernel *CpuReshapeFp32KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {
if (opParameter == nullptr) {
MS_LOG(ERROR) << "Input opParameter is nullptr!";
return nullptr;
}
MS_ASSERT(desc.type == schema::PrimitiveType_Reshape);
auto *kernel = new (std::nothrow) ReshapeCPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "kernel is nullptr.";
MS_LOG(ERROR) << "new ConcatCPUKernel fail!";
return nullptr;
}
auto ret = kernel->Init();
@ -101,6 +105,7 @@ kernel::LiteKernel *CpuReshapeKernelCreator(const std::vector<lite::tensor::Tens
return kernel;
}
REG_KERNEL(kCPU, PrimitiveType_Reshape, CpuReshapeKernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt8, PrimitiveType_Reshape, CpuReshapeInt8KernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt32, PrimitiveType_Reshape, CpuReshapeInt32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Reshape, CpuReshapeFp32KernelCreator)
} // namespace mindspore::kernel

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

@ -16,6 +16,8 @@
#include "src/runtime/kernel/arm/fp16/convolution_3x3_fp16.h"
#include "src/runtime/kernel/arm/opclib/fp16/conv_fp16.h"
#include "src/runtime/kernel/arm/opclib/fp16/winograd_transform_fp16.h"
#include "src/runtime/kernel/arm/opclib/fp16/pack_fp16.h"
#include "src/runtime/kernel/arm/base/layout_transform.h"
#include "schema/model_generated.h"
#include "src/kernel_registry.h"
@ -165,7 +167,6 @@ void Convolution3x3FP16CPUKernel::ConfigInputOutput() {
}
int Convolution3x3FP16CPUKernel::Init() {
ConvolutionBaseCPUKernel::Init();
auto ret = ConvolutionBaseCPUKernel::Init();
if (ret != RET_OK) {
MS_LOG(ERROR) << "ConvolutionBase init failed.";

2
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_3x3_fp16.h
Unescape View File

@ -20,8 +20,6 @@
#include <arm_neon.h>
#include <vector>
#include "src/lite_kernel.h"
#include "src/runtime/kernel/arm/opclib/winograd_transform.h"
#include "src/runtime/kernel/arm/base/convolution_base.h"
#include "src/runtime/kernel/arm/opclib/optimized_kernel.h"

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

@ -15,6 +15,7 @@
*/
#include "src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.h"
#include "src/runtime/kernel/arm/opclib/fp16/pack_fp16.h"
#include "schema/model_generated.h"
#include "src/kernel_registry.h"
#include "include/errorcode.h"
@ -161,4 +162,27 @@ int ConvolutionDepthwiseFp16CPUKernel::Run() {
return RET_OK;
}
kernel::LiteKernel *CpuConvDwFp16KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_DepthwiseConv2D);
auto kernel = new (std::nothrow) ConvolutionDepthwiseFp16CPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
REG_KERNEL(kCPU, kNumberTypeFloat16, PrimitiveType_DepthwiseConv2D, CpuConvDwFp16KernelCreator)
} // namespace mindspore::kernel

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

@ -15,7 +15,9 @@
*/
#include "src/runtime/kernel/arm/fp16/convolution_fp16.h"
#include "src/runtime/kernel/arm/fp16/convolution_3x3_fp16.h"
#include "src/runtime/kernel/arm/opclib/fp16/conv_fp16.h"
#include "src/runtime/kernel/arm/opclib/fp16/pack_fp16.h"
#include "src/runtime/kernel/arm/base/layout_transform.h"
#include "schema/model_generated.h"
#include "src/kernel_registry.h"
@ -218,5 +220,42 @@ int ConvolutionFP16CPUKernel::Run() {
}
return RET_OK;
}
} // namespace mindspore::kernel
kernel::LiteKernel *CpuConvFp16KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Conv2D);
auto conv_param = reinterpret_cast<ConvParameter *>(opParameter);
int kernel_h = conv_param->kernel_h_;
int kernel_w = conv_param->kernel_w_;
int stride_h = conv_param->stride_h_;
int stride_w = conv_param->stride_w_;
int dilation_h = conv_param->dilation_h_;
int dilation_w = conv_param->dilation_w_;
conv_param->input_h_ = inputs.front()->Height();
conv_param->input_w_ = inputs.front()->Width();
conv_param->output_h_ = outputs.front()->Height();
conv_param->output_w_ = outputs.front()->Width();
kernel::LiteKernel *kernel;
if (kernel_h == 3 && kernel_w == 3 && stride_h == 1 && stride_w == 1 && dilation_h == 1 && dilation_w == 1) {
kernel = new (std::nothrow) kernel::Convolution3x3FP16CPUKernel(opParameter, inputs, outputs, ctx);
} else {
kernel = new (std::nothrow) kernel::ConvolutionFP16CPUKernel(opParameter, inputs, outputs, ctx);
}
if (kernel == nullptr) {
MS_LOG(ERROR) << "Create conv fp16 kernel failed.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
REG_KERNEL(kCPU, kNumberTypeFloat16, PrimitiveType_Conv2D, CpuConvFp16KernelCreator)
} // namespace mindspore::kernel

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

@ -15,6 +15,7 @@
*/
#include "src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.h"
#include "src/runtime/kernel/arm/opclib/fp16/pack_fp16.h"
#include "schema/model_generated.h"
#include "src/kernel_registry.h"
#include "include/errorcode.h"
@ -24,7 +25,7 @@ using mindspore::kernel::KERNEL_ARCH::kCPU;
using mindspore::lite::KernelRegistrar;
using mindspore::lite::RET_ERROR;
using mindspore::lite::RET_OK;
using mindspore::schema::PrimitiveType_DepthwiseConv2D;
using mindspore::schema::PrimitiveType_DeDepthwiseConv2D;
namespace mindspore::kernel {
int DeconvolutionDepthwiseFp16CPUKernel::InitSlideParam() {
@ -171,4 +172,27 @@ int DeconvolutionDepthwiseFp16CPUKernel::Run() {
conv_param_->output_h_ * conv_param_->output_w_, conv_param_->output_channel_);
return RET_OK;
}
kernel::LiteKernel *CpuDeconvDwFp16KernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *opParameter, const lite::Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_DeDepthwiseConv2D);
auto kernel = new (std::nothrow) DeconvolutionDepthwiseFp16CPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}
REG_KERNEL(kCPU, kNumberTypeFloat16, PrimitiveType_DeDepthwiseConv2D, CpuDeconvDwFp16KernelCreator)
} // namespace mindspore::kernel

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

@ -93,6 +93,10 @@ kernel::LiteKernel *CpuActivationFp32KernelCreator(const std::vector<lite::tenso
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Activation);
auto *kernel = new (std::nothrow) ActivationCPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
@ -101,6 +105,5 @@ kernel::LiteKernel *CpuActivationFp32KernelCreator(const std::vector<lite::tenso
return kernel;
}
REG_KERNEL(kCPU, PrimitiveType_Activation, CpuActivationFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Activation, CpuActivationFp32KernelCreator)
} // namespace mindspore::kernel

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

@ -100,7 +100,7 @@ kernel::LiteKernel *CpuAddNFp32KernelCreator(const std::vector<lite::tensor::Ten
MS_LOG(ERROR) << "Input context is nullptr!";
return nullptr;
}
MS_ASSERT(desc.type == schema::PrimitiveType_AddN);
op_parameter->thread_num_ = ctx->threadNum;
auto *kernel = new (std::nothrow) AddNCPUKernel(op_parameter, inputs, outputs);
if (kernel == nullptr) {
@ -117,5 +117,5 @@ kernel::LiteKernel *CpuAddNFp32KernelCreator(const std::vector<lite::tensor::Ten
return kernel;
}
REG_KERNEL(kCPU, PrimitiveType_AddN, CpuAddNFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_AddN, CpuAddNFp32KernelCreator)
} // namespace mindspore::kernel

7
mindspore/lite/src/runtime/kernel/arm/fp32/argminmax.cc
Unescape View File

@ -92,9 +92,6 @@ kernel::LiteKernel *CpuArgMinMaxFp32KernelCreator(const std::vector<lite::tensor
return kernel;
}
REG_KERNEL(kCPU, PrimitiveType_ArgMax, CpuArgMinMaxFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_ArgMin, CpuArgMinMaxFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_ArgMax, CpuArgMinMaxFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_ArgMin, CpuArgMinMaxFp32KernelCreator)
} // namespace mindspore::kernel

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

@ -112,25 +112,8 @@ kernel::LiteKernel *CpuArithmeticFp32KernelCreator(const std::vector<lite::tenso
const std::vector<lite::tensor::Tensor *> &outputs,
OpParameter *parameter, const lite::Context *ctx,
const kernel::KernelKey &desc) {
MS_ASSERT(parameter);
MS_ASSERT(inputs.at(0));
auto data_type = inputs.at(0)->data_type();
kernel::LiteKernel *kernel = nullptr;
switch (data_type) {
case kNumberTypeFloat32:
kernel = new (std::nothrow) ArithmeticCPUKernel(parameter, inputs, outputs, ctx);
break;
case kNumberTypeInt8:
if (desc.type == schema::PrimitiveType_Add) {
kernel = new (std::nothrow) QuantizedAddCPUKernel(parameter, inputs, outputs, ctx);
} else if (desc.type == schema::PrimitiveType_Mul) {
kernel = new (std::nothrow) MulInt8CPUKernel(parameter, inputs, outputs, ctx);
} else {
}
break;
default:
break;
}
MS_ASSERT(parameter != nullptr);
auto kernel = new (std::nothrow) ArithmeticCPUKernel(parameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "Create kernel failed, name: " << parameter->name_;
return nullptr;
@ -145,24 +128,23 @@ kernel::LiteKernel *CpuArithmeticFp32KernelCreator(const std::vector<lite::tenso
return kernel;
}
REG_KERNEL(kCPU, PrimitiveType_Mul, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_Add, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_Sub, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_Div, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_LogicalAnd, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_LogicalOr, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_Maximum, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_Minimum, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_FloorDiv, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_FloorMod, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_SquaredDifference, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_Equal, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_NotEqual, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_Less, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_LessEqual, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_Greater, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_GreaterEqual, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, PrimitiveType_Eltwise, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Mul, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Add, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Sub, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Div, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_LogicalAnd, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_LogicalOr, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Maximum, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Minimum, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_FloorDiv, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_FloorMod, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_SquaredDifference, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Equal, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_NotEqual, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Less, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_LessEqual, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Greater, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_GreaterEqual, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Eltwise, CpuArithmeticFp32KernelCreator)
} // namespace mindspore::kernel

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

Write Preview
Loading…
Cancel
Save