modified: ge/graph/build/graph_builder.cc

modified:   ge/graph/load/model_manager/model_manager.cc
	modified:   ge/host_kernels/identity_kernel.cc
	modified:   ge/hybrid/model/hybrid_model.h
	modified:   ge/hybrid/model/hybrid_model_builder.cc
	modified:   ge/hybrid/node_executor/task_context.cc

ge/graph/build/graph_builder.cc

@@ -394,6 +394,10 @@ static Status InsertMemcpyNode(const ComputeGraphPtr &graph, const OutDataAnchor
 }
 
 static Status GenerateTaskForConstant(const std::shared_ptr<ComputeGraph> &graph) {
+  if (graph->GetGraphUnknownFlag()) {
+    GELOGI("Graph %s is unknown graph, ignore gen_task for constant.", graph->GetName().c_str());
+    return SUCCESS;
+  }
   for (auto &node : graph->GetDirectNode()) {
     // CONSTANT not generate task, so insert IDENTITY between CONSTANT and NETOUTPUT
     auto op_desc = node->GetOpDesc();

ge/graph/load/model_manager/model_manager.cc

@@ -297,10 +297,8 @@ Status ModelManager::LoadModelOnline(uint32_t &model_id, const shared_ptr<ge::Ge
     GenModelId(&model_id);
   }
 
-  bool is_shape_unknown = false;
   string model_name = "";
-  GE_CHK_STATUS_RET(ge_root_model->CheckIsUnknownShape(is_shape_unknown), "CheckIsUnknownShape failed, model id:%u",
-                    model_id);
+  bool is_shape_unknown = ge_root_model->GetRootGraph()->GetGraphUnknownFlag();
   if (is_shape_unknown || GetContext().GetHostExecFlag()) {
     return DoLoadHybridModelOnline(model_id, model_name, ge_root_model, listener);
   }

ge/host_kernels/identity_kernel.cc

@@ -61,4 +61,5 @@ Status IdentityKernel::Compute(const ge::OpDescPtr op_desc, const std::vector<ge
   return SUCCESS;
 }
 REGISTER_KERNEL(IDENTITY, IdentityKernel);
+REGISTER_KERNEL(PLACEHOLDERWITHDEFAULT, IdentityKernel);
 }  // namespace ge

ge/hybrid/model/hybrid_model.h

@@ -150,6 +150,7 @@ class HybridModel {
   uint32_t model_id_ = 0;
   uint8_t *var_mem_base_ = nullptr;
   std::unique_ptr<TensorBuffer> weight_buffer_;
+  std::map<string, std::unique_ptr<TensorBuffer>> weight_buffer_map_;
   RuntimeParam root_runtime_param_;
   string om_name_;
 };

ge/hybrid/model/hybrid_model_builder.cc

@@ -996,16 +996,8 @@ Status HybridModelBuilder::InitVariableTensors() {
 
 Status HybridModelBuilder::InitWeights() {
   // For constant in root graph
-  const auto &root_graph = ge_root_model_->GetRootGraph();
-  const auto &subgraph_models = ge_root_model_->GetSubgraphInstanceNameToModel();
-  auto iter = subgraph_models.find(root_graph->GetName());
-  if (iter == subgraph_models.end()) {
-    GELOGD("Root graph model not found");
-    return SUCCESS;
-  }
-
-  auto &root_model = iter->second;
-  const auto &weight_buffer = root_model->GetWeight();
+  for (const auto &subgraph_model : ge_root_model_->GetSubgraphInstanceNameToModel()) {
+    const auto &weight_buffer = subgraph_model.second->GetWeight();
     if (weight_buffer.GetSize() == 0) {
       GELOGD("weight is empty");
       return SUCCESS;
@@ -1013,18 +1005,20 @@ Status HybridModelBuilder::InitWeights() {
 
     auto allocator = NpuMemoryAllocator::GetAllocator();
     GE_CHECK_NOTNULL(allocator);
-  hybrid_model_.weight_buffer_ = TensorBuffer::Create(allocator, weight_buffer.size());
-  GE_CHECK_NOTNULL(hybrid_model_.weight_buffer_);
-  auto weight_base = reinterpret_cast<uint8_t *>(hybrid_model_.weight_buffer_->GetData());
+    auto sub_weight_buffer = TensorBuffer::Create(allocator, weight_buffer.size());
+    GE_CHECK_NOTNULL(sub_weight_buffer);
+    auto weight_base = reinterpret_cast<uint8_t *>(sub_weight_buffer->GetData());
     GE_CHK_RT_RET(rtMemcpy(weight_base,
-                         hybrid_model_.weight_buffer_->GetSize(),
+                           sub_weight_buffer->GetSize(),
                            weight_buffer.GetData(),
                            weight_buffer.GetSize(),
                            RT_MEMCPY_HOST_TO_DEVICE));
 
     GELOGI("Init weight mem successfully, weight base %p, weight size = %zu",
            weight_base,
-         hybrid_model_.weight_buffer_->GetSize());
+           sub_weight_buffer->GetSize());
+    auto root_graph = GraphUtils::GetComputeGraph(subgraph_model.second->GetGraph());
+    hybrid_model_.weight_buffer_map_.emplace(root_graph->GetName(),std::move(sub_weight_buffer));
     for (auto &node : root_graph->GetDirectNode()) {
       if (node->GetType() != CONSTANT) {
         continue;
@@ -1061,6 +1055,7 @@ Status HybridModelBuilder::InitWeights() {
       hybrid_model_.constant_tensors_.emplace(node, std::move(constant_tensor));
       GELOGD("[%s] Constant node [%s] added, size = %ld", GetGraphName(), node->GetName().c_str(), tensor_size);
     }
+  }
   return SUCCESS;
 }
 

ge/hybrid/node_executor/task_context.cc

@@ -236,7 +236,7 @@ Status TaskContext::AllocateOutput(int index,
            ref_node->GetName().c_str(),
            ref_node->GetType().c_str());
 
-    TensorValue *ref_tensor = execution_context_->model->GetVariable(ref_node->GetName());
+    TensorValue *ref_tensor = execution_context_->model->GetTensor(ref_node);
     GE_CHECK_NOTNULL(ref_tensor);
     outputs_start_[index] = *ref_tensor;
   } else {