!1324 Fix bug of single_op ageing.

From: @zhao_zhixuan
Reviewed-by: @xchu42,@startzgf168
Signed-off-by: @startzgf168

ge/executor/ge_executor.cc

@@ -1051,12 +1051,22 @@ 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);
+  return LoadSingleOpV2(model_name, modelData, stream, single_op, 0);
+}
+
+Status GeExecutor::LoadSingleOpV2(const std::string &model_name, const ge::ModelData &modelData, void *stream,
+                                  SingleOp **single_op, const uint64_t model_id) {
+  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);
+  return LoadDynamicSingleOpV2(model_name, modelData, stream, single_op, 0);
+}
+
+Status GeExecutor::LoadDynamicSingleOpV2(const std::string &model_name, const ge::ModelData &modelData, void *stream,
+                                         DynamicSingleOp **single_op, const uint64_t model_id) {
+  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;
@@ -45,14 +46,14 @@ FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status SingleOpManager::GetOpFr
     return ACL_ERROR_GE_MEMORY_ALLOCATION;
   }
 
-  SingleOp *op = res->GetOperator(model_data.model_data);
+  SingleOp *op = res->GetOperator(model_id);
   if (op != nullptr) {
     GELOGD("Got operator from stream cache");
     *single_op = op;
     return SUCCESS;
   }
 
-  return res->BuildOperator(model_name, model_data, single_op);
+  return res->BuildOperator(model_data, single_op, model_id);
 }
 
 FMK_FUNC_HOST_VISIBILITY FMK_FUNC_DEV_VISIBILITY Status SingleOpManager::ReleaseResource(void *stream) {
@@ -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();
   }
@@ -113,14 +116,14 @@ Status SingleOpManager::GetDynamicOpFromModel(const string &model_name,
     return ACL_ERROR_GE_MEMORY_ALLOCATION;
   }
 
-  DynamicSingleOp *op = res->GetDynamicOperator(model_data.model_data);
+  DynamicSingleOp *op = res->GetDynamicOperator(model_id);
   if (op != nullptr) {
     GELOGD("Got operator from stream cache");
     *single_op = op;
     return SUCCESS;
   }
 
-  return res->BuildDynamicOperator(model_name, model_data, single_op);
+  return res->BuildDynamicOperator(model_data, single_op, model_id);
 }
 
 void SingleOpManager::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);
 

ge/single_op/stream_resource.cc

@@ -41,7 +41,7 @@ StreamResource::~StreamResource() {
   }
 }
 
-SingleOp *StreamResource::GetOperator(const void *key) {
+SingleOp *StreamResource::GetOperator(const uint64_t key) {
   std::lock_guard<std::mutex> lk(mu_);
   auto it = op_map_.find(key);
   if (it == op_map_.end()) {
@@ -51,7 +51,7 @@ SingleOp *StreamResource::GetOperator(const void *key) {
   return it->second.get();
 }
 
-DynamicSingleOp *StreamResource::GetDynamicOperator(const void *key) {
+DynamicSingleOp *StreamResource::GetDynamicOperator(const uint64_t key) {
   std::lock_guard<std::mutex> lk(mu_);
   auto it = dynamic_op_map_.find(key);
   if (it == dynamic_op_map_.end()) {
@@ -134,11 +134,12 @@ uint8_t *StreamResource::MallocWeight(const std::string &purpose, size_t size) {
   return buffer;
 }
 
-Status StreamResource::BuildDynamicOperator(const string &model_name,
-                                            const ModelData &model_data,
-                                            DynamicSingleOp **single_op) {
+Status StreamResource::BuildDynamicOperator(const ModelData &model_data,
+                                            DynamicSingleOp **single_op,
+                                            const uint64_t model_id) {
+  const string &model_name = std::to_string(model_id);
   std::lock_guard<std::mutex> lk(mu_);
-  auto it = dynamic_op_map_.find(model_data.model_data);
+  auto it = dynamic_op_map_.find(model_id);
   if (it != dynamic_op_map_.end()) {
     *single_op = it->second.get();
     return SUCCESS;
@@ -158,13 +159,14 @@ Status StreamResource::BuildDynamicOperator(const string &model_name,
   GE_CHK_STATUS_RET(model.BuildDynamicOp(*this, *new_op),
                     "Build op failed. op = %s, ret = %u", model_name.c_str(), ret);
   *single_op = new_op.get();
-  dynamic_op_map_[model_data.model_data] = std::move(new_op);
+  dynamic_op_map_[model_id] = std::move(new_op);
   return SUCCESS;
 }
 
-Status StreamResource::BuildOperator(const string &model_name, const ModelData &model_data, SingleOp **single_op) {
+Status StreamResource::BuildOperator(const ModelData &model_data, SingleOp **single_op, const uint64_t model_id) {
+  const string &model_name = std::to_string(model_id);
   std::lock_guard<std::mutex> lk(mu_);
-  auto it = op_map_.find(model_data.model_data);
+  auto it = op_map_.find(model_id);
   if (it != op_map_.end()) {
     *single_op = it->second.get();
     return SUCCESS;
@@ -187,7 +189,7 @@ Status StreamResource::BuildOperator(const string &model_name, const ModelData &
   GE_CHK_STATUS_RET(model.BuildOp(*this, *new_op), "Build op failed. op = %s, ret = %u", model_name.c_str(), ret);
 
   *single_op = new_op.get();
-  op_map_[model_data.model_data] = std::move(new_op);
+  op_map_[model_id] = std::move(new_op);
   return SUCCESS;
 }
 

ge/single_op/stream_resource.h

@@ -39,11 +39,11 @@ class StreamResource {
   StreamResource &operator=(StreamResource &&) = delete;
   void SetStream(rtStream_t stream);
 
-  SingleOp *GetOperator(const void *key);
-  DynamicSingleOp *GetDynamicOperator(const void *key);
+  SingleOp *GetOperator(const uint64_t key);
+  DynamicSingleOp *GetDynamicOperator(const uint64_t key);
 
-  Status BuildOperator(const std::string &model_name, const ModelData &model_data, SingleOp **single_op);
-  Status BuildDynamicOperator(const std::string &model_name, const ModelData &model_data, DynamicSingleOp **single_op);
+  Status BuildOperator(const ModelData &model_data, SingleOp **single_op, const uint64_t model_id);
+  Status BuildDynamicOperator(const ModelData &model_data, DynamicSingleOp **single_op, const uint64_t model_id);
 
   uint8_t *MallocMemory(const std::string &purpose, size_t size, bool holding_lock = true);
   uint8_t *MallocWeight(const std::string &purpose, size_t size);
@@ -59,8 +59,8 @@ class StreamResource {
   size_t max_memory_size_ = 0;
   std::vector<uint8_t *> memory_list_;
   std::vector<uint8_t *> weight_list_;
-  std::unordered_map<const void *, std::unique_ptr<SingleOp>> op_map_;
-  std::unordered_map<const void *, std::unique_ptr<DynamicSingleOp>> dynamic_op_map_;
+  std::unordered_map<uint64_t, std::unique_ptr<SingleOp>> op_map_;
+  std::unordered_map<uint64_t, std::unique_ptr<DynamicSingleOp>> dynamic_op_map_;
   rtStream_t stream_ = nullptr;
   std::mutex mu_;
   std::mutex stream_mu_;

inc/framework/executor/ge_executor.h

@@ -274,12 +274,18 @@ class GE_FUNC_DEV_VISIBILITY GE_FUNC_HOST_VISIBILITY GeExecutor {
   static ge::Status LoadSingleOp(const std::string &modelName, const ge::ModelData &modelData, void *stream,
                                  SingleOp **single_op);
 
+  static ge::Status LoadSingleOpV2(const std::string &modelName, const ge::ModelData &modelData, void *stream,
+                                   SingleOp **single_op, const uint64_t model_id);
+
   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);
 
+  static ge::Status LoadDynamicSingleOpV2(const std::string &model_name, const ge::ModelData &modelData, void *stream,
+                                          DynamicSingleOp **single_op, const uint64_t model_id);
+
   static ge::Status ExecuteAsync(DynamicSingleOp *executor, const std::vector<GeTensorDesc> &input_desc,
                                  const std::vector<DataBuffer> &inputs, std::vector<GeTensorDesc> &output_desc,
                                  std::vector<DataBuffer> &outputs);