Huawei_Technology
/
MindSpore-GraphEngine
Not watched
1
0
Fork 0
Code
Releases 10 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
Browse Source

Add UT

pull/826/head
zhangxiaokun 5 years ago
parent
72c8720a87
commit
68f3736441
4 changed files with 344 additions and 9 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +4
    -2
      ge/graph/load/new_model_manager/davinci_model.cc
  2. +1
    -1
      ge/graph/load/new_model_manager/davinci_model.h
  3. +0
    -1
      ge/graph/load/new_model_manager/davinci_model_parser.cc
  4. +339
    -5
      tests/ut/ge/graph/load/davinci_model_unittest.cc

+ 4
- 2
ge/graph/load/new_model_manager/davinci_model.cc View File

@@ -3965,7 +3965,8 @@ Status DavinciModel::InitOrigInputInfo(uint32_t index, const OpDescPtr &op_desc)
GELOGI("GetOrigInputInfo: origin input str: %s", input.c_str());
std::vector<std::string> infos = ge::StringUtils::Split(input, ':');
if (infos.size() != kAippInfoNum) {
GELOGW("origin input str is invalid.");
GELOGE(ACL_ERROR_GE_AIPP_MODE_INVALID, "origin input str is invalid[%zu, %u].", infos.size(), kAippInfoNum);
return ACL_ERROR_GE_AIPP_MODE_INVALID;
}

OriginInputInfo input_info;
@@ -4000,7 +4001,8 @@ void DavinciModel::ParseAIPPInfo(std::string in_out_info, InputOutputDims &dims_
GELOGI("ParseAIPPInfo: origin str: %s", in_out_info.c_str());
std::vector<std::string> infos = ge::StringUtils::Split(in_out_info, ':');
if (infos.size() != kAippInfoNum) {
GELOGW("origin input str is invalid.");
GELOGE(ACL_ERROR_GE_AIPP_MODE_INVALID, "origin input str is invalid[%zu, %u].", infos.size(), kAippInfoNum);
return;
}
dims_info.name = infos[kAippInfoTensorName];
dims_info.size = std::strtol(infos[kAippInfoTensorSize].c_str(), nullptr, kDecimal);


+ 1
- 1
ge/graph/load/new_model_manager/davinci_model.h View File

@@ -319,7 +319,7 @@ class DavinciModel {
Status GetInputOutputDescInfo(vector<InputOutputDescInfo> &input_desc, vector<InputOutputDescInfo> &output_desc);

Status GetInputOutputDescInfo(vector<InputOutputDescInfo> &input_desc, vector<InputOutputDescInfo> &output_desc,
vector<uint32_t> &inputFormats, vector<uint32_t> &output_formats);
vector<uint32_t> &input_formats, vector<uint32_t> &output_formats);

///
/// @ingroup ge


+ 0
- 1
ge/graph/load/new_model_manager/davinci_model_parser.cc View File

@@ -17,7 +17,6 @@
#include "graph/load/new_model_manager/davinci_model_parser.h"

namespace ge {

DavinciModelParser::DavinciModelParser() {}

DavinciModelParser::~DavinciModelParser() {}


+ 339
- 5
tests/ut/ge/graph/load/davinci_model_unittest.cc View File

@@ -121,13 +121,14 @@ TEST_F(UtestDavinciModel, init_data_op) {
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

OpDescPtr op_input = CreateOpDesc("data", DATA);
GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_input = CreateOpDesc("data", DATA);
op_input->AddInputDesc(tensor);
op_input->AddOutputDesc(tensor);
op_input->SetInputOffset({1024});
op_input->SetOutputOffset({5120});
op_input->SetOutputOffset({1024});
NodePtr node_input = graph->AddNode(op_input);

OpDescPtr op_output = CreateOpDesc("output", NETOUTPUT);
@@ -150,12 +151,14 @@ TEST_F(UtestDavinciModel, init_data_op_subgraph) {
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

OpDescPtr op_input = CreateOpDesc("data", DATA);
GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_input = CreateOpDesc("data", DATA);
op_input->AddInputDesc(tensor);
op_input->AddOutputDesc(tensor);
op_input->SetInputOffset({1024});
op_input->SetOutputOffset({5120});
op_input->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_input);

uint32_t data_op_index = 0;
@@ -174,8 +177,10 @@ TEST_F(UtestDavinciModel, init_netoutput_op_subgraph) {
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

OpDescPtr op_output = CreateOpDesc("output", NETOUTPUT);
GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_output = CreateOpDesc("output", NETOUTPUT);
op_output->AddInputDesc(tensor);
op_output->SetInputOffset({1024});
op_output->SetSrcName( { "data" } );
@@ -282,4 +287,333 @@ TEST_F(UtestDavinciModel, init_unknown) {
const vector<void *> outputs = { &virtual_addr };
EXPECT_EQ(model.UpdateKnownNodeArgs(inputs, outputs), SUCCESS);
}

TEST_F(UtestDavinciModel, init_data_aipp_info) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc);

GeAttrValue::NAMED_ATTRS aipp_attr;
aipp_attr.SetAttr("aipp_mode", GeAttrValue::CreateFrom<GeAttrValue::INT>(domi::AippOpParams::dynamic));
aipp_attr.SetAttr("related_input_rank", GeAttrValue::CreateFrom<GeAttrValue::INT>(0));
aipp_attr.SetAttr("max_src_image_size", GeAttrValue::CreateFrom<GeAttrValue::INT>(2048));
aipp_attr.SetAttr("support_rotation", GeAttrValue::CreateFrom<GeAttrValue::INT>(1));
EXPECT_TRUE(AttrUtils::SetNamedAttrs(op_desc, ATTR_NAME_AIPP, aipp_attr));

AippConfigInfo aipp_info;
EXPECT_EQ(model.GetAIPPInfo(0, aipp_info), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), SUCCESS);
EXPECT_EQ(model.GetAIPPInfo(0, aipp_info), SUCCESS);
EXPECT_EQ(aipp_info.aipp_mode, domi::AippOpParams::dynamic);

EXPECT_EQ(model.input_addrs_list_.size(), 1);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 1);
}

TEST_F(UtestDavinciModel, init_data_aipp_static) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc);

AttrUtils::SetStr(op_desc, ATTR_DATA_RELATED_AIPP_MODE, "static_aipp");

InputAippType aipp_type;
size_t aipp_index = 0;
EXPECT_EQ(model.GetAippType(0, aipp_type, aipp_index), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), SUCCESS);
EXPECT_EQ(model.GetAippType(0, aipp_type, aipp_index), SUCCESS);
EXPECT_EQ(aipp_type, DATA_WITH_STATIC_AIPP);
EXPECT_EQ(aipp_index, 0xFFFFFFFFu);

EXPECT_EQ(model.input_addrs_list_.size(), 1);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 1);
}

TEST_F(UtestDavinciModel, init_data_aipp_dynamic) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc); // op_index 0
AttrUtils::SetStr(op_desc, ATTR_DATA_RELATED_AIPP_MODE, "dynamic_aipp");
AttrUtils::SetStr(op_desc, ATTR_DATA_AIPP_DATA_NAME_MAP, "releated_aipp");

InputAippType aipp_type;
size_t aipp_index = 0;
EXPECT_EQ(model.GetAippType(0, aipp_type, aipp_index), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), SUCCESS);
EXPECT_EQ(model.GetAippType(0, aipp_type, aipp_index), ACL_ERROR_GE_AIPP_NOT_EXIST);

EXPECT_EQ(model.input_addrs_list_.size(), 1);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 1);
}

TEST_F(UtestDavinciModel, init_data_aipp_releated) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

{
OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc); // op_index 0
AttrUtils::SetStr(op_desc, ATTR_DATA_RELATED_AIPP_MODE, "dynamic_aipp");
AttrUtils::SetStr(op_desc, ATTR_DATA_AIPP_DATA_NAME_MAP, "releated_aipp");
}
{
OpDescPtr op_desc = CreateOpDesc("releated_aipp", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc); // op_index 1
}

InputAippType aipp_type;
size_t aipp_index = 0;
EXPECT_EQ(model.GetAippType(0, aipp_type, aipp_index), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), SUCCESS);
EXPECT_EQ(model.GetAippType(0, aipp_type, aipp_index), SUCCESS);
EXPECT_EQ(aipp_type, DATA_WITH_DYNAMIC_AIPP);
EXPECT_EQ(aipp_index, 1);

EXPECT_EQ(model.input_addrs_list_.size(), 2);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 2);
}

TEST_F(UtestDavinciModel, init_data_aipp_dynamic_conf) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc); // op_index 0
AttrUtils::SetStr(op_desc, ATTR_DATA_RELATED_AIPP_MODE, "dynamic_aipp_conf");

InputAippType aipp_type;
size_t aipp_index = 0;
EXPECT_EQ(model.GetAippType(0, aipp_type, aipp_index), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), SUCCESS);
EXPECT_EQ(model.GetAippType(0, aipp_type, aipp_index), SUCCESS);
EXPECT_EQ(aipp_type, DYNAMIC_AIPP_NODE);
EXPECT_EQ(aipp_index, 0xFFFFFFFFU);

EXPECT_EQ(model.input_addrs_list_.size(), 1);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 1);
}

TEST_F(UtestDavinciModel, init_data_aipp_dynamic_invalid) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc); // op_index 0
AttrUtils::SetStr(op_desc, ATTR_DATA_RELATED_AIPP_MODE, "dynamic_aipp_invalid");

InputAippType aipp_type;
size_t aipp_index = 0;
EXPECT_EQ(model.GetAippType(0, aipp_type, aipp_index), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), ACL_ERROR_GE_AIPP_MODE_INVALID);

EXPECT_EQ(model.input_addrs_list_.size(), 1);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 1);
}

TEST_F(UtestDavinciModel, init_data_aipp_input_info_empty) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc); // op_index 0

vector<string> inputs = {};
AttrUtils::SetListStr(op_desc, ATTR_NAME_AIPP_INPUTS, inputs);
vector<string> outputs = {};
AttrUtils::SetListStr(op_desc, ATTR_NAME_AIPP_OUTPUTS, outputs);

OriginInputInfo orig_input_info;
EXPECT_EQ(model.GetOrigInputInfo(0, orig_input_info), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), SUCCESS);
EXPECT_EQ(model.GetOrigInputInfo(0, orig_input_info), SUCCESS);

EXPECT_EQ(model.input_addrs_list_.size(), 1);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 1);
}

TEST_F(UtestDavinciModel, init_data_aipp_input_info_normal) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc); // op_index 0

vector<string> inputs = { "NCHW:DT_FLOAT:TensorName:TensorSize:3:1,2,8" };
AttrUtils::SetListStr(op_desc, ATTR_NAME_AIPP_INPUTS, inputs);
vector<string> outputs = { "NCHW:DT_FLOAT:TensorName:TensorSize:3:1,2,8" };
AttrUtils::SetListStr(op_desc, ATTR_NAME_AIPP_OUTPUTS, outputs);

OriginInputInfo orig_input_info;
EXPECT_EQ(model.GetOrigInputInfo(0, orig_input_info), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), SUCCESS);
EXPECT_EQ(model.GetOrigInputInfo(0, orig_input_info), SUCCESS);

EXPECT_EQ(model.input_addrs_list_.size(), 1);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 1);
}

TEST_F(UtestDavinciModel, init_data_aipp_input_info_invalid) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc); // op_index 0

vector<string> inputs = { "NCHW:DT_FLOAT:TensorName" }; // Invalid
AttrUtils::SetListStr(op_desc, ATTR_NAME_AIPP_INPUTS, inputs);
vector<string> outputs = { "NCHW:DT_FLOAT:TensorName:TensorSize:3:1,2,8" };
AttrUtils::SetListStr(op_desc, ATTR_NAME_AIPP_OUTPUTS, outputs);

OriginInputInfo orig_input_info;
EXPECT_EQ(model.GetOrigInputInfo(0, orig_input_info), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), ACL_ERROR_GE_AIPP_MODE_INVALID);
EXPECT_EQ(model.GetOrigInputInfo(0, orig_input_info), ACL_ERROR_GE_AIPP_NOT_EXIST);

EXPECT_EQ(model.input_addrs_list_.size(), 1);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 1);
}

TEST_F(UtestDavinciModel, init_data_aipp_input_info_normal) {
DavinciModel model(0, nullptr);
model.ge_model_ = make_shared<GeModel>(); // for CustAICPUKernelStore::GetCustAICPUKernelStore()
model.runtime_param_.mem_base = (uint8_t *)0x08000000;
model.runtime_param_.mem_size = 5120000;
ComputeGraphPtr graph = make_shared<ComputeGraph>("default");

GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
TensorUtils::SetSize(tensor, 512);

OpDescPtr op_desc = CreateOpDesc("data", DATA);
op_desc->AddInputDesc(tensor);
op_desc->AddOutputDesc(tensor);
op_desc->SetInputOffset({1024});
op_desc->SetOutputOffset({1024});
NodePtr node = graph->AddNode(op_desc); // op_index 0

vector<string> inputs = { "NCHW:DT_FLOAT:TensorName:TensorSize:3:1,2,8" };
AttrUtils::SetListStr(op_desc, ATTR_NAME_AIPP_INPUTS, inputs);
vector<string> outputs = { "NCHW:DT_FLOAT:TensorName:TensorSize:3:1,2,8" };
AttrUtils::SetListStr(op_desc, ATTR_NAME_AIPP_OUTPUTS, outputs);

vector<InputOutputDims> input_dims;
vector<InputOutputDims> output_dims;
EXPECT_EQ(model.GetAllAippInputOutputDims(0, input_dims, output_dims), ACL_ERROR_GE_AIPP_NOT_EXIST);
EXPECT_EQ(model.InitNodes(graph), SUCCESS);
EXPECT_EQ(model.GetAllAippInputOutputDims(0, input_dims, output_dims), SUCCESS);
EXPECT_EQ(input_dims.size(), 1);
EXPECT_EQ(output_dims.size(), 1);

EXPECT_EQ(model.input_addrs_list_.size(), 1);
EXPECT_EQ(model.output_addrs_list_.size(), 0);
EXPECT_EQ(model.op_list_.size(), 1);
}
} // namespace ge

Write Preview
Loading…
Cancel
Save