@@ -239,6 +239,10 @@ std::string DNNEngineManager::GetDNNEngineName(const ge::NodePtr &node_ptr) { | |||||
op_desc->SetOpEngineName(it.engine); | op_desc->SetOpEngineName(it.engine); | ||||
op_desc->SetOpKernelLibName(kernel_name); | op_desc->SetOpKernelLibName(kernel_name); | ||||
// set attrs for taking information when load txt to graph object | // set attrs for taking information when load txt to graph object | ||||
if (it.flagAsync) { | |||||
GELOGD("Set aicpu blocking op:%s attribute(is_blocking_op):true", op_desc->GetName().c_str()); | |||||
(void)AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true); | |||||
} | |||||
(void) AttrUtils::SetStr(op_desc, ATTR_NAME_ENGINE_NAME_FOR_LX, it.engine); | (void) AttrUtils::SetStr(op_desc, ATTR_NAME_ENGINE_NAME_FOR_LX, it.engine); | ||||
(void) AttrUtils::SetStr(op_desc, ATTR_NAME_KKERNEL_LIB_NAME_FOR_LX, kernel_name); | (void) AttrUtils::SetStr(op_desc, ATTR_NAME_KKERNEL_LIB_NAME_FOR_LX, kernel_name); | ||||
GELOGD("DNNEngineManager:Set OpKernelLibName %s and engine name %s to op_desc %s", kernel_name.c_str(), | GELOGD("DNNEngineManager:Set OpKernelLibName %s and engine name %s to op_desc %s", kernel_name.c_str(), | ||||
@@ -238,6 +238,12 @@ DavinciModel::~DavinciModel() { | |||||
GE_LOGW_IF(rtEventDestroy(event_list_[i]) != RT_ERROR_NONE, "Destroy event failed, index: %zu", i); | GE_LOGW_IF(rtEventDestroy(event_list_[i]) != RT_ERROR_NONE, "Destroy event failed, index: %zu", i); | ||||
} | } | ||||
for (const auto &it : stream_2_event_) { | |||||
if (rtEventDestroy(it.second) != RT_ERROR_NONE) { | |||||
GELOGW("Destroy event failed"); | |||||
} | |||||
} | |||||
FreeWeightsMem(); | FreeWeightsMem(); | ||||
FreeFeatureMapMem(); | FreeFeatureMapMem(); | ||||
@@ -4648,4 +4654,50 @@ Status DavinciModel::GetTotalMemSizeExcludeZeroCopy(int64_t &total_useful_size) | |||||
total_useful_size = runtime_param_.mem_size - runtime_param_.zero_copy_size; | total_useful_size = runtime_param_.mem_size - runtime_param_.zero_copy_size; | ||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
Status DavinciModel::GetEventIdForBlockingAicpuOp(const OpDescPtr &op_desc, rtStream_t stream, uint32_t &event_id) { | |||||
GELOGI("Get event id for aicpu blocking op:%s", op_desc->GetName().c_str()); | |||||
auto it = stream_2_event_.find(stream); | |||||
if (it != stream_2_event_.end()) { | |||||
auto rt_ret = rtGetEventID(it->second, &event_id); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetEventID failed for op:%s(%s), ret:0x%X", | |||||
op_desc->GetName().c_str(), op_desc->GetType().c_str(), rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetEventID] failed for op:%s(%s), ret:0x%X", | |||||
op_desc->GetName().c_str(), op_desc->GetType().c_str(), rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
} else { | |||||
rtEvent_t rt_event = nullptr; | |||||
auto rt_ret = rtEventCreateWithFlag(&rt_event, RT_EVENT_WITH_FLAG); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtEventCreateWithFlag failed for op:%s(%s), ret:0x%X", | |||||
op_desc->GetName().c_str(), op_desc->GetType().c_str(), rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtEventCreateWithFlag] failed for op:%s(%s), ret:0x%X", | |||||
op_desc->GetName().c_str(), op_desc->GetType().c_str(), rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
rt_ret = rtGetEventID(rt_event, &event_id); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetEventID failed for op:%s(%s), ret:0x%X", | |||||
op_desc->GetName().c_str(), op_desc->GetType().c_str(), rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetEventID] failed for op:%s(%s), ret:0x%X", | |||||
op_desc->GetName().c_str(), op_desc->GetType().c_str(), rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
stream_2_event_.emplace(stream, rt_event); | |||||
} | |||||
return SUCCESS; | |||||
} | |||||
Status DavinciModel::GetEventByStream(const rtStream_t &stream, rtEvent_t &rt_event) { | |||||
auto it = stream_2_event_.find(stream); | |||||
if (it == stream_2_event_.end()) { | |||||
REPORT_INNER_ERROR("E19999", "Get event failed"); | |||||
GELOGE(FAILED, "[Get][Event] Get event failed"); | |||||
return FAILED; | |||||
} | |||||
rt_event = it->second; | |||||
return SUCCESS; | |||||
} | |||||
} // namespace ge | } // namespace ge |
@@ -582,6 +582,10 @@ class DavinciModel { | |||||
void SetRunningFlag(bool flag) { running_flg_ = flag; } | void SetRunningFlag(bool flag) { running_flg_ = flag; } | ||||
Status SetRunAsyncListenerCallback(const RunAsyncCallback &callback); | Status SetRunAsyncListenerCallback(const RunAsyncCallback &callback); | ||||
// for blocking aicpu op | |||||
Status GetEventByStream(const rtStream_t &stream, rtEvent_t &rt_event); | |||||
Status GetEventIdForBlockingAicpuOp(const OpDescPtr &op_desc, rtStream_t stream, uint32_t &event_id); | |||||
private: | private: | ||||
// memory address of weights | // memory address of weights | ||||
uint8_t *weights_mem_base_; | uint8_t *weights_mem_base_; | ||||
@@ -1107,6 +1111,8 @@ class DavinciModel { | |||||
// op name to attrs mapping | // op name to attrs mapping | ||||
std::map<std::string, std::map<std::string, std::vector<std::string>>> op_name_to_attrs_; | std::map<std::string, std::map<std::string, std::vector<std::string>>> op_name_to_attrs_; | ||||
std::map<rtStream_t, rtEvent_t> stream_2_event_; | |||||
}; | }; | ||||
} // namespace ge | } // namespace ge | ||||
#endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_DAVINCI_MODEL_H_ | #endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_DAVINCI_MODEL_H_ |
@@ -26,8 +26,8 @@ | |||||
#include "external/graph/attr_value.h" | #include "external/graph/attr_value.h" | ||||
#include "graph/load/model_manager/davinci_model.h" | #include "graph/load/model_manager/davinci_model.h" | ||||
#include "graph/load/model_manager/model_manager.h" | #include "graph/load/model_manager/model_manager.h" | ||||
#include "hybrid/node_executor/aicpu/aicpu_ext_info.h" | |||||
#include "framework/common/debug/log.h" | #include "framework/common/debug/log.h" | ||||
#include "runtime/rt.h" | |||||
namespace { | namespace { | ||||
const char *const kAicpuAllshape = "_AllShape"; | const char *const kAicpuAllshape = "_AllShape"; | ||||
@@ -43,7 +43,7 @@ Status KernelExTaskInfo::InitTaskExtInfo(const std::string &ext_info, const OpDe | |||||
UnknowShapeOpType unknown_type = static_cast<UnknowShapeOpType>(unknown_shape_type_val); | UnknowShapeOpType unknown_type = static_cast<UnknowShapeOpType>(unknown_shape_type_val); | ||||
uint32_t num_inputs = op_desc->GetInputsSize(); | uint32_t num_inputs = op_desc->GetInputsSize(); | ||||
uint32_t num_outputs = op_desc->GetOutputsSize(); | uint32_t num_outputs = op_desc->GetOutputsSize(); | ||||
std::unique_ptr<ge::hybrid::AicpuExtInfoHandler> ext_handle( | |||||
std::shared_ptr<ge::hybrid::AicpuExtInfoHandler> ext_handle( | |||||
new(std::nothrow) ::ge::hybrid::AicpuExtInfoHandler(op_desc->GetName(), | new(std::nothrow) ::ge::hybrid::AicpuExtInfoHandler(op_desc->GetName(), | ||||
num_inputs, | num_inputs, | ||||
num_outputs, | num_outputs, | ||||
@@ -76,6 +76,16 @@ Status KernelExTaskInfo::InitTaskExtInfo(const std::string &ext_info, const OpDe | |||||
} | } | ||||
} | } | ||||
} | } | ||||
AttrUtils::GetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, is_blocking_aicpu_op_); | |||||
GELOGD("Get op:%s attribute(is_blocking_op), value:%d", op_desc->GetName().c_str(), is_blocking_aicpu_op_); | |||||
if (UpdateEventIdForAicpuBlockingOp(op_desc, ext_handle) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][UpdateEventIdForAicpuBlockingOp] failed for op:%s(%s)", | |||||
op_desc->GetName().c_str(), op_desc->GetType().c_str()); | |||||
return FAILED; | |||||
} | |||||
auto rt_ret = rtMalloc(&ext_info_addr_, ext_handle->GetExtInfoLen(), RT_MEMORY_HBM); | auto rt_ret = rtMalloc(&ext_info_addr_, ext_handle->GetExtInfoLen(), RT_MEMORY_HBM); | ||||
GE_IF_BOOL_EXEC(rt_ret != RT_ERROR_NONE, | GE_IF_BOOL_EXEC(rt_ret != RT_ERROR_NONE, | ||||
REPORT_CALL_ERROR("E19999", "Call rtMalloc failed, size:%zu, ret:0x%X", ext_info.size(), rt_ret); | REPORT_CALL_ERROR("E19999", "Call rtMalloc failed, size:%zu, ret:0x%X", ext_info.size(), rt_ret); | ||||
@@ -448,6 +458,101 @@ Status KernelExTaskInfo::Distribute() { | |||||
stream_id_ = stream_id; | stream_id_ = stream_id; | ||||
GELOGI("KernelExTaskInfo Distribute Success. task id: %u, stream id: %u", task_id_, stream_id_); | GELOGI("KernelExTaskInfo Distribute Success. task id: %u, stream id: %u", task_id_, stream_id_); | ||||
if (is_blocking_aicpu_op_) { | |||||
if (DistributeWaitTaskForAicpuBlockingOp() != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][DistributeWaitTaskForAicpuBlockingOp] Call DistributeWaitTaskForAicpuBlockingOp failed"); | |||||
return FAILED; | |||||
} | |||||
} | |||||
return SUCCESS; | |||||
} | |||||
Status KernelExTaskInfo::CheckDeviceSupportBlockingAicpuOpProcess(bool &is_support) { | |||||
int32_t device_id = 0; | |||||
auto rt_ret = rtGetDevice(&device_id); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetDevice failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetDevice] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
int32_t value = 0; | |||||
rt_ret = rtGetDeviceCapability(device_id, FEATURE_TYPE_BLOCKING_OPERATOR, RT_MODULE_TYPE_AICPU, &value); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetDeviceCapability failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetDeviceCapability] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
if (value != RT_AICPU_BLOCKING_OP_NOT_SUPPORT && value != RT_AICPU_BLOCKING_OP_SUPPORT) { | |||||
REPORT_INNER_ERROR("E19999", "Value should be %d or %d but %d", | |||||
RT_AICPU_BLOCKING_OP_NOT_SUPPORT, RT_AICPU_BLOCKING_OP_SUPPORT, value); | |||||
GELOGE(FAILED, "[Check][Value] Value should be %d or %d but %d", | |||||
RT_AICPU_BLOCKING_OP_NOT_SUPPORT, RT_AICPU_BLOCKING_OP_SUPPORT, value); | |||||
return FAILED; | |||||
} | |||||
is_support = (value == RT_AICPU_BLOCKING_OP_SUPPORT ? true : false); | |||||
return SUCCESS; | |||||
} | |||||
Status KernelExTaskInfo::UpdateEventIdForAicpuBlockingOp(const OpDescPtr &op_desc, | |||||
std::shared_ptr<ge::hybrid::AicpuExtInfoHandler> &ext_handle) { | |||||
if (is_blocking_aicpu_op_) { | |||||
bool is_support = false; | |||||
if (CheckDeviceSupportBlockingAicpuOpProcess(is_support) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][CheckDeviceSupportBlockingAicpuOpProcess] Call CheckDeviceSupportBlockingAicpuOpProcess failed"); | |||||
return FAILED; | |||||
} | |||||
if (!is_support) { | |||||
GELOGD("Device not support blocking aicpu op process"); | |||||
return SUCCESS; | |||||
} | |||||
uint32_t event_id = 0; | |||||
if (davinci_model_->GetEventIdForBlockingAicpuOp(op_desc, stream_, event_id) != SUCCESS) { | |||||
REPORT_CALL_ERROR("E19999", "Get event id failed for op:%s(%s).", op_desc->GetName().c_str(), | |||||
op_desc->GetType().c_str()); | |||||
GELOGE(FAILED, "[Get][EventId] Get event id failed for op:%s(%s)", op_desc->GetName().c_str(), | |||||
op_desc->GetType().c_str()); | |||||
return FAILED; | |||||
} | |||||
if (ext_handle->UpdateEventId(event_id) != SUCCESS) { | |||||
REPORT_CALL_ERROR("E19999", "Update event id failed for op:%s(%s).", op_desc->GetName().c_str(), | |||||
op_desc->GetType().c_str()); | |||||
GELOGE(FAILED, "[Update][EventId] Update event id failed for op:%s(%s)", op_desc->GetName().c_str(), | |||||
op_desc->GetType().c_str()); | |||||
return FAILED; | |||||
} | |||||
GELOGI("Update event_id=%u success", event_id); | |||||
} | |||||
return SUCCESS; | |||||
} | |||||
Status KernelExTaskInfo::DistributeWaitTaskForAicpuBlockingOp() { | |||||
bool is_support = false; | |||||
if (CheckDeviceSupportBlockingAicpuOpProcess(is_support) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][CheckDeviceSupportBlockingAicpuOpProcess] Call CheckDeviceSupportBlockingAicpuOpProcess failed"); | |||||
return FAILED; | |||||
} | |||||
if (!is_support) { | |||||
GELOGD("Device not support blocking aicpu op process."); | |||||
return SUCCESS; | |||||
} | |||||
GELOGD("Distribute wait task begin"); | |||||
rtEvent_t rt_event = nullptr; | |||||
if (davinci_model_->GetEventByStream(stream_, rt_event) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][GetEventByStream] Call GetEventByStream failed"); | |||||
return FAILED; | |||||
} | |||||
auto rt_ret = rtStreamWaitEvent(stream_, rt_event); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtStreamWaitEvent failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][RtApi] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
rt_ret = rtEventReset(rt_event, stream_); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtEventReset failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][RtApi] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
@@ -19,6 +19,7 @@ | |||||
#include "graph/load/model_manager/task_info/task_info.h" | #include "graph/load/model_manager/task_info/task_info.h" | ||||
#include "graph/op_desc.h" | #include "graph/op_desc.h" | ||||
#include "hybrid/node_executor/aicpu/aicpu_ext_info.h" | |||||
namespace ge { | namespace ge { | ||||
class KernelExTaskInfo : public TaskInfo { | class KernelExTaskInfo : public TaskInfo { | ||||
@@ -65,6 +66,12 @@ class KernelExTaskInfo : public TaskInfo { | |||||
void InitDumpArgs(void *addr, const OpDescPtr &op_desc); | void InitDumpArgs(void *addr, const OpDescPtr &op_desc); | ||||
Status InitTaskExtInfo(const std::string &ext_info, const OpDescPtr &op_desc); | Status InitTaskExtInfo(const std::string &ext_info, const OpDescPtr &op_desc); | ||||
// for blocking aicpu op | |||||
Status DistributeWaitTaskForAicpuBlockingOp(); | |||||
Status CheckDeviceSupportBlockingAicpuOpProcess(bool &is_support); | |||||
Status UpdateEventIdForAicpuBlockingOp(const OpDescPtr &op_desc, | |||||
std::shared_ptr<ge::hybrid::AicpuExtInfoHandler> &ext_handle); | |||||
uint32_t task_id_; | uint32_t task_id_; | ||||
uint32_t stream_id_; | uint32_t stream_id_; | ||||
uint32_t dump_flag_; | uint32_t dump_flag_; | ||||
@@ -79,6 +86,7 @@ class KernelExTaskInfo : public TaskInfo { | |||||
uint32_t args_offset_ = 0; | uint32_t args_offset_ = 0; | ||||
int64_t fixed_addr_offset_ = 0; | int64_t fixed_addr_offset_ = 0; | ||||
int32_t topic_type_flag_ = -1; | int32_t topic_type_flag_ = -1; | ||||
bool is_blocking_aicpu_op_ = false; | |||||
}; | }; | ||||
} // namespace ge | } // namespace ge | ||||
#endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_TASK_INFO_KERNEL_EX_TASK_INFO_H_ | #endif // GE_GRAPH_LOAD_NEW_MODEL_MANAGER_TASK_INFO_KERNEL_EX_TASK_INFO_H_ |
@@ -28,11 +28,10 @@ | |||||
#include "graph/load/model_manager/davinci_model.h" | #include "graph/load/model_manager/davinci_model.h" | ||||
#include "graph/load/model_manager/model_manager.h" | #include "graph/load/model_manager/model_manager.h" | ||||
#include "graph/load/model_manager/model_utils.h" | #include "graph/load/model_manager/model_utils.h" | ||||
#include "runtime/kernel.h" | |||||
#include "runtime/rt.h" | |||||
#include "graph/load/model_manager/task_info/super_kernel/super_kernel.h" | #include "graph/load/model_manager/task_info/super_kernel/super_kernel.h" | ||||
#include "graph/load/model_manager/task_info/super_kernel/super_kernel_factory.h" | #include "graph/load/model_manager/task_info/super_kernel/super_kernel_factory.h" | ||||
#include "cce/aicpu_engine_struct.h" | #include "cce/aicpu_engine_struct.h" | ||||
#include "hybrid/node_executor/aicpu/aicpu_ext_info.h" | |||||
#include "framework/common/debug/log.h" | #include "framework/common/debug/log.h" | ||||
namespace { | namespace { | ||||
@@ -474,6 +473,12 @@ Status KernelTaskInfo::Distribute() { | |||||
} | } | ||||
// set for task_id_ | // set for task_id_ | ||||
UpdateTaskId(); | UpdateTaskId(); | ||||
if (is_blocking_aicpu_op_) { | |||||
if (DistributeWaitTaskForAicpuBlockingOp() != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][DistributeWaitTaskForAicpuBlockingOp] Call DistributeWaitTaskForAicpuBlockingOp failed"); | |||||
return FAILED; | |||||
} | |||||
} | |||||
GELOGD( | GELOGD( | ||||
"KernelTaskInfo Distribute Success. sktenable:%d taskid:%d sktid:%d stubfunc_name:%s stubfunc:%p " | "KernelTaskInfo Distribute Success. sktenable:%d taskid:%d sktid:%d stubfunc_name:%s stubfunc:%p " | ||||
"blockdim:%d stream:%p", | "blockdim:%d stream:%p", | ||||
@@ -482,6 +487,91 @@ Status KernelTaskInfo::Distribute() { | |||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
Status KernelTaskInfo::CheckDeviceSupportBlockingAicpuOpProcess(bool &is_support) { | |||||
int32_t device_id = 0; | |||||
auto rt_ret = rtGetDevice(&device_id); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetDevice failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetDevice] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
int32_t value = 0; | |||||
rt_ret = rtGetDeviceCapability(device_id, FEATURE_TYPE_BLOCKING_OPERATOR, RT_MODULE_TYPE_AICPU, &value); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetDeviceCapability failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetDeviceCapability] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
if (value != RT_AICPU_BLOCKING_OP_NOT_SUPPORT && value != RT_AICPU_BLOCKING_OP_SUPPORT) { | |||||
REPORT_INNER_ERROR("E19999", "Value should be %d or %d but %d", | |||||
RT_AICPU_BLOCKING_OP_NOT_SUPPORT, RT_AICPU_BLOCKING_OP_SUPPORT, value); | |||||
GELOGE(FAILED, "[Check][Value] Value should be %d or %d but %d", | |||||
RT_AICPU_BLOCKING_OP_NOT_SUPPORT, RT_AICPU_BLOCKING_OP_SUPPORT, value); | |||||
return FAILED; | |||||
} | |||||
is_support = (value == RT_AICPU_BLOCKING_OP_SUPPORT ? true : false); | |||||
return SUCCESS; | |||||
} | |||||
Status KernelTaskInfo::UpdateEventIdForAicpuBlockingOp(std::shared_ptr<ge::hybrid::AicpuExtInfoHandler> &ext_handle) { | |||||
if (is_blocking_aicpu_op_) { | |||||
bool is_support = false; | |||||
if (CheckDeviceSupportBlockingAicpuOpProcess(is_support) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][CheckDeviceSupportBlockingAicpuOpProcess] Call CheckDeviceSupportBlockingAicpuOpProcess failed"); | |||||
return FAILED; | |||||
} | |||||
if (!is_support) { | |||||
GELOGD("Device not support blocking aicpu op process"); | |||||
return SUCCESS; | |||||
} | |||||
uint32_t event_id = 0; | |||||
if (davinci_model_->GetEventIdForBlockingAicpuOp(op_desc_, stream_, event_id) != SUCCESS) { | |||||
GELOGE(FAILED, "[Get][EventId] Get event id failed for op:%s(%s)", op_desc_->GetName().c_str(), | |||||
op_desc_->GetType().c_str()); | |||||
return FAILED; | |||||
} | |||||
if (ext_handle->UpdateEventId(event_id) != SUCCESS) { | |||||
GELOGE(FAILED, "[Update][EventId] Update event id failed for op:%s(%s)", op_desc_->GetName().c_str(), | |||||
op_desc_->GetType().c_str()); | |||||
return FAILED; | |||||
} | |||||
GELOGI("Update event_id=%u success", event_id); | |||||
} | |||||
return SUCCESS; | |||||
} | |||||
Status KernelTaskInfo::DistributeWaitTaskForAicpuBlockingOp() { | |||||
bool is_support = false; | |||||
if (CheckDeviceSupportBlockingAicpuOpProcess(is_support) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][CheckDeviceSupportBlockingAicpuOpProcess] Call CheckDeviceSupportBlockingAicpuOpProcess failed"); | |||||
return FAILED; | |||||
} | |||||
if (!is_support) { | |||||
GELOGD("device not support blocking aicpu op process."); | |||||
return SUCCESS; | |||||
} | |||||
GELOGD("Distribute wait task begin"); | |||||
rtEvent_t rt_event = nullptr; | |||||
if (davinci_model_->GetEventByStream(stream_, rt_event) != SUCCESS) { | |||||
REPORT_CALL_ERROR("E19999", "Call GetEventByStream failed"); | |||||
GELOGE(FAILED, "[Call][GetEventByStream] Call GetEventByStream failed"); | |||||
return FAILED; | |||||
} | |||||
auto rt_ret = rtStreamWaitEvent(stream_, rt_event); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtStreamWaitEvent failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][RtApi] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
rt_ret = rtEventReset(rt_event, stream_); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtEventReset failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][RtApi] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
return SUCCESS; | |||||
} | |||||
void KernelTaskInfo::SetIoAddrs(const OpDescPtr &op_desc) { | void KernelTaskInfo::SetIoAddrs(const OpDescPtr &op_desc) { | ||||
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); | ||||
@@ -1109,7 +1199,7 @@ Status KernelTaskInfo::InitAicpuTaskExtInfo(const std::string &ext_info) { | |||||
UnknowShapeOpType unknown_type = static_cast<UnknowShapeOpType>(unknown_shape_type_val); | UnknowShapeOpType unknown_type = static_cast<UnknowShapeOpType>(unknown_shape_type_val); | ||||
uint32_t num_inputs = op_desc_->GetInputsSize(); | uint32_t num_inputs = op_desc_->GetInputsSize(); | ||||
uint32_t num_outputs = op_desc_->GetOutputsSize(); | uint32_t num_outputs = op_desc_->GetOutputsSize(); | ||||
std::unique_ptr<ge::hybrid::AicpuExtInfoHandler> ext_handle( | |||||
std::shared_ptr<ge::hybrid::AicpuExtInfoHandler> ext_handle( | |||||
new(std::nothrow) ::ge::hybrid::AicpuExtInfoHandler(op_desc_->GetName(), | new(std::nothrow) ::ge::hybrid::AicpuExtInfoHandler(op_desc_->GetName(), | ||||
num_inputs, | num_inputs, | ||||
num_outputs, | num_outputs, | ||||
@@ -1145,6 +1235,16 @@ Status KernelTaskInfo::InitAicpuTaskExtInfo(const std::string &ext_info) { | |||||
j, op_desc_->GetName().c_str()); | j, op_desc_->GetName().c_str()); | ||||
} | } | ||||
} | } | ||||
AttrUtils::GetBool(op_desc_, ATTR_NAME_IS_BLOCKING_OP, is_blocking_aicpu_op_); | |||||
GELOGD("Get op:%s attribute(is_blocking_op), value:%d", op_desc_->GetName().c_str(), is_blocking_aicpu_op_); | |||||
if (UpdateEventIdForAicpuBlockingOp(ext_handle) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][UpdateEventIdForAicpuBlockingOp] failed for op:%s(%s)", | |||||
op_desc_->GetName().c_str(), op_desc_->GetType().c_str()); | |||||
return FAILED; | |||||
} | |||||
auto rt_ret = rtMalloc(&aicpu_ext_info_addr_, ext_handle->GetExtInfoLen(), RT_MEMORY_HBM); | auto rt_ret = rtMalloc(&aicpu_ext_info_addr_, ext_handle->GetExtInfoLen(), RT_MEMORY_HBM); | ||||
if (rt_ret != RT_ERROR_NONE) { | if (rt_ret != RT_ERROR_NONE) { | ||||
REPORT_CALL_ERROR("E19999", "Call rtMalloc failed for op:%s(%s), size:%zu, ret:0x%X", | REPORT_CALL_ERROR("E19999", "Call rtMalloc failed for op:%s(%s), size:%zu, ret:0x%X", | ||||
@@ -24,6 +24,8 @@ | |||||
#include "graph/load/model_manager/task_info/task_info.h" | #include "graph/load/model_manager/task_info/task_info.h" | ||||
#include "graph/op_desc.h" | #include "graph/op_desc.h" | ||||
#include "hybrid/node_executor/aicpu/aicpu_ext_info.h" | |||||
namespace ge { | namespace ge { | ||||
class KernelTaskInfo : public TaskInfo { | class KernelTaskInfo : public TaskInfo { | ||||
public: | public: | ||||
@@ -148,6 +150,11 @@ class KernelTaskInfo : public TaskInfo { | |||||
bool DoubleCallSKTSaveCheck(); | bool DoubleCallSKTSaveCheck(); | ||||
void SetArgs(); | void SetArgs(); | ||||
// for blocking aicpu op | |||||
Status DistributeWaitTaskForAicpuBlockingOp(); | |||||
Status CheckDeviceSupportBlockingAicpuOpProcess(bool &is_support); | |||||
Status UpdateEventIdForAicpuBlockingOp(std::shared_ptr<ge::hybrid::AicpuExtInfoHandler> &ext_handle); | |||||
void *stub_func_; | void *stub_func_; | ||||
void *args_; | void *args_; | ||||
void *sm_desc_; | void *sm_desc_; | ||||
@@ -187,6 +194,7 @@ class KernelTaskInfo : public TaskInfo { | |||||
uint32_t skt_dump_flag_ = RT_KERNEL_DEFAULT; | uint32_t skt_dump_flag_ = RT_KERNEL_DEFAULT; | ||||
void *superkernel_device_args_addr_ = nullptr; | void *superkernel_device_args_addr_ = nullptr; | ||||
void *superkernel_dev_nav_table_ = nullptr; | void *superkernel_dev_nav_table_ = nullptr; | ||||
bool is_blocking_aicpu_op_ = false; | |||||
struct AICPUCustomInfo { | struct AICPUCustomInfo { | ||||
void *input_descs = nullptr; | void *input_descs = nullptr; | ||||
@@ -81,6 +81,9 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) { | |||||
case aicpu::FWKAdapter::FWK_ADPT_EXT_TOPIC_TYPE: | case aicpu::FWKAdapter::FWK_ADPT_EXT_TOPIC_TYPE: | ||||
GE_CHK_STATUS_RET(ParseExtTopicType(aicpu_ext_info), "[Parse][ExtTopicType] failed."); | GE_CHK_STATUS_RET(ParseExtTopicType(aicpu_ext_info), "[Parse][ExtTopicType] failed."); | ||||
break; | break; | ||||
case aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT: | |||||
GE_CHK_STATUS_RET(ParseExtAsyncWait(aicpu_ext_info), "[Parse][ExtAsyncWait] failed."); | |||||
break; | |||||
default: | default: | ||||
GELOGD("Node[%s] ignore infoType=%d, infoLen=%u.", | GELOGD("Node[%s] ignore infoType=%d, infoLen=%u.", | ||||
node_name_.c_str(), aicpu_ext_info->infoType, aicpu_ext_info->infoLen); | node_name_.c_str(), aicpu_ext_info->infoType, aicpu_ext_info->infoLen); | ||||
@@ -101,6 +104,22 @@ Status AicpuExtInfoHandler::Parse(const std::string &ext_info) { | |||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
Status AicpuExtInfoHandler::ParseExtAsyncWait(AicpuExtInfo *aicpu_ext_info) { | |||||
if (aicpu_ext_info->infoLen != sizeof(AsyncWaitInfo)) { | |||||
REPORT_INNER_ERROR("E19999", | |||||
"Node[%s] parse ext async wait info failed as infoLen must be %zu but %u.", | |||||
node_name_.c_str(), sizeof(AsyncWaitInfo), aicpu_ext_info->infoLen); | |||||
GELOGE(ACL_ERROR_GE_PARAM_INVALID, | |||||
"[Check][DataLen]Node[%s] parse ext async wait info failed as infoLen must be %zu but %u.", | |||||
node_name_.c_str(), sizeof(AsyncWaitInfo), aicpu_ext_info->infoLen); | |||||
return ACL_ERROR_GE_PARAM_INVALID; | |||||
} | |||||
async_wait_ = reinterpret_cast<AsyncWaitInfo *>(aicpu_ext_info->infoMsg); | |||||
GELOGI("Node[%s] parse async wait info success infoLen=%u.", node_name_.c_str(), aicpu_ext_info->infoLen); | |||||
return SUCCESS; | |||||
} | |||||
Status AicpuExtInfoHandler::ParseExtShapeType(AicpuExtInfo *aicpu_ext_info) { | Status AicpuExtInfoHandler::ParseExtShapeType(AicpuExtInfo *aicpu_ext_info) { | ||||
GE_IF_BOOL_EXEC(aicpu_ext_info->infoLen != sizeof(int32_t), | GE_IF_BOOL_EXEC(aicpu_ext_info->infoLen != sizeof(int32_t), | ||||
REPORT_INNER_ERROR("E19999", "Node[%s] parse ext shape type failed as infoLen must be %zu but %u.", | REPORT_INNER_ERROR("E19999", "Node[%s] parse ext shape type failed as infoLen must be %zu but %u.", | ||||
@@ -280,6 +299,17 @@ Status AicpuExtInfoHandler::UpdateSessionInfo(uint64_t session_id, uint64_t kern | |||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
Status AicpuExtInfoHandler::UpdateEventId(uint32_t event_id) { | |||||
if (async_wait_ == nullptr) { | |||||
REPORT_INNER_ERROR("E19999", "async_wait_ is nullptr."); | |||||
GELOGE(FAILED, "[Check][async_wait_] async_wait_ is nullptr."); | |||||
return FAILED; | |||||
} | |||||
async_wait_->waitType = 1; | |||||
async_wait_->waitId = event_id; | |||||
return SUCCESS; | |||||
} | |||||
Status AicpuExtInfoHandler::UpdateSessionInfoSessionId(uint64_t session_id) { | Status AicpuExtInfoHandler::UpdateSessionInfoSessionId(uint64_t session_id) { | ||||
if (session_info_ == nullptr) { | if (session_info_ == nullptr) { | ||||
GELOGD("There is no session info in ext_info, no need update."); | GELOGD("There is no session info in ext_info, no need update."); | ||||
@@ -27,6 +27,7 @@ namespace ge { | |||||
namespace hybrid { | namespace hybrid { | ||||
using AicpuShapeAndType = aicpu::FWKAdapter::ShapeAndType; | using AicpuShapeAndType = aicpu::FWKAdapter::ShapeAndType; | ||||
using AicpuExtInfo = aicpu::FWKAdapter::ExtInfo; | using AicpuExtInfo = aicpu::FWKAdapter::ExtInfo; | ||||
using AsyncWaitInfo = aicpu::FWKAdapter::AsyncWait; | |||||
using AicpuSessionInfo = SessionInfo; | using AicpuSessionInfo = SessionInfo; | ||||
class AicpuExtInfoHandler { | class AicpuExtInfoHandler { | ||||
@@ -59,6 +60,8 @@ class AicpuExtInfoHandler { | |||||
Status UpdateExecuteMode(bool flag); | Status UpdateExecuteMode(bool flag); | ||||
Status UpdateEventId(uint32_t event_id); | |||||
Status GetOutputShapeAndType(uint32_t output_index, GeShape &shape, DataType &data_type); | Status GetOutputShapeAndType(uint32_t output_index, GeShape &shape, DataType &data_type); | ||||
bool IsNeedRefreshIOAddr(); | bool IsNeedRefreshIOAddr(); | ||||
@@ -73,6 +76,7 @@ class AicpuExtInfoHandler { | |||||
Status ParseExtBitMap(AicpuExtInfo *aicpu_ext_info); | Status ParseExtBitMap(AicpuExtInfo *aicpu_ext_info); | ||||
Status ParseExtUpdateAddr(AicpuExtInfo *aicpu_ext_info); | Status ParseExtUpdateAddr(AicpuExtInfo *aicpu_ext_info); | ||||
Status ParseExtTopicType(AicpuExtInfo *aicpu_ext_info); | Status ParseExtTopicType(AicpuExtInfo *aicpu_ext_info); | ||||
Status ParseExtAsyncWait(AicpuExtInfo *aicpu_ext_info); | |||||
static Status UpdateShapeAndType(const GeShape &shape, | static Status UpdateShapeAndType(const GeShape &shape, | ||||
DataType data_type, | DataType data_type, | ||||
@@ -90,6 +94,7 @@ class AicpuExtInfoHandler { | |||||
const uint32_t output_num_; | const uint32_t output_num_; | ||||
UnknowShapeOpType unknown_type_; | UnknowShapeOpType unknown_type_; | ||||
AicpuSessionInfo *session_info_ = nullptr; | AicpuSessionInfo *session_info_ = nullptr; | ||||
AsyncWaitInfo *async_wait_ = nullptr; | |||||
uint64_t *bit_map_ = nullptr; | uint64_t *bit_map_ = nullptr; | ||||
uint32_t *update_addr_ = nullptr; | uint32_t *update_addr_ = nullptr; | ||||
int32_t topic_type_flag_ = -1; | int32_t topic_type_flag_ = -1; | ||||
@@ -22,6 +22,7 @@ | |||||
#include "graph/utils/node_utils.h" | #include "graph/utils/node_utils.h" | ||||
#include "hybrid/executor/hybrid_execution_context.h" | #include "hybrid/executor/hybrid_execution_context.h" | ||||
#include "hybrid/model/hybrid_model.h" | #include "hybrid/model/hybrid_model.h" | ||||
#include "runtime/rt.h" | |||||
namespace ge { | namespace ge { | ||||
namespace hybrid { | namespace hybrid { | ||||
@@ -33,6 +34,12 @@ const char *const kAicpuAllshape = "_AllShape"; | |||||
REGISTER_NODE_EXECUTOR_BUILDER(NodeExecutorManager::ExecutorType::AICPU_TF, AiCpuNodeExecutor); | REGISTER_NODE_EXECUTOR_BUILDER(NodeExecutorManager::ExecutorType::AICPU_TF, AiCpuNodeExecutor); | ||||
REGISTER_NODE_EXECUTOR_BUILDER(NodeExecutorManager::ExecutorType::AICPU_CUSTOM, AiCpuNodeExecutor); | REGISTER_NODE_EXECUTOR_BUILDER(NodeExecutorManager::ExecutorType::AICPU_CUSTOM, AiCpuNodeExecutor); | ||||
AicpuNodeTaskBase::~AicpuNodeTaskBase() { | |||||
if (rt_event_ != nullptr) { | |||||
(void)rtEventDestroy(rt_event_); | |||||
} | |||||
} | |||||
Status AicpuNodeTaskBase::AllocTensorBuffer(size_t size, std::unique_ptr<TensorBuffer> &tensor_buffer) { | Status AicpuNodeTaskBase::AllocTensorBuffer(size_t size, std::unique_ptr<TensorBuffer> &tensor_buffer) { | ||||
auto allocator = NpuMemoryAllocator::GetAllocator(); | auto allocator = NpuMemoryAllocator::GetAllocator(); | ||||
GE_CHECK_NOTNULL(allocator); | GE_CHECK_NOTNULL(allocator); | ||||
@@ -64,6 +71,13 @@ Status AicpuNodeTaskBase::InitExtInfo(const std::string &kernel_ext_info, int64_ | |||||
GE_CHK_STATUS_RET(aicpu_ext_handle_.UpdateSessionInfoSessionId(session_id), | GE_CHK_STATUS_RET(aicpu_ext_handle_.UpdateSessionInfoSessionId(session_id), | ||||
"[Update][SessionInfoSessionId] failed, session_id:%ld.", session_id); | "[Update][SessionInfoSessionId] failed, session_id:%ld.", session_id); | ||||
if (is_blocking_aicpu_op_) { | |||||
if (UpdateEventIdForBlockingAicpuOp() != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][UpdateEventIdForBlockingAicpuOp] Call UpdateEventIdForBlockingAicpuOp failed"); | |||||
return FAILED; | |||||
} | |||||
} | |||||
// copy task args buf | // copy task args buf | ||||
GE_CHK_STATUS_RET(AllocTensorBuffer(aicpu_ext_handle_.GetExtInfoLen(), ext_info_addr_dev_), | GE_CHK_STATUS_RET(AllocTensorBuffer(aicpu_ext_handle_.GetExtInfoLen(), ext_info_addr_dev_), | ||||
"[Invoke][AllocTensorBuffer]Node[%s] alloc kernel_ext_info buf failed, size=%zu", | "[Invoke][AllocTensorBuffer]Node[%s] alloc kernel_ext_info buf failed, size=%zu", | ||||
@@ -230,6 +244,96 @@ Status AicpuNodeTaskBase::ExecuteAsync(TaskContext &context, std::function<void( | |||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
Status AicpuNodeTaskBase::UpdateEventIdForBlockingAicpuOp() { | |||||
bool is_support = false; | |||||
if (CheckDeviceSupportBlockingAicpuOpProcess(is_support) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][CheckDeviceSupportBlockingAicpuOpProcess] Call CheckDeviceSupportBlockingAicpuOpProcess failed"); | |||||
return FAILED; | |||||
} | |||||
if (!is_support) { | |||||
GELOGD("Device not support blocking aicpu op process"); | |||||
return SUCCESS; | |||||
} | |||||
uint32_t event_id = 0; | |||||
auto rt_ret = rtEventCreateWithFlag(&rt_event_, RT_EVENT_WITH_FLAG); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtEventCreateWithFlag failed for node:%s, ret:0x%X", node_name_.c_str(), | |||||
rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtEventCreateWithFlag] failed for node:%s, ret:0x%X", node_name_.c_str(), rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
rt_ret = rtGetEventID(rt_event_, &event_id); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetEventID failed for node:%s, ret:0x%X", node_name_.c_str(), rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetEventID] failed for node:%s, ret:0x%X", node_name_.c_str(), rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
if (aicpu_ext_handle_.UpdateEventId(event_id) != SUCCESS) { | |||||
REPORT_CALL_ERROR("E19999", "Update event id failed for node:%s.", node_name_.c_str()); | |||||
GELOGE(FAILED, "[Update][EventId] Update event id failed for node:%s", node_name_.c_str()); | |||||
return FAILED; | |||||
} | |||||
GELOGI("Update event_id=%u success", event_id); | |||||
return SUCCESS; | |||||
} | |||||
Status AicpuNodeTaskBase::CheckDeviceSupportBlockingAicpuOpProcess(bool &is_support) { | |||||
int32_t device_id = 0; | |||||
auto rt_ret = rtGetDevice(&device_id); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetDevice failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetDevice] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
int32_t value = 0; | |||||
rt_ret = rtGetDeviceCapability(device_id, FEATURE_TYPE_BLOCKING_OPERATOR, RT_MODULE_TYPE_AICPU, &value); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetDeviceCapability failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetDeviceCapability] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
if (value != RT_AICPU_BLOCKING_OP_NOT_SUPPORT && value != RT_AICPU_BLOCKING_OP_SUPPORT) { | |||||
REPORT_INNER_ERROR("E19999", "Value should be %d or %d but %d", | |||||
RT_AICPU_BLOCKING_OP_NOT_SUPPORT, RT_AICPU_BLOCKING_OP_SUPPORT, value); | |||||
GELOGE(FAILED, "[Check][Value] Value should be %d or %d but %d", | |||||
RT_AICPU_BLOCKING_OP_NOT_SUPPORT, RT_AICPU_BLOCKING_OP_SUPPORT, value); | |||||
return FAILED; | |||||
} | |||||
is_support = (value == RT_AICPU_BLOCKING_OP_SUPPORT ? true : false); | |||||
return SUCCESS; | |||||
} | |||||
Status AicpuNodeTaskBase::DistributeWaitTaskForAicpuBlockingOp(rtStream_t stream) { | |||||
bool is_support = false; | |||||
if (CheckDeviceSupportBlockingAicpuOpProcess(is_support) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][CheckDeviceSupportBlockingAicpuOpProcess] Call CheckDeviceSupportBlockingAicpuOpProcess failed"); | |||||
return FAILED; | |||||
} | |||||
if (!is_support) { | |||||
GELOGD("Device not support blocking aicpu op process."); | |||||
return SUCCESS; | |||||
} | |||||
GELOGD("Distribute queue task begin"); | |||||
if (rt_event_ == nullptr) { | |||||
REPORT_INNER_ERROR("E19999", "rt_event_ is nullptr"); | |||||
GELOGE(FAILED, "[Check][rt_event_] rt_event_ is nullptr"); | |||||
return FAILED; | |||||
} | |||||
auto rt_ret = rtStreamWaitEvent(stream, rt_event_); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtStreamWaitEvent failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][RtApi] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
rt_ret = rtEventReset(rt_event_, stream); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtEventReset failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][RtApi] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
return SUCCESS; | |||||
} | |||||
Status AicpuTfNodeTask::InitForDependComputeTask() { | Status AicpuTfNodeTask::InitForDependComputeTask() { | ||||
if ((unknown_type_ != DEPEND_COMPUTE) || (node_item_->num_outputs == 0)) { | if ((unknown_type_ != DEPEND_COMPUTE) || (node_item_->num_outputs == 0)) { | ||||
GELOGD("Node[%s] type[%s] unknown_type is %d, output num is %d.", | GELOGD("Node[%s] type[%s] unknown_type is %d, output num is %d.", | ||||
@@ -325,6 +429,9 @@ Status AicpuTfNodeTask::Init(const HybridModel &model) { | |||||
// init ext info | // init ext info | ||||
uint64_t ext_session_id = model.GetSessionId(); | uint64_t ext_session_id = model.GetSessionId(); | ||||
const OpDescPtr op_desc = node_item_->GetOpDesc(); | |||||
AttrUtils::GetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, is_blocking_aicpu_op_); | |||||
GELOGD("Get op:%s attribute(is_blocking_op), value:%d", op_desc->GetName().c_str(), is_blocking_aicpu_op_); | |||||
GE_CHK_STATUS_RET(InitExtInfo(kernel_ext_info, ext_session_id), "[Init][ExtInfo] failed for Node[%s].", | GE_CHK_STATUS_RET(InitExtInfo(kernel_ext_info, ext_session_id), "[Init][ExtInfo] failed for Node[%s].", | ||||
node_name_.c_str()); | node_name_.c_str()); | ||||
GE_CHK_STATUS_RET(InitForDependComputeTask(), "[Init][DependComputeTask] failed for Node[%s].", node_name_.c_str()); | GE_CHK_STATUS_RET(InitForDependComputeTask(), "[Init][DependComputeTask] failed for Node[%s].", node_name_.c_str()); | ||||
@@ -642,6 +749,12 @@ Status AicpuTfNodeTask::LaunchTask(TaskContext &context) { | |||||
kernel_buf_->GetSize(), flag, context.GetStream())); | kernel_buf_->GetSize(), flag, context.GetStream())); | ||||
RECORD_EXECUTION_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[AicpuTfNodertKernelLaunchEx] End"); | RECORD_EXECUTION_EVENT(context.GetExecutionContext(), node_name_.c_str(), "[AicpuTfNodertKernelLaunchEx] End"); | ||||
GELOGD("Node[%s] launch end.", node_name_.c_str()); | GELOGD("Node[%s] launch end.", node_name_.c_str()); | ||||
if (is_blocking_aicpu_op_) { | |||||
if (DistributeWaitTaskForAicpuBlockingOp(context.GetStream()) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][DistributeWaitTaskForAicpuBlockingOp] Call DistributeWaitTaskForAicpuBlockingOp failed"); | |||||
return FAILED; | |||||
} | |||||
} | |||||
if (need_sync_) { | if (need_sync_) { | ||||
GELOGD("[%s] Task needs sync", node_name_.c_str()); | GELOGD("[%s] Task needs sync", node_name_.c_str()); | ||||
GE_CHK_STATUS_RET_NOLOG(context.Synchronize()); | GE_CHK_STATUS_RET_NOLOG(context.Synchronize()); | ||||
@@ -760,6 +873,8 @@ Status AicpuNodeTask::Init(const HybridModel &model) { | |||||
return FAILED;); | return FAILED;); | ||||
uint64_t ext_session_id = model.GetSessionId(); | uint64_t ext_session_id = model.GetSessionId(); | ||||
AttrUtils::GetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, is_blocking_aicpu_op_); | |||||
GELOGD("Get op:%s attribute(is_blocking_op), value:%d", op_desc->GetName().c_str(), is_blocking_aicpu_op_); | |||||
GE_CHK_STATUS_RET(InitExtInfo(kernel_ext_info, ext_session_id), | GE_CHK_STATUS_RET(InitExtInfo(kernel_ext_info, ext_session_id), | ||||
"[Init][ExtInfo] failed for Node[%s].", node_name.c_str()); | "[Init][ExtInfo] failed for Node[%s].", node_name.c_str()); | ||||
@@ -826,6 +941,12 @@ Status AicpuNodeTask::LaunchTask(TaskContext &context) { | |||||
args_.get(), args_size_, | args_.get(), args_size_, | ||||
nullptr, context.GetStream(), flag); | nullptr, context.GetStream(), flag); | ||||
GE_CHK_RT_RET(rt_ret); | GE_CHK_RT_RET(rt_ret); | ||||
if (is_blocking_aicpu_op_) { | |||||
if (DistributeWaitTaskForAicpuBlockingOp(context.GetStream()) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][DistributeWaitTaskForAicpuBlockingOp] Call DistributeWaitTaskForAicpuBlockingOp failed"); | |||||
return FAILED; | |||||
} | |||||
} | |||||
GELOGD("Node[%s] launch task end.", node_name_.c_str()); | GELOGD("Node[%s] launch task end.", node_name_.c_str()); | ||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
@@ -35,7 +35,7 @@ class AicpuNodeTaskBase : public NodeTask { | |||||
node_item->num_outputs, | node_item->num_outputs, | ||||
node_item->shape_inference_type) {} | node_item->shape_inference_type) {} | ||||
~AicpuNodeTaskBase() override = default; | |||||
~AicpuNodeTaskBase() override; | |||||
using NodeTask::Init; | using NodeTask::Init; | ||||
@@ -61,6 +61,10 @@ class AicpuNodeTaskBase : public NodeTask { | |||||
static Status AllocTensorBuffer(size_t size, std::unique_ptr<TensorBuffer> &tensor_buffer); | static Status AllocTensorBuffer(size_t size, std::unique_ptr<TensorBuffer> &tensor_buffer); | ||||
Status DistributeWaitTaskForAicpuBlockingOp(rtStream_t stream); | |||||
Status CheckDeviceSupportBlockingAicpuOpProcess(bool &is_support); | |||||
Status UpdateEventIdForBlockingAicpuOp(); | |||||
protected: | protected: | ||||
const NodeItem *node_item_; | const NodeItem *node_item_; | ||||
// just reference. | // just reference. | ||||
@@ -78,6 +82,10 @@ class AicpuNodeTaskBase : public NodeTask { | |||||
// ext info addr, device mem | // ext info addr, device mem | ||||
std::unique_ptr<TensorBuffer> ext_info_addr_dev_; | std::unique_ptr<TensorBuffer> ext_info_addr_dev_; | ||||
// for blocking aicpu op | |||||
bool is_blocking_aicpu_op_ = false; | |||||
rtEvent_t rt_event_ = nullptr; | |||||
}; | }; | ||||
class AicpuTfNodeTask : public AicpuNodeTaskBase { | class AicpuTfNodeTask : public AicpuNodeTaskBase { | ||||
@@ -564,6 +564,41 @@ AiCpuBaseTask::~AiCpuBaseTask() { | |||||
if (ext_info_addr_dev_ != nullptr) { | if (ext_info_addr_dev_ != nullptr) { | ||||
(void)rtFree(ext_info_addr_dev_); | (void)rtFree(ext_info_addr_dev_); | ||||
} | } | ||||
if (rt_event_ != nullptr) { | |||||
(void)rtEventDestroy(rt_event_); | |||||
} | |||||
} | |||||
Status AiCpuBaseTask::UpdateEventIdForBlockingAicpuOp() { | |||||
bool is_support = false; | |||||
if (CheckDeviceSupportBlockingAicpuOpProcess(is_support) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][CheckDeviceSupportBlockingAicpuOpProcess] Call CheckDeviceSupportBlockingAicpuOpProcess failed"); | |||||
return FAILED; | |||||
} | |||||
if (!is_support) { | |||||
GELOGD("Device not support blocking aicpu op process"); | |||||
return SUCCESS; | |||||
} | |||||
uint32_t event_id = 0; | |||||
auto rt_ret = rtEventCreateWithFlag(&rt_event_, RT_EVENT_WITH_FLAG); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtEventCreateWithFlag failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtEventCreateWithFlag] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
rt_ret = rtGetEventID(rt_event_, &event_id); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetEventID failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetEventID] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
if (aicpu_ext_handle_->UpdateEventId(event_id) != SUCCESS) { | |||||
REPORT_CALL_ERROR("E19999", "Update event id=%u failed.", event_id); | |||||
GELOGE(FAILED, "[Update][EventId] Update event id failed", event_id); | |||||
return FAILED; | |||||
} | |||||
GELOGI("Update event_id=%u success", event_id); | |||||
return SUCCESS; | |||||
} | } | ||||
Status AiCpuBaseTask::SetExtInfoAndType(const std::string &kernel_ext_info, uint64_t kernel_id) { | Status AiCpuBaseTask::SetExtInfoAndType(const std::string &kernel_ext_info, uint64_t kernel_id) { | ||||
@@ -577,6 +612,9 @@ Status AiCpuBaseTask::SetExtInfoAndType(const std::string &kernel_ext_info, uint | |||||
GELOGD("Get unknown_type is %d.", unknown_shape_type_val); | GELOGD("Get unknown_type is %d.", unknown_shape_type_val); | ||||
unknown_type_ = static_cast<UnknowShapeOpType>(unknown_shape_type_val); | unknown_type_ = static_cast<UnknowShapeOpType>(unknown_shape_type_val); | ||||
AttrUtils::GetBool(op_desc_, ATTR_NAME_IS_BLOCKING_OP, is_blocking_aicpu_op_); | |||||
GELOGD("Get op:%s attribute(is_blocking_op), value:%d", op_desc_->GetName().c_str(), is_blocking_aicpu_op_); | |||||
aicpu_ext_handle_.reset(new(std::nothrow) ::ge::hybrid::AicpuExtInfoHandler(op_desc_->GetName(), | aicpu_ext_handle_.reset(new(std::nothrow) ::ge::hybrid::AicpuExtInfoHandler(op_desc_->GetName(), | ||||
num_inputs_, | num_inputs_, | ||||
num_outputs_, | num_outputs_, | ||||
@@ -595,6 +633,13 @@ Status AiCpuBaseTask::SetExtInfoAndType(const std::string &kernel_ext_info, uint | |||||
GE_CHK_STATUS_RET(aicpu_ext_handle_->UpdateSessionInfo(ULLONG_MAX, kernel_id, false), | GE_CHK_STATUS_RET(aicpu_ext_handle_->UpdateSessionInfo(ULLONG_MAX, kernel_id, false), | ||||
"[Update][SessionInfo] failed."); | "[Update][SessionInfo] failed."); | ||||
if (is_blocking_aicpu_op_) { | |||||
if (UpdateEventIdForBlockingAicpuOp() != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][UpdateEventIdForBlockingAicpuOp] Call UpdateEventIdForBlockingAicpuOp failed"); | |||||
return FAILED; | |||||
} | |||||
} | |||||
GE_CHK_RT_RET(rtMalloc(&ext_info_addr_dev_, aicpu_ext_handle_->GetExtInfoLen(), RT_MEMORY_HBM)); | GE_CHK_RT_RET(rtMalloc(&ext_info_addr_dev_, aicpu_ext_handle_->GetExtInfoLen(), RT_MEMORY_HBM)); | ||||
GE_CHK_RT_RET(rtMemcpy(ext_info_addr_dev_, aicpu_ext_handle_->GetExtInfoLen(), | GE_CHK_RT_RET(rtMemcpy(ext_info_addr_dev_, aicpu_ext_handle_->GetExtInfoLen(), | ||||
aicpu_ext_handle_->GetExtInfo(), aicpu_ext_handle_->GetExtInfoLen(), | aicpu_ext_handle_->GetExtInfo(), aicpu_ext_handle_->GetExtInfoLen(), | ||||
@@ -770,6 +815,63 @@ Status AiCpuBaseTask::UpdateIoAddr(const vector<DataBuffer> &inputs, const vecto | |||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
Status AiCpuBaseTask::CheckDeviceSupportBlockingAicpuOpProcess(bool &is_support) { | |||||
int32_t device_id = 0; | |||||
auto rt_ret = rtGetDevice(&device_id); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetDevice failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetDevice] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
int32_t value = 0; | |||||
rt_ret = rtGetDeviceCapability(device_id, FEATURE_TYPE_BLOCKING_OPERATOR, RT_MODULE_TYPE_AICPU, &value); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtGetDeviceCapability failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][rtGetDeviceCapability] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
if (value != RT_AICPU_BLOCKING_OP_NOT_SUPPORT && value != RT_AICPU_BLOCKING_OP_SUPPORT) { | |||||
REPORT_INNER_ERROR("E19999", "Value should be %d or %d but %d", | |||||
RT_AICPU_BLOCKING_OP_NOT_SUPPORT, RT_AICPU_BLOCKING_OP_SUPPORT, value); | |||||
GELOGE(FAILED, "[Check][Value] Value should be %d or %d but %d", | |||||
RT_AICPU_BLOCKING_OP_NOT_SUPPORT, RT_AICPU_BLOCKING_OP_SUPPORT, value); | |||||
return FAILED; | |||||
} | |||||
is_support = (value == RT_AICPU_BLOCKING_OP_SUPPORT ? true : false); | |||||
return SUCCESS; | |||||
} | |||||
Status AiCpuBaseTask::DistributeWaitTaskForAicpuBlockingOp(rtStream_t stream) { | |||||
bool is_support = false; | |||||
if (CheckDeviceSupportBlockingAicpuOpProcess(is_support) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][CheckDeviceSupportBlockingAicpuOpProcess] Call CheckDeviceSupportBlockingAicpuOpProcess failed"); | |||||
return FAILED; | |||||
} | |||||
if (!is_support) { | |||||
GELOGD("Device not support blocking aicpu op process."); | |||||
return SUCCESS; | |||||
} | |||||
GELOGI("Distribute queue task begin"); | |||||
if (rt_event_ == nullptr) { | |||||
REPORT_INNER_ERROR("E19999", "rt_event_ is nullptr"); | |||||
GELOGE(FAILED, "[Check][rt_event_] rt_event_ is nullptr"); | |||||
return FAILED; | |||||
} | |||||
auto rt_ret = rtStreamWaitEvent(stream, rt_event_); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtStreamWaitEvent failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][RtApi] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
rt_ret = rtEventReset(rt_event_, stream); | |||||
if (rt_ret != RT_ERROR_NONE) { | |||||
REPORT_CALL_ERROR("E19999", "Call rtEventReset failed, ret:0x%X", rt_ret); | |||||
GELOGE(RT_FAILED, "[Call][RtApi] failed, ret:0x%X", rt_ret); | |||||
return RT_ERROR_TO_GE_STATUS(rt_ret); | |||||
} | |||||
return SUCCESS; | |||||
} | |||||
AiCpuTask::~AiCpuTask() { | AiCpuTask::~AiCpuTask() { | ||||
FreeHbm(args_); | FreeHbm(args_); | ||||
FreeHbm(io_addr_); | FreeHbm(io_addr_); | ||||
@@ -813,6 +915,14 @@ Status AiCpuTask::LaunchKernel(rtStream_t stream) { | |||||
GELOGI("[TASK_INFO] %lu/%s", kernel_id_, op_type_.c_str()); | GELOGI("[TASK_INFO] %lu/%s", kernel_id_, op_type_.c_str()); | ||||
GELOGD("Done launch kernel successfully. task = %s", this->op_type_.c_str()); | GELOGD("Done launch kernel successfully. task = %s", this->op_type_.c_str()); | ||||
if (is_blocking_aicpu_op_) { | |||||
if (DistributeWaitTaskForAicpuBlockingOp(stream) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][DistributeWaitTaskForAicpuBlockingOp] Call DistributeWaitTaskForAicpuBlockingOp failed"); | |||||
return FAILED; | |||||
} | |||||
} | |||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
@@ -1089,6 +1199,13 @@ Status AiCpuCCTask::LaunchKernel(rtStream_t stream) { | |||||
} | } | ||||
GELOGI("[TASK_INFO] %lu/%s", kernel_id_, op_type_.c_str()); | GELOGI("[TASK_INFO] %lu/%s", kernel_id_, op_type_.c_str()); | ||||
GELOGD("Invoke rtCpuKernelLaunch succeeded"); | GELOGD("Invoke rtCpuKernelLaunch succeeded"); | ||||
if (is_blocking_aicpu_op_) { | |||||
if (DistributeWaitTaskForAicpuBlockingOp(stream) != SUCCESS) { | |||||
GELOGE(FAILED, "[Call][DistributeWaitTaskForAicpuBlockingOp] Call DistributeWaitTaskForAicpuBlockingOp failed"); | |||||
return FAILED; | |||||
} | |||||
} | |||||
return SUCCESS; | return SUCCESS; | ||||
} | } | ||||
@@ -178,6 +178,10 @@ class AiCpuBaseTask : public OpTask { | |||||
rtStream_t stream); | rtStream_t stream); | ||||
Status UpdateOutputShape(vector<GeTensorDesc> &output_desc); | Status UpdateOutputShape(vector<GeTensorDesc> &output_desc); | ||||
Status UpdateShapeToOutputDesc(const GeShape &shape_new, GeTensorDesc &output_desc); | Status UpdateShapeToOutputDesc(const GeShape &shape_new, GeTensorDesc &output_desc); | ||||
// for blocking aicpu op | |||||
Status DistributeWaitTaskForAicpuBlockingOp(rtStream_t stream); | |||||
Status UpdateEventIdForBlockingAicpuOp(); | |||||
Status CheckDeviceSupportBlockingAicpuOpProcess(bool &is_support); | |||||
protected: | protected: | ||||
size_t num_inputs_ = 0; | size_t num_inputs_ = 0; | ||||
@@ -186,6 +190,9 @@ class AiCpuBaseTask : public OpTask { | |||||
std::unique_ptr<ge::hybrid::AicpuExtInfoHandler> aicpu_ext_handle_; | std::unique_ptr<ge::hybrid::AicpuExtInfoHandler> aicpu_ext_handle_; | ||||
void *ext_info_addr_dev_ = nullptr; | void *ext_info_addr_dev_ = nullptr; | ||||
vector<bool> input_is_const_; | vector<bool> input_is_const_; | ||||
// for blocking aicpu op | |||||
bool is_blocking_aicpu_op_ = false; | |||||
rtEvent_t rt_event_ = nullptr; | |||||
}; | }; | ||||
class AiCpuTask : public AiCpuBaseTask { | class AiCpuTask : public AiCpuBaseTask { | ||||
@@ -16,12 +16,94 @@ | |||||
#include <cce/dnn.h> | #include <cce/dnn.h> | ||||
#include <securec.h> | #include <securec.h> | ||||
#include "runtime_stub.h" | |||||
#include "runtime/rt.h" | |||||
#define ADD_STUB_RETURN_VALUE(FUNC, TYPE) std::vector<TYPE> g_Stub_##FUNC##_RETURN | |||||
#define GET_STUB_RETURN_VALUE(FUNC, TYPE, DEFAULT) ({ \ | |||||
TYPE result = DEFAULT; \ | |||||
if (!g_Stub_##FUNC##_RETURN.empty()) { \ | |||||
result = g_Stub_##FUNC##_RETURN.back(); \ | |||||
g_Stub_##FUNC##_RETURN.pop_back(); \ | |||||
} \ | |||||
result; \ | |||||
}) | |||||
#define DEL_STUB_RETURN_VALUE(FUNC, TYPE) \ | |||||
do { \ | |||||
extern std::vector<TYPE> g_Stub_##FUNC##_RETURN; \ | |||||
g_Stub_##FUNC##_RETURN.clear(); \ | |||||
} while (0) | |||||
#define ADD_STUB_OUTBOUND_VALUE(FUNC, TYPE, NAME) std::vector<TYPE> g_Stub_##FUNC##_OUT_##NAME | |||||
#define GET_STUB_OUTBOUND_VALUE(FUNC, TYPE, NAME, DEFAULT) ({ \ | |||||
TYPE value; \ | |||||
if (!g_Stub_##FUNC##_OUT_##NAME.empty()) { \ | |||||
value = g_Stub_##FUNC##_OUT_##NAME.back(); \ | |||||
g_Stub_##FUNC##_OUT_##NAME.pop_back(); \ | |||||
} else { \ | |||||
value = DEFAULT; \ | |||||
} \ | |||||
value; \ | |||||
}) | |||||
#define DEL_STUB_OUTBOUND_VALUE(FUNC, TYPE, NAME) \ | |||||
do { \ | |||||
extern std::vector<TYPE> g_Stub_##FUNC##_OUT_##NAME; \ | |||||
g_Stub_##FUNC##_OUT_##NAME.clear(); \ | |||||
} while (0) | |||||
#ifdef __cplusplus | #ifdef __cplusplus | ||||
extern "C" { | extern "C" { | ||||
#endif | #endif | ||||
#define EVENT_LENTH 10 | #define EVENT_LENTH 10 | ||||
void rtStubTearDown() { | |||||
DEL_STUB_RETURN_VALUE(rtGetDevice, rtError_t); | |||||
DEL_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t); | |||||
DEL_STUB_RETURN_VALUE(rtStreamWaitEvent, rtError_t); | |||||
DEL_STUB_RETURN_VALUE(rtEventReset, rtError_t); | |||||
DEL_STUB_RETURN_VALUE(rtEventCreate, rtError_t); | |||||
DEL_STUB_RETURN_VALUE(rtGetEventID, rtError_t); | |||||
} | |||||
ADD_STUB_RETURN_VALUE(rtGetDevice, rtError_t); | |||||
rtError_t rtGetDevice(int32_t *device) { | |||||
return GET_STUB_RETURN_VALUE(rtGetDevice, rtError_t, RT_ERROR_NONE); | |||||
} | |||||
ADD_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t); | |||||
ADD_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value); | |||||
rtError_t rtGetDeviceCapability(int32_t device, int32_t moduleType, int32_t featureType, int32_t *value) { | |||||
*value = GET_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_SUPPORT); | |||||
return GET_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
} | |||||
ADD_STUB_RETURN_VALUE(rtStreamWaitEvent, rtError_t); | |||||
rtError_t rtStreamWaitEvent(rtStream_t stream, rtEvent_t event) { | |||||
return GET_STUB_RETURN_VALUE(rtStreamWaitEvent, rtError_t, RT_ERROR_NONE); | |||||
} | |||||
ADD_STUB_RETURN_VALUE(rtEventReset, rtError_t); | |||||
rtError_t rtEventReset(rtEvent_t event, rtStream_t stream) { | |||||
return GET_STUB_RETURN_VALUE(rtEventReset, rtError_t, RT_ERROR_NONE); | |||||
} | |||||
ADD_STUB_RETURN_VALUE(rtEventCreate, rtError_t); | |||||
rtError_t rtEventCreate(rtEvent_t *event) { | |||||
*event = new int[EVENT_LENTH]; | |||||
return GET_STUB_RETURN_VALUE(rtEventCreate, rtError_t, RT_ERROR_NONE); | |||||
} | |||||
ADD_STUB_RETURN_VALUE(rtGetEventID, rtError_t); | |||||
rtError_t rtGetEventID(rtEvent_t event, uint32_t *event_id) { | |||||
*event_id = 0; | |||||
return GET_STUB_RETURN_VALUE(rtEventCreate, rtError_t, RT_ERROR_NONE); | |||||
} | |||||
rtError_t rtCtxSetCurrent(rtContext_t ctx) { return RT_ERROR_NONE; } | rtError_t rtCtxSetCurrent(rtContext_t ctx) { return RT_ERROR_NONE; } | ||||
rtError_t rtGetStreamId(rtStream_t stream, int32_t *stream_id) { | rtError_t rtGetStreamId(rtStream_t stream, int32_t *stream_id) { | ||||
@@ -42,11 +124,6 @@ rtError_t rtEventGetTimeStamp(uint64_t *time, rtEvent_t event) { | |||||
return RT_ERROR_NONE; | return RT_ERROR_NONE; | ||||
} | } | ||||
rtError_t rtEventCreate(rtEvent_t *event) { | |||||
*event = new int[EVENT_LENTH]; | |||||
return RT_ERROR_NONE; | |||||
} | |||||
rtError_t rtEventCreateWithFlag(rtEvent_t *event, uint32_t flag) { | rtError_t rtEventCreateWithFlag(rtEvent_t *event, uint32_t flag) { | ||||
return rtEventCreate(event); | return rtEventCreate(event); | ||||
} | } | ||||
@@ -112,8 +189,6 @@ rtError_t rtMemcpyAsync(void *dst, uint64_t dest_max, const void *src, uint64_t | |||||
return RT_ERROR_NONE; | return RT_ERROR_NONE; | ||||
} | } | ||||
rtError_t rtStreamWaitEvent(rtStream_t stream, rtEvent_t event) { return RT_ERROR_NONE; } | |||||
rtError_t rtSetTSDevice(uint32_t tsId) { | rtError_t rtSetTSDevice(uint32_t tsId) { | ||||
return RT_ERROR_NONE; | return RT_ERROR_NONE; | ||||
} | } | ||||
@@ -347,10 +422,6 @@ rtError_t rtStreamSwitchEx(void *ptr, rtCondition_t condition, void *value_ptr, | |||||
rtError_t rtStreamActive(rtStream_t active_stream, rtStream_t stream) { return RT_ERROR_NONE; } | rtError_t rtStreamActive(rtStream_t active_stream, rtStream_t stream) { return RT_ERROR_NONE; } | ||||
rtError_t rtEventReset(rtEvent_t event, rtStream_t stream) { return RT_ERROR_NONE; } | |||||
rtError_t rtGetDevice(int32_t *device) { return RT_ERROR_NONE; } | |||||
rtError_t rtDatadumpInfoLoad(const void *dump_info, uint32_t length) { return RT_ERROR_NONE; } | rtError_t rtDatadumpInfoLoad(const void *dump_info, uint32_t length) { return RT_ERROR_NONE; } | ||||
rtError_t rtKernelLaunchWithFlag(const void *stub_func, uint32_t block_dim, void *args, uint32_t args_size, | rtError_t rtKernelLaunchWithFlag(const void *stub_func, uint32_t block_dim, void *args, uint32_t args_size, | ||||
@@ -0,0 +1,70 @@ | |||||
/** | |||||
* Copyright 2021 Huawei Technologies Co., Ltd | |||||
* | |||||
* Licensed under the Apache License, Version 2.0 (the "License"); | |||||
* you may not use this file except in compliance with the License. | |||||
* You may obtain a copy of the License at | |||||
* | |||||
* http://www.apache.org/licenses/LICENSE-2.0 | |||||
* | |||||
* Unless required by applicable law or agreed to in writing, software | |||||
* distributed under the License is distributed on an "AS IS" BASIS, | |||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||||
* See the License for the specific language governing permissions and | |||||
* limitations under the License. | |||||
*/ | |||||
#ifndef __INC_LLT_RUNTIME_STUB_H | |||||
#define __INC_LLT_RUNTIME_STUB_H | |||||
#include <vector> | |||||
#ifdef __cplusplus | |||||
extern "C" { | |||||
#endif | |||||
void rtStubTearDown(); | |||||
#define RTS_STUB_SETUP() \ | |||||
do { \ | |||||
rtStubTearDown(); \ | |||||
} while (0) | |||||
#define RTS_STUB_TEARDOWN() \ | |||||
do { \ | |||||
rtStubTearDown(); \ | |||||
} while (0) | |||||
#define RTS_STUB_RETURN_VALUE(FUNC, TYPE, VALUE) \ | |||||
do { \ | |||||
g_Stub_##FUNC##_RETURN.emplace(g_Stub_##FUNC##_RETURN.begin(), VALUE); \ | |||||
} while (0) | |||||
#define RTS_STUB_OUTBOUND_VALUE(FUNC, TYPE, NAME, VALUE) \ | |||||
do { \ | |||||
g_Stub_##FUNC##_OUT_##NAME.emplace(g_Stub_##FUNC##_OUT_##NAME.begin(), VALUE); \ | |||||
} while (0) | |||||
#define RTS_STUB_RETURN_EXTERN(FUNC, TYPE) extern std::vector<TYPE> g_Stub_##FUNC##_RETURN; | |||||
#define RTS_STUB_OUTBOUND_EXTERN(FUNC, TYPE, NAME) extern std::vector<TYPE> g_Stub_##FUNC##_OUT_##NAME; | |||||
RTS_STUB_RETURN_EXTERN(rtGetDevice, rtError_t); | |||||
RTS_STUB_OUTBOUND_EXTERN(rtGetDevice, int32_t, device) | |||||
RTS_STUB_RETURN_EXTERN(rtGetDeviceCapability, rtError_t); | |||||
RTS_STUB_OUTBOUND_EXTERN(rtGetDeviceCapability, int32_t, value); | |||||
RTS_STUB_RETURN_EXTERN(rtStreamWaitEvent, rtError_t); | |||||
RTS_STUB_RETURN_EXTERN(rtEventReset, rtError_t); | |||||
RTS_STUB_RETURN_EXTERN(rtEventCreate, rtError_t); | |||||
RTS_STUB_OUTBOUND_EXTERN(rtEventCreate, rtEvent_t, event); | |||||
RTS_STUB_RETURN_EXTERN(rtGetEventID, rtError_t); | |||||
RTS_STUB_OUTBOUND_EXTERN(rtEventCreate, uint32_t, event_id); | |||||
#ifdef __cplusplus | |||||
} | |||||
#endif | |||||
#endif // __INC_LLT_RUNTIME_STUB_H |
@@ -935,6 +935,7 @@ target_link_libraries(ge_single_op PRIVATE | |||||
ascend_protobuf | ascend_protobuf | ||||
json | json | ||||
c_sec | c_sec | ||||
runtime_stub | |||||
) | ) | ||||
# ut binary | # ut binary | ||||
@@ -23,15 +23,20 @@ | |||||
#include "graph/load/model_manager/task_info/kernel_ex_task_info.h" | #include "graph/load/model_manager/task_info/kernel_ex_task_info.h" | ||||
#include "cce/aicpu_engine_struct.h" | #include "cce/aicpu_engine_struct.h" | ||||
#include "tests/depends/runtime/src/runtime_stub.h" | |||||
namespace ge { | namespace ge { | ||||
extern OpDescPtr CreateOpDesc(string name, string type); | extern OpDescPtr CreateOpDesc(string name, string type); | ||||
class UtestKernelExTaskInfo : public testing::Test { | class UtestKernelExTaskInfo : public testing::Test { | ||||
protected: | protected: | ||||
void SetUp() {} | |||||
void SetUp() { | |||||
RTS_STUB_SETUP(); | |||||
} | |||||
void TearDown() {} | |||||
void TearDown() { | |||||
RTS_STUB_TEARDOWN(); | |||||
} | |||||
}; | }; | ||||
// test kernel_ex_task_Release | // test kernel_ex_task_Release | ||||
@@ -209,4 +214,136 @@ TEST_F(UtestKernelExTaskInfo, parse_topic_type_failed_2) { | |||||
KernelExTaskInfo kernel_ex_task_info; | KernelExTaskInfo kernel_ex_task_info; | ||||
EXPECT_NE(kernel_ex_task_info.InitTaskExtInfo(ext_info, op_desc), SUCCESS); | EXPECT_NE(kernel_ex_task_info.InitTaskExtInfo(ext_info, op_desc), SUCCESS); | ||||
} | } | ||||
TEST_F(UtestKernelExTaskInfo, blocking_aicpu_op) { | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::TaskDef task_def; | |||||
domi::KernelExDef kernel_ex_def; | |||||
kernel_ex_def.set_kernel_ext_info(buf, len); | |||||
kernel_ex_def.set_kernel_ext_info_size(len); | |||||
domi::KernelExDef *kernel_ex_def_tmp = task_def.mutable_kernel_ex(); | |||||
*kernel_ex_def_tmp = kernel_ex_def; | |||||
const OpDescPtr op_desc = CreateOpDesc("deque", "Deque"); | |||||
ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true); | |||||
KernelExTaskInfo kernel_ex_task_info; | |||||
kernel_ex_task_info.op_desc_ = op_desc; | |||||
DavinciModel davinci_model(0, nullptr); | |||||
kernel_ex_task_info.davinci_model_ = &davinci_model; | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), SUCCESS); | |||||
EXPECT_EQ(kernel_ex_task_info.Distribute(), SUCCESS); | |||||
kernel_ex_task_info.op_desc_ = op_desc; | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), SUCCESS); | |||||
EXPECT_EQ(kernel_ex_task_info.Distribute(), SUCCESS); | |||||
} | |||||
TEST_F(UtestKernelExTaskInfo, blocking_aicpu_op_fail_01) { | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::TaskDef task_def; | |||||
domi::KernelExDef kernel_ex_def; | |||||
kernel_ex_def.set_kernel_ext_info(buf, len); | |||||
kernel_ex_def.set_kernel_ext_info_size(len); | |||||
domi::KernelExDef *kernel_ex_def_tmp = task_def.mutable_kernel_ex(); | |||||
*kernel_ex_def_tmp = kernel_ex_def; | |||||
const OpDescPtr op_desc = CreateOpDesc("deque", "Deque"); | |||||
KernelExTaskInfo kernel_ex_task_info; | |||||
kernel_ex_task_info.op_desc_ = op_desc; | |||||
DavinciModel davinci_model(0, nullptr); | |||||
kernel_ex_task_info.davinci_model_ = &davinci_model; | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), SUCCESS); | |||||
kernel_ex_task_info.is_blocking_aicpu_op_ = true; | |||||
EXPECT_EQ(kernel_ex_task_info.Distribute(), FAILED); | |||||
} | |||||
TEST_F(UtestKernelExTaskInfo, blocking_aicpu_op_fail_02) { | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::TaskDef task_def; | |||||
domi::KernelExDef kernel_ex_def; | |||||
kernel_ex_def.set_kernel_ext_info(buf, len); | |||||
kernel_ex_def.set_kernel_ext_info_size(len); | |||||
domi::KernelExDef *kernel_ex_def_tmp = task_def.mutable_kernel_ex(); | |||||
*kernel_ex_def_tmp = kernel_ex_def; | |||||
const OpDescPtr op_desc = CreateOpDesc("deque", "Deque"); | |||||
ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true); | |||||
KernelExTaskInfo kernel_ex_task_info; | |||||
kernel_ex_task_info.op_desc_ = op_desc; | |||||
DavinciModel davinci_model(0, nullptr); | |||||
kernel_ex_task_info.davinci_model_ = &davinci_model; | |||||
RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_SUPPORT + 1); | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_ex_task_info.Distribute(), FAILED); | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtStreamWaitEvent, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_ex_task_info.Distribute(), FAILED); | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtEventReset, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_ex_task_info.Distribute(), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
EXPECT_EQ(kernel_ex_task_info.InitTaskExtInfo(kernel_ex_def.kernel_ext_info(), op_desc), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
EXPECT_EQ(kernel_ex_task_info.Distribute(), SUCCESS); | |||||
} | |||||
} // namespace ge | } // namespace ge |
@@ -22,15 +22,20 @@ | |||||
#include "graph/load/model_manager/davinci_model.h" | #include "graph/load/model_manager/davinci_model.h" | ||||
#include "graph/load/model_manager/task_info/kernel_task_info.h" | #include "graph/load/model_manager/task_info/kernel_task_info.h" | ||||
#include "graph/load/model_manager/task_info/hccl_task_info.h" | #include "graph/load/model_manager/task_info/hccl_task_info.h" | ||||
#include "tests/depends/runtime/src/runtime_stub.h" | |||||
namespace ge { | namespace ge { | ||||
extern OpDescPtr CreateOpDesc(string name, string type); | extern OpDescPtr CreateOpDesc(string name, string type); | ||||
class UtestKernelTaskInfo : public testing::Test { | class UtestKernelTaskInfo : public testing::Test { | ||||
protected: | protected: | ||||
void SetUp() {} | |||||
void SetUp() { | |||||
RTS_STUB_SETUP(); | |||||
} | |||||
void TearDown() {} | |||||
void TearDown() { | |||||
RTS_STUB_TEARDOWN(); | |||||
} | |||||
}; | }; | ||||
// test KernelTaskInfo Init. | // test KernelTaskInfo Init. | ||||
@@ -1240,4 +1245,135 @@ TEST_F(UtestKernelTaskInfo, kernel_task_info_super_kernel_info) { | |||||
EXPECT_EQ(kernel_task_info.SKTFinalize(), SUCCESS); | EXPECT_EQ(kernel_task_info.SKTFinalize(), SUCCESS); | ||||
} | } | ||||
TEST_F(UtestKernelTaskInfo, blocking_aicpu_op) { | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::TaskDef task_def; | |||||
domi::KernelDef kernel_def; | |||||
kernel_def.set_kernel_ext_info(buf, len); | |||||
kernel_def.set_kernel_ext_info_size(len); | |||||
const OpDescPtr op_desc = CreateOpDesc("deque", "Deque"); | |||||
op_desc->SetId(0); | |||||
ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true); | |||||
DavinciModel davinci_model(0, nullptr); | |||||
davinci_model.op_list_.emplace(0, op_desc); | |||||
KernelTaskInfo kernel_task_info; | |||||
kernel_task_info.op_desc_ = op_desc; | |||||
kernel_task_info.davinci_model_ = &davinci_model; | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), SUCCESS); | |||||
EXPECT_EQ(kernel_task_info.Distribute(), SUCCESS); | |||||
kernel_task_info.op_desc_ = op_desc; | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), SUCCESS); | |||||
EXPECT_EQ(kernel_task_info.Distribute(), SUCCESS); | |||||
} | |||||
TEST_F(UtestKernelTaskInfo, blocking_aicpu_op_fail_01) { | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::KernelDef kernel_def; | |||||
kernel_def.set_kernel_ext_info(buf, len); | |||||
kernel_def.set_kernel_ext_info_size(len); | |||||
const OpDescPtr op_desc = CreateOpDesc("deque", "Deque"); | |||||
op_desc->SetId(0); | |||||
DavinciModel davinci_model(0, nullptr); | |||||
davinci_model.op_list_.emplace(0, op_desc); | |||||
KernelTaskInfo kernel_task_info; | |||||
kernel_task_info.davinci_model_ = &davinci_model; | |||||
kernel_task_info.op_desc_ = op_desc; | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), SUCCESS); | |||||
kernel_task_info.is_blocking_aicpu_op_ = true; | |||||
EXPECT_EQ(kernel_task_info.Distribute(), FAILED); | |||||
} | |||||
TEST_F(UtestKernelTaskInfo, blocking_aicpu_op_fail_02) { | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::KernelDef kernel_def; | |||||
kernel_def.set_kernel_ext_info(buf, len); | |||||
kernel_def.set_kernel_ext_info_size(len); | |||||
const OpDescPtr op_desc = CreateOpDesc("deque", "Deque"); | |||||
ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true); | |||||
op_desc->SetId(0); | |||||
DavinciModel davinci_model(0, nullptr); | |||||
davinci_model.op_list_.emplace(0, op_desc); | |||||
KernelTaskInfo kernel_task_info; | |||||
kernel_task_info.davinci_model_ = &davinci_model; | |||||
kernel_task_info.op_desc_ = op_desc; | |||||
RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_SUPPORT + 1); | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_task_info.Distribute(), FAILED); | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtStreamWaitEvent, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_task_info.Distribute(), FAILED); | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtEventReset, rtError_t, 0x78000001); | |||||
EXPECT_EQ(kernel_task_info.Distribute(), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
EXPECT_EQ(kernel_task_info.InitAicpuTaskExtInfo(kernel_def.kernel_ext_info()), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
EXPECT_EQ(kernel_task_info.Distribute(), SUCCESS); | |||||
} | |||||
} // namespace ge | } // namespace ge |
@@ -27,7 +27,7 @@ | |||||
#include "hybrid/node_executor/aicpu/aicpu_node_executor.h" | #include "hybrid/node_executor/aicpu/aicpu_node_executor.h" | ||||
#undef protected | #undef protected | ||||
#undef private | #undef private | ||||
#include "tests/depends/runtime/src/runtime_stub.h" | |||||
using namespace std; | using namespace std; | ||||
using namespace testing; | using namespace testing; | ||||
@@ -43,8 +43,12 @@ using namespace hybrid; | |||||
class UtestAicpuNodeExecutor : public testing::Test { | class UtestAicpuNodeExecutor : public testing::Test { | ||||
protected: | protected: | ||||
void SetUp() {} | |||||
void TearDown() {} | |||||
void SetUp() { | |||||
RTS_STUB_SETUP(); | |||||
} | |||||
void TearDown() { | |||||
RTS_STUB_TEARDOWN(); | |||||
} | |||||
}; | }; | ||||
static NodePtr CreateNode(ComputeGraphPtr graph, const string &name, const string &type, int in_num, int out_num) { | static NodePtr CreateNode(ComputeGraphPtr graph, const string &name, const string &type, int in_num, int out_num) { | ||||
@@ -164,5 +168,222 @@ TEST_F(UtestAicpuNodeExecutor, aicpu_tf_node_task) { | |||||
} | } | ||||
TEST_F(UtestAicpuNodeExecutor, aicpu_blocking_node_task) { | |||||
ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test"); | |||||
GeRootModelPtr ge_root_model = std::make_shared<GeRootModel>(graph); | |||||
ge_root_model->SetModelName("test_name"); | |||||
HybridModel hybrid_model(ge_root_model); | |||||
NodePtr node = CreateNode(graph, "deque", FRAMEWORK_OP_TYPE, 1, 1); | |||||
ge::AttrUtils::SetBool(node->GetOpDesc(), ATTR_NAME_IS_BLOCKING_OP, true); | |||||
std::unique_ptr<NodeItem> new_node; | |||||
ASSERT_EQ(NodeItem::Create(node, new_node), SUCCESS); | |||||
NodeItem *node_item = new_node.get(); | |||||
node_item->input_start = 0; | |||||
node_item->output_start = 0; | |||||
node_item->is_dynamic = true; | |||||
node_item->shape_inference_type = DEPEND_SHAPE_RANGE; | |||||
GraphItem graph_item; | |||||
graph_item.node_items_.emplace_back(node_item); | |||||
graph_item.total_inputs_ = 1; | |||||
graph_item.total_outputs_ = 1; | |||||
GraphExecutionContext graph_execution_context; | |||||
SubgraphContext subgraph_context(&graph_item, &graph_execution_context); | |||||
ASSERT_EQ(subgraph_context.Init(), SUCCESS); | |||||
graph_execution_context.callback_manager = std::unique_ptr<CallbackManager>(new CallbackManager()); | |||||
auto node_state = subgraph_context.GetOrCreateNodeState(node_item); | |||||
ASSERT_NE(node_state, nullptr); | |||||
uint64_t value_0 = 512; | |||||
TensorValue in_tensor0(&value_0, sizeof(value_0)); | |||||
subgraph_context.SetInput(*node_item, 0, in_tensor0); | |||||
TensorValue out_tensor0(&value_0, sizeof(value_0)); | |||||
subgraph_context.SetOutput(*node_item, 0, out_tensor0); | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::KernelDef kernel_def; | |||||
kernel_def.set_kernel_ext_info(buf, len); | |||||
kernel_def.set_kernel_ext_info_size(len); | |||||
domi::TaskDef task_def; | |||||
AicpuTaskStruct args; | |||||
args.head.length = sizeof(args); | |||||
args.head.ioAddrNum = 2; | |||||
kernel_def.set_args(reinterpret_cast<const char *>(&args), args.head.length); | |||||
kernel_def.set_args_size(args.head.length); | |||||
domi::KernelDef *kernel_def_tmp = task_def.mutable_kernel(); | |||||
*kernel_def_tmp = kernel_def; | |||||
AicpuNodeTask aicpu_node_task(node_item, task_def); | |||||
ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS); | |||||
ASSERT_EQ(aicpu_node_task.LaunchTask(*node_state->GetTaskContext()), SUCCESS); | |||||
node_item->shape_inference_type = DEPEND_COMPUTE; | |||||
domi::KernelExDef kernel_ex_def; | |||||
kernel_ex_def.set_kernel_ext_info(buf, len); | |||||
kernel_ex_def.set_kernel_ext_info_size(len); | |||||
kernel_ex_def.set_args(reinterpret_cast<const char *>(&args), args.head.length); | |||||
kernel_ex_def.set_args_size(args.head.length); | |||||
domi::KernelExDef *kernel_ex_def_tmp = task_def.mutable_kernel_ex(); | |||||
*kernel_ex_def_tmp = kernel_ex_def; | |||||
hybrid_model.task_defs_[node] = std::vector<domi::TaskDef>({task_def, task_def}); | |||||
AicpuTfNodeTask aicpu_tf_node_task(node_item, task_def); | |||||
ASSERT_EQ(aicpu_tf_node_task.Init(hybrid_model), SUCCESS); | |||||
ASSERT_EQ(aicpu_tf_node_task.LaunchTask(*node_state->GetTaskContext()), SUCCESS); | |||||
} | |||||
TEST_F(UtestAicpuNodeExecutor, aicpu_blocking_node_task_fail) { | |||||
ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test"); | |||||
GeRootModelPtr ge_root_model = std::make_shared<GeRootModel>(graph); | |||||
ge_root_model->SetModelName("test_name"); | |||||
HybridModel hybrid_model(ge_root_model); | |||||
NodePtr node = CreateNode(graph, "deque", FRAMEWORK_OP_TYPE, 1, 1); | |||||
ge::AttrUtils::SetBool(node->GetOpDesc(), ATTR_NAME_IS_BLOCKING_OP, true); | |||||
std::unique_ptr<NodeItem> new_node; | |||||
ASSERT_EQ(NodeItem::Create(node, new_node), SUCCESS); | |||||
NodeItem *node_item = new_node.get(); | |||||
node_item->input_start = 0; | |||||
node_item->output_start = 0; | |||||
node_item->is_dynamic = true; | |||||
node_item->shape_inference_type = DEPEND_SHAPE_RANGE; | |||||
GraphItem graph_item; | |||||
graph_item.node_items_.emplace_back(node_item); | |||||
graph_item.total_inputs_ = 1; | |||||
graph_item.total_outputs_ = 1; | |||||
GraphExecutionContext graph_execution_context; | |||||
SubgraphContext subgraph_context(&graph_item, &graph_execution_context); | |||||
ASSERT_EQ(subgraph_context.Init(), SUCCESS); | |||||
graph_execution_context.callback_manager = std::unique_ptr<CallbackManager>(new CallbackManager()); | |||||
auto node_state = subgraph_context.GetOrCreateNodeState(node_item); | |||||
ASSERT_NE(node_state, nullptr); | |||||
uint64_t value_0 = 512; | |||||
TensorValue in_tensor0(&value_0, sizeof(value_0)); | |||||
subgraph_context.SetInput(*node_item, 0, in_tensor0); | |||||
TensorValue out_tensor0(&value_0, sizeof(value_0)); | |||||
subgraph_context.SetOutput(*node_item, 0, out_tensor0); | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::KernelDef kernel_def; | |||||
kernel_def.set_kernel_ext_info(buf, len); | |||||
kernel_def.set_kernel_ext_info_size(len); | |||||
domi::TaskDef task_def; | |||||
AicpuTaskStruct args; | |||||
args.head.length = sizeof(args); | |||||
args.head.ioAddrNum = 2; | |||||
kernel_def.set_args(reinterpret_cast<const char *>(&args), args.head.length); | |||||
kernel_def.set_args_size(args.head.length); | |||||
domi::KernelDef *kernel_def_tmp = task_def.mutable_kernel(); | |||||
*kernel_def_tmp = kernel_def; | |||||
AicpuNodeTask aicpu_node_task(node_item, task_def); | |||||
RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_node_task.Init(hybrid_model), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_node_task.Init(hybrid_model), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_node_task.Init(hybrid_model), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_SUPPORT + 1); | |||||
ASSERT_EQ(aicpu_node_task.Init(hybrid_model), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_node_task.LaunchTask(*node_state->GetTaskContext()), FAILED); | |||||
ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtStreamWaitEvent, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_node_task.LaunchTask(*node_state->GetTaskContext()), FAILED); | |||||
ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtEventReset, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_node_task.LaunchTask(*node_state->GetTaskContext()), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
ASSERT_EQ(aicpu_node_task.Init(hybrid_model), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
ASSERT_EQ(aicpu_node_task.LaunchTask(*node_state->GetTaskContext()), SUCCESS); | |||||
node_item->shape_inference_type = DEPEND_COMPUTE; | |||||
domi::KernelExDef kernel_ex_def; | |||||
kernel_ex_def.set_kernel_ext_info(buf, len); | |||||
kernel_ex_def.set_kernel_ext_info_size(len); | |||||
kernel_ex_def.set_args(reinterpret_cast<const char *>(&args), args.head.length); | |||||
kernel_ex_def.set_args_size(args.head.length); | |||||
domi::KernelExDef *kernel_ex_def_tmp = task_def.mutable_kernel_ex(); | |||||
*kernel_ex_def_tmp = kernel_ex_def; | |||||
hybrid_model.task_defs_[node] = std::vector<domi::TaskDef>({task_def, task_def}); | |||||
AicpuTfNodeTask aicpu_tf_node_task(node_item, task_def); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_tf_node_task.Init(hybrid_model), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_tf_node_task.Init(hybrid_model), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_SUPPORT + 1); | |||||
ASSERT_EQ(aicpu_tf_node_task.Init(hybrid_model), FAILED); | |||||
ASSERT_EQ(aicpu_tf_node_task.Init(hybrid_model), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtStreamWaitEvent, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_tf_node_task.LaunchTask(*node_state->GetTaskContext()), FAILED); | |||||
ASSERT_EQ(aicpu_tf_node_task.Init(hybrid_model), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtEventReset, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_tf_node_task.LaunchTask(*node_state->GetTaskContext()), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
EXPECT_EQ(aicpu_tf_node_task.Init(hybrid_model), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
EXPECT_EQ(aicpu_tf_node_task.LaunchTask(*node_state->GetTaskContext()), SUCCESS); | |||||
} | |||||
} // namespace ge | } // namespace ge | ||||
@@ -19,6 +19,7 @@ | |||||
#include "graph/load/model_manager/model_utils.h" | #include "graph/load/model_manager/model_utils.h" | ||||
#include "graph/utils/graph_utils.h" | #include "graph/utils/graph_utils.h" | ||||
#include "hybrid/node_executor/aicpu/aicpu_ext_info.h" | |||||
#include "runtime/rt.h" | #include "runtime/rt.h" | ||||
#define protected public | #define protected public | ||||
@@ -30,6 +31,7 @@ | |||||
#include "external/register/op_tiling_registry.h" | #include "external/register/op_tiling_registry.h" | ||||
#undef private | #undef private | ||||
#undef protected | #undef protected | ||||
#include "tests/depends/runtime/src/runtime_stub.h" | |||||
using namespace std; | using namespace std; | ||||
using namespace testing; | using namespace testing; | ||||
@@ -38,9 +40,13 @@ using namespace optiling; | |||||
class UtestSingleOpTask : public testing::Test { | class UtestSingleOpTask : public testing::Test { | ||||
protected: | protected: | ||||
void SetUp() {} | |||||
void SetUp() { | |||||
RTS_STUB_SETUP(); | |||||
} | |||||
void TearDown() {} | |||||
void TearDown() { | |||||
RTS_STUB_TEARDOWN(); | |||||
} | |||||
}; | }; | ||||
TEST_F(UtestSingleOpTask, test_build_kernel_task) { | TEST_F(UtestSingleOpTask, test_build_kernel_task) { | ||||
@@ -237,3 +243,124 @@ TEST_F(UtestSingleOpTask, test_aicpu_task_update_io_addr) { | |||||
ASSERT_EQ(ret, PARAM_INVALID); | ASSERT_EQ(ret, PARAM_INVALID); | ||||
} | } | ||||
} | } | ||||
TEST_F(UtestSingleOpTask, test_blocking_aicpu_op_01) { | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::KernelDef kernel_def; | |||||
kernel_def.set_kernel_ext_info(buf, len); | |||||
kernel_def.set_kernel_ext_info_size(len); | |||||
auto op_desc = make_shared<OpDesc>("deque", "Deque"); | |||||
ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true); | |||||
AiCpuCCTask aicpu_task; | |||||
aicpu_task.SetOpDesc(op_desc); | |||||
rtStream_t stream; | |||||
ASSERT_EQ(rtStreamCreate(&stream, 0), RT_ERROR_NONE); | |||||
ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS); | |||||
ASSERT_EQ(aicpu_task.LaunchKernel(stream), SUCCESS); | |||||
} | |||||
TEST_F(UtestSingleOpTask, test_blocking_aicpu_op_02) { | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::KernelDef kernel_def; | |||||
kernel_def.set_kernel_ext_info(buf, len); | |||||
kernel_def.set_kernel_ext_info_size(len); | |||||
auto op_desc = make_shared<OpDesc>("deque", "Deque"); | |||||
ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true); | |||||
AiCpuTask aicpu_task; | |||||
aicpu_task.SetOpDesc(op_desc); | |||||
rtStream_t stream; | |||||
ASSERT_EQ(rtStreamCreate(&stream, 0), RT_ERROR_NONE); | |||||
ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS); | |||||
ASSERT_EQ(aicpu_task.LaunchKernel(stream), SUCCESS); | |||||
} | |||||
TEST_F(UtestSingleOpTask, test_blocking_aicpu_op_fail) { | |||||
int len = sizeof(hybrid::AicpuExtInfo) + sizeof(hybrid::AsyncWaitInfo); | |||||
vector<char> aicpu_ext_info(len, 0); | |||||
char *buf = aicpu_ext_info.data(); | |||||
int offset = 0; | |||||
hybrid::AicpuExtInfo *ext_info = reinterpret_cast<hybrid::AicpuExtInfo*>(buf + offset); | |||||
ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT; | |||||
ext_info->infoLen = sizeof(hybrid::AsyncWaitInfo); | |||||
offset += sizeof(hybrid::AicpuExtInfo); | |||||
hybrid::AsyncWaitInfo *async_wait_info = reinterpret_cast<hybrid::AsyncWaitInfo*>(buf + offset); | |||||
async_wait_info->waitType = 0; | |||||
async_wait_info->waitId = 0; | |||||
async_wait_info->timeOut = 0; | |||||
async_wait_info->reserved = 0; | |||||
domi::KernelDef kernel_def; | |||||
kernel_def.set_kernel_ext_info(buf, len); | |||||
kernel_def.set_kernel_ext_info_size(len); | |||||
auto op_desc = make_shared<OpDesc>("deque", "Deque"); | |||||
ge::AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true); | |||||
AiCpuTask aicpu_task; | |||||
aicpu_task.SetOpDesc(op_desc); | |||||
rtStream_t stream; | |||||
ASSERT_EQ(rtStreamCreate(&stream, 0), RT_ERROR_NONE); | |||||
ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS); | |||||
ASSERT_EQ(aicpu_task.LaunchKernel(stream), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_SUPPORT + 1); | |||||
ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDevice, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_task.LaunchKernel(stream), FAILED); | |||||
ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtStreamWaitEvent, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_task.LaunchKernel(stream), FAILED); | |||||
ASSERT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtEventReset, rtError_t, 0x78000001); | |||||
ASSERT_EQ(aicpu_task.LaunchKernel(stream), FAILED); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
EXPECT_EQ(aicpu_task.SetExtInfoAndType(kernel_def.kernel_ext_info(), 0), SUCCESS); | |||||
RTS_STUB_RETURN_VALUE(rtGetDeviceCapability, rtError_t, RT_ERROR_NONE); | |||||
RTS_STUB_OUTBOUND_VALUE(rtGetDeviceCapability, int32_t, value, RT_AICPU_BLOCKING_OP_NOT_SUPPORT); | |||||
EXPECT_EQ(aicpu_task.LaunchKernel(stream), SUCCESS); | |||||
} |
@@ -62,6 +62,7 @@ enum FWKTaskExtInfoType { | |||||
FWK_ADPT_EXT_SESSION_INFO, | FWK_ADPT_EXT_SESSION_INFO, | ||||
FWK_ADPT_EXT_BITMAP, | FWK_ADPT_EXT_BITMAP, | ||||
FWK_ADPT_EXT_TOPIC_TYPE, | FWK_ADPT_EXT_TOPIC_TYPE, | ||||
FWK_ADPT_EXT_ASYNCWAIT, | |||||
FWK_ADPT_EXT_INVALID | FWK_ADPT_EXT_INVALID | ||||
}; | }; | ||||
@@ -80,6 +81,12 @@ enum FWKExtUpdateAddrType { | |||||
FWK_ADPT_UPDATE_INPUT_OUTPUT | FWK_ADPT_UPDATE_INPUT_OUTPUT | ||||
}; | }; | ||||
enum FWKExtWaitType { | |||||
FWK_ADPT_WAIT_TYPE_NULL = 0, | |||||
FWK_ADPT_WAIT_TYPE_EVENT, | |||||
FWK_ADPT_WAIT_TYPE_INVALID | |||||
}; | |||||
#pragma pack(push, 1) | #pragma pack(push, 1) | ||||
// API Parameter Structure | // API Parameter Structure | ||||
struct StrFWKKernel { | struct StrFWKKernel { | ||||
@@ -133,6 +140,15 @@ struct ResultSummary { | |||||
uint64_t raw_data_size; // size of raw data | uint64_t raw_data_size; // size of raw data | ||||
}; | }; | ||||
#pragma pack(pop) | #pragma pack(pop) | ||||
#pragma pack(push, 1) | |||||
struct AsyncWait { | |||||
uint8_t waitType; // wait type, FWK_ADPT_WAIT_TYPE_EVENT: event wait | |||||
uint32_t waitId; // wait id, GE refresh | |||||
uint32_t timeOut; // reserved | |||||
uint64_t reserved; | |||||
}; | |||||
#pragma pack(pop) | |||||
} // end namespace FWKAdapter | } // end namespace FWKAdapter | ||||
} // namespace aicpu | } // namespace aicpu | ||||
@@ -52,6 +52,14 @@ typedef enum tagRtAicpuScheType { | |||||
SCHEDULE_HARDWARE, /* HWTS Schedule */ | SCHEDULE_HARDWARE, /* HWTS Schedule */ | ||||
} rtAicpuScheType; | } rtAicpuScheType; | ||||
typedef enum tagRtDeviceCapabilityType { | |||||
RT_SCHEDULE_SOFTWARE = 0, // SoftWare Schedule | |||||
RT_SCHEDULE_SOFTWARE_OPT, | |||||
RT_SCHEDULE_HARDWARE, // HWTS Schedule | |||||
RT_AICPU_BLOCKING_OP_NOT_SUPPORT, | |||||
RT_AICPU_BLOCKING_OP_SUPPORT, // 1910/1980/1951 ts support AICPU blocking operation | |||||
} rtDeviceCapabilityType; | |||||
typedef enum tagRtVersion { | typedef enum tagRtVersion { | ||||
VER_BEGIN = 0, | VER_BEGIN = 0, | ||||
VER_NA = VER_BEGIN, | VER_NA = VER_BEGIN, | ||||
@@ -65,6 +65,7 @@ typedef enum tagRtFeatureType { | |||||
typedef enum tagRtDeviceFeatureType { | typedef enum tagRtDeviceFeatureType { | ||||
FEATURE_TYPE_SCHE, | FEATURE_TYPE_SCHE, | ||||
FEATURE_TYPE_BLOCKING_OPERATOR, | |||||
FEATURE_TYPE_END, | FEATURE_TYPE_END, | ||||
} rtDeviceFeatureType_t; | } rtDeviceFeatureType_t; | ||||
@@ -78,6 +79,17 @@ typedef enum tagMemoryInfo { | |||||
MEMORY_INFO_RSV | MEMORY_INFO_RSV | ||||
} rtMemoryInfo_t; | } rtMemoryInfo_t; | ||||
typedef enum tagRtDeviceModuleType { | |||||
RT_MODULE_TYPE_SYSTEM = 0, | |||||
RT_MODULE_TYPE_AICPU, | |||||
RT_MODULE_TYPE_CCPU, | |||||
RT_MODULE_TYPE_DCPU, | |||||
RT_MODULE_TYPE_AICORE, | |||||
RT_MODULE_TYPE_TSCPU, | |||||
RT_MODULE_TYPE_PCIE, | |||||
RT_MODULE_TYPE_VECTOR_CORE | |||||
} tagRtDeviceModuleType_t; | |||||
/** | /** | ||||
* @ingroup dvrt_dev | * @ingroup dvrt_dev | ||||
* @brief get total device number. | * @brief get total device number. | ||||