Feature: reset shape of dynamic single op

ge/graph/passes/dynamic_single_op_reset_shape_pass.cc

@@ -0,0 +1,105 @@
+/**
+ * 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 "common/ge_inner_error_codes.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 {
+namespace {
+const int64_t kDynamicShapeDim = -2;
+const char *const kEngineNameAiCpu = "aicpu_ascend_kernel";
+const char *const kEngineNameAiCpuTf = "aicpu_tf_kernel";
+}  // namespace
+Status DynamicSingleOpResetShapePass::Run(ComputeGraphPtr graph) {
+  GE_CHECK_NOTNULL(graph);
+
+  std::shared_ptr<GELib> 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());
+    // pass input and output node
+    if (node->GetType() == DATA || node->GetType() == CONSTANT || node->GetType() == CONSTANTOP ||
+        node->GetType() == NETOUTPUT) {
+      continue;
+    }
+
+    // pass node without attr: ATTR_DYNAMIC_SHAPE_SINGLE_AICPU
+    bool single_aicpu_unknown = false;
+    if (!AttrUtils::GetBool(node->GetOpDesc(), ATTR_DYNAMIC_SHAPE_SINGLE_AICPU, single_aicpu_unknown) ||
+        !single_aicpu_unknown) {
+      continue;
+    }
+
+    // pass not aicpu node.
+    auto op_desc = node->GetOpDesc();
+    string engine_name = op_desc->GetOpEngineName();
+    if (engine_name.empty()) {
+      GELOGE(GRAPH_FAILED, "Get engine failed of node[%s].", node->GetName().c_str());
+      return GRAPH_FAILED;
+    }
+    if (engine_name != kEngineNameAiCpu && engine_name != kEngineNameAiCpuTf) {
+      continue;
+    }
+
+    // reset aicpu shape to unknown shape
+    if (ResetOpShape(op_desc) != SUCCESS) {
+      GELOGE(ge::GE_CLI_GE_NOT_INITIALIZED, "Reset node[%s] dynamic shapr failed.", node->GetName().c_str());
+      return ge::GE_CLI_GE_NOT_INITIALIZED;
+    }
+    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;
+}
+
+Status DynamicSingleOpResetShapePass::ResetOpShape(OpDescPtr &op_desc) {
+  GE_CHECK_NOTNULL(op_desc);
+  std::vector<int64_t> 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<uint32_t>(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);
+  }
+  for (size_t i = 0; i < op_desc->GetAllOutputsDesc().size(); i++) {
+    auto output_desc = op_desc->MutableOutputDesc(static_cast<uint32_t>(i));
+    GE_CHECK_NOTNULL(output_desc);
+    // pass scalar input desc
+    auto output_dims_ori = output_desc->GetShape().GetDims();
+    if (output_dims_ori.size() == 0) {
+      continue;
+    }
+    output_desc->SetShape(dynamic_shape);
+  }
+  return SUCCESS;
+}
+}  // namespace ge

ge/graph/passes/dynamic_single_op_reset_shape_pass.h

@@ -0,0 +1,32 @@
+/**
+ * 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"
+#include "init/gelib.h"
+
+namespace ge {
+class DynamicSingleOpResetShapePass : public GraphPass {
+ public:
+  Status Run(ComputeGraphPtr graph) override;
+
+ private:
+  Status ResetOpShape(OpDescPtr &op_desc);
+};
+}  // namespace ge
+#endif  // GE_GRAPH_PASSES_DYNAMIC_SINGLE_OP_RESET_SHAPE_PASS_H_