Add single_op model_id.

ge/executor/ge_executor.cc

@@ -929,13 +929,13 @@ Status GeExecutor::GetMemAndWeightSize(const void *model_data, size_t model_size
 }
 
 Status GeExecutor::LoadSingleOp(const std::string &model_name, const ge::ModelData &modelData, void *stream,
-                                SingleOp **single_op) {
-  return SingleOpManager::GetInstance().GetOpFromModel(model_name, modelData, stream, single_op);
+                                SingleOp **single_op, const uint64_t model_id = 0) {
+  return SingleOpManager::GetInstance().GetOpFromModel(model_name, modelData, stream, single_op, model_id);
 }
 
 Status GeExecutor::LoadDynamicSingleOp(const std::string &model_name, const ge::ModelData &modelData, void *stream,
-                                       DynamicSingleOp **single_op) {
-  return SingleOpManager::GetInstance().GetDynamicOpFromModel(model_name, modelData, stream, single_op);
+                                       DynamicSingleOp **single_op, const uint64_t model_id = 0) {
+  return SingleOpManager::GetInstance().GetDynamicOpFromModel(model_name, modelData, stream, single_op, model_id);
 }
 
 Status GeExecutor::ExecuteAsync(SingleOp *executor, const std::vector<DataBuffer> &inputs,

ge/single_op/single_op_manager.cc

@@ -30,8 +30,9 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY SingleOpManager::~SingleOpManag
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status SingleOpManager::GetOpFromModel(const std::string &model_name,
                                                                                         const ModelData &model_data,
                                                                                         void *stream,
-                                                                                        SingleOp **single_op) {
-  GELOGI("GetOpFromModel in. model name = %s", model_name.c_str());
+                                                                                        SingleOp **single_op,
+                                                                                        const uint64_t model_id) {
+  GELOGI("GetOpFromModel in. model name = %s, model id = %lu", model_name.c_str(), model_id);
   if (single_op == nullptr) {
     GELOGE(ACL_ERROR_GE_INTERNAL_ERROR, "single op is null");
     return ACL_ERROR_GE_INTERNAL_ERROR;
@@ -99,7 +100,9 @@ StreamResource *SingleOpManager::TryGetResource(uintptr_t resource_id) {
 Status SingleOpManager::GetDynamicOpFromModel(const string &model_name,
                                               const ModelData &model_data,
                                               void *stream,
-                                              DynamicSingleOp **single_op) {
+                                              DynamicSingleOp **single_op,
+                                              const uint64_t model_id) {
+  GELOGI("GetOpFromModel in. model name = %s, model id = %lu", model_name.c_str(), model_id);
   if (!tiling_func_registered_) {
     RegisterTilingFunc();
   }

ge/single_op/single_op_manager.h

@@ -37,12 +37,14 @@ class SingleOpManager {
   Status GetOpFromModel(const std::string &model_name,
                         const ge::ModelData &model_data,
                         void *stream,
-                        SingleOp **single_op);
+                        SingleOp **single_op,
+                        const uint64_t model_id);
 
   Status GetDynamicOpFromModel(const std::string &model_name,
                                const ge::ModelData &model_data,
                                void *stream,
-                               DynamicSingleOp **dynamic_single_op);
+                               DynamicSingleOp **dynamic_single_op,
+                               const uint64_t model_id);
 
   StreamResource *GetResource(uintptr_t resource_id, rtStream_t stream);
 

inc/framework/executor/ge_executor.h

@@ -258,13 +258,13 @@ class GE_FUNC_VISIBILITY GeExecutor {
   ge::Status GetMemAndWeightSize(const void *model_data, size_t model_size, size_t &mem_size, size_t &weight_size);
 
   static ge::Status LoadSingleOp(const std::string &modelName, const ge::ModelData &modelData, void *stream,
-                                 SingleOp **single_op);
+                                 SingleOp **single_op, const uint64_t model_id = 0);
 
   static ge::Status ExecuteAsync(SingleOp *executor, const std::vector<DataBuffer> &inputs,
                                  std::vector<DataBuffer> &outputs);
 
   static ge::Status LoadDynamicSingleOp(const std::string &model_name, const ge::ModelData &modelData, void *stream,
-                                        DynamicSingleOp **single_op);
+                                        DynamicSingleOp **single_op, const uint64_t model_id = 0);
 
   static ge::Status ExecuteAsync(DynamicSingleOp *executor, const std::vector<GeTensorDesc> &input_desc,
                                  const std::vector<DataBuffer> &inputs, std::vector<GeTensorDesc> &output_desc,