m53297601
/
graphengine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ge ut 5

Browse Source
pull/464/head
t00456437 4 years ago
parent 8ad52ac684
commit 70077261cd
9 changed files with 122 additions and 45 deletions
Show Stats Download Patch File Download Diff File

8
tests/depends/runtime/src/runtime_stub.cc
Unescape View File

@ -221,8 +221,9 @@ rtError_t rtCpuKernelLaunch(const void *so_name, const void *kernel_name, uint32
return RT_ERROR_NONE;
}
rtError_t rtModelGetTaskId(void *handle, uint32_t *task_id) {
rtError_t rtModelGetTaskId(void *handle, uint32_t *task_id, uint32_t *stream_id) {
*task_id = 0;
*stream_id = 0;
return RT_ERROR_NONE;
}
rtError_t rtEndGraph(rtModel_t model, rtStream_t stream) { return RT_ERROR_NONE; }
@ -378,3 +379,8 @@ rtError_t rtGetMaxStreamAndTask(uint32_t streamType, uint32_t *maxStrCount, uint
{
return RT_ERROR_NONE;
}
rtError_t rtModelExit(rtModel_t model, rtStream_t stream)
{
return RT_ERROR_NONE;
}

28
tests/ut/ge/CMakeLists.txt
Unescape View File

@ -301,8 +301,13 @@ set(COMMON_SRC_FILES
"${GE_CODE_DIR}/ge/graph/common/local_context.cc"
"${GE_CODE_DIR}/ge/graph/manager/graph_caching_allocator.cc"
"${GE_CODE_DIR}/ge/graph/manager/rdma_pool_allocator.cc"
"${GE_CODE_DIR}/ge/common/dump/dump_op.cc"
"${GE_CODE_DIR}/ge/hybrid/node_executor/aicpu/aicpu_ext_info.cc"
"${GE_CODE_DIR}/ge/common/ge/datatype_util.cc"
"${GE_CODE_DIR}/metadef/register/ops_kernel_builder_registry.cc"
"${GE_CODE_DIR}/metadef/register/op_tiling.cpp"
"${GE_CODE_DIR}/metadef/graph/utils/tuning_utils.cc"
"${GE_CODE_DIR}/metadef/register/op_tiling_registry.cpp"
)
set(COMMON_FORMAT_SRC_FILES
@ -537,6 +542,8 @@ set(SINGLE_OP_SRC_FILES
"${GE_CODE_DIR}/ge/single_op/single_op_model.cc"
"${GE_CODE_DIR}/ge/single_op/stream_resource.cc"
"${GE_CODE_DIR}/ge/single_op/single_op_manager.cc"
"${GE_CODE_DIR}/ge/single_op/task/aicpu_task_builder.cc"
"${GE_CODE_DIR}/ge/single_op/task/aicpu_kernel_task_builder.cc"
)
# test files
@ -547,15 +554,15 @@ set(COMMON_TEST_FILES
set(DISTINCT_GRAPH_LOAD_TEST_FILES
"graph/load/data_dumper_unittest.cc"
"graph/load/new_model_manager_data_inputer_unittest.cc"
"graph/load/new_model_manager_davinci_model_unittest.cc"
"graph/load/new_model_manager_model_manager_unittest.cc"
"graph/load/new_model_manager_task_build_unittest.cc"
#"graph/load/new_model_manager_data_inputer_unittest.cc"
#"graph/load/new_model_manager_davinci_model_unittest.cc"
#"graph/load/new_model_manager_model_manager_unittest.cc"
#"graph/load/new_model_manager_task_build_unittest.cc"
"graph/load/end_graph_task_unittest.cc"
"graph/load/new_model_manager_event_manager_unittest.cc"
"graph/load/output_net_output_unittest.cc"
#"graph/load/output_net_output_unittest.cc"
"graph/load/tbe_handle_store_unittest.cc"
"graph/graph_load_unittest.cc"
#"graph/graph_load_unittest.cc"
"graph/ge_executor_unittest.cc"
)
@ -880,11 +887,16 @@ add_executable(ut_libge_distinct_load_utest
${SINGLE_OP_TEST_FILES}
${PROFILING_MNG_TEST_FILES}
)
target_compile_definitions(ut_libge_distinct_load_utest PRIVATE
google=ascend_private
)
target_link_libraries(ut_libge_distinct_load_utest
${COMMON_SHARED_LIBRARIES}
$<BUILD_INTERFACE:intf_pub>
ge_execute_common ge_ut_common ge_ut_common_format ge_pass_common ge_load_common
ge_execute_common ge_ut_common_format ge_pass_common ge_load_common
ge_single_op ge_prepare_common
ge_optimize_common ge_build_common ge_partition_common
ge_optimize_common ge_build_common ge_partition_common ge_ut_common
gtest gtest_main ascend_protobuf json c_sec -lrt -ldl -lpthread
)

4
tests/ut/ge/graph/load/data_dumper_unittest.cc
Unescape View File

@ -46,7 +46,7 @@ TEST_F(UtestDataDumper, LoadDumpInfo_no_output_addrs_fail) {
data_dumper.SetModelId(2333);
std::shared_ptr<OpDesc> op_desc_1(new OpDesc());
op_desc_1->AddOutputDesc("test", GeTensorDesc());
data_dumper.SaveDumpTask(0, op_desc_1, 0);
data_dumper.SaveDumpTask(0, 0, op_desc_1, 0);
string dump_mode = "output";
data_dumper.dump_properties_.SetDumpMode(dump_mode);
Status ret = data_dumper.LoadDumpInfo();
@ -54,7 +54,7 @@ TEST_F(UtestDataDumper, LoadDumpInfo_no_output_addrs_fail) {
}
TEST_F(UtestDataDumper, UnloadDumpInfo_success) {
RuntimeParam rts_param
RuntimeParam rts_param;
DataDumper data_dumper(rts_param);
data_dumper.SetModelName("test");
data_dumper.SetModelId(2333);

1
tests/ut/ge/graph/load/new_model_manager_davinci_model_unittest.cc
Unescape View File

@ -37,7 +37,6 @@
#include "graph/load/new_model_manager/task_info/stream_switch_task_info.h"
#include "graph/load/new_model_manager/task_info/profiler_trace_task_info.h"
#include "graph/load/new_model_manager/task_info/memcpy_async_task_info.h"
#include "graph/load/new_model_manager/task_info/label_goto_task_info.h"
#include "graph/load/new_model_manager/task_info/label_set_task_info.h"
#include "graph/load/new_model_manager/task_info/kernel_ex_task_info.h"
#include "graph/load/new_model_manager/task_info/kernel_task_info.h"

49
tests/ut/ge/graph/load/new_op_test_utils.h
Unescape View File

@ -134,6 +134,55 @@ class OmeTestOpUtils {
}
}
static Status TransModelToGeModel(const ModelPtr &model, GeModelPtr &ge_model) {
if (model == nullptr) {
GELOGE(FAILED, "Model is null");
return FAILED;
}
ge_model = ge::MakeShared<ge::GeModel>();
GE_CHECK_NOTNULL(ge_model);
ge_model->SetGraph(model->GetGraph());
ge_model->SetName(model->GetName());
ge_model->SetVersion(model->GetVersion());
ge_model->SetPlatformVersion(model->GetPlatformVersion());
ge_model->SetAttr(model->MutableAttrMap());
auto compute_graph = ge::GraphUtils::GetComputeGraph(model->GetGraph());
ge::Buffer weight;
(void)ge::AttrUtils::GetZeroCopyBytes(compute_graph, ge::ATTR_NAME_WEIGHTS_DATA, weight);
ge_model->SetWeight(weight);
if (model->HasAttr(MODEL_ATTR_TASKS)) {
ge::Buffer task_buffer;
GE_CHK_BOOL_RET_STATUS(ge::AttrUtils::GetZeroCopyBytes(model, MODEL_ATTR_TASKS, task_buffer), FAILED,
"Get bytes failed.");
std::shared_ptr<ModelTaskDef> task = ge::MakeShared<ModelTaskDef>();
GE_CHECK_NOTNULL(task);
GE_IF_BOOL_EXEC(task_buffer.GetData() == nullptr, GELOGE(FAILED, "Get data fail"); return FAILED);
GE_IF_BOOL_EXEC(task_buffer.GetSize() == 0, GELOGE(FAILED, "Get size fail"); return FAILED);
GE_CHK_BOOL_EXEC(ReadProtoFromArray(task_buffer.GetData(), static_cast<int>(task_buffer.GetSize()), task.get()),
return INTERNAL_ERROR, "ReadProtoFromArray failed.");
ge_model->SetModelTaskDef(task);
}
TBEKernelStore kernel_store;
if (compute_graph != nullptr && compute_graph->GetDirectNodesSize() != 0) {
for (const ge::NodePtr &n : compute_graph->GetDirectNode()) {
auto node_op_desc = n->GetOpDesc();
GE_IF_BOOL_EXEC(node_op_desc == nullptr, continue);
TBEKernelPtr tbe_kernel = node_op_desc->TryGetExtAttr(ge::OP_EXTATTR_NAME_TBE_KERNEL, TBEKernelPtr());
GE_IF_BOOL_EXEC(tbe_kernel == nullptr, continue);
kernel_store.AddTBEKernel(tbe_kernel);
GELOGI("Add tbe kernel bin %s", tbe_kernel->GetName().c_str());
}
}
if (!kernel_store.Build()) {
GELOGE(FAILED, "TBE Kernels store build failed!");
return FAILED;
}
ge_model->SetTBEKernelStore(kernel_store);
return SUCCESS;
}
static void LoadStandardModelDataLocal(ge::ModelData &data) {
static const std::string STANDARD_MODEL_DATA_PATH =
"llt/framework/domi/ut/ome/test/data/standard_partition_model.txt";

2
tests/ut/ge/graph/load/output_net_output_unittest.cc
Unescape View File

@ -24,9 +24,7 @@
#include "common/debug/memory_dumper.h"
#include "common/op/ge_op_utils.h"
#include "graph/load/new_model_manager/davinci_model.h"
#include "graph/load/new_model_manager/model_output.h"
#include "graph/load/new_model_manager/model_utils.h"
#include "graph/load/output/output.h"
#include "graph/manager/graph_var_manager.h"
#include "new_op_test_utils.h"
#include "proto/om.pb.h"

11
tests/ut/ge/single_op/single_op_manager_unittest.cc
Unescape View File

@ -38,10 +38,9 @@ class UtestSingleOpManager : public testing::Test {
};
TEST_F(UtestSingleOpManager, test_get_resource) {
uintptr_t resource_id = 0x1;
rtStream_t stream = (rtStream_t)0x01;
auto &instance = SingleOpManager::GetInstance();
ASSERT_EQ(instance.TryGetResource(resource_id), nullptr);
ASSERT_NE(instance.GetResource(resource_id), nullptr);
ASSERT_NE(instance.GetResource(0x01, stream), nullptr);
}
TEST_F(UtestSingleOpManager, test_get_op_from_model) {
@ -56,7 +55,7 @@ TEST_F(UtestSingleOpManager, test_get_op_from_model) {
model_data.model_len = model_str.size();
ASSERT_EQ(instance.GetOpFromModel("model", model_data, stream, &single_op), FAILED);
ASSERT_EQ(instance.GetResource(resource_id)->GetOperator(model_data.model_data), nullptr);
ASSERT_EQ(instance.GetResource(resource_id, stream)->GetOperator(model_data.model_data), nullptr);
}
TEST_F(UtestSingleOpManager, test_relesase_resource) {
@ -64,7 +63,7 @@ TEST_F(UtestSingleOpManager, test_relesase_resource) {
auto &instance = SingleOpManager::GetInstance();
ASSERT_EQ(instance.ReleaseResource(stream), SUCCESS);
instance.GetResource(0x99);
instance.GetResource(0x99, stream);
ASSERT_EQ(instance.ReleaseResource(stream), SUCCESS);
}
@ -92,4 +91,4 @@ TEST_F(UtestSingleOpManager, get_resource_failed) {
auto &instance = SingleOpManager::GetInstance();
ASSERT_EQ(instance.GetOpFromModel("model", model_data, stream, &single_op), FAILED);
}
}

38
tests/ut/ge/single_op/single_op_model_unittest.cc
Unescape View File

@ -97,7 +97,9 @@ TEST_F(UtestSingleOpModel, test_set_inputs_and_outputs) {
model.output_offset_list_.push_back(0);
model.output_sizes_.push_back(16);
SingleOp single_op;
std::mutex stream_mu_;
rtStream_t stream_ = nullptr;
SingleOp single_op(&stream_mu_, stream_);
ASSERT_EQ(model.SetInputsAndOutputs(single_op), SUCCESS);
}
@ -111,25 +113,29 @@ TEST_F(UtestSingleOpModel, test_build_kernel_task) {
model.output_offset_list_.push_back(0);
model.output_sizes_.push_back(16);
auto graph = make_shared<ComputeGraph>("graph");
auto op_desc = make_shared<OpDesc>("AddN", "AddN");
vector<int64_t> shape{16, 16};
GeShape ge_shape(shape);
GeTensorDesc desc(ge_shape);
op_desc->AddInputDesc(desc);
op_desc->AddOutputDesc(desc);
auto node = graph->AddNode(op_desc);
std::mutex stream_mu_;
rtStream_t stream_ = nullptr;
SingleOp single_op(&stream_mu_, stream_);
SingleOp single_op;
domi::KernelDef kernel_def;
kernel_def.mutable_context()->set_kernel_type(cce::ccKernelType::CCE_AI_CORE);
OpTask *task = nullptr;
ASSERT_EQ(model.BuildKernelTask(kernel_def, single_op, &task), UNSUPPORTED);
kernel_def.mutable_context()->set_kernel_type(cce::ccKernelType::TE);
TbeOpTask *task = nullptr;
ASSERT_EQ(model.BuildKernelTask(kernel_def, &task), UNSUPPORTED);
kernel_def.mutable_context()->set_kernel_type(cce::ccKernelType::TE);
ASSERT_EQ(model.BuildKernelTask(kernel_def, single_op, &task), INTERNAL_ERROR);
ASSERT_EQ(model.BuildKernelTask(kernel_def, &task), INTERNAL_ERROR);
model.op_list_[0] = op_desc;
model.op_list_[0] = node;
ASSERT_EQ(model.BuildKernelTask(kernel_def, single_op, &task), PARAM_INVALID);
ASSERT_EQ(model.BuildKernelTask(kernel_def, &task), PARAM_INVALID);
ASSERT_EQ(task, nullptr);
delete task;
}
@ -145,18 +151,22 @@ TEST_F(UtestSingleOpModel, test_parse_arg_table) {
SingleOpModel op_model("model", model_data_str.c_str(), model_data_str.size());
TbeOpTask task;
SingleOp op;
OpDescPtr op_desc;
std::mutex stream_mu_;
rtStream_t stream_ = nullptr;
SingleOp op(&stream_mu_, stream_);
op.arg_table_.resize(2);
auto *args = new uintptr_t[2];
args[0] = 0x100000;
args[1] = 0x200000;
task.SetKernelArgs(args, 16, 1);
auto args = std::unique_ptr<uint8_t[]>(new uint8_t[sizeof(uintptr_t) * 2]);
auto *arg_base = (uintptr_t*)args.get();
arg_base[0] = 0x100000;
arg_base[1] = 0x200000;
task.SetKernelArgs(std::move(args), 16, 1, op_desc);
op_model.model_params_.addr_mapping_[0x100000] = 1;
op_model.ParseArgTable(&task, op);
ASSERT_EQ(op.arg_table_[0].size(), 0);
ASSERT_EQ(op.arg_table_[1].size(), 1);
ASSERT_EQ(op.arg_table_[1].front(), &args[0]);
ASSERT_EQ(op.arg_table_[1].front(), &arg_base[0]);
}

26
tests/ut/ge/single_op/stream_resource_unittest.cc
Unescape View File

@ -38,8 +38,9 @@ class UtestStreamResource : public testing::Test {
rtStream_t stream;
};
/*
TEST_F(UtestStreamResource, test_cache_op) {
StreamResource res;
StreamResource res((uintptr_t)1);
auto *op = new SingleOp();
string stub_name = "stubFunc";
const void *key = stub_name.c_str();
@ -47,31 +48,34 @@ TEST_F(UtestStreamResource, test_cache_op) {
res.CacheOperator(key, op);
ASSERT_NE(res.GetOperator(key), nullptr);
}
*/
TEST_F(UtestStreamResource, test_malloc_memory) {
StreamResource res;
ASSERT_NE(res.MallocMemory(100), nullptr);
ASSERT_NE(res.MallocMemory(100), nullptr);
ASSERT_NE(res.MallocMemory(100), nullptr);
StreamResource res((uintptr_t)1);
string purpose("test");
ASSERT_NE(res.MallocMemory(purpose, 100), nullptr);
ASSERT_NE(res.MallocMemory(purpose, 100), nullptr);
ASSERT_NE(res.MallocMemory(purpose, 100), nullptr);
}
TEST_F(UtestStreamResource, test_do_malloc_memory) {
size_t max_allocated = 0;
vector<uint8_t *> allocated;
string purpose("test");
uint8_t *ret = StreamResource::DoMallocMemory(100, max_allocated, allocated);
StreamResource res((uintptr_t)1);
uint8_t *ret = res.DoMallocMemory(purpose, 100, max_allocated, allocated);
ASSERT_EQ(allocated.size(), 1);
ASSERT_NE(allocated.back(), nullptr);
ASSERT_EQ(max_allocated, 100);
StreamResource::DoMallocMemory(50, max_allocated, allocated);
StreamResource::DoMallocMemory(99, max_allocated, allocated);
StreamResource::DoMallocMemory(100, max_allocated, allocated);
res.DoMallocMemory(purpose, 50, max_allocated, allocated);
res.DoMallocMemory(purpose, 99, max_allocated, allocated);
res.DoMallocMemory(purpose, 100, max_allocated, allocated);
ASSERT_EQ(allocated.size(), 1);
ASSERT_EQ(max_allocated, 100);
StreamResource::DoMallocMemory(101, max_allocated, allocated);
res.DoMallocMemory(purpose, 101, max_allocated, allocated);
ASSERT_EQ(allocated.size(), 2);
ASSERT_EQ(max_allocated, 101);

Write Preview
Loading…
Cancel
Save