Feature: Support single op profiling

ge/single_op/single_op.cc

@@ -182,8 +182,9 @@ Status SingleOp::ProfilingTaskInfo(uint32_t index) {
   if (!ProfilingManager::Instance().ProfilingModelExecuteOn()) {
     return SUCCESS;
   }
-  if (op_name_.size() <= index) {
-    GELOGE(ACL_ERROR_GE_PARAM_INVALID, "index[%d] is out of range of op_name_ size[%d].", index, op_name_.size());
+  if (op_name_.size() <= index || block_dim_.size() <= index) {
+    GELOGE(ACL_ERROR_GE_PARAM_INVALID, "index[%d] is out of range of op_name_ size[%d] or block_dim_ size[%d].", index,
+           op_name_.size(), block_dim_.size());
     return ACL_ERROR_GE_PARAM_INVALID;
   }
   GELOGD("ProfilingReport of op[%s] model[%s] start.", op_name_[index].c_str(), model_name_.c_str());
@@ -198,7 +199,7 @@ Status SingleOp::ProfilingTaskInfo(uint32_t index) {
   TaskDescInfo tmp_task_desc_info;
   tmp_task_desc_info.model_name = model_name_;
   tmp_task_desc_info.op_name = op_name_[index];
-  tmp_task_desc_info.block_dim = 0;
+  tmp_task_desc_info.block_dim = block_dim_[index];
   tmp_task_desc_info.task_id = task_id;
   tmp_task_desc_info.stream_id = stream_id;
   GELOGD("GetTaskDescInfo of op [%s] end, task_id[%u], stream_id[%u]", op_name_[index].c_str(), task_id, stream_id);
@@ -317,7 +318,7 @@ Status DynamicSingleOp::ProfilingTaskInfo() {
   TaskDescInfo tmp_task_desc_info;
   tmp_task_desc_info.model_name = model_name_;
   tmp_task_desc_info.op_name = op_name_;
-  tmp_task_desc_info.block_dim = 0;
+  tmp_task_desc_info.block_dim = block_dim_;
   tmp_task_desc_info.task_id = task_id;
   tmp_task_desc_info.stream_id = stream_id;
   GELOGD("GetTaskDescInfo of op [%s] end, task_id[%u], stream_id[%u]", op_name_.c_str(), task_id, stream_id);

ge/single_op/single_op.h

@@ -55,6 +55,7 @@ class SingleOp {
 
   std::vector<OpTask *> tasks_;
   std::vector<std::string> op_name_;
+  std::vector<uint32_t> block_dim_;
   std::vector<std::vector<uintptr_t *>> arg_table_;
   std::string model_name_;
   uint32_t model_id_ = 0;
@@ -94,6 +95,7 @@ class DynamicSingleOp {
   std::string model_name_;
   std::string op_name_;
   uint32_t model_id_ = 0;
+  uint32_t block_dim_ = 1;
 };
 }  // namespace ge
 #endif  // GE_SINGLE_OP_SINGLE_OP_H_

ge/single_op/single_op_model.cc

@@ -41,6 +41,7 @@ using std::vector;
 namespace ge {
 namespace {
 const size_t kDataOutputNum = 1;
+const uint32_t kDefaultBlockDim = 1;
 }  // namespace
 SingleOpModel::SingleOpModel(const std::string &model_name, const void *model_data, uint32_t model_size)
     : model_name_(model_name), ori_model_data_(model_data), ori_model_size_(model_size) {}
@@ -253,6 +254,7 @@ Status SingleOpModel::BuildTaskList(SingleOp &single_op) {
         ParseArgTable(tbe_task, single_op);
         single_op.tasks_.emplace_back(tbe_task);
         single_op.op_name_.emplace_back(tbe_op_name);
+        single_op.block_dim_.emplace_back(kernel_def.block_dim());
       } else if (kernel_type == cce::ccKernelType::AI_CPU || kernel_type == cce::ccKernelType::CUST_AI_CPU) {
         GELOGD("Building AICPU_CC task");
         OpTask *task = nullptr;
@@ -265,6 +267,7 @@ Status SingleOpModel::BuildTaskList(SingleOp &single_op) {
         string aicpu_op_name = op_list_[context.op_index()]->GetName();
         single_op.tasks_.emplace_back(task);
         single_op.op_name_.emplace_back(aicpu_op_name);
+        single_op.block_dim_.emplace_back(kernel_def.block_dim());
       } else {
         GELOGE(ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID, "Only TBE, AI_CPU, CUST_AI_CPU kernel are supported, but got %u", context.kernel_type());
         return ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID;
@@ -282,6 +285,7 @@ Status SingleOpModel::BuildTaskList(SingleOp &single_op) {
       string op_name = op_list_[task_def.kernel_ex().op_index()]->GetName();
       single_op.tasks_.emplace_back(aicpu_task);
       single_op.op_name_.emplace_back(op_name);
+      single_op.block_dim_.emplace_back(kDefaultBlockDim);
     } else {
       // skip
       GELOGD("Skip task type: %d", static_cast<int>(task_type));
@@ -403,6 +407,7 @@ Status SingleOpModel::BuildModelTaskKernel(const TaskDef &task_def, DynamicSingl
     GE_CHK_STATUS_RET_NOLOG(BuildKernelTask(task_def.kernel(), &tbe_task));
     string te_op_name = op_list_[context.op_index()]->GetName();
     single_op.op_name_ = te_op_name;
+    single_op.block_dim_ = kernel_def.block_dim();
     single_op.op_task_.reset(tbe_task);
   } else if (kernel_type == cce::ccKernelType::AI_CPU || kernel_type == cce::ccKernelType::CUST_AI_CPU) {
     GELOGD("Building AICPU_CC task");
@@ -412,6 +417,7 @@ Status SingleOpModel::BuildModelTaskKernel(const TaskDef &task_def, DynamicSingl
     GE_CHK_STATUS_RET_NOLOG(BuildCpuKernelTask(task_def.kernel(), &task, dynamic_singleop_kernel_id));
     string aicpu_op_name = op_list_[context.op_index()]->GetName();
     single_op.op_name_ = aicpu_op_name;
+    single_op.block_dim_ = kernel_def.block_dim();
     single_op.op_task_.reset(task);
   } else {
     GELOGE(ACL_ERROR_GE_OP_KERNEL_TYPE_INVALID,
@@ -460,6 +466,7 @@ Status SingleOpModel::BuildTaskListForDynamicOp(DynamicSingleOp &single_op) {
       }
       string op_name = op_list_[task_def.kernel_ex().op_index()]->GetName();
       single_op.op_name_ = op_name;
+      single_op.block_dim_ = kDefaultBlockDim;
       single_op.op_task_.reset(aicpu_task);
     } else {
       // skip