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

!48963 acl bugs fix 

Merge pull request !48963 from liubuyu/acl_launch
This commit is contained in:
i-robot 2023-02-21 07:40:31 +00:00 committed by Gitee
parent 58d5eeb4ac 807ff2d7da
commit 770c9fc703
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
16 changed files with 66 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
mindspore/ccsrc/plugin/device/ascend/kernel/acl/acl_kernel_utils.cc
View File

@ -66,6 +66,7 @@ static const std::map<std::string, std::vector<int>> kInputOrders = {
// op_name: {graph_id to kernel_id} . -1 means the the graph id is useless in acl kernel
{prim::kPrimOneHotD->name(), {0, 2, 3}},
{prim::kPrimAvgPool->name(), {0, -1, -1}},
{prim::kPrimInplaceUpdateD->name(), {0, 2}},
{prim::kPrimDeformableOffsets->name(), {0, 1, -1}}};
static const std::map<std::string, std::vector<int>> kOutputOrders = {

1
mindspore/ccsrc/plugin/device/ascend/optimizer/mindir/reg_ascend_vm_op_adaptation_info.h
View File

@ -240,7 +240,6 @@ REG_ASCEND_VM_OP_ADAPTATION_INFO(kCropAndResizeOpName)
REG_ASCEND_VM_OP_ADAPTATION_INFO(kCumProdOpName)
.set_backend_op_name(kCumprodOpName)
.set_target_op_name(kCumprodDOpName)
.set_need_tbe_check_supported(true)
.set_input_attr_info(1, "int");
REG_ASCEND_VM_OP_ADAPTATION_INFO(kCumSumOpName)

20
mindspore/ccsrc/transform/graph_ir/op_adapter.cc
View File

@ -638,7 +638,8 @@ int OpAdapterImpl::SetCustomOpAttr(const CusOperatorPtr &op, const PrimitivePtr
return 0;
}
std::map<std::string, ValuePtr> OpAdapterImpl::GetNormalOpAttrList(const AnfNodePtr &node) const {
std::map<std::string, ValuePtr> OpAdapterImpl::GetNormalOpAttrList(const OperatorPtr &op,
const AnfNodePtr &node) const {
MS_EXCEPTION_IF_NULL(node);
if (!node->isa<CNode>()) {
return {};
@ -658,17 +659,16 @@ std::map<std::string, ValuePtr> OpAdapterImpl::GetNormalOpAttrList(const AnfNode
auto prim = GetValueNode<PrimitivePtr>(inputs[0]);
std::map<std::string, ValuePtr> attr_list;
for (auto &it : attr_map_) {
auto value = prim->GetAttr(it.first);
if (value != nullptr) {
it.second.get_attr(&value);
// set attr from extra_attr
auto it_extra = extra_attr_->find(it.first);
if (it_extra != extra_attr_->end()) {
auto value = it_extra->second;
(void)attr_list.emplace(it.second.name, value);
} else {
// set attr from extra_attr
auto it_extra = extra_attr_->find(it.first);
if (it_extra != extra_attr_->end()) {
value = it_extra->second;
}
auto value = prim->GetAttr(it.first);
it.second.get_attr(op, &value);
(void)attr_list.emplace(it.second.name, value);
}
(void)attr_list.emplace(it.second.name, value);
}
// set attr from const input

4
mindspore/ccsrc/transform/graph_ir/op_adapter.h
View File

@ -87,7 +87,7 @@ class OpAdapterImpl {
Status UpdateSingleOutputDesc(const OperatorPtr &op, const abstract::BaseShapePtr &shp, const TypePtr &type,
const std::string &format);
size_t GetCustomOpOutputSize(const CusOperatorPtr &cus_op) const;
std::map<std::string, ValuePtr> GetNormalOpAttrList(const AnfNodePtr &node) const;
std::map<std::string, ValuePtr> GetNormalOpAttrList(const OperatorPtr &op, const AnfNodePtr &node) const;
std::shared_ptr<GeTensorDesc> CreateOutputDesc(const abstract::ShapePtr &shape_ptr, const TypePtr &type,
const std::string &format) const;
Status UpdateMultiOutputDesc(const OperatorPtr &op, const abstract::BaseShapePtr &shp, const TypePtr &type,
@ -242,7 +242,7 @@ class OpAdapter : public BaseOpAdapter {
const mindspore::HashMap<int, DynOutputDesc> &getDynOutputMap() override { return dyn_output_map_; }
const mindspore::HashMap<int, DynSubGraphDesc> &getDynSubgraphMap() override { return dyn_subgraph_map_; }
std::map<std::string, ValuePtr> GetNormalOpAttrList(const AnfNodePtr &node) override {
return impl_->GetNormalOpAttrList(node);
return impl_->GetNormalOpAttrList(std::make_shared<::ge::Operator>(op_type_), node);
}
bool IsDynInputOp(uint64_t index) override { return dyn_input_map_.find(index) != dyn_input_map_.end(); }
bool IsDyOutputOp(uint64_t index) override { return dyn_output_map_.find(index) != dyn_output_map_.end(); }

2
mindspore/ccsrc/transform/graph_ir/op_adapter_base.h
View File

@ -55,7 +55,7 @@ namespace transform {
using CusOperatorPtr = std::shared_ptr<::ge::CustomOperator>;
using CustomOperator = ::ge::CustomOperator;
using AttrFunc = std::function<void(OperatorPtr, ValuePtr)>;
using GetAttrFunc = std::function<void(ValuePtr *)>;
using GetAttrFunc = std::function<void(OperatorPtr, ValuePtr *)>;
using OutputFunc = std::function<OutHandler(OperatorPtr)>;
using InputOpFunc = std::function<void(OperatorPtr, OperatorPtr)>;
using InputHandleFunc = std::function<void(OperatorPtr, OutHandler)>;

1
mindspore/ccsrc/transform/graph_ir/op_adapter_map.h
View File

@ -137,6 +137,7 @@ constexpr const char kNameArgMinWithValue[] = "ArgMinWithValue";
constexpr const char kNameReduceProd[] = "ReduceProd";
constexpr const char kNameDynamicReduceProd[] = "DynamicReduceProd";
constexpr const char kNameCumProd[] = "CumProd";
constexpr const char kNameCumProdD[] = "CumProdD";
constexpr const char kNameDiagpart[] = "Diagpart";
constexpr const char kNameSplit[] = "Split";
constexpr const char kNameBatchToSpaceNd[] = "BatchToSpaceND";

8
mindspore/ccsrc/transform/graph_ir/op_declare/nn_detect_ops_declare.cc
View File

@ -96,16 +96,16 @@ REG_ADPT_DESC(PSROIPooling, prim::kPrimPSROIPooling->name(), ADPT_DESC(PSROIPool
// PSROIPoolingV2
INPUT_MAP(PSROIPoolingV2) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(rois)}};
ATTR_MAP(PSROIPoolingV2) = {{"output_dim", ATTR_DESC(output_dim, AnyTraits<int64_t>())},
{"group_size", ATTR_DESC(group_size, AnyTraits<int64_t>())},
ATTR_MAP(PSROIPoolingV2) = {{"output_dim", ATTR_DESC(output_dim, AnyTraits<int64_t>(), AnyTraits<int32_t>())},
{"group_size", ATTR_DESC(group_size, AnyTraits<int64_t>(), AnyTraits<int32_t>())},
{"spatial_scale", ATTR_DESC(spatial_scale, AnyTraits<float>())}};
OUTPUT_MAP(PSROIPoolingV2) = {{0, OUTPUT_DESC(y)}};
REG_ADPT_DESC(PSROIPoolingV2, prim::kPrimPSROIPoolingV2->name(), ADPT_DESC(PSROIPoolingV2))
// PSROIPoolingGradV2D
INPUT_MAP(PSROIPoolingGradV2D) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(rois)}};
ATTR_MAP(PSROIPoolingGradV2D) = {{"output_dim", ATTR_DESC(output_dim, AnyTraits<int64_t>())},
{"group_size", ATTR_DESC(group_size, AnyTraits<int64_t>())},
ATTR_MAP(PSROIPoolingGradV2D) = {{"output_dim", ATTR_DESC(output_dim, AnyTraits<int64_t>(), AnyTraits<int32_t>())},
{"group_size", ATTR_DESC(group_size, AnyTraits<int64_t>(), AnyTraits<int32_t>())},
{"spatial_scale", ATTR_DESC(spatial_scale, AnyTraits<float>())},
{"input_size", ATTR_DESC(input_size, AnyTraits<std::vector<int64_t>>())}};
OUTPUT_MAP(PSROIPoolingGradV2D) = {{0, OUTPUT_DESC(y)}};

12
mindspore/ccsrc/transform/graph_ir/op_declare/op_declare_macro.h
View File

@ -145,9 +145,15 @@ namespace mindspore::transform {
auto p = std::static_pointer_cast<OpType>(op); \
(void)p->set_attr_##name(ConvertAny(value, __VA_ARGS__)); \
}, \
[](ValuePtr* ms_value) { \
auto real_value = ConvertAny(*ms_value, __VA_ARGS__); \
*ms_value = GetRealValue<decltype(real_value)>(real_value); \
[](const OperatorPtr op, ValuePtr* ms_value) { \
if (ms_value == nullptr || *ms_value == nullptr) { \
auto p = std::static_pointer_cast<OpType>(op); \
auto real_value = p->get_attr_##name(); \
*ms_value = GetRealValue<decltype(real_value)>(real_value); \
} else { \
auto real_value = ConvertAny(*ms_value, __VA_ARGS__); \
*ms_value = GetRealValue<decltype(real_value)>(real_value); \
} \
} \
}

12
mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.cc
View File

@ -28,7 +28,7 @@ REG_ADPT_DESC(CumSum, kNameCumSum, ADPT_DESC(CumsumD))
// Cumsum
INPUT_MAP(Cumsum) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(axis)}};
ATTR_INPUT_MAP(Cumsum) = {{"axis", {"axis"}}};
ATTR_INPUT_MAP(Cumsum) = {{"axis", "axis"}};
ATTR_MAP(Cumsum) = {{"exclusive", ATTR_DESC(exclusive, AnyTraits<bool>())},
{"reverse", ATTR_DESC(reverse, AnyTraits<bool>())}};
OUTPUT_MAP(Cumsum) = {{0, OUTPUT_DESC(y)}};
@ -41,7 +41,15 @@ INPUT_ATTR_MAP(CumprodD) = {{2, ATTR_DESC(axis, AnyTraits<int64_t>())}};
ATTR_MAP(CumprodD) = {{"exclusive", ATTR_DESC(exclusive, AnyTraits<bool>())},
{"reverse", ATTR_DESC(reverse, AnyTraits<bool>())}};
OUTPUT_MAP(CumprodD) = {{0, OUTPUT_DESC(y)}};
REG_ADPT_DESC(CumprodD, kNameCumProd, ADPT_DESC(CumprodD))
REG_ADPT_DESC(Cumprod, kNameCumProd, ADPT_DESC(CumprodD))
// Cumprod
INPUT_MAP(Cumprod) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(axis)}};
ATTR_INPUT_MAP(Cumprod) = {{"axis", "axis"}};
ATTR_MAP(Cumprod) = {{"exclusive", ATTR_DESC(exclusive, AnyTraits<bool>())},
{"reverse", ATTR_DESC(reverse, AnyTraits<bool>())}};
OUTPUT_MAP(Cumprod) = {{0, OUTPUT_DESC(y)}};
REG_ADPT_DESC(CumprodD, kNameCumProdD, ADPT_DESC(Cumprod))
INPUT_MAP(Tile) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(multiples)}};
ATTR_INPUT_MAP(Tile) = {{"multiples", "multiples"}};

3
mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.h
View File

@ -74,6 +74,9 @@ DECLARE_OP_ADAPTER(CumprodD)
DECLARE_OP_USE_INPUT_ATTR(CumprodD)
DECLARE_OP_USE_OUTPUT(CumprodD)
DECLARE_OP_ADAPTER(Cumprod)
DECLARE_OP_USE_OUTPUT(Cumprod)
DECLARE_OP_ADAPTER(Tile)
DECLARE_OP_USE_OUTPUT(Tile)

17
mindspore/core/expander/emitter.cc
View File

@ -310,6 +310,23 @@ NodePtr Emitter::ReduceSum(const NodePtr &x, const ShapeVector &axis, bool keep_
if (!need_reduce.first) {
return Reshape(x, need_reduce.second);
}
#ifdef WITH_BACKEND
const auto &shape = x->shape();
auto real_axis = axis;
if (axis.empty()) {
for (int64_t i = 0; i < SizeToLong(shape.size()); i++) {
(void)real_axis.emplace_back(i);
}
}
if (std::any_of(real_axis.begin(), real_axis.end(), [](int64_t v) { return v < 0; })) {
for (size_t i = 0; i < real_axis.size(); i++) {
if (real_axis[i] < 0) {
real_axis[i] = real_axis[i] + SizeToLong(real_axis.size());
}
}
}
return Emit(prim::kPrimReduceSum->name(), {x, Value<ShapeVector>(real_axis)}, {{"keep_dims", MakeValue(keep_dims)}});
#endif
return Emit(prim::kPrimReduceSum->name(), {x, Value<ShapeVector>(axis)}, {{"keep_dims", MakeValue(keep_dims)}});
}

1
mindspore/core/ops/core_ops.h
View File

@ -1369,6 +1369,7 @@ GVAR_DEF(PrimitivePtr, kPrimSubscalar, std::make_shared<Primitive>("Subscalar"))
GVAR_DEF(PrimitivePtr, kPrimInplaceAdd, std::make_shared<Primitive>("InplaceAdd"));
GVAR_DEF(PrimitivePtr, kPrimInplaceIndexAdd, std::make_shared<Primitive>("InplaceIndexAdd"));
GVAR_DEF(PrimitivePtr, kPrimInplaceUpdate, std::make_shared<Primitive>("InplaceUpdate"));
GVAR_DEF(PrimitivePtr, kPrimInplaceUpdateD, std::make_shared<Primitive>("InplaceUpdateD"));
GVAR_DEF(PrimitivePtr, kPrimInplaceUpdateV2, std::make_shared<Primitive>("InplaceUpdateV2"));
GVAR_DEF(PrimitivePtr, kPrimLpNorm, std::make_shared<Primitive>(kLpNorm));
GVAR_DEF(PrimitivePtr, kPrimInplaceSub, std::make_shared<Primitive>("InplaceSub"));

4
mindspore/core/ops/depth_to_space.cc
View File

@ -65,10 +65,6 @@ abstract::ShapePtr DepthToSpaceInferShape(const PrimitivePtr &primitive,
auto data_format_ptr = primitive->GetAttr("format");
int64_t format = CheckAndConvertUtils::GetAndCheckFormat(primitive->GetAttr("format"));
(void)primitive->AddAttr("data_format", data_format_ptr);
// Set default value for mode
if (!primitive->GetAttr("mode")) {
(void)primitive->AddAttr("mode", MakeValue("DCR"));
}
const int64_t dim_0 = 0;
const int64_t dim_1 = 1;
const int64_t dim_2 = 2;

4
mindspore/core/ops/inplace_index_add.cc
View File

@ -49,9 +49,11 @@ abstract::ShapePtr InplaceIndexAddInferShape(const PrimitivePtr &primitive,
auto indices_shape = indices_shape_ptr->shape();
auto indices_rank = SizeToLong(indices_shape.size());
(void)CheckAndConvertUtils::CheckInteger("indices size", indices_rank, kEqual, 1, prim_name);
size_t axis_rank = LongToSize(axis);
size_t axis_rank = 0;
if (axis < 0) {
axis_rank = axis + var_rank;
} else {
axis_rank = LongToSize(axis);
}
if (updates_is_dynamic) {
return var_shape_ptr;

4
mindspore/core/ops/max_pool3d.cc
View File

@ -200,10 +200,6 @@ abstract::ShapePtr MaxPool3DInferShape(const PrimitivePtr &primitive, const std:
MS_EXCEPTION(ValueError) << "For '" << primitive->name()
<< "', output shape's all elements must be positive, but got shape: " << out_shape << ".";
}
if (!primitive->HasAttr("dilation")) {
const std::vector<int> def_dilation = {1, 1, 1, 1, 1};
primitive->AddAttr("dilation", MakeValue(def_dilation));
}
return std::make_shared<abstract::Shape>(out_shape);
}

5
tests/ut/cpp/stub/transform/util.cc
View File

@ -82,7 +82,10 @@ int OpAdapterImpl::setInput(const OperatorPtr &op, int index,
}
void OpAdapterImpl::updateOutputDesc(const OperatorPtr &op, const abstract::BaseShapePtr &shp, const TypePtr &type,
const AnfNodePtr &node) {}
std::map<std::string, ValuePtr> OpAdapterImpl::GetNormalOpAttrList(const AnfNodePtr &node) const { return {}; }
std::map<std::string, ValuePtr> OpAdapterImpl::GetNormalOpAttrList(const OperatorPtr &op,
const AnfNodePtr &node) const {
return {};
}
OutHandler OpAdapterImpl::getOutput(const OperatorPtr &op, int index) {
OutHandler handler;
return handler;