ShiyuW
/
mindspore2022
forked from huawei/mindspore2022
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

!20765 [MS][LITE][STABLE]code check fix 

Merge pull request !20765 from chenjianping/kernel_reg
This commit is contained in:
i-robot 2021-07-26 12:33:05 +00:00 committed by Gitee
parent e8951815f7 68aa08f3ef
commit 4917d80c0a
19 changed files with 106 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
mindspore/lite/src/common/string_util.cc
View File

@ -252,6 +252,9 @@ std::pair<uint64_t, uint64_t> HashLen32WithSeeds(const char *s, uint64_t a, uint
} // namespace
uint64_t StringHash64(const char *s, size_t len) {
if (s == nullptr) {
return 0;
}
const uint64_t seed_value = 81;
if (len <= 16) {
return HashStringLen0to16(s, len);

29
mindspore/lite/src/kernel_registry.cc
View File

@ -126,32 +126,13 @@ bool KernelRegistry::SupportKernel(const KernelKey &key) {
}
int KernelRegistry::GetCustomKernel(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
const InnerContext *ctx, const mindspore::Context *ms_ctx,
const kernel::KernelKey &key, kernel::LiteKernel **kernel, const void *primitive) {
const mindspore::Context *ms_ctx, const kernel::KernelKey &key,
kernel::LiteKernel **kernel, const void *primitive) {
MS_ASSERT(ms_ctx != nullptr);
MS_ASSERT(kernel != nullptr);
kernel::KernelDesc desc;
auto prim_type = GetPrimitiveType(primitive);
CreateKernel creator;
if (prim_type == schema::PrimitiveType_Custom) {
for (auto &&device : ctx->device_list_) {
if (!device.provider_.empty() && !device.provider_device_.empty()) {
kernel::KernelKey key_tmp = key;
key_tmp.kernel_arch = device.provider_device_;
key_tmp.provider = device.provider_;
KernelKeyToKernelDesc(key_tmp, &desc);
creator = kernel::RegisterKernel::GetCreator(static_cast<const schema::Primitive *>(primitive), &desc);
if (creator == nullptr) {
continue;
}
}
}
}
if (creator == nullptr) {
KernelKeyToKernelDesc(key, &desc);
creator = kernel::RegisterKernel::GetCreator(static_cast<const schema::Primitive *>(primitive), &desc);
}
KernelKeyToKernelDesc(key, &desc);
CreateKernel creator = kernel::RegisterKernel::GetCreator(static_cast<const schema::Primitive *>(primitive), &desc);
if (creator == nullptr) {
return RET_NOT_SUPPORT;
}
@ -198,7 +179,7 @@ int KernelRegistry::GetKernel(const std::vector<Tensor *> &in_tensors, const std
return RET_ERROR;
}
} else {
auto ret = GetCustomKernel(in_tensors, out_tensors, ctx, ms_ctx, key, kernel, primitive);
auto ret = GetCustomKernel(in_tensors, out_tensors, ms_ctx, key, kernel, primitive);
if (ret == RET_OK) {
(*kernel)->set_context(ctx);
}

4
mindspore/lite/src/kernel_registry.h
View File

@ -50,8 +50,8 @@ class KernelRegistry {
protected:
int GetCustomKernel(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
const InnerContext *inner_ctx, const mindspore::Context *ctx, const kernel::KernelKey &key,
kernel::LiteKernel **kernel, const void *primitive = nullptr);
const mindspore::Context *ctx, const kernel::KernelKey &key, kernel::LiteKernel **kernel,
const void *primitive = nullptr);
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};

5
mindspore/lite/src/ops/populate/broadcast_to_populate.cc
View File

@ -41,6 +41,11 @@ OpParameter *PopulateBroadcastToParameter(const void *prim) {
MS_LOG(INFO) << "broadcast_to has not shape const tensor.";
} else {
param->shape_size_ = dst_shape->size();
if (param->shape_size_ > MAX_SHAPE_SIZE) {
MS_LOG(ERROR) << "Invalid shape size: " << param->shape_size_;
free(param);
return nullptr;
}
for (size_t i = 0; i < param->shape_size_; ++i) {
param->shape_[i] = dst_shape->Get(i);
}

2
mindspore/lite/src/ops/populate/constant_of_shape_populate.cc
View File

@ -57,6 +57,8 @@ OpParameter *PopulateConstantOfShapeParameter(const void *prim) {
break;
default:
MS_LOG(ERROR) << "The value of constant of shape is invalid";
free(param);
return nullptr;
}
}
return reinterpret_cast<OpParameter *>(param);

9
mindspore/lite/src/ops/populate/conv2d_populate.cc
View File

@ -20,6 +20,7 @@ using mindspore::schema::PrimitiveType_Conv2DFusion;
namespace mindspore {
namespace lite {
constexpr auto kMinShapeSize = 2;
OpParameter *PopulateConvParameter(const void *prim) {
auto primitive = static_cast<const schema::Primitive *>(prim);
MS_ASSERT(primitive != nullptr);
@ -42,7 +43,13 @@ OpParameter *PopulateConvParameter(const void *prim) {
auto pad_list = value->pad_list();
auto dilation = value->dilation();
if (kernel_size == nullptr || stride == nullptr || dilation == nullptr) {
MS_LOG(ERROR) << "nullptr";
MS_LOG(ERROR) << "kernel_size/stride/dilation is nullptr";
free(param);
return nullptr;
}
if (kernel_size->size() < kMinShapeSize || stride->size() < kMinShapeSize || dilation->size() < kMinShapeSize) {
MS_LOG(ERROR) << "Invalid shape size!kernel_size size: " << kernel_size->size()
<< ", stride size: " << stride->size() << ", dilation size: " << dilation->size();
free(param);
return nullptr;
}

8
mindspore/lite/src/ops/populate/deconv2d_populate.cc
View File

@ -20,6 +20,7 @@ using mindspore::schema::PrimitiveType_Conv2dTransposeFusion;
namespace mindspore {
namespace lite {
constexpr auto kMinShapeSize = 2;
OpParameter *PopulateDeconvParameter(const void *prim) {
auto primitive = static_cast<const schema::Primitive *>(prim);
MS_ASSERT(primitive != nullptr);
@ -47,6 +48,13 @@ OpParameter *PopulateDeconvParameter(const void *prim) {
free(param);
return nullptr;
}
if (kernel_size->size() < kMinShapeSize || stride->size() < kMinShapeSize || dilation->size() < kMinShapeSize) {
MS_LOG(ERROR) << "Invalid shape size!kernel_size size: " << kernel_size->size()
<< ", stride size: " << stride->size() << ", dilation size: " << dilation->size()
<< ", output_paddings size:" << output_paddings->size();
free(param);
return nullptr;
}
param->kernel_h_ = static_cast<int>(*(kernel_size->begin()));
param->kernel_w_ = static_cast<int>(*(kernel_size->begin() + 1));
param->group_ = static_cast<int>(value->group());

6
mindspore/lite/src/ops/populate/detection_post_process_populate.cc
View File

@ -19,6 +19,7 @@ using mindspore::schema::PrimitiveType_DetectionPostProcess;
namespace mindspore {
namespace lite {
constexpr auto kScaleMinSize = 4;
OpParameter *PopulateDetectionPostProcessParameter(const void *prim) {
auto primitive = static_cast<const schema::Primitive *>(prim);
MS_ASSERT(primitive != nullptr);
@ -42,6 +43,11 @@ OpParameter *PopulateDetectionPostProcessParameter(const void *prim) {
free(param);
return nullptr;
}
if (scale->size() < kScaleMinSize) {
MS_LOG(ERROR) << "Invalid scale shape size " << scale->size();
free(param);
return nullptr;
}
param->h_scale_ = *(scale->begin());
param->w_scale_ = *(scale->begin() + 1);
param->x_scale_ = *(scale->begin() + 2);

6
mindspore/lite/src/ops/populate/l2_norm_populate.cc
View File

@ -44,7 +44,11 @@ OpParameter *PopulateL2NormParameter(const void *prim) {
}
param->axis_num_ = axis_vec->size();
MS_ASSERT(axis_vec->size() < 8);
if (axis_vec->size() > MAX_SHAPE_SIZE) {
MS_LOG(ERROR) << "axis_vec size " << axis_vec->size() << " is invalid!";
free(param);
return nullptr;
}
for (size_t i = 0; i < axis_vec->size(); i++) {
param->axis_[i] = static_cast<int>(axis_vec->Get(i));
}

19
mindspore/lite/src/ops/populate/pooling_populate.cc
View File

@ -20,6 +20,8 @@ using mindspore::schema::PrimitiveType_MaxPoolFusion;
namespace mindspore {
namespace lite {
constexpr auto kMinShapeSize = 2;
constexpr auto kMinPadSize = 4;
OpParameter *PopulateAvgPoolParameter(const void *primitive) {
auto pooling_prim = static_cast<const schema::Primitive *>(primitive);
MS_ASSERT(pooling_prim != nullptr);
@ -40,15 +42,15 @@ OpParameter *PopulateAvgPoolParameter(const void *primitive) {
param->pool_mode_ = PoolMode_AvgPool;
param->global_ = value->global();
auto strides = value->strides();
if (strides == nullptr) {
MS_LOG(ERROR) << "strides is nullptr";
if (strides == nullptr || strides->size() < kMinShapeSize) {
MS_LOG(ERROR) << "strides is invalid!";
free(param);
return nullptr;
}
param->stride_w_ = static_cast<int>(*(strides->begin() + 1));
param->stride_h_ = static_cast<int>(*(strides->begin()));
auto pad = value->pad();
if (pad != nullptr) {
if (pad != nullptr && pad->size() >= kMinPadSize) {
param->pad_u_ = static_cast<int>(*(pad->begin()));
param->pad_d_ = static_cast<int>(*(pad->begin() + 1));
param->pad_l_ = static_cast<int>(*(pad->begin() + 2));
@ -56,8 +58,8 @@ OpParameter *PopulateAvgPoolParameter(const void *primitive) {
}
if (!param->global_) {
auto kernel_size = value->kernel_size();
if (kernel_size == nullptr) {
MS_LOG(ERROR) << "kernel_size is nullptr";
if (kernel_size == nullptr || kernel_size->size() < kMinShapeSize) {
MS_LOG(ERROR) << "kernel_size is invalid";
free(param);
return nullptr;
}
@ -122,8 +124,9 @@ OpParameter *PopulateMaxPoolParameter(const void *primitive) {
if (!param->global_) {
auto kernel_size = value->kernel_size();
auto strides = value->strides();
if (kernel_size == nullptr || strides == nullptr) {
MS_LOG(ERROR) << "kernel_size or strides is nullptr";
if (kernel_size == nullptr || strides == nullptr || kernel_size->size() < kMinShapeSize ||
strides->size() < kMinShapeSize) {
MS_LOG(ERROR) << "kernel_size or strides is invalid";
free(param);
return nullptr;
}
@ -132,7 +135,7 @@ OpParameter *PopulateMaxPoolParameter(const void *primitive) {
param->stride_w_ = static_cast<int>(*(strides->begin() + 1));
param->stride_h_ = static_cast<int>(*(strides->begin()));
auto pad = value->pad();
if (pad != nullptr) {
if (pad != nullptr && pad->size() >= kMinPadSize) {
param->pad_u_ = static_cast<int>(*(pad->begin()));
param->pad_d_ = static_cast<int>(*(pad->begin() + 1));
param->pad_l_ = static_cast<int>(*(pad->begin() + 2));

5
mindspore/lite/src/ops/populate/reverse_populate.cc
View File

@ -43,6 +43,11 @@ OpParameter *PopulateReverseParameter(const void *prim) {
return nullptr;
}
param->num_axis_ = flatAxis->size();
if (param->num_axis_ > REVERSE_SHAPE_MAX_SIZE) {
MS_LOG(ERROR) << "Invalid axis size: " << param->num_axis_;
free(param);
return nullptr;
}
int i = 0;
for (auto flatAxi : *flatAxis) {
param->axis_[i++] = static_cast<int>(flatAxi);

5
mindspore/lite/src/ops/populate/slice_populate.cc
View File

@ -39,6 +39,11 @@ OpParameter *PopulateSliceParameter(const void *prim) {
auto axes = value->axes();
// if begin is not const input, then axis can not be decided in converter
if (axes != nullptr) {
if (axes->size() > DIMENSION_8D) {
MS_LOG(ERROR) << "Invalid axes size: " << axes->size();
free(param);
return nullptr;
}
for (size_t i = 0; i < axes->size(); ++i) {
param->axis_[i] = axes->Get(i);
}

9
mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc
View File

@ -41,12 +41,11 @@ OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) {
return reinterpret_cast<OpParameter *>(param);
}
auto block_shapes = std::vector<int64_t>(block_shape->begin(), block_shape->end());
if (block_shapes.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
if (block_shapes.size() > COMM_SHAPE_SIZE) {
MS_LOG(ERROR) << "The value of block_shapes.size() is too big";
free(param);
return nullptr;
}
param->m_ = block_shapes.size();
auto param_paddings = value->paddings();
if (param_paddings == nullptr) {
@ -79,7 +78,11 @@ OpParameter *PopulateSpaceToBatchNDParameter(const void *prim) {
auto paddings_vec = std::vector<int64_t>(paddings_data->begin(), paddings_data->end());
paddings.insert(paddings.end(), paddings_vec.begin(), paddings_vec.end());
}
if (paddings.size() > COMM_SHAPE_SIZE) {
MS_LOG(ERROR) << "Invalid paddings size " << paddings.size();
free(param);
return nullptr;
}
for (size_t i = 0; i < block_shapes.size(); ++i) {
param->block_sizes_[i] = static_cast<int>(block_shapes[i]);
}

8
mindspore/lite/src/ops/populate/space_to_batch_populate.cc
View File

@ -43,7 +43,7 @@ OpParameter *PopulateSpaceToBatchParameter(const void *prim) {
return nullptr;
}
auto block_sizes = std::vector<int64_t>(block_size->begin(), block_size->end());
if (block_sizes.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
if (block_sizes.size() > COMM_SHAPE_SIZE) {
MS_LOG(ERROR) << "The value of block_sizes.size() is too big";
free(param);
return nullptr;
@ -81,7 +81,11 @@ OpParameter *PopulateSpaceToBatchParameter(const void *prim) {
auto paddings_vec = std::vector<int64_t>(paddings_data->begin(), paddings_data->end());
paddings.insert(paddings.end(), paddings_vec.begin(), paddings_vec.end());
}
if (paddings.size() > COMM_SHAPE_SIZE) {
MS_LOG(ERROR) << "Invalid paddings size " << paddings.size();
free(param);
return nullptr;
}
for (size_t i = 0; i < block_sizes.size(); ++i) {
param->block_sizes_[i] = static_cast<int>(block_sizes[i]);
}

4
mindspore/lite/src/ops/populate/split_populate.cc
View File

@ -37,7 +37,7 @@ OpParameter *PopulateSplitParameter(const void *prim) {
param->op_parameter_.type_ = primitive->value_type();
param->num_split_ = value->output_num();
if (param->num_split_ > std::numeric_limits<int>::max() / static_cast<int>(sizeof(int))) {
if (param->num_split_ > std::numeric_limits<int>::max() / static_cast<int>(sizeof(int)) || param->num_split_ < 0) {
MS_LOG(ERROR) << "The value of param->num_split_ is too big";
free(param);
return nullptr;
@ -52,7 +52,7 @@ OpParameter *PopulateSplitParameter(const void *prim) {
}
memset(param->split_sizes_, 0, param->num_split_ * sizeof(int));
auto split_sizes_vector_ = value->size_splits();
if (split_sizes_vector_ != nullptr) {
if (split_sizes_vector_ != nullptr && split_sizes_vector_->size() <= static_cast<uint32_t>(param->num_split_)) {
int i = 0;
for (auto iter : *split_sizes_vector_) {
param->split_sizes_[i++] = iter;

5
mindspore/lite/src/ops/populate/squeeze_populate.cc
View File

@ -39,6 +39,11 @@ OpParameter *PopulateSqueezeParameter(const void *prim) {
auto axis = value->axis();
if (axis != nullptr) {
param->axis_size_ = axis->size();
if (param->axis_size_ > MAX_SHAPE_SIZE) {
MS_LOG(ERROR) << "Invalid axis size " << param->axis_size_;
free(param);
return nullptr;
}
for (size_t i = 0; i < param->axis_size_; i++) {
param->axis_[i] = *(axis->begin() + i);
}

5
mindspore/lite/src/ops/populate/tile_populate.cc
View File

@ -38,6 +38,11 @@ OpParameter *PopulateTileParameter(const void *prim) {
param->op_parameter_.type_ = primitive->value_type();
auto dims = value->dims();
if (dims != nullptr) {
if (dims->size() > MAX_SHAPE_SIZE) {
MS_LOG(ERROR) << "Invalid dims size " << dims->size();
free(param);
return nullptr;
}
for (size_t i = 0; i < dims->size(); ++i) {
param->dims_[i] = static_cast<int>(dims->Get(i));
}

5
mindspore/lite/src/ops/populate/unsqueeze_populate.cc
View File

@ -43,6 +43,11 @@ OpParameter *PopulateUnsqueezeParameter(const void *prim) {
return nullptr;
}
auto flat_axis = std::vector<int>(axis->begin(), axis->end());
if (flat_axis.size() > COMM_SHAPE_SIZE) {
MS_LOG(ERROR) << "Invalid axis size " << flat_axis.size();
free(param);
return nullptr;
}
param->num_dim_ = flat_axis.size();
int i = 0;
for (int &flat_axi : flat_axis) {

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

@ -723,6 +723,18 @@ int Scheduler::FindProviderKernel(const std::vector<Tensor *> &in_tensors, const
int ret = RET_NOT_SUPPORT;
auto prim_type = GetPrimitiveType(node->primitive_);
if (prim_type == schema::PrimitiveType_Custom) {
for (auto &&device : context_->device_list_) {
if (!device.provider_.empty() && !device.provider_device_.empty()) {
kernel::KernelKey desc{kernel::KERNEL_ARCH::kCPU, data_type, prim_type, device.provider_device_,
device.provider_};
ret = KernelRegistry::GetInstance()->GetKernel(in_tensors, out_tensors, context_, ms_context_, desc, nullptr,
kernel, node->primitive_);
if (ret == RET_OK && *kernel != nullptr) {
return ret;
}
}
}
kernel::KernelKey desc{kernel::KERNEL_ARCH::kCPU, data_type, prim_type, "", ""};
ret = KernelRegistry::GetInstance()->GetKernel(in_tensors, out_tensors, context_, ms_context_, desc, nullptr,
kernel, node->primitive_);