Debian Codegraph @

packages/stk/stk_unit_tests/stk_util/parallel/UnitTestTreeReductionIndexer.cpp

raw
1 #include "stk_util/parallel/TreeReductionIndexer.hpp"
2 #include "gtest/gtest.h"
3
4 TEST(TreeReductionIndexer, Getters)
5 {
6 stk::impl::TreeReductionIndexer indexer(36, 3);
7
8 EXPECT_EQ(indexer.get_tree_width(), 36);
9 EXPECT_EQ(indexer.get_tree_depth(), 5);
10 EXPECT_EQ(indexer.get_num_children(), 3);
11 }
12
13 TEST(TreeReductionIndexer, TreeDepth2Children)
14 {
15
16 std::vector<int> tree_widths = {1, 2, 3, 4, 5, 6, 7, 8};
17 std::vector<int> tree_depths = {1, 2, 3, 3, 4, 4, 4, 4};
18
19 for (size_t i=0; i < tree_widths.size(); ++i)
20 {
21 stk::impl::TreeReductionIndexer indexer(tree_widths[i], 2);
22 EXPECT_EQ(indexer.get_tree_depth(), tree_depths[i]);
23 }
24 }
25
26 TEST(TreeReductionIndexer, TreeDepth3Children)
27 {
28
29 std::vector<int> tree_widths = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
30 std::vector<int> tree_depths = {1, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4};
31
32 for (size_t i=0; i < tree_widths.size(); ++i)
33 {
34 stk::impl::TreeReductionIndexer indexer(tree_widths[i], 3);
35 EXPECT_EQ(indexer.get_tree_depth(), tree_depths[i]);
36 }
37 }
38
39 TEST(TreeReductionIndexer, NumChildrenErrors)
40 {
41 EXPECT_ANY_THROW(stk::impl::TreeReductionIndexer indexer(2, -1));
42 EXPECT_ANY_THROW(stk::impl::TreeReductionIndexer indexer(2, 0));
43 EXPECT_ANY_THROW(stk::impl::TreeReductionIndexer indexer(2, 1));
44 }
45
46
47 TEST(TreeReductionIndexer, ParentRank3Children)
48 {
49 int treeWidth = 13;
50 stk::impl::TreeReductionIndexer indexer(treeWidth, 3);
51 std::vector<int> levelZeroParents = {0, 0, 0, 3, 3, 3, 6, 6, 6, 9, 9, 9, 12};
52 for (int i=0; i < treeWidth; ++i)
53 {
54 EXPECT_EQ(indexer.get_parent_rank(1, i), levelZeroParents[i]);
55 }
56
57 std::vector<int> levelOneParents = {0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9};
58 for (int i=0; i < treeWidth; ++i)
59 {
60 EXPECT_EQ(indexer.get_parent_rank(2, i), levelOneParents[i]);
61 }
62
63 std::vector<int> levelTwoParents(treeWidth, 0);
64 for (int i=0; i < treeWidth; ++i)
65 {
66 EXPECT_EQ(indexer.get_parent_rank(3, i), levelTwoParents[i]);
67 }
68 }
69
70 TEST(TreeReductionIndexer, ParentRankErrors)
71 {
72
73 int treeWidth = 13;
74 stk::impl::TreeReductionIndexer indexer(treeWidth, 3);
75 EXPECT_ANY_THROW(indexer.get_parent_rank(indexer.get_tree_depth() + 1, 0));
76 EXPECT_ANY_THROW(indexer.get_parent_rank(-1, 0));
77 }
78
79 namespace {
80 void testChildren(stk::impl::TreeReductionIndexer& indexer, int level, std::vector< std::vector<int> >& levelChildren)
81 {
82 int idx = 0;
83 std::vector<int> children;
84 for (int i=0; i < indexer.get_tree_width(); ++i)
85 {
86 if (indexer.is_rank_on_level(level+1, i))
87 {
88 indexer.get_child_ranks(level, i, children);
89 EXPECT_EQ(children.size(), levelChildren[idx].size());
90 for (size_t j=0; j < levelChildren[idx].size(); ++j)
91 {
92 EXPECT_EQ(children[j], levelChildren[idx][j]);
93 }
94 idx++;
95 } else
96 {
97 EXPECT_ANY_THROW(indexer.get_child_ranks(level, i, children));
98 }
99 }
100 }
101 }
102
103 TEST(TreeReductionIndexer, ChildRanks3Children)
104 {
105 int treeWidth = 13;
106 stk::impl::TreeReductionIndexer indexer(treeWidth, 3);
107
108 std::vector< std::vector<int> > levelZeroChildren = { {1, 2}, {4, 5}, {7, 8}, {10, 11}, {} };
109 std::vector< std::vector<int> > levelOneChildren = { {3, 6}, {12}};
110
111 testChildren(indexer, 0, levelZeroChildren);
112
113 testChildren(indexer, 1, levelOneChildren);
114 }
115
116 TEST(TreeReductionIndexer, ChildRankErrors)
117 {
118 int treeWidth = 13;
119 stk::impl::TreeReductionIndexer indexer(treeWidth, 3);
120
121 std::vector<int> invalidRanks = {1, 2, 4, 5, 7, 8, 10, 11};
122 std::vector<int> children;
123 for (auto& rank : invalidRanks)
124 {
125 EXPECT_ANY_THROW(indexer.get_child_ranks(rank, 1, children));
126 }
127 }
128
129
130 TEST(TreeReductionIndexer, IsRankOnLevel)
131 {
132 int treeWidth = 13;
133 stk::impl::TreeReductionIndexer indexer(treeWidth, 3);
134
135 std::vector<bool> isOnLevelOne = {true, false, false, true, false, false, true, false, false, true, false, false, true};
136 std::vector<bool> isOnLevelTwo = {true, false, false, false, false, false, false, false, false, true, false, false, false};
137
138 for (int i=0; i < treeWidth; ++i)
139 {
140 EXPECT_TRUE(indexer.is_rank_on_level(0, i));
141 EXPECT_EQ(indexer.is_rank_on_level(1, i), isOnLevelOne[i]);
142 EXPECT_EQ(indexer.is_rank_on_level(2, i), isOnLevelTwo[i]);
143 }
144
145 }