hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: bb87417aff
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bb87417aff'
${ noResults }
graphengine/tests/ut/ge/graph/build/mem_assigner_unittest.cc

252 lines
11 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2019-2020 Huawei Technologies Co., Ltd

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  * http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. 

  17. #include <gtest/gtest.h>

  18. #include <memory>

  19. 

  20. #include "graph/anchor.h"

  21. #include "graph/attr_value.h"

  22. #include "graph/debug/ge_attr_define.h"

  23. #include "graph/utils/graph_utils.h"

  24. #include "graph/utils/node_utils.h"

  25. #include "graph/utils/op_desc_utils.h"

  26. #include "graph/utils/tensor_utils.h"

  27. #include "omg/omg_inner_types.h"

  28. #include "../passes/graph_builder_utils.h"

  29. 

  30. #define protected public

  31. #define private public

  32. #include "graph/build/memory/binary_block_mem_assigner.h"

  33. #include "graph/build/memory/graph_mem_assigner.h"

  34. #include "graph/build/memory/hybrid_mem_assigner.h"

  35. #include "graph/build/memory/max_block_mem_assigner.h"

  36. #undef protected

  37. #undef private

  38. 

  39. using namespace std;

  40. using namespace testing;

  41. using namespace ge;

  42. using domi::GetContext;

  43. 

  44. class UtestMemoryAssignerTest : public testing::Test {

  45.  public:

  46.   ge::OpDescPtr CreateOpWithWsSize(const string &name, int64_t wsByte, const string &type = "some") {

  47.     ge::OpDescPtr op_def = make_shared<ge::OpDesc>(name, type);

  48.     auto desc_temp_ptr = make_shared<ge::GeTensorDesc>();

  49.     auto desc_temp = *desc_temp_ptr;

  50. 

  51.     TensorUtils::SetSize(desc_temp, 1024);

  52.     op_def->AddInputDesc(desc_temp);

  53.     op_def->AddOutputDesc(desc_temp);

  54. 

  55.     std::vector<int64_t> workspace_bytes;

  56.     workspace_bytes.push_back(wsByte);

  57.     op_def->SetWorkspaceBytes(workspace_bytes);

  58.     return op_def;

  59.   }

  60.   ge::OpDescPtr CreateRefOpWithWsSize(const string &name, int64_t wsByte, const string &type = "some") {

  61.     ge::OpDescPtr op_def = make_shared<ge::OpDesc>(name, type);

  62.     auto desc_temp_ptr = make_shared<ge::GeTensorDesc>();

  63.     auto desc_temp = *desc_temp_ptr;

  64. 

  65.     TensorUtils::SetSize(desc_temp, 1024);

  66.     op_def->AddInputDesc(desc_temp);

  67. 

  68.     auto desc_output_ptr = make_shared<ge::GeTensorDesc>();

  69.     auto desc_output = *desc_output_ptr;

  70.     TensorUtils::SetSize(desc_output, 6500);

  71.     ge::TensorUtils::SetReuseInput(desc_output, true);

  72.     ge::TensorUtils::SetReuseInputIndex(desc_output, 0);

  73.     op_def->AddOutputDesc(desc_output);

  74. 

  75.     std::vector<int64_t> workspace_bytes;

  76.     workspace_bytes.push_back(wsByte);

  77.     op_def->SetWorkspaceBytes(workspace_bytes);

  78.     return op_def;

  79.   }

  80.   void MakeGraph(ge::ComputeGraphPtr &graph) {

  81.     ge::OpDescPtr op_def_a = CreateOpWithWsSize("A", 6000);

  82.     op_def_a->SetStreamId(0);

  83.     ge::OpDescPtr op_def_b = CreateOpWithWsSize("B", 120000);

  84.     op_def_b->SetStreamId(0);

  85.     ge::OpDescPtr op_def_c = CreateOpWithWsSize("C", 16000);

  86.     op_def_c->SetStreamId(1);

  87.     ge::OpDescPtr op_def_d = CreateOpWithWsSize("D", 24000);

  88.     op_def_d->SetStreamId(2);

  89.     ge::OpDescPtr op_def_e = CreateOpWithWsSize("E", 24000);

  90.     op_def_e->SetStreamId(3);

  91.     ge::OpDescPtr op_def_f = CreateOpWithWsSize("F", 30000);

  92.     op_def_f->SetStreamId(2);

  93.     ge::OpDescPtr op_def_g = CreateOpWithWsSize("G", 32000);

  94.     op_def_g->SetStreamId(3);

  95.     ge::OpDescPtr op_def_h = CreateOpWithWsSize("H", 48000);

  96.     op_def_h->SetStreamId(2);

  97.     ge::OpDescPtr op_def_i = CreateOpWithWsSize("I", 60000);

  98.     op_def_i->SetStreamId(2);

  99.     ge::OpDescPtr op_def_j = CreateOpWithWsSize("J", 256000, NETOUTPUT);

  100.     op_def_j->SetStreamId(3);

  101. 

  102.     // add node

  103.     ge::NodePtr node_a = graph->AddNode(op_def_a);

  104.     ge::NodePtr node_b = graph->AddNode(op_def_b);

  105.     ge::NodePtr node_c = graph->AddNode(op_def_c);

  106.     ge::NodePtr node_d = graph->AddNode(op_def_d);

  107.     ge::NodePtr node_e = graph->AddNode(op_def_e);

  108.     ge::NodePtr node_f = graph->AddNode(op_def_f);

  109.     ge::NodePtr node_g = graph->AddNode(op_def_g);

  110.     ge::NodePtr node_h = graph->AddNode(op_def_h);

  111.     ge::NodePtr node_i = graph->AddNode(op_def_i);

  112.     ge::NodePtr node_j = graph->AddNode(op_def_j);

  113. 

  114.     // add edge

  115.     ge::GraphUtils::AddEdge(node_a->GetOutDataAnchor(0), node_b->GetInDataAnchor(0));

  116.     ge::GraphUtils::AddEdge(node_a->GetOutDataAnchor(0), node_c->GetInDataAnchor(0));

  117.     ge::GraphUtils::AddEdge(node_b->GetOutDataAnchor(0), node_d->GetInDataAnchor(0));

  118.     ge::GraphUtils::AddEdge(node_b->GetOutDataAnchor(0), node_e->GetInDataAnchor(0));

  119.     ge::GraphUtils::AddEdge(node_c->GetOutDataAnchor(0), node_g->GetInDataAnchor(0));

  120.     ge::GraphUtils::AddEdge(node_d->GetOutDataAnchor(0), node_f->GetInDataAnchor(0));

  121.     ge::GraphUtils::AddEdge(node_e->GetOutDataAnchor(0), node_g->GetInDataAnchor(1));

  122.     ge::GraphUtils::AddEdge(node_f->GetOutDataAnchor(0), node_h->GetInDataAnchor(0));

  123.     ge::GraphUtils::AddEdge(node_g->GetOutDataAnchor(0), node_j->GetInDataAnchor(0));

  124.     ge::GraphUtils::AddEdge(node_h->GetOutDataAnchor(0), node_i->GetInDataAnchor(0));

  125.     ge::GraphUtils::AddEdge(node_i->GetOutDataAnchor(0), node_j->GetInDataAnchor(1));

  126. 

  127.     GetContext().out_nodes_map["H"] = {0};

  128.     GetContext().out_nodes_map["I"] = {0};

  129.     GetContext().out_nodes_map["J"] = {0};

  130.     graph->TopologicalSorting();

  131.   }

  132. 

  133.   void MakeReuseGraph(ge::ComputeGraphPtr graph) {

  134.     ge::OpDescPtr op_def_a = CreateOpWithWsSize("A", 6000);

  135.     ge::OpDescPtr op_def_b = CreateOpWithWsSize("B", 120000);

  136.     ge::OpDescPtr op_def_c = CreateRefOpWithWsSize("C", 120000);

  137.     ge::OpDescPtr op_def_d = make_shared<ge::OpDesc>("D", "CONSTANT");

  138. 

  139.     ge::NodePtr node_a = graph->AddNode(op_def_a);

  140.     ge::NodePtr node_b = graph->AddNode(op_def_b);

  141.     ge::NodePtr node_c = graph->AddNode(op_def_c);

  142.     ge::NodePtr node_d = graph->AddNode(op_def_d);

  143. 

  144.     ge::GraphUtils::AddEdge(node_a->GetOutDataAnchor(0), node_b->GetInDataAnchor(0));

  145.     ge::GraphUtils::AddEdge(node_a->GetOutDataAnchor(0), node_c->GetInDataAnchor(0));

  146.     ge::GraphUtils::AddEdge(node_a->GetOutDataAnchor(0), node_d->GetInDataAnchor(0));

  147.     GetContext().out_nodes_map["B"] = {0};

  148.     GetContext().out_nodes_map["C"] = {0};

  149.     graph->TopologicalSorting();

  150.   }

  151. 

  152.   ComputeGraphPtr MakeCascadeContinuousMemoryGraph() {

  153.     ge::ut::GraphBuilder builder("graph");

  154.     auto data = builder.AddNode("data", "Data", 1, 1);

  155.     auto addn1 = builder.AddNode("addn1", "AddN", 1, 1);

  156.     auto addn2 = builder.AddNode("addn2", "AddN", 1, 1);

  157.     auto addn3 = builder.AddNode("addn3", "AddN", 1, 1);

  158.     auto concat1 = builder.AddNode("concat1", "Concat", 2, 1);

  159.     auto concat2 = builder.AddNode("concat2", "Concat", 2, 1);

  160.     auto netoutput = builder.AddNode("netoutput", "NetOutput", 2, 0);

  161. 

  162.     ge::AttrUtils::SetBool(concat1->GetOpDesc(), ATTR_NAME_NOPADDING_CONTINUOUS_INPUT, true);

  163.     ge::AttrUtils::SetBool(concat1->GetOpDesc(), ATTR_NAME_CONTINUOUS_INPUT_ALLOC, true);

  164.     ge::AttrUtils::SetBool(concat1->GetOpDesc(), ATTR_NAME_OUTPUT_REUSE_INPUT, true);

  165. 

  166.     ge::AttrUtils::SetBool(concat2->GetOpDesc(), ATTR_NAME_NOPADDING_CONTINUOUS_INPUT, true);

  167.     ge::AttrUtils::SetBool(concat2->GetOpDesc(), ATTR_NAME_CONTINUOUS_INPUT_ALLOC, true);

  168.     ge::AttrUtils::SetBool(concat2->GetOpDesc(), ATTR_NAME_OUTPUT_REUSE_INPUT, true);

  169. 

  170.     addn1->GetOpDesc()->SetOutputOffset({100});

  171.     addn2->GetOpDesc()->SetOutputOffset({200});

  172.     concat1->GetOpDesc()->SetOutputOffset({100});

  173.     addn3->GetOpDesc()->SetOutputOffset({700});

  174.     concat2->GetOpDesc()->SetOutputOffset({500});

  175. 

  176.     ge::AttrUtils::SetListInt(addn1->GetOpDesc(), ATTR_NAME_OUTPUT_OFFSET_FOR_BUFFER_FUSION, {100});

  177.     ge::AttrUtils::SetListInt(addn2->GetOpDesc(), ATTR_NAME_OUTPUT_OFFSET_FOR_BUFFER_FUSION, {100});

  178.     ge::AttrUtils::SetListInt(addn3->GetOpDesc(), ATTR_NAME_OUTPUT_OFFSET_FOR_BUFFER_FUSION, {100});

  179.     ge::AttrUtils::SetListInt(concat1->GetOpDesc(), ATTR_NAME_OUTPUT_OFFSET_FOR_BUFFER_FUSION, {200});

  180.     ge::AttrUtils::SetListInt(concat2->GetOpDesc(), ATTR_NAME_OUTPUT_OFFSET_FOR_BUFFER_FUSION, {300});

  181. 

  182. 

  183.     builder.AddDataEdge(data, 0, addn1, 0);

  184.     builder.AddDataEdge(data, 0, addn2, 0);

  185.     builder.AddDataEdge(addn1, 0, concat1, 0);

  186.     builder.AddDataEdge(addn2, 0, concat1, 1);

  187.     builder.AddDataEdge(concat1, 0, concat2, 0);

  188.     builder.AddDataEdge(addn3, 0, concat2, 1);

  189. 

  190.     return builder.GetGraph();

  191.   }

  192. 

  193.  protected:

  194.   void SetUp() {}

  195. 

  196.   void TearDown() { GetContext().out_nodes_map.clear(); }

  197. };

  198. 

  199. /*

  200. TEST_F(UtestMemoryAssignerTest, MemoryBlock_Resize_RealSizeList_is_empty) {

  201.   ge::ComputeGraphPtr graph = make_shared<ge::ComputeGraph>("");

  202.   ge::OpDescPtr op_def_a = CreateOpWithWsSize("A", 6000);

  203.   ge::NodePtr node_a = graph->AddNode(op_def_a);

  204.   MemoryBlock* memory_block = new MemoryBlock(0);

  205.   memory_block->Init(1, kOutput, node_a, 0, 1);

  206.   memory_block->real_size_list_.clear();

  207.   memory_block->Resize();

  208. 

  209.   EXPECT_EQ(memory_block->Size(), 0);

  210. 

  211.   delete memory_block;

  212. }

  213. */

  214. 

  215. namespace ge {

  216. 

  217. class MockBlockMemAssigner : public BlockMemAssigner {

  218.  public:

  219.   explicit MockBlockMemAssigner(ge::ComputeGraphPtr compute_graph, const std::map<std::string, std::string> &anchor_to_symbol, const std::map<std::string, std::list<NodeIndexIO>> &symbol_to_anchors) : BlockMemAssigner(compute_graph, anchor_to_symbol, symbol_to_anchors) {};

  220. 

  221.   virtual ~MockBlockMemAssigner(){};

  222. 

  223.   Status GetMemoryRanges(std::vector<int64_t> &ranges) override { return FAILED; }

  224. };

  225. }  // namespace ge

  226. 

  227. // when check GetMemoryRanges return fail, Assign return fail

  228. TEST_F(UtestMemoryAssignerTest, Mock_block_mem_assigner_failed) {

  229.   ge::ComputeGraphPtr graph = make_shared<ge::ComputeGraph>("");

  230.   MakeGraph(graph);

  231.   std::map<std::string, std::string> anchor_to_symbol;

  232.   std::map<std::string, std::list<NodeIndexIO>> symbol_to_anchors;

  233.   EXPECT_EQ(GraphUtils::GetRefMapping(graph, symbol_to_anchors, anchor_to_symbol), GRAPH_SUCCESS);

  234. 

  235.   MockBlockMemAssigner mock_assigner(graph, anchor_to_symbol, symbol_to_anchors);

  236.   EXPECT_EQ(mock_assigner.Assign(), FAILED);

  237. }

  238. 

  239. TEST_F(UtestMemoryAssignerTest, graph_memory_assign_continuous_input) {

  240.   ge::ComputeGraphPtr graph = MakeCascadeContinuousMemoryGraph();

  241.   auto addn1 = graph->FindNode("addn1");

  242.   auto addn2 = graph->FindNode("addn2");

  243.   EXPECT_EQ(addn1->GetOpDesc()->GetOutputOffset()[0], 100);

  244.   EXPECT_EQ(addn2->GetOpDesc()->GetOutputOffset()[0], 200);

  245.   GraphMemoryAssigner memoryAssigner(graph);

  246.   MemoryOffset memory_offset(RT_MEMORY_HBM, 0);

  247.   memoryAssigner.memory_offset_.emplace(RT_MEMORY_HBM, memory_offset);

  248.   EXPECT_EQ(memoryAssigner.ReAssignContinuousMemory(false), GRAPH_SUCCESS);

  249.   EXPECT_EQ(addn1->GetOpDesc()->GetOutputOffset()[0], 500);

  250.   EXPECT_EQ(addn2->GetOpDesc()->GetOutputOffset()[0], 600);

  251. }