m53297601
/
graphengine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

modified: ge/graph/build/graph_builder.cc

Browse Source 
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
pull/1204/head
zhaoxinxin 4 years ago
parent 80f41237c5
commit 58a3e06c17
6 changed files with 63 additions and 64 deletions
Show Stats Download Patch File Download Diff File

4
ge/graph/build/graph_builder.cc
Unescape View File

@ -394,6 +394,10 @@ static Status InsertMemcpyNode(const ComputeGraphPtr &graph, const OutDataAnchor
} }
static Status GenerateTaskForConstant(const std::shared_ptr<ComputeGraph> &graph) { 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()) { for (auto &node : graph->GetDirectNode()) {
// CONSTANT not generate task, so insert IDENTITY between CONSTANT and NETOUTPUT // CONSTANT not generate task, so insert IDENTITY between CONSTANT and NETOUTPUT
auto op_desc = node->GetOpDesc(); auto op_desc = node->GetOpDesc();

4
ge/graph/load/model_manager/model_manager.cc
Unescape View File

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

1
ge/host_kernels/identity_kernel.cc
Unescape View File

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

1
ge/hybrid/model/hybrid_model.h
Unescape View File

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

115
ge/hybrid/model/hybrid_model_builder.cc
Unescape View File

@ -996,70 +996,65 @@ Status HybridModelBuilder::InitVariableTensors() {
Status HybridModelBuilder::InitWeights() { Status HybridModelBuilder::InitWeights() {
// For constant in root graph // For constant in root graph
const auto &root_graph = ge_root_model_->GetRootGraph(); for (const auto &subgraph_model : ge_root_model_->GetSubgraphInstanceNameToModel()) {
const auto &subgraph_models = ge_root_model_->GetSubgraphInstanceNameToModel(); const auto &weight_buffer = subgraph_model.second->GetWeight();
auto iter = subgraph_models.find(root_graph->GetName()); if (weight_buffer.GetSize() == 0) {
if (iter == subgraph_models.end()) { GELOGD("weight is empty");
GELOGD("Root graph model not found"); return SUCCESS;
return SUCCESS; }
}
auto &root_model = iter->second; auto allocator = NpuMemoryAllocator::GetAllocator();
const auto &weight_buffer = root_model->GetWeight(); GE_CHECK_NOTNULL(allocator);
if (weight_buffer.GetSize() == 0) { auto sub_weight_buffer = TensorBuffer::Create(allocator, weight_buffer.size());
GELOGD("weight is empty"); GE_CHECK_NOTNULL(sub_weight_buffer);
return SUCCESS; auto weight_base = reinterpret_cast<uint8_t *>(sub_weight_buffer->GetData());
} GE_CHK_RT_RET(rtMemcpy(weight_base,
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,
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;
}
auto allocator = NpuMemoryAllocator::GetAllocator(); auto op_desc = node->GetOpDesc();
GE_CHECK_NOTNULL(allocator); auto v_weights = ModelUtils::GetWeights(op_desc);
hybrid_model_.weight_buffer_ = TensorBuffer::Create(allocator, weight_buffer.size()); if (v_weights.empty()) {
GE_CHECK_NOTNULL(hybrid_model_.weight_buffer_); GELOGE(INTERNAL_ERROR, "[%s] Constant has no value", node->GetName().c_str());
auto weight_base = reinterpret_cast<uint8_t *>(hybrid_model_.weight_buffer_->GetData()); return INTERNAL_ERROR;
GE_CHK_RT_RET(rtMemcpy(weight_base, }
hybrid_model_.weight_buffer_->GetSize(), auto *ge_tensor = const_cast<GeTensor *>(v_weights[0].get());
weight_buffer.GetData(), GE_CHECK_NOTNULL(ge_tensor);
weight_buffer.GetSize(), const GeTensorDesc &tensor_desc = ge_tensor->GetTensorDesc();
RT_MEMCPY_HOST_TO_DEVICE)); int64_t tensor_size = 0;
GE_CHK_GRAPH_STATUS_RET(TensorUtils::GetSize(*op_desc->MutableOutputDesc(0), tensor_size),
GELOGI("Init weight mem successfully, weight base %p, weight size = %zu", "[%s] Failed to get tensor size",
weight_base, node->GetName().c_str());
hybrid_model_.weight_buffer_->GetSize()); int64_t data_offset = 0;
for (auto &node : root_graph->GetDirectNode()) { GE_CHK_GRAPH_STATUS_RET(TensorUtils::GetDataOffset(tensor_desc, data_offset),
if (node->GetType() != CONSTANT) { "[%s] Failed to get data offset",
continue; node->GetName().c_str());
} GELOGD("[%s] Start to init Constant node [%s], size = %ld, offset = %ld",
GetGraphName(),
node->GetName().c_str(),
tensor_size,
data_offset);
auto op_desc = node->GetOpDesc(); auto tensor_buffer = TensorBuffer::Create(weight_base + data_offset, tensor_size);
auto v_weights = ModelUtils::GetWeights(op_desc); GE_CHECK_NOTNULL(tensor_buffer);
if (v_weights.empty()) { std::unique_ptr<TensorValue> constant_tensor(new (std::nothrow)TensorValue(std::move(tensor_buffer)));
GELOGE(INTERNAL_ERROR, "[%s] Constant has no value", node->GetName().c_str()); GE_CHECK_NOTNULL(constant_tensor);
return INTERNAL_ERROR; constant_tensor->SetName("Constant_" + op_desc->GetName());
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);
} }
auto *ge_tensor = const_cast<GeTensor *>(v_weights[0].get());
GE_CHECK_NOTNULL(ge_tensor);
const GeTensorDesc &tensor_desc = ge_tensor->GetTensorDesc();
int64_t tensor_size = 0;
GE_CHK_GRAPH_STATUS_RET(TensorUtils::GetSize(*op_desc->MutableOutputDesc(0), tensor_size),
"[%s] Failed to get tensor size",
node->GetName().c_str());
int64_t data_offset = 0;
GE_CHK_GRAPH_STATUS_RET(TensorUtils::GetDataOffset(tensor_desc, data_offset),
"[%s] Failed to get data offset",
node->GetName().c_str());
GELOGD("[%s] Start to init Constant node [%s], size = %ld, offset = %ld",
GetGraphName(),
node->GetName().c_str(),
tensor_size,
data_offset);
auto tensor_buffer = TensorBuffer::Create(weight_base + data_offset, tensor_size);
GE_CHECK_NOTNULL(tensor_buffer);
std::unique_ptr<TensorValue> constant_tensor(new (std::nothrow)TensorValue(std::move(tensor_buffer)));
GE_CHECK_NOTNULL(constant_tensor);
constant_tensor->SetName("Constant_" + op_desc->GetName());
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; return SUCCESS;
} }

2
ge/hybrid/node_executor/task_context.cc
Unescape View File

@ -236,7 +236,7 @@ Status TaskContext::AllocateOutput(int index,
ref_node->GetName().c_str(), ref_node->GetName().c_str(),
ref_node->GetType().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); GE_CHECK_NOTNULL(ref_tensor);
outputs_start_[index] = *ref_tensor; outputs_start_[index] = *ref_tensor;
} else { } else {

Write Preview
Loading…
Cancel
Save