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

Continuous memory optimization, code refactoring

Browse Source
pull/953/head
TangQunzhang 4 years ago
parent 8dc0a8b3fc
commit 14732acd6f
8 changed files with 503 additions and 708 deletions
Show Stats Download Patch File Download Diff File

4
ge/graph/build/memory/binary_block_mem_assigner.cc
Unescape View File

@ -69,8 +69,8 @@ Status BinaryBlockMemAssigner::GetMemoryRanges(vector<int64_t> &range_ceils) {
GELOGW("Vector all_memory_size is empty!");
return SUCCESS;
}
if ((all_memory_size.front() == 0) || (log(kLogBase) == 0)) {
GELOGE(FAILED, "dividend is 0!");
if ((all_memory_size.front() <= 0) || (log(kLogBase) == 0)) {
GELOGE(FAILED, "Memory size:%ld is invalid.", all_memory_size.front());
return FAILED;
}
// Memory size is 512 aligned, so it is not necessary to take less than 512

264
ge/graph/build/memory/block_mem_assigner.cc
View File

File diff suppressed because it is too large Load Diff

54
ge/graph/build/memory/block_mem_assigner.h
Unescape View File

@ -39,14 +39,15 @@ using DependStreamLife = std::map<int64_t, std::map<int64_t, size_t>>;
enum OpMemoryType { kOutput, kWorkspace };
struct NodeTypeIndex {
NodeTypeIndex(ge::NodePtr node, OpMemoryType mem_type, uint32_t index, bool ref_input = false)
: node(std::move(node)), mem_type(mem_type), index(index), ref_input(ref_input) {}
NodeTypeIndex(ge::NodePtr node, OpMemoryType mem_type, uint32_t index, bool ref_input = false, size_t begin = 0)
: node(std::move(node)), mem_type(mem_type), index(index), ref_input(ref_input), life_time_begin(begin) {}
ge::NodePtr node = nullptr;
OpMemoryType mem_type = kOutput;
uint32_t index = 0;
size_t life_time_end = kMaxLifeTime;
bool ref_input = false;
size_t life_time_begin = 0;
size_t life_time_end = kMaxLifeTime;
const string GetMemType() const {
if (mem_type == kOutput) {
return "output";
@ -55,6 +56,34 @@ struct NodeTypeIndex {
}
return "unknown";
}
size_t GetLifeBegin() const {
if ((node == nullptr) || (node->GetOpDesc() == nullptr)) {
return 0;
}
if ((life_time_begin > 0) && (life_time_begin < static_cast<size_t>(node->GetOpDesc()->GetId()))) {
return life_time_begin;
} else {
return node->GetOpDesc()->GetId();
}
}
std::string GetLifeBeginDesc() const {
if (node == nullptr) {
return "";
}
auto node_op_desc = node->GetOpDesc();
if (node_op_desc != nullptr) {
auto life_begin = GetLifeBegin();
if (life_begin != static_cast<size_t>(node_op_desc->GetId())) {
return std::to_string(life_begin) + "-" + std::to_string(node_op_desc->GetId());
} else {
return std::to_string(node_op_desc->GetId());
}
}
return "";
}
};
class MemoryBlock {
@ -86,16 +115,13 @@ class MemoryBlock {
symbol_list_.clear();
}
void Init(size_t real_size, OpMemoryType type, const ge::NodePtr &node, uint32_t out_index, size_t no_align_size,
int64_t stream_id) {
real_size_list_.emplace_back(real_size);
no_align_size_list_.emplace_back(no_align_size);
node_type_index_list_.emplace_back(node, type, out_index, false);
if (stream_id != stream_id_) {
same_stream_ = false;
size_t Size() const { return block_size_; }
void SetSize(size_t size) {
if (size > block_size_) {
block_size_ = size;
}
}
size_t Size() const { return block_size_; }
size_t AlignSize() const;
@ -143,7 +169,7 @@ class MemoryBlock {
size_t GetLifeBegin();
size_t GetLifeEnd();
size_t GetLifeEnd() const;
void AddDependLifeBegin(DependStreamLife &node_depend_stream_life);
@ -406,6 +432,7 @@ class BlockMemAssigner : public MemAssigner {
bool IsOutNodeSetContinuousInput(const NodePtr &n, uint32_t out_index, std::string &peer_name,
uint32_t &peer_input_index, bool &no_need_assign_memory, bool &reset_zero_copy_flag);
bool IsContinuousMemoryReuse(const NodePtr &n, const NodePtr &peer_node, uint32_t out_index);
///
/// @ingroup GE
/// @|+++++++++block1++++++++| |+++++++++block1++++++++|
@ -425,8 +452,6 @@ class BlockMemAssigner : public MemAssigner {
std::unordered_map<int64_t, std::unordered_map<int64_t, std::vector<MemoryBlock *>>> reusable_blocks_;
std::map<std::string, uint64_t> reusable_block_counts_;
std::unordered_map<int64_t, std::unordered_map<int64_t, std::vector<MemoryBlock *>>> stream_workspace_blocks_;
std::unordered_map<std::string, std::vector<MemoryBlock *>> node_out_blocks_;
@ -456,6 +481,7 @@ class BlockMemAssigner : public MemAssigner {
std::string max_batch_label_;
size_t continuous_life_begin_ = 0;
///
/// @ [stream1][nodeid]
/// @[nodeid] [stream2][nodeid]

855
ge/graph/build/memory/graph_mem_assigner.cc
View File

File diff suppressed because it is too large Load Diff

24
ge/graph/build/memory/graph_mem_assigner.h
Unescape View File

@ -119,31 +119,15 @@ class GraphMemoryAssigner {
///
ge::Status ReAssignContinuousMemory(bool is_loop_graph);
ge::Status ReAssignReuseAndNoPaddingContinuousInputMemory();
ge::Status ReAssignReuseAndNoPaddingContinuousOutputMemory();
ge::Status ReAssignVirtualInputNodeMemory(NodePtr node, size_t &mem_offset_reuse);
ge::Status ReAssignVirtualOutputNodeMemory(NodePtr node, size_t &mem_offset_reuse);
ge::Status ReAssignVirtualNodesMemory(map<string, vector<NodePtr>> &mem_reuse_nodes_map, int32_t mem_reuse_model);
ge::Status GetMaxBatchLabel(const map<string, vector<NodePtr>> &mem_reuse_virtual_nodes_map,
int32_t mem_reuse_model, string &max_batch_label);
ge::Status CalculateTensorRealSizeAndOutSize(const ge::ConstGeTensorDescPtr &output_desc, int64_t dim_index,
int64_t &output_mem_size, int64_t &batch_dim_num, int64_t &out_size);
ge::Status ReAssignAtomicMemory(bool is_loop_graph);
ge::Status FilterAtomicNodesForMemoryAssign(map<string, map<NodePtr, vector<NodePtr>>> &normal_atomic_nodes_map,
map<string, vector<NodePtr>> &connecting_output_atomic_nodes);
ge::Status AssignContinuousInputMemory(const ge::NodePtr &node, int64_t &continuous_mem_start,
int64_t &continuous_mem_size, int64_t memory_type);
int64_t &continuous_mem_size, int64_t memory_type, uint32_t continuous_type);
ge::Status AssignContinuousOutputMemory(const ge::NodePtr &node);
ge::Status AssignContinuousOutputMemory(const ge::NodePtr &node, int64_t memory_type, uint32_t continuous_type);
///
/// @brief check the input of node whether support atomic attr
@ -169,10 +153,10 @@ class GraphMemoryAssigner {
ge::Status AssignConnectNetOutputAtomicMemory(vector<NodePtr> &connect_netoutput_nodes);
ge::Status SetIndependentAtomicAttr(const ge::NodePtr &node, int64_t atomic_mem_start,
const std::vector<int64_t> &mem_offset_end);
const std::vector<int64_t> &mem_offset_end, int64_t memory_type);
ge::Status SetAtomicCleanAttr(const ge::NodePtr &node, const std::vector<int64_t> &atomic_mem_start,
const std::vector<int64_t> &atomic_mem_size);
const std::vector<int64_t> &atomic_mem_size, int64_t memory_type);
ge::Status IsIndependentAtomicClean(const ge::NodePtr &node, bool &is_independent_atomic_clean_node);

6
ge/graph/load/new_model_manager/davinci_model.cc
Unescape View File

@ -1820,7 +1820,7 @@ void DavinciModel::GetUserDesignateShapeOrder(std::vector<std::string> &user_inp
///
Status DavinciModel::InitAippInfo(uint32_t index, const OpDescPtr &op_desc) {
if (!op_desc->HasAttr(ATTR_NAME_AIPP)) {
GELOGW("there is not AIPP related with index %u.", index);
GELOGW("There is not AIPP related with index %u.", index);
return SUCCESS;
}
@ -1829,7 +1829,7 @@ Status DavinciModel::InitAippInfo(uint32_t index, const OpDescPtr &op_desc) {
GE_CHK_BOOL_RET_STATUS(AttrUtils::GetNamedAttrs(op_desc, ATTR_NAME_AIPP, aipp_attr), GE_AIPP_NOT_EXIST,
"Data node do not contain param aipp!");
GE_CHK_STATUS_RET(OpUtils::ConvertAippParams(aipp_attr, &aipp_params), "get aipp params failed");
GELOGI("node data: %s, type: %s, current index: %u, current node related input rank: %u",
GELOGI("Node data: %s, type: %s, current index: %u, current node related input rank: %u",
op_desc->GetName().c_str(), op_desc->GetType().c_str(), index, aipp_params.related_input_rank());
AippConfigInfo aipp_info;
@ -2492,7 +2492,7 @@ Status DavinciModel::CopyOutputData(uint32_t data_id, OutputData &output_data, r
uint64_t buffer_length = buffer.length;
void *buffer_addr = reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(buffer.data));
GELOGI("[IMAS]CopyPlainData memcpy graph_%u type[F] output[%u] memaddr[%p] mem_size[%lu] datasize[%lu]",
GELOGI("CopyPlainData memcpy graph_%u type[F] output[%u] memaddr[%p] mem_size[%lu] datasize[%lu]",
runtime_param_.graph_id, output.first, output.second.GetBasicAddr(), data_size, buffer_length);
GE_CHK_RT_RET(rtMemcpy(buffer_addr, buffer_length, output.second.GetBasicAddr(), data_size, kind));
idx++;

2
metadef

@ -1 +1 @@
Subproject commit dc6cceb67bc82b567bcbd6f415776644253e1467
Subproject commit fcd0833cffcd201701f71d17db0c696c1bb01715

2
parser

@ -1 +1 @@
Subproject commit 4e72aae41e78af1a19cd965da4a45cbd988b9a75
Subproject commit 1601d66b6187c83cbf38e762beb5538ce2c7c573
Write Preview
Loading…
Cancel
Save