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

!731 revert

Browse Source 
* 回退 'Pull Request !703 : TaskInfo release OpDesc after distribute.'
pull/731/MERGE
王笑天 4 years ago
parent 5f3d42f4de
commit 325c1abd5b
10 changed files with 178 additions and 183 deletions
Show Stats Download Patch File Download Diff File

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

@ -139,7 +139,6 @@ DavinciModel::DavinciModel(int32_t priority, const std::shared_ptr<ModelListener
is_l1_fusion_enable_(false), is_l1_fusion_enable_(false),
is_first_execute_(true) { is_first_execute_(true) {
op_list_.clear(); op_list_.clear();
skt_info_ = {0, 0, 0, 0, nullptr, nullptr, {}, {}, {}, {}, {}, RT_KERNEL_DEFAULT, -1, 0, nullptr};
} }
DavinciModel::~DavinciModel() { DavinciModel::~DavinciModel() {
@ -262,7 +261,6 @@ Status DavinciModel::Assign(const GeModelPtr &ge_model) {
/// @return: void /// @return: void
/// ///
void DavinciModel::Shrink() { void DavinciModel::Shrink() {
skt_info_ = {0, 0, 0, 0, nullptr, nullptr, {}, {}, {}, {}, {}, RT_KERNEL_DEFAULT, -1, 0, nullptr};
ge_model_.reset(); // delete object. ge_model_.reset(); // delete object.
} }

31
ge/graph/load/new_model_manager/davinci_model.h
Unescape View File

@ -76,25 +76,6 @@ struct timeInfo {
int64_t dumpEndTime; int64_t dumpEndTime;
}; };
// For super kernel
struct SuperKernelTaskInfo {
uint32_t last_block_dim;
uint32_t last_args_size;
uint32_t last_task_id;
uint32_t last_stream_id;
void *last_stream;
void *last_sm_desc;
std::vector<void *> kernel_list;
std::vector<void *> arg_list;
std::vector<uint32_t> dump_flag_list;
std::vector<OpDescPtr> op_desc_list;
std::vector<uintptr_t> dump_args_list;
uint32_t last_dump_flag;
int64_t last_group_key;
uintptr_t last_dump_args;
OpDescPtr last_op;
};
struct TaskMemInfo { struct TaskMemInfo {
int64_t input_size{0}; int64_t input_size{0};
int64_t output_size{0}; int64_t output_size{0};
@ -223,14 +204,13 @@ class DavinciModel {
// get total mem size // get total mem size
size_t TotalMemSize() const { return runtime_param_.mem_size; } size_t TotalMemSize() const { return runtime_param_.mem_size; }
const std::map<uint32_t, MemInfo> &P2PMemInfos() const { return runtime_param_.memory_infos; } const std::map<uint32_t, MemInfo> &P2PMemInfos() const {return runtime_param_.memory_infos;}
// model name // model name
string Name() const { return name_; } string Name() const { return name_; }
// om_name // om_name
string OmName() const { return om_name_; } string OmName() const { return om_name_; }
// version // version
uint32_t Version() const { return version_; } uint32_t Version() const { return version_; }
@ -275,16 +255,12 @@ class DavinciModel {
} }
return nullptr; return nullptr;
} }
// get task info for profiling // get task info for profiling
const std::vector<TaskDescInfo> &GetTaskDescInfo() const { return task_desc_info_; } const std::vector<TaskDescInfo> &GetTaskDescInfo() const { return task_desc_info_; }
// get updated task info list // get updated task info list
std::vector<TaskInfoPtr> GetTaskList() { return task_list_; } std::vector<TaskInfoPtr> GetTaskList() { return task_list_; }
// Modified from KernelTaskInfo.
SuperKernelTaskInfo &GetSuperKernelTaskInfo() { return skt_info_; }
/// ///
/// @ingroup ge /// @ingroup ge
/// @brief get model input and output format /// @brief get model input and output format
@ -634,7 +610,7 @@ class DavinciModel {
uint8_t *MallocWeightsMem(size_t weights_size); uint8_t *MallocWeightsMem(size_t weights_size);
uint8_t *MallocP2PMem(size_t p2p_data_size); uint8_t* MallocP2PMem(size_t p2p_data_size);
void FreeFeatureMapMem(); void FreeFeatureMapMem();
@ -1020,9 +996,6 @@ class DavinciModel {
std::multimap<uint32_t, uint32_t> op_id_map_; std::multimap<uint32_t, uint32_t> op_id_map_;
std::vector<ProfileInfo> profile_list_; std::vector<ProfileInfo> profile_list_;
// For super kernel.
SuperKernelTaskInfo skt_info_;
}; };
} // namespace ge } // namespace ge
#endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_DAVINCI_MODEL_H_ #endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_DAVINCI_MODEL_H_

56
ge/graph/load/new_model_manager/task_info/hccl_task_info.cc
Unescape View File

@ -59,40 +59,40 @@ Status HcclTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *davinci_m
GELOGI("HcclTaskInfo Init, op_index is: %u", op_index); GELOGI("HcclTaskInfo Init, op_index is: %u", op_index);
// Get HCCL op // Get HCCL op
const auto op_desc = davinci_model_->GetOpByIndex(op_index); op_desc_ = davinci_model->GetOpByIndex(op_index);
GE_CHECK_NOTNULL(op_desc); GE_CHECK_NOTNULL(op_desc_);
// Create the kernel hccl infos // Create the kernel hccl infos
CreateKernelHcclInfo(op_desc); CreateKernelHcclInfo(op_desc_);
// Initialize the hccl_type of all kernel hccl info // Initialize the hccl_type of all kernel hccl info
HcomOmeUtil::GetHcclType(task_def, kernel_hccl_infos_); HcomOmeUtil::GetHcclType(task_def, kernel_hccl_infos_);
// Only in Horovod scenario should get the inputName and GeShape // Only in Horovod scenario should get the inputName and GeShape
ret = HcomOmeUtil::GetHorovodInputs(op_desc, kernel_hccl_infos_); ret = HcomOmeUtil::GetHorovodInputs(op_desc_, kernel_hccl_infos_);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "davinci_model: GetHorovodInputs fail! domi error: %u", ret); GELOGE(ret, "davinci_model: GetHorovodInputs fail! domi error: %u", ret);
return ret; return ret;
} }
Status dmrt = HcomOmeUtil::GetHcclDataType(op_desc, kernel_hccl_infos_); Status dmrt = HcomOmeUtil::GetHcclDataType(op_desc_, kernel_hccl_infos_);
if (dmrt != SUCCESS) { if (dmrt != SUCCESS) {
GELOGE(dmrt, "davinci_model: GetHcomDataType fail! domi error: %u", dmrt); GELOGE(dmrt, "davinci_model: GetHcomDataType fail! domi error: %u", dmrt);
return dmrt; return dmrt;
} }
dmrt = HcomOmeUtil::GetHcclCount(op_desc, kernel_hccl_infos_); dmrt = HcomOmeUtil::GetHcclCount(op_desc_, kernel_hccl_infos_);
if (dmrt != SUCCESS) { if (dmrt != SUCCESS) {
GELOGE(dmrt, "davinci_model: GetHcomCount fail! domi error: %u", dmrt); GELOGE(dmrt, "davinci_model: GetHcomCount fail! domi error: %u", dmrt);
return dmrt; return dmrt;
} }
// Only HCOMBROADCAST and HVDCALLBACKBROADCAST need to get the rootId // Only HCOMBROADCAST and HVDCALLBACKBROADCAST need to get the rootId
dmrt = HcomOmeUtil::GetAllRootId(op_desc, kernel_hccl_infos_); dmrt = HcomOmeUtil::GetAllRootId(op_desc_, kernel_hccl_infos_);
if (dmrt != SUCCESS) { if (dmrt != SUCCESS) {
GELOGE(dmrt, "davinci_model: Get rootId fail! domi error: %u", dmrt); GELOGE(dmrt, "davinci_model: Get rootId fail! domi error: %u", dmrt);
return dmrt; return dmrt;
} }
// GE's new process: hccl declares the number of streams required, creates a stream by GE, and sends it to hccl // GE's new process: hccl declares the number of streams required, creates a stream by GE, and sends it to hccl
ret = SetFollowStream(op_desc, davinci_model); ret = SetFollowStream(op_desc_, davinci_model);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "SetStream Fail."); GELOGE(ret, "SetStream Fail.");
return ret; return ret;
@ -100,28 +100,21 @@ Status HcclTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *davinci_m
if (davinci_model_->IsKnownNode()) { if (davinci_model_->IsKnownNode()) {
args_ = davinci_model_->GetCurrentArgsAddr(args_offset_); args_ = davinci_model_->GetCurrentArgsAddr(args_offset_);
GELOGI("Known node %s args addr %p, offset %u.", op_desc->GetName().c_str(), args_, args_offset_); GELOGI("Known node %s args addr %p, offset %u.", op_desc_->GetName().c_str(), args_, args_offset_);
} }
ret = SetAddrs(op_desc, kernel_hccl_infos_); ret = SetAddrs(op_desc_, kernel_hccl_infos_);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "Setaddrs Fail."); GELOGE(ret, "Setaddrs Fail.");
return ret; return ret;
} }
// GE's new process: hccl declares the need for Workspace size, and GE allocates Workspace // GE's new process: hccl declares the need for Workspace size, and GE allocates Workspace
ret = SetWorkspace(op_desc, kernel_hccl_infos_); ret = SetWorkspace(op_desc_, kernel_hccl_infos_);
if (ret != SUCCESS) { if (ret != SUCCESS) {
GELOGE(ret, "SetWorkspace Fail."); GELOGE(ret, "SetWorkspace Fail.");
return ret; return ret;
} }
const RuntimeParam &rts_param = davinci_model_->GetRuntimeParam();
const auto input_data_addrs = ModelUtils::GetInputDataAddrs(rts_param, op_desc);
const auto output_data_addrs = ModelUtils::GetOutputDataAddrs(rts_param, op_desc);
const auto workspace_data_addrs = ModelUtils::GetWorkspaceDataAddrs(rts_param, op_desc);
io_addrs_.insert(io_addrs_.end(), input_data_addrs.begin(), input_data_addrs.end());
io_addrs_.insert(io_addrs_.end(), output_data_addrs.begin(), output_data_addrs.end());
io_addrs_.insert(io_addrs_.end(), workspace_data_addrs.begin(), workspace_data_addrs.end());
GELOGI("HcclTaskInfo Init Success"); GELOGI("HcclTaskInfo Init Success");
return SUCCESS; return SUCCESS;
} }
@ -238,7 +231,18 @@ Status HcclTaskInfo::CalculateArgs(const domi::TaskDef &task_def, DavinciModel *
Status HcclTaskInfo::UpdateArgs() { Status HcclTaskInfo::UpdateArgs() {
GELOGI("HcclTaskInfo::UpdateArgs in."); GELOGI("HcclTaskInfo::UpdateArgs in.");
davinci_model_->SetTotalIOAddrs(io_addrs_); const RuntimeParam &rts_param = davinci_model_->GetRuntimeParam();
input_data_addrs_ = ModelUtils::GetInputDataAddrs(rts_param, op_desc_);
output_data_addrs_ = ModelUtils::GetOutputDataAddrs(rts_param, op_desc_);
workspace_data_addrs_ = ModelUtils::GetWorkspaceDataAddrs(rts_param, op_desc_);
vector<void *> io_addrs;
io_addrs.insert(io_addrs.end(), input_data_addrs_.begin(), input_data_addrs_.end());
io_addrs.insert(io_addrs.end(), output_data_addrs_.begin(), output_data_addrs_.end());
io_addrs.insert(io_addrs.end(), workspace_data_addrs_.begin(), workspace_data_addrs_.end());
davinci_model_->SetTotalIOAddrs(io_addrs);
GELOGI("HcclTaskInfo::UpdateArgs success."); GELOGI("HcclTaskInfo::UpdateArgs success.");
return SUCCESS; return SUCCESS;
} }
@ -257,11 +261,9 @@ Status HcclTaskInfo::SetAddrs(const std::shared_ptr<OpDesc> &op_desc,
HcclReduceOp op_type = HCCL_REDUCE_SUM; HcclReduceOp op_type = HCCL_REDUCE_SUM;
GE_CHECK_NOTNULL(davinci_model_); GE_CHECK_NOTNULL(davinci_model_);
GELOGI("Calc opType[%s] input address before. Node name[%s]", op_desc->GetType().c_str(), op_desc->GetName().c_str()); GELOGI("Calc opType[%s] input address before. Node name[%s]", op_desc->GetType().c_str(), op_desc->GetName().c_str());
vector<void *> input_data_addrs;
vector<void *> output_data_addrs;
if (!davinci_model_->IsKnownNode()) { if (!davinci_model_->IsKnownNode()) {
input_data_addrs = ModelUtils::GetInputDataAddrs(davinci_model_->GetRuntimeParam(), op_desc); input_data_addrs_ = ModelUtils::GetInputDataAddrs(davinci_model_->GetRuntimeParam(), op_desc);
output_data_addrs = ModelUtils::GetOutputDataAddrs(davinci_model_->GetRuntimeParam(), op_desc); output_data_addrs_ = ModelUtils::GetOutputDataAddrs(davinci_model_->GetRuntimeParam(), op_desc);
} }
void *input_data_addr = nullptr; void *input_data_addr = nullptr;
void *output_data_addr = nullptr; void *output_data_addr = nullptr;
@ -273,8 +275,8 @@ Status HcclTaskInfo::SetAddrs(const std::shared_ptr<OpDesc> &op_desc,
output_data_addr = reinterpret_cast<void *>(reinterpret_cast<uint64_t *>(args_) + op_desc->GetInputsSize() + i); output_data_addr = reinterpret_cast<void *>(reinterpret_cast<uint64_t *>(args_) + op_desc->GetInputsSize() + i);
GELOGI("Hccl task info known input addr %p, output addr %p.", input_data_addr, output_data_addr); GELOGI("Hccl task info known input addr %p, output addr %p.", input_data_addr, output_data_addr);
} else { } else {
input_data_addr = input_data_addrs.empty() ? nullptr : input_data_addrs[i]; input_data_addr = input_data_addrs_.empty() ? nullptr : input_data_addrs_[i];
output_data_addr = output_data_addrs.empty() ? nullptr : output_data_addrs[i]; output_data_addr = output_data_addrs_.empty() ? nullptr : output_data_addrs_[i];
} }
kernel_hccl_infos[i].inputDataAddr = input_data_addr; kernel_hccl_infos[i].inputDataAddr = input_data_addr;
if (hccl_type == HCOMALLGATHER || hccl_type == HCOMRECEIVE || hccl_type == HVDCALLBACKALLGATHER) { if (hccl_type == HCOMALLGATHER || hccl_type == HCOMRECEIVE || hccl_type == HVDCALLBACKALLGATHER) {
@ -364,8 +366,8 @@ Status HcclTaskInfo::SetWorkspace(const std::shared_ptr<OpDesc> &op_desc,
workspace_addr = reinterpret_cast<void *>(reinterpret_cast<uint64_t *>(args_) + op_desc->GetInputsSize() + workspace_addr = reinterpret_cast<void *>(reinterpret_cast<uint64_t *>(args_) + op_desc->GetInputsSize() +
op_desc->GetOutputsSize()); op_desc->GetOutputsSize());
} else { } else {
const auto workspace_data_addrs = ModelUtils::GetWorkspaceDataAddrs(davinci_model_->GetRuntimeParam(), op_desc); workspace_data_addrs_ = ModelUtils::GetWorkspaceDataAddrs(davinci_model_->GetRuntimeParam(), op_desc);
workspace_addr = workspace_data_addrs.empty() ? nullptr : workspace_data_addrs[0]; workspace_addr = workspace_data_addrs_.empty() ? nullptr : workspace_data_addrs_[0];
} }
} }
} }

6
ge/graph/load/new_model_manager/task_info/hccl_task_info.h
Unescape View File

@ -35,6 +35,7 @@ class HcclTaskInfo : public TaskInfo {
ops_kernel_store_(nullptr), ops_kernel_store_(nullptr),
private_def_(nullptr), private_def_(nullptr),
private_def_len_(0), private_def_len_(0),
op_desc_(nullptr),
args_(nullptr), args_(nullptr),
args_offset_(0) {} args_offset_(0) {}
@ -75,7 +76,10 @@ class HcclTaskInfo : public TaskInfo {
uint32_t private_def_len_; uint32_t private_def_len_;
static std::mutex hccl_follow_stream_mutex_; static std::mutex hccl_follow_stream_mutex_;
vector<GETaskKernelHcclInfo> kernel_hccl_infos_; vector<GETaskKernelHcclInfo> kernel_hccl_infos_;
vector<void *> io_addrs_; vector<void *> input_data_addrs_;
vector<void *> output_data_addrs_;
vector<void *> workspace_data_addrs_;
OpDescPtr op_desc_;
void *args_; void *args_;
uint32_t args_offset_; uint32_t args_offset_;
}; };

45
ge/graph/load/new_model_manager/task_info/kernel_ex_task_info.cc
Unescape View File

@ -30,7 +30,11 @@
namespace ge { namespace ge {
Status KernelExTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *davinci_model) { Status KernelExTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *davinci_model) {
GELOGI("KernelExTaskInfo Init Start."); GELOGI("KernelExTaskInfo Init Start.");
GE_CHECK_NOTNULL(davinci_model); if (davinci_model == nullptr) {
GELOGE(PARAM_INVALID, "davinci_model is null!");
return PARAM_INVALID;
}
davinci_model_ = davinci_model; davinci_model_ = davinci_model;
Status ret = SetStream(task_def.stream_id(), davinci_model_->GetStreamList()); Status ret = SetStream(task_def.stream_id(), davinci_model_->GetStreamList());
if (ret != SUCCESS) { if (ret != SUCCESS) {
@ -47,6 +51,7 @@ Status KernelExTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *davin
GELOGE(INTERNAL_ERROR, "Init aicpu task info error, index is out of range!"); GELOGE(INTERNAL_ERROR, "Init aicpu task info error, index is out of range!");
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
op_desc_ = op_desc;
// 2. Reconstruct kernelExDef.args to STR_FWK_OP_KERNEL // 2. Reconstruct kernelExDef.args to STR_FWK_OP_KERNEL
STR_FWK_OP_KERNEL fwk_op_kernel = {0}; STR_FWK_OP_KERNEL fwk_op_kernel = {0};
@ -74,8 +79,8 @@ Status KernelExTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *davin
return RT_ERROR_TO_GE_STATUS(rt_ret);) return RT_ERROR_TO_GE_STATUS(rt_ret);)
} }
GELOGI("Node[%s] type[%s] kernel_ext_info size=%zu, ext_info_addr_=%p", op_desc->GetName().c_str(), GELOGI("Node[%s] type[%s] kernel_ext_info size=%zu, ext_info_addr_=%p", op_desc_->GetName().c_str(),
op_desc->GetType().c_str(), ext_info.size(), ext_info_addr_); op_desc_->GetType().c_str(), ext_info.size(), ext_info_addr_);
// 2.1 get loop cond variable for tensor array write // 2.1 get loop cond variable for tensor array write
uint64_t step_id_addr = 0; uint64_t step_id_addr = 0;
@ -128,7 +133,7 @@ Status KernelExTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *davin
return RT_ERROR_TO_GE_STATUS(rt_ret);) return RT_ERROR_TO_GE_STATUS(rt_ret);)
GELOGI("KernelExTaskInfo knonw node Init Success."); GELOGI("KernelExTaskInfo knonw node Init Success.");
return SetIoAddrs(op_desc); return SUCCESS;
} }
// 3. Set workspaceaddr, inputOutputDataAddr // 3. Set workspaceaddr, inputOutputDataAddr
@ -192,7 +197,7 @@ Status KernelExTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *davin
davinci_model_->SetZeroCopyAddr(op_desc, io_addrs, io_addrs.data(), input_output_addr_, addrs_size, 0); davinci_model_->SetZeroCopyAddr(op_desc, io_addrs, io_addrs.data(), input_output_addr_, addrs_size, 0);
GELOGI("KernelExTaskInfo Init Success. session id: %lu", session_id); GELOGI("KernelExTaskInfo Init Success. session id: %lu", session_id);
return SetIoAddrs(op_desc); return SUCCESS;
} }
Status KernelExTaskInfo::CalculateArgs(const domi::TaskDef &task_def, DavinciModel *davinci_model) { Status KernelExTaskInfo::CalculateArgs(const domi::TaskDef &task_def, DavinciModel *davinci_model) {
@ -231,40 +236,36 @@ Status KernelExTaskInfo::CalculateArgs(const domi::TaskDef &task_def, DavinciMod
return SUCCESS; return SUCCESS;
} }
Status KernelExTaskInfo::SetIoAddrs(const OpDescPtr &op_desc) { Status KernelExTaskInfo::UpdateArgs() {
GELOGI("KernelExTaskInfo::UpdateArgs in.");
const RuntimeParam &rts_param = davinci_model_->GetRuntimeParam(); const RuntimeParam &rts_param = davinci_model_->GetRuntimeParam();
vector<void *> input_data_addrs = ModelUtils::GetInputDataAddrs(rts_param, op_desc); vector<void *> input_data_addrs = ModelUtils::GetInputDataAddrs(rts_param, op_desc_);
vector<void *> output_data_addrs = ModelUtils::GetOutputDataAddrs(rts_param, op_desc); vector<void *> output_data_addrs = ModelUtils::GetOutputDataAddrs(rts_param, op_desc_);
if (!op_desc->HasAttr(ATTR_DYNAMIC_SHAPE_FIXED_ADDR)) { vector<void *> io_addrs;
io_addrs_.insert(io_addrs_.end(), input_data_addrs.begin(), input_data_addrs.end()); if (!op_desc_->HasAttr(ATTR_DYNAMIC_SHAPE_FIXED_ADDR)) {
io_addrs_.insert(io_addrs_.end(), output_data_addrs.begin(), output_data_addrs.end()); io_addrs.insert(io_addrs.end(), input_data_addrs.begin(), input_data_addrs.end());
io_addrs.insert(io_addrs.end(), output_data_addrs.begin(), output_data_addrs.end());
} else { } else {
string peer_input_name; string peer_input_name;
if (AttrUtils::GetStr(op_desc, ATTR_DYNAMIC_SHAPE_FIXED_ADDR, peer_input_name)) { if (AttrUtils::GetStr(op_desc_, ATTR_DYNAMIC_SHAPE_FIXED_ADDR, peer_input_name)) {
uint32_t output_index = davinci_model_->GetFixedAddrOutputIndex(peer_input_name); uint32_t output_index = davinci_model_->GetFixedAddrOutputIndex(peer_input_name);
if (output_index > output_data_addrs.size()) { if (output_index > output_data_addrs.size()) {
GELOGE(FAILED, "The output data addr size[%zu] and output index[%u] are inconsistent.", GELOGE(FAILED, "The output data addr size[%zu] and output index[%u] are inconsistent.",
output_data_addrs.size(), output_index); output_data_addrs.size(), output_index);
return FAILED; return FAILED;
} }
io_addrs_.insert(io_addrs_.end(), input_data_addrs.begin(), input_data_addrs.end()); io_addrs.insert(io_addrs.end(), input_data_addrs.begin(), input_data_addrs.end());
for (size_t i = 0; i < output_data_addrs.size(); ++i) { for (size_t i = 0; i < output_data_addrs.size(); ++i) {
if (i == output_index) { if (i == output_index) {
void *fixed_addr = davinci_model_->GetCurrentFixedAddr(fixed_addr_offset_); void *fixed_addr = davinci_model_->GetCurrentFixedAddr(fixed_addr_offset_);
io_addrs_.emplace_back(fixed_addr); io_addrs.emplace_back(fixed_addr);
continue; continue;
} }
io_addrs_.emplace_back(output_data_addrs[i]); io_addrs.emplace_back(output_data_addrs[i]);
} }
} }
} }
davinci_model_->SetTotalIOAddrs(io_addrs);
return SUCCESS;
}
Status KernelExTaskInfo::UpdateArgs() {
GELOGI("KernelExTaskInfo::UpdateArgs in.");
davinci_model_->SetTotalIOAddrs(io_addrs_);
GELOGI("KernelExTaskInfo::UpdateArgs success."); GELOGI("KernelExTaskInfo::UpdateArgs success.");
return SUCCESS; return SUCCESS;
} }

3
ge/graph/load/new_model_manager/task_info/kernel_ex_task_info.h
Unescape View File

@ -59,7 +59,6 @@ class KernelExTaskInfo : public TaskInfo {
}; };
private: private:
Status CopyTaskInfo(const domi::KernelExDef &kernel_def, const RuntimeParam &rts_param, const OpDescPtr &op_desc); Status CopyTaskInfo(const domi::KernelExDef &kernel_def, const RuntimeParam &rts_param, const OpDescPtr &op_desc);
Status SetIoAddrs(const OpDescPtr &op_desc);
uint32_t task_id_; uint32_t task_id_;
uint32_t stream_id_; uint32_t stream_id_;
@ -70,7 +69,7 @@ class KernelExTaskInfo : public TaskInfo {
void *input_output_addr_; void *input_output_addr_;
void *ext_info_addr_; void *ext_info_addr_;
void *dump_args_; void *dump_args_;
vector<void *> io_addrs_; OpDescPtr op_desc_ = nullptr;
uint32_t args_offset_ = 0; uint32_t args_offset_ = 0;
int64_t fixed_addr_offset_ = 0; int64_t fixed_addr_offset_ = 0;
}; };

137
ge/graph/load/new_model_manager/task_info/kernel_task_info.cc
View File

File diff suppressed because it is too large Load Diff

26
ge/graph/load/new_model_manager/task_info/kernel_task_info.h
Unescape View File

@ -38,6 +38,7 @@ class KernelTaskInfo : public TaskInfo {
flowtable_(nullptr), flowtable_(nullptr),
block_dim_(0), block_dim_(0),
args_size_(0), args_size_(0),
flowtable_size_(0),
task_id_(0), task_id_(0),
stream_id_(0), stream_id_(0),
so_name_(""), so_name_(""),
@ -45,6 +46,7 @@ class KernelTaskInfo : public TaskInfo {
kernel_type_(ccKernelType::CCE_AI_CORE), kernel_type_(ccKernelType::CCE_AI_CORE),
dump_flag_(RT_KERNEL_DEFAULT), dump_flag_(RT_KERNEL_DEFAULT),
dump_args_(nullptr), dump_args_(nullptr),
op_desc_(nullptr),
davinci_model_(nullptr), davinci_model_(nullptr),
skt_id_(0), skt_id_(0),
stub_func_name_(""), stub_func_name_(""),
@ -126,7 +128,6 @@ class KernelTaskInfo : public TaskInfo {
Status SuperKernelDistribute(); Status SuperKernelDistribute();
bool IsL1FusionOp(const OpDescPtr &op_desc); bool IsL1FusionOp(const OpDescPtr &op_desc);
void SetIoAddrs(const OpDescPtr &op_desc);
// For super kernel // For super kernel
Status SaveSKTDumpInfo(); Status SaveSKTDumpInfo();
@ -147,6 +148,7 @@ class KernelTaskInfo : public TaskInfo {
void *flowtable_; void *flowtable_;
uint32_t block_dim_; uint32_t block_dim_;
uint32_t args_size_; uint32_t args_size_;
uint32_t flowtable_size_;
uint32_t task_id_; uint32_t task_id_;
uint32_t stream_id_; uint32_t stream_id_;
std::string so_name_; std::string so_name_;
@ -154,8 +156,7 @@ class KernelTaskInfo : public TaskInfo {
ccKernelType kernel_type_; ccKernelType kernel_type_;
uint32_t dump_flag_; uint32_t dump_flag_;
void *dump_args_; void *dump_args_;
OpDescPtr op_desc_; // Clear after distribute. OpDescPtr op_desc_;
vector<void *> io_addrs_;
DavinciModel *davinci_model_; DavinciModel *davinci_model_;
uint32_t args_offset_ = 0; uint32_t args_offset_ = 0;
uint32_t hybrid_args_offset_ = 0; uint32_t hybrid_args_offset_ = 0;
@ -185,6 +186,25 @@ class KernelTaskInfo : public TaskInfo {
void *output_addrs = nullptr; void *output_addrs = nullptr;
void *attr_handle = nullptr; void *attr_handle = nullptr;
} custom_info_; } custom_info_;
// For super kernel
static struct SuperKernelTaskInfo {
uint32_t last_block_dim;
uint32_t last_args_size;
uint32_t last_task_id;
uint32_t last_stream_id;
void *last_stream;
void *last_sm_desc;
std::vector<void *> kernel_list;
std::vector<void *> arg_list;
std::vector<uint32_t> dump_flag_list;
std::vector<OpDescPtr> op_desc_list;
std::vector<uintptr_t> dump_args_list;
uint32_t last_dump_flag;
int64_t last_group_key;
uintptr_t last_dump_args;
OpDescPtr last_op;
} skt_info_;
}; };
} // namespace ge } // namespace ge
#endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_TASK_INFO_KERNEL_TASK_INFO_H_ #endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_TASK_INFO_KERNEL_TASK_INFO_H_

52
ge/graph/load/new_model_manager/task_info/memcpy_async_task_info.cc
Unescape View File

@ -30,13 +30,14 @@ Status MemcpyAsyncTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *da
return ret; return ret;
} }
const domi::MemcpyAsyncDef &memcpy_async = task_def.memcpy_async(); memcpy_async_ = task_def.memcpy_async();
count_ = memcpy_async.count(); count_ = memcpy_async_.count();
kind_ = memcpy_async.kind(); kind_ = memcpy_async_.kind();
dst_max_ = memcpy_async.dst_max(); dst_max_ = memcpy_async_.dst_max();
OpDescPtr op_desc = davinci_model_->GetOpByIndex(memcpy_async.op_index()); OpDescPtr op_desc = davinci_model_->GetOpByIndex(memcpy_async_.op_index());
op_desc_ = op_desc;
if (op_desc == nullptr) { if (op_desc == nullptr) {
GELOGE(INTERNAL_ERROR, "Task op index:%u out of range", memcpy_async.op_index()); GELOGE(INTERNAL_ERROR, "Task op index:%u out of range", memcpy_async_.op_index());
return INTERNAL_ERROR; return INTERNAL_ERROR;
} }
@ -51,7 +52,7 @@ Status MemcpyAsyncTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *da
} }
const RuntimeParam &rts_param = davinci_model_->GetRuntimeParam(); const RuntimeParam &rts_param = davinci_model_->GetRuntimeParam();
ret = ModelUtils::GetRtAddress(rts_param, memcpy_async.src(), src_); ret = ModelUtils::GetRtAddress(rts_param, memcpy_async_.src(), src_);
if (ret != SUCCESS) { if (ret != SUCCESS) {
return ret; return ret;
} }
@ -60,32 +61,23 @@ Status MemcpyAsyncTaskInfo::Init(const domi::TaskDef &task_def, DavinciModel *da
vector<int64_t> memory_type_list; vector<int64_t> memory_type_list;
(void)AttrUtils::GetListInt(op_desc, ATTR_NAME_OUTPUT_MEM_TYPE_LIST, memory_type_list); (void)AttrUtils::GetListInt(op_desc, ATTR_NAME_OUTPUT_MEM_TYPE_LIST, memory_type_list);
if (!memory_type_list.empty() && memory_type_list[0] == RT_MEMORY_TS_4G) { // TS Feature, Just one. if (!memory_type_list.empty() && memory_type_list[0] == RT_MEMORY_TS_4G) { // TS Feature, Just one.
uint64_t mem_offset = memcpy_async.dst() - rts_param.logic_mem_base; uint64_t mem_offset = memcpy_async_.dst() - rts_param.logic_mem_base;
dst_ = static_cast<uint8_t *>(rts_param.ts_mem_mall->Acquire(mem_offset, memcpy_async.dst_max())); dst_ = static_cast<uint8_t *>(rts_param.ts_mem_mall->Acquire(mem_offset, memcpy_async_.dst_max()));
if (dst_ == nullptr) { if (dst_ == nullptr) {
return FAILED; return FAILED;
} }
} else { } else {
ret = ModelUtils::GetRtAddress(rts_param, memcpy_async.dst(), dst_); ret = ModelUtils::GetRtAddress(rts_param, memcpy_async_.dst(), dst_);
if (ret != SUCCESS) { if (ret != SUCCESS) {
return ret; return ret;
} }
} }
GELOGI("MemcpyAsyncTaskInfo Init Success, logic[0x%lx, 0x%lx], src:%p, dst:%p, max:%lu, count:%lu", GELOGI("MemcpyAsyncTaskInfo Init Success, logic[0x%lx, 0x%lx], src:%p, dst:%p, max:%lu, count:%lu",
memcpy_async.src(), memcpy_async.dst(), src_, dst_, dst_max_, count_); memcpy_async_.src(), memcpy_async_.dst(), src_, dst_, dst_max_, count_);
davinci_model_->DisableZeroCopy(src_); davinci_model_->DisableZeroCopy(src_);
davinci_model_->DisableZeroCopy(dst_); davinci_model_->DisableZeroCopy(dst_);
io_addrs_.emplace_back(reinterpret_cast<void *>(src_));
if (op_desc->HasAttr(ATTR_DYNAMIC_SHAPE_FIXED_ADDR)) {
void *fixed_addr = davinci_model_->GetCurrentFixedAddr(fixed_addr_offset_);
io_addrs_.emplace_back(fixed_addr);
} else {
io_addrs_.emplace_back(reinterpret_cast<void *>(dst_));
}
return SUCCESS; return SUCCESS;
} }
@ -126,7 +118,25 @@ Status MemcpyAsyncTaskInfo::CalculateArgs(const domi::TaskDef &task_def, Davinci
Status MemcpyAsyncTaskInfo::UpdateArgs() { Status MemcpyAsyncTaskInfo::UpdateArgs() {
GELOGI("MemcpyAsyncTaskInfo::UpdateArgs in."); GELOGI("MemcpyAsyncTaskInfo::UpdateArgs in.");
GE_CHECK_NOTNULL(davinci_model_); GE_CHECK_NOTNULL(davinci_model_);
davinci_model_->SetTotalIOAddrs(io_addrs_); Status ret = ModelUtils::GetRtAddress(davinci_model_->GetRuntimeParam(), memcpy_async_.src(), src_);
if (ret != SUCCESS) {
return ret;
}
ret = ModelUtils::GetRtAddress(davinci_model_->GetRuntimeParam(), memcpy_async_.dst(), dst_);
if (ret != SUCCESS) {
return ret;
}
vector<void *> io_addrs;
io_addrs.emplace_back(reinterpret_cast<void *>(src_));
if (op_desc_->HasAttr(ATTR_DYNAMIC_SHAPE_FIXED_ADDR)) {
void *fixed_addr = davinci_model_->GetCurrentFixedAddr(fixed_addr_offset_);
io_addrs.emplace_back(fixed_addr);
} else {
io_addrs.emplace_back(reinterpret_cast<void *>(dst_));
}
davinci_model_->SetTotalIOAddrs(io_addrs);
GELOGI("MemcpyAsyncTaskInfo::UpdateArgs success."); GELOGI("MemcpyAsyncTaskInfo::UpdateArgs success.");
return SUCCESS; return SUCCESS;

3
ge/graph/load/new_model_manager/task_info/memcpy_async_task_info.h
Unescape View File

@ -44,10 +44,11 @@ class MemcpyAsyncTaskInfo : public TaskInfo {
uint8_t *src_; uint8_t *src_;
uint64_t count_; uint64_t count_;
uint32_t kind_; uint32_t kind_;
vector<void *> io_addrs_; OpDescPtr op_desc_;
int64_t fixed_addr_offset_; int64_t fixed_addr_offset_;
DavinciModel *davinci_model_ = nullptr; DavinciModel *davinci_model_ = nullptr;
uint32_t args_offset_ = 0; uint32_t args_offset_ = 0;
domi::MemcpyAsyncDef memcpy_async_;
}; };
} // namespace ge } // namespace ge
#endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_TASK_INFO_MEMCPY_ASYNC_TASK_INFO_H_ #endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_TASK_INFO_MEMCPY_ASYNC_TASK_INFO_H_

Write Preview
Loading…
Cancel
Save