hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

Fix bug of single_op ageing.

pull/1324/head
unknown 4 years ago
parent
5d094c7f72
commit
63e8d1e291
6 changed files with 50 additions and 27 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +12
    -2
      ge/executor/ge_executor.cc
  2. +10
    -7
      ge/single_op/single_op_manager.cc
  3. +4
    -2
      ge/single_op/single_op_manager.h
  4. +12
    -10
      ge/single_op/stream_resource.cc
  5. +6
    -6
      ge/single_op/stream_resource.h
  6. +6
    -0
      inc/framework/executor/ge_executor.h

+ 12
- 2
ge/executor/ge_executor.cc View File

@@ -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,


+ 10
- 7
ge/single_op/single_op_manager.cc View File

@@ -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() {


+ 4
- 2
ge/single_op/single_op_manager.h View File

@@ -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);



+ 12
- 10
ge/single_op/stream_resource.cc View File

@@ -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;
}



+ 6
- 6
ge/single_op/stream_resource.h View File

@@ -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_;


+ 6
- 0
inc/framework/executor/ge_executor.h View File

@@ -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);


Write Preview
Loading…
Cancel
Save