From 5eca3025394c740198708ef2f1e852dc3b3698c5 Mon Sep 17 00:00:00 2001 From: l00444296 Date: Wed, 9 Dec 2020 15:22:09 +0800 Subject: [PATCH 1/8] Feature: reset shape of dynamic single op --- ge/CMakeLists.txt | 2 + ge/ge_inference.mk | 1 + ge/ge_runner.mk | 1 + ge/graph/manager/graph_manager.cc | 1 + .../passes/dynamic_single_op_reset_shape_pass.cc | 54 ++++++++++++++++++++++ .../passes/dynamic_single_op_reset_shape_pass.h | 28 +++++++++++ metadef | 2 +- tests/ut/ge/CMakeLists.txt | 1 + 8 files changed, 89 insertions(+), 1 deletion(-) create mode 100644 ge/graph/passes/dynamic_single_op_reset_shape_pass.cc create mode 100644 ge/graph/passes/dynamic_single_op_reset_shape_pass.h diff --git a/ge/CMakeLists.txt b/ge/CMakeLists.txt index b037f4a4..5207275b 100755 --- a/ge/CMakeLists.txt +++ b/ge/CMakeLists.txt @@ -142,6 +142,7 @@ set(TRAIN_SRC_LIST "graph/passes/atomic_addr_clean_pass.cc" "graph/passes/mark_same_addr_pass.cc" "graph/passes/mark_graph_unknown_status_pass.cc" + "graph/passes/dynamic_single_op_reset_shape_pass.cc" "graph/passes/mark_agnostic_pass.cc" "graph/partition/dynamic_shape_partition.cc" "graph/partition/stage_partition.cc" @@ -433,6 +434,7 @@ set(INFER_SRC_LIST "graph/passes/atomic_addr_clean_pass.cc" "graph/passes/mark_same_addr_pass.cc" "graph/passes/mark_graph_unknown_status_pass.cc" + "graph/passes/dynamic_single_op_reset_shape_pass.cc" "graph/passes/mark_agnostic_pass.cc" "graph/common/omg_util.cc" "graph/common/bcast.cc" diff --git a/ge/ge_inference.mk b/ge/ge_inference.mk index fe76a612..b6986043 100755 --- a/ge/ge_inference.mk +++ b/ge/ge_inference.mk @@ -109,6 +109,7 @@ OMG_HOST_SRC_FILES := \ graph/passes/atomic_addr_clean_pass.cc \ graph/passes/mark_same_addr_pass.cc \ graph/passes/mark_graph_unknown_status_pass.cc \ + graph/passes/dynamic_single_op_reset_shape_pass.cc \ graph/passes/mark_agnostic_pass.cc \ graph/common/omg_util.cc \ graph/common/bcast.cc \ diff --git a/ge/ge_runner.mk b/ge/ge_runner.mk index 58ad1266..82e99c33 100644 --- a/ge/ge_runner.mk +++ b/ge/ge_runner.mk @@ -111,6 +111,7 @@ LIBGE_LOCAL_SRC_FILES := \ graph/passes/atomic_addr_clean_pass.cc \ graph/passes/mark_same_addr_pass.cc \ graph/passes/mark_graph_unknown_status_pass.cc \ + graph/passes/dynamic_single_op_reset_shape_pass.cc \ graph/passes/mark_agnostic_pass.cc \ graph/partition/dynamic_shape_partition.cc \ graph/partition/stage_partition.cc \ diff --git a/ge/graph/manager/graph_manager.cc b/ge/graph/manager/graph_manager.cc index d4c6ca8d..64ced699 100755 --- a/ge/graph/manager/graph_manager.cc +++ b/ge/graph/manager/graph_manager.cc @@ -69,6 +69,7 @@ #include "graph/passes/iterator_op_pass.h" #include "graph/passes/link_gen_mask_nodes_pass.h" #include "graph/passes/mark_graph_unknown_status_pass.h" +#include "graph/passes/dynamic_single_op_reset_shape_pass.h" #include "graph/passes/merge_pass.h" #include "graph/passes/merge_input_memcpy_pass.h" #include "graph/passes/merge_to_stream_merge_pass.h" diff --git a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc new file mode 100644 index 00000000..0328271a --- /dev/null +++ b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc @@ -0,0 +1,54 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "graph/passes/dynamic_single_op_reset_shape_pass.h" +#include "graph/utils/node_utils.h" +#include "graph/utils/graph_utils.h" +#include "graph/utils/tensor_utils.h" +#include "graph/utils/op_desc_utils.h" +#include "graph/utils/type_utils.h" +#include "graph/debug/ge_attr_define.h" + +namespace ge { +Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) { + GE_CHECK_NOTNULL(graph); + for (const auto &node : graph->GetDirectNode()) { + GE_CHECK_NOTNULL(node->GetOpDesc()); + if (node->GetType() == DATA || node->GetType() == NETOUTPUT) { + continue; + } + + bool single_aicpu_unknown = false; + if (!AttrUtils::GetBool(node->GetOpDesc(), ATTR_DYNAMIC_SHAPE_SINGLE_AICPU, single_aicpu_unknown) || + !single_aicpu_unknown) { + continue; + } + + auto op_desc = node->GetOpDesc(); + std::vector dynamic_shape_dims = {-2}; + ge::Shape dynamic_shape(dynamic_shape_dims); + for (size_t i = 0; i < op_desc->GetAllInputsDesc().size(); i++) { + const auto &input_desc = op_desc->MutableInputDesc(static_cast(i)); + GE_CHECK_NOTNULL(input_desc); + input_desc->SetShape(dynamic_shape); + } + GELOGD("Reset dynamic aicpu node [%s] shape success!", node->GetName().c_str()); + } + + GELOGD("Reset dynamic aicpu nodes shape of graph [%s] success!", graph->GetName().c_str()); + return SUCCESS; +} +} // namespace ge \ No newline at end of file diff --git a/ge/graph/passes/dynamic_single_op_reset_shape_pass.h b/ge/graph/passes/dynamic_single_op_reset_shape_pass.h new file mode 100644 index 00000000..e82d4e16 --- /dev/null +++ b/ge/graph/passes/dynamic_single_op_reset_shape_pass.h @@ -0,0 +1,28 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef GE_GRAPH_PASSES_DYNAMIC_SINGLE_OP_RESET_SHAPE_PASS_H_ +#define GE_GRAPH_PASSES_DYNAMIC_SINGLE_OP_RESET_SHAPE_PASS_H_ +#include "graph/graph.h" +#include "inc/graph_pass.h" + +namespace ge { +class DynamicSingleOpResetShapePass : public GraphPass { + public: + Status Run(ComputeGraphPtr graph); +}; +} // namespace ge +#endif // GE_GRAPH_PASSES_DYNAMIC_SINGLE_OP_RESET_SHAPE_PASS_H_ diff --git a/metadef b/metadef index 7472245f..0aee9775 160000 --- a/metadef +++ b/metadef @@ -1 +1 @@ -Subproject commit 7472245fcaed273b7cff99a1f6e6bab3313be684 +Subproject commit 0aee977581117ca5c8df5d5ccdf7333c6ea33834 diff --git a/tests/ut/ge/CMakeLists.txt b/tests/ut/ge/CMakeLists.txt index e305d281..1dfd8bbc 100755 --- a/tests/ut/ge/CMakeLists.txt +++ b/tests/ut/ge/CMakeLists.txt @@ -182,6 +182,7 @@ set(COMMON_SRC_FILES "${GE_CODE_DIR}/ge/graph/passes/atomic_addr_clean_pass.cc" "${GE_CODE_DIR}/ge/graph/passes/mark_same_addr_pass.cc" "${GE_CODE_DIR}/ge/graph/passes/mark_graph_unknown_status_pass.cc" + "${GE_CODE_DIR}/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc" "${GE_CODE_DIR}/ge/graph/passes/mark_agnostic_pass.cc" "${GE_CODE_DIR}/ge/graph/passes/dimension_compute_pass.cc" "${GE_CODE_DIR}/ge/graph/passes/dimension_adjust_pass.cc" From 1d484422594b2e72dea1bbb715e5017e36c47e2d Mon Sep 17 00:00:00 2001 From: l00444296 Date: Wed, 9 Dec 2020 15:25:11 +0800 Subject: [PATCH 2/8] Feature: reset shape of dynamic single op --- ge/graph/manager/graph_manager.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/ge/graph/manager/graph_manager.cc b/ge/graph/manager/graph_manager.cc index 64ced699..bb806da3 100755 --- a/ge/graph/manager/graph_manager.cc +++ b/ge/graph/manager/graph_manager.cc @@ -2281,6 +2281,9 @@ Status GraphManager::OptimizeStage2(ge::ComputeGraphPtr &compute_graph) { new (std::nothrow) VariableRefDeleteOpPass)) GE_CHK_STATUS_RET(pass_for_control_attr_optimize.AddPass("OptimizeStage2::ControlAttrOptimize::CompileNodesPass", new (std::nothrow) CompileNodesPass)) + GE_CHK_STATUS_RET( + pass_for_control_attr_optimize.AddPass("OptimizeStage2::AfterMergePasses::DynamicSingleOpResetShapePass", + new (std::nothrow) DynamicSingleOpResetShapePass)) GE_CHK_STATUS_RET(pass_for_control_attr_optimize.AddPass( "OptimizeStage2::AfterMergePasses::MarkGraphUnknownStatusPass", new(std::nothrow) MarkGraphUnknownStatusPass)) GE_CHK_STATUS_RET( From 67726374b7a80ad410460be57890548c40139c7e Mon Sep 17 00:00:00 2001 From: l00444296 Date: Wed, 9 Dec 2020 15:33:10 +0800 Subject: [PATCH 3/8] Feature: reset shape of dynamic single op --- ge/graph/passes/dynamic_single_op_reset_shape_pass.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc index 0328271a..dcb6fbe8 100644 --- a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc +++ b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc @@ -41,7 +41,7 @@ Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) { std::vector dynamic_shape_dims = {-2}; ge::Shape dynamic_shape(dynamic_shape_dims); for (size_t i = 0; i < op_desc->GetAllInputsDesc().size(); i++) { - const auto &input_desc = op_desc->MutableInputDesc(static_cast(i)); + auto input_desc = op_desc->MutableInputDesc(static_cast(i)); GE_CHECK_NOTNULL(input_desc); input_desc->SetShape(dynamic_shape); } From 976d6a6b76301fdb40eca7102da8db34c760c2d3 Mon Sep 17 00:00:00 2001 From: l00444296 Date: Wed, 9 Dec 2020 15:37:53 +0800 Subject: [PATCH 4/8] Feature: reset shape of dynamic single op --- ge/graph/passes/dynamic_single_op_reset_shape_pass.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc index dcb6fbe8..1a59f348 100644 --- a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc +++ b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc @@ -39,7 +39,7 @@ Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) { auto op_desc = node->GetOpDesc(); std::vector dynamic_shape_dims = {-2}; - ge::Shape dynamic_shape(dynamic_shape_dims); + GeShape dynamic_shape(dynamic_shape_dims); for (size_t i = 0; i < op_desc->GetAllInputsDesc().size(); i++) { auto input_desc = op_desc->MutableInputDesc(static_cast(i)); GE_CHECK_NOTNULL(input_desc); From 201680cb59759928dd7e5c4374ed5e43f8f785f2 Mon Sep 17 00:00:00 2001 From: l00444296 Date: Wed, 9 Dec 2020 19:19:38 +0800 Subject: [PATCH 5/8] Feature: reset shape of dynamic single op --- ge/graph/passes/dynamic_single_op_reset_shape_pass.cc | 5 ++++- ge/graph/passes/dynamic_single_op_reset_shape_pass.h | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc index 1a59f348..43fbe86b 100644 --- a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc +++ b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc @@ -23,6 +23,9 @@ #include "graph/debug/ge_attr_define.h" namespace ge { +namespace { +const int64_t kDynamicShapeDim = -2; +} Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) { GE_CHECK_NOTNULL(graph); for (const auto &node : graph->GetDirectNode()) { @@ -38,7 +41,7 @@ Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) { } auto op_desc = node->GetOpDesc(); - std::vector dynamic_shape_dims = {-2}; + std::vector dynamic_shape_dims = {kDynamicShapeDim}; GeShape dynamic_shape(dynamic_shape_dims); for (size_t i = 0; i < op_desc->GetAllInputsDesc().size(); i++) { auto input_desc = op_desc->MutableInputDesc(static_cast(i)); diff --git a/ge/graph/passes/dynamic_single_op_reset_shape_pass.h b/ge/graph/passes/dynamic_single_op_reset_shape_pass.h index e82d4e16..a8a1a724 100644 --- a/ge/graph/passes/dynamic_single_op_reset_shape_pass.h +++ b/ge/graph/passes/dynamic_single_op_reset_shape_pass.h @@ -22,7 +22,7 @@ namespace ge { class DynamicSingleOpResetShapePass : public GraphPass { public: - Status Run(ComputeGraphPtr graph); + Status Run(ComputeGraphPtr graph) override; }; } // namespace ge #endif // GE_GRAPH_PASSES_DYNAMIC_SINGLE_OP_RESET_SHAPE_PASS_H_ From 77c22da837155e013b2b8554cca5adbb95f9f3a9 Mon Sep 17 00:00:00 2001 From: l00444296 Date: Wed, 9 Dec 2020 21:14:10 +0800 Subject: [PATCH 6/8] Feature: reset shape of dynamic single op --- .../passes/dynamic_single_op_reset_shape_pass.cc | 95 +++++++++++++++++++++- .../passes/dynamic_single_op_reset_shape_pass.h | 6 ++ 2 files changed, 99 insertions(+), 2 deletions(-) diff --git a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc index 43fbe86b..1d1d3add 100644 --- a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc +++ b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc @@ -15,6 +15,7 @@ */ #include "graph/passes/dynamic_single_op_reset_shape_pass.h" +#include "common/ge_inner_error_codes.h" #include "graph/utils/node_utils.h" #include "graph/utils/graph_utils.h" #include "graph/utils/tensor_utils.h" @@ -25,12 +26,25 @@ namespace ge { namespace { const int64_t kDynamicShapeDim = -2; -} +const char *const kAICPUKernelLibName = "aicpu_tf_kernel"; +} // namespace Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) { GE_CHECK_NOTNULL(graph); + + std::shared_ptr instance = ge::GELib::GetInstance(); + if (instance == nullptr || !instance->InitFlag()) { + GELOGE(ge::GE_CLI_GE_NOT_INITIALIZED, "Run CompileNodesPass failed."); + return ge::GE_CLI_GE_NOT_INITIALIZED; + } + for (const auto &node : graph->GetDirectNode()) { GE_CHECK_NOTNULL(node->GetOpDesc()); - if (node->GetType() == DATA || node->GetType() == NETOUTPUT) { + // pass input node + if (node->GetType() == DATA || node->GetType() == CONSTANT || node->GetType() == CONSTANTOP) { + continue; + } + // pass output node + if (node->GetType() == NETOUTPUT) { continue; } @@ -40,6 +54,17 @@ Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) { continue; } + // pass node aicpu node. + string kernel_lib_name; + if (GetSupportedKernel(node, instance, kernel_lib_name) != GRAPH_SUCCESS) { + GELOGE(GRAPH_FAILED, "Get kernel lib failed of node[%s].", node->GetName().c_str()); + return GRAPH_FAILED; + } + if (kernel_lib_name != kAICPUKernelLibName) { + continue; + } + + // reset aicpu shape to unknown shape auto op_desc = node->GetOpDesc(); std::vector dynamic_shape_dims = {kDynamicShapeDim}; GeShape dynamic_shape(dynamic_shape_dims); @@ -54,4 +79,70 @@ Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) { GELOGD("Reset dynamic aicpu nodes shape of graph [%s] success!", graph->GetName().c_str()); return SUCCESS; } + +graphStatus DynamicSingleOpResetShapePass::GetSupportedKernel(const NodePtr &node, + const std::shared_ptr instance, + string &kernel_lib_name) { + auto op_desc = node->GetOpDesc(); + if (op_desc == nullptr) { + GELOGE(ge::GE_GRAPH_PARAM_NULLPTR, "Get op %s opdesc failed", node->GetName().c_str()); + return ge::GE_GRAPH_PARAM_NULLPTR; + } + // reset op kernel lib, find supported kernel + kernel_lib_name = op_desc->GetOpKernelLibName(); + if (kernel_lib_name.empty()) { + (void)instance->DNNEngineManagerObj().GetDNNEngineName(node); + kernel_lib_name = op_desc->GetOpKernelLibName(); + if (kernel_lib_name.empty()) { + GELOGE(GRAPH_FAILED, "Get node:%s, type:%s kernel lib failed.", node->GetName().c_str(), + op_desc->GetType().c_str()); + return GRAPH_FAILED; + } + } + OpsKernelInfoStorePtr kernel_info = instance->OpsKernelManagerObj().GetOpsKernelInfoStore(kernel_lib_name); + if (kernel_info == nullptr) { + GELOGE(ge::GE_GRAPH_PARAM_NULLPTR, "Get op %s ops kernel info store failed", node->GetName().c_str()); + return ge::GE_GRAPH_PARAM_NULLPTR; + } + // begin accuracy supported check + if (!CheckAccuracySupport(kernel_info, instance, op_desc)) { + // if check accuracy support failed , try to go to other engine. + GELOGD("Check Accuracy Supported return not support, node name is %s. Try to go to other engine.", + op_desc->GetName().c_str()); + string kernel_name_origin = kernel_lib_name; + OpsKernelManager &ops_kernel_manager = instance->OpsKernelManagerObj(); + auto kernel_map = ops_kernel_manager.GetAllOpsKernelInfoStores(); + for (auto it = kernel_map.begin(); it != kernel_map.end(); ++it) { + string tmp_kernel_name = it->first; + if (tmp_kernel_name == kernel_name_origin) { + continue; + } + OpsKernelInfoStorePtr tmp_kernel_info = it->second; + if (CheckAccuracySupport(tmp_kernel_info, instance, op_desc)) { + kernel_lib_name = tmp_kernel_name; + GELOGD("Find kernel lib %s support node:%s, type:%s , get kernel lib success.", tmp_kernel_name.c_str(), + node->GetName().c_str(), op_desc->GetType().c_str()); + return GRAPH_SUCCESS; + } + } + GELOGE(GRAPH_FAILED, "Cannot find kernel lib support node:%s, type:%s , get kernel lib failed.", + node->GetName().c_str(), op_desc->GetType().c_str()); + return GRAPH_FAILED; + } + return GRAPH_SUCCESS; +} + +bool DynamicSingleOpResetShapePass::CheckAccuracySupport(const OpsKernelInfoStorePtr &kernel_info, + const std::shared_ptr instance, OpDescPtr &op_desc) { + auto ge_desc = MakeShared(op_desc); + if (ge_desc == nullptr) { + GELOGE(GE_GRAPH_MEMORY_ALLOC_FAILED, "Fail to malloc op desc."); + return false; + } + string reason; + if (!(kernel_info->CheckAccuracySupported(*ge_desc, reason, true))) { + return false; + } + return true; +} } // namespace ge \ No newline at end of file diff --git a/ge/graph/passes/dynamic_single_op_reset_shape_pass.h b/ge/graph/passes/dynamic_single_op_reset_shape_pass.h index a8a1a724..dbea89ea 100644 --- a/ge/graph/passes/dynamic_single_op_reset_shape_pass.h +++ b/ge/graph/passes/dynamic_single_op_reset_shape_pass.h @@ -18,11 +18,17 @@ #define GE_GRAPH_PASSES_DYNAMIC_SINGLE_OP_RESET_SHAPE_PASS_H_ #include "graph/graph.h" #include "inc/graph_pass.h" +#include "init/gelib.h" namespace ge { class DynamicSingleOpResetShapePass : public GraphPass { public: Status Run(ComputeGraphPtr graph) override; + + private: + graphStatus GetSupportedKernel(const NodePtr &node, const std::shared_ptr instance, string &kernel_lib_name); + bool CheckAccuracySupport(const OpsKernelInfoStorePtr &kernel_info, const std::shared_ptr instance, + OpDescPtr &op_desc); }; } // namespace ge #endif // GE_GRAPH_PASSES_DYNAMIC_SINGLE_OP_RESET_SHAPE_PASS_H_ From b0f6c5094f7bf3801b9fee98f3ec378dbe4f36e8 Mon Sep 17 00:00:00 2001 From: l00444296 Date: Thu, 10 Dec 2020 14:39:48 +0800 Subject: [PATCH 7/8] Feature: reset shape of dynamic single op --- ge/generator/ge_generator.cc | 53 +++++++++++++++++++++- .../passes/dynamic_single_op_reset_shape_pass.cc | 5 ++ 2 files changed, 56 insertions(+), 2 deletions(-) diff --git a/ge/generator/ge_generator.cc b/ge/generator/ge_generator.cc index dc64aac1..614b69ef 100644 --- a/ge/generator/ge_generator.cc +++ b/ge/generator/ge_generator.cc @@ -47,6 +47,8 @@ const char *const kEngineNameDefault = "default"; const char *const kVectorEngine = "VectorEngine"; const char *const kAIcoreEngine = "AIcoreEngine"; const char *const kFileNameSuffix = "online"; +const int kDynamicDimSize = 1; +const int64_t kDynamicDimValue = -2; std::map engine_type_map{ {ge::ENGINE_SYS, kEngineNameDefault}, {ge::ENGINE_AICORE, kAIcoreEngine}, {ge::ENGINE_VECTOR, kVectorEngine}}; @@ -231,6 +233,43 @@ static void GetOpsProtoPath(string &opsproto_path) { opsproto_path = (path_base + "ops/op_proto/custom/" + ":") + (path_base + "ops/op_proto/built-in/"); } +static Status CheckShapeReset(const OpDescPtr &op_desc, bool &change_shape_flag) { + GE_CHECK_NOTNULL_EXEC(op_desc, return PARAM_INVALID); + change_shape_flag = false; + for (size_t i = 0; i < op_desc->GetAllInputsDesc().size(); i++) { + auto input_desc = op_desc->MutableInputDesc(static_cast(i)); + GE_CHECK_NOTNULL(input_desc); + // pass scalar input desc + auto dims = input_desc->GetShape().GetDims(); + if (dims.size() == kDynamicDimSize && dims[0] == kDynamicDimValue) { + change_shape_flag = true; + } + } + return SUCCESS; +} + +static void ResetInputShape(const vector &inputs, vector &inputs_dynamic) { + for (auto input : inputs) { + auto input_desc = input.GetTensorDesc(); + GeShape shape_ori = input_desc.GetShape(); + Format format_ori = input_desc.GetFormat(); + DataType type_ori = input_desc.GetDataType(); + + std::vector dynamic_shape_dims = {kDynamicDimValue}; + GeShape dynamic_shape(dynamic_shape_dims); + + ge::GeTensor inputTensor; + if (shape_ori.GetDims().size() == 0) { + ge::GeTensorDesc desc(shape_ori, format_ori, type_ori); + } else { + ge::GeTensorDesc desc(dynamic_shape, format_ori, type_ori); + } + + inputTensor.SetTensorDesc(desc); + inputs_dynamic.push_back(inputTensor); + } +} + class GeGenerator::Impl { public: Impl(OmgContext &omg_context) : omg_context_(omg_context) {} @@ -557,7 +596,9 @@ Status GeGenerator::CheckForSingleOp(OpDescPtr &op_desc, const vector Status GeGenerator::BuildSingleOp(OpDescPtr &op_desc, const vector &inputs, const vector &outputs, const string &model_file_name, OpEngineType engine_type, ModelBufferData &model_buff, bool is_offline) { - + if (is_offline) { + (void)AttrUtils::SetBool(data_op, ATTR_DYNAMIC_SHAPE_SINGLE_AICPU, true); + } if (CheckForSingleOp(op_desc, inputs, outputs) != SUCCESS) { GELOGE(PARAM_INVALID, "input param is invalid when build single op!"); return PARAM_INVALID; @@ -634,7 +675,15 @@ Status GeGenerator::BuildSingleOp(OpDescPtr &op_desc, const vector &in } GeModelPtr &ge_model = name_to_ge_model.begin()->second; GELOGD("The opType in op_desc_tmp is [%s]", op_desc_tmp->GetType().c_str()); - GE_CHK_STATUS_RET_NOLOG(impl_->SaveParams(ge_model, op_desc_tmp->GetType(), op_attrs, inputs, outputs)); + + bool dynamic_flag = false; + if (CheckShapeReset(op_desc, dynamic_flag) == SUCCESS && dynamic_flag) { + vector inputs_dynamic; + ResetInputShape(inputs, inputs_dynamic); + GE_CHK_STATUS_RET_NOLOG(impl_->SaveParams(ge_model, op_desc_tmp->GetType(), op_attrs, inputs_dynamic, outputs)); + } else { + GE_CHK_STATUS_RET_NOLOG(impl_->SaveParams(ge_model, op_desc_tmp->GetType(), op_attrs, inputs, outputs)); + } GE_CHK_STATUS_RET_NOLOG(impl_->SaveModel(model_file_name, ge_model, model_buff)); return SUCCESS; } diff --git a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc index 1d1d3add..e1384571 100644 --- a/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc +++ b/ge/graph/passes/dynamic_single_op_reset_shape_pass.cc @@ -71,6 +71,11 @@ Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) { for (size_t i = 0; i < op_desc->GetAllInputsDesc().size(); i++) { auto input_desc = op_desc->MutableInputDesc(static_cast(i)); GE_CHECK_NOTNULL(input_desc); + // pass scalar input desc + auto dims_ori = input_desc->GetShape().GetDims(); + if (dims_ori.size() == 0) { + continue; + } input_desc->SetShape(dynamic_shape); } GELOGD("Reset dynamic aicpu node [%s] shape success!", node->GetName().c_str()); From 56649dcc8136f942330d3ae4214ed82339e1054b Mon Sep 17 00:00:00 2001 From: l00444296 Date: Thu, 10 Dec 2020 14:48:00 +0800 Subject: [PATCH 8/8] Feature: reset shape of dynamic single op --- ge/generator/ge_generator.cc | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/ge/generator/ge_generator.cc b/ge/generator/ge_generator.cc index 614b69ef..7140170e 100644 --- a/ge/generator/ge_generator.cc +++ b/ge/generator/ge_generator.cc @@ -259,10 +259,9 @@ static void ResetInputShape(const vector &inputs, vector &in GeShape dynamic_shape(dynamic_shape_dims); ge::GeTensor inputTensor; - if (shape_ori.GetDims().size() == 0) { - ge::GeTensorDesc desc(shape_ori, format_ori, type_ori); - } else { - ge::GeTensorDesc desc(dynamic_shape, format_ori, type_ori); + ge::GeTensorDesc desc(shape_ori, format_ori, type_ori); + if (shape_ori.GetDims().size() > 0) { + desc.SetShape(dynamic_shape); } inputTensor.SetTensorDesc(desc); @@ -597,7 +596,7 @@ Status GeGenerator::BuildSingleOp(OpDescPtr &op_desc, const vector &in const string &model_file_name, OpEngineType engine_type, ModelBufferData &model_buff, bool is_offline) { if (is_offline) { - (void)AttrUtils::SetBool(data_op, ATTR_DYNAMIC_SHAPE_SINGLE_AICPU, true); + (void)AttrUtils::SetBool(op_desc, ATTR_DYNAMIC_SHAPE_SINGLE_AICPU, true); } if (CheckForSingleOp(op_desc, inputs, outputs) != SUCCESS) { GELOGE(PARAM_INVALID, "input param is invalid when build single op!");