1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
//===- StableFunctionMapTest.cpp ------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/CGData/StableFunctionMap.h"
#include "gmock/gmock-matchers.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
using testing::Contains;
using testing::IsEmpty;
using testing::Key;
using testing::Not;
using testing::Pair;
using testing::SizeIs;
TEST(StableFunctionMap, Name) {
StableFunctionMap Map;
EXPECT_TRUE(Map.empty());
EXPECT_TRUE(Map.getNames().empty());
unsigned ID1 = Map.getIdOrCreateForName("Func1");
unsigned ID2 = Map.getIdOrCreateForName("Func2");
unsigned ID3 = Map.getIdOrCreateForName("Func1");
EXPECT_THAT(Map.getNames(), SizeIs(2));
// The different names should return different IDs.
EXPECT_NE(ID1, ID2);
// The same name should return the same ID.
EXPECT_EQ(ID1, ID3);
// The IDs should be valid.
EXPECT_EQ(*Map.getNameForId(ID1), "Func1");
EXPECT_EQ(*Map.getNameForId(ID2), "Func2");
}
TEST(StableFunctionMap, Insert) {
StableFunctionMap Map;
StableFunction Func1{1, "Func1", "Mod1", 2, {{{0, 1}, 3}}};
StableFunction Func2{1, "Func2", "Mod1", 2, {{{0, 1}, 2}}};
Map.insert(Func1);
Map.insert(Func2);
// We only have a unique hash, 1
EXPECT_THAT(Map, SizeIs(1));
// We have two functions with the same hash which are potentially mergeable.
EXPECT_EQ(Map.size(StableFunctionMap::SizeType::TotalFunctionCount), 2u);
EXPECT_EQ(Map.size(StableFunctionMap::SizeType::MergeableFunctionCount), 2u);
}
TEST(StableFunctionMap, Merge) {
StableFunctionMap Map1;
StableFunction Func1{1, "Func1", "Mod1", 2, {{{0, 1}, 3}}};
StableFunction Func2{1, "Func2", "Mod1", 2, {{{0, 1}, 2}}};
StableFunction Func3{2, "Func3", "Mod1", 2, {{{1, 1}, 2}}};
Map1.insert(Func1);
Map1.insert(Func2);
Map1.insert(Func3);
StableFunctionMap Map2;
StableFunction Func4{1, "Func4", "Mod2", 2, {{{0, 1}, 4}}};
StableFunction Func5{2, "Func5", "Mod2", 2, {{{1, 1}, 5}}};
StableFunction Func6{3, "Func6", "Mod2", 2, {{{1, 1}, 6}}};
Map2.insert(Func4);
Map2.insert(Func5);
Map2.insert(Func6);
// Merge two maps.
Map1.merge(Map2);
// We only have two unique hashes, 1, 2 and 3
EXPECT_THAT(Map1, SizeIs(3));
// We have total 6 functions.
EXPECT_EQ(Map1.size(StableFunctionMap::SizeType::TotalFunctionCount), 6u);
// We have 5 mergeable functions. Func6 only has a unique hash, 3.
EXPECT_EQ(Map1.size(StableFunctionMap::SizeType::MergeableFunctionCount), 5u);
}
TEST(StableFunctionMap, Finalize1) {
StableFunctionMap Map;
StableFunction Func1{1, "Func1", "Mod1", 2, {{{0, 1}, 3}}};
StableFunction Func2{1, "Func2", "Mod2", 3, {{{0, 1}, 2}}};
Map.insert(Func1);
Map.insert(Func2);
// Instruction count is mis-matched, so they're not mergeable.
Map.finalize();
EXPECT_THAT(Map, IsEmpty());
}
TEST(StableFunctionMap, Finalize2) {
StableFunctionMap Map;
StableFunction Func1{1, "Func1", "Mod1", 2, {{{0, 1}, 3}}};
StableFunction Func2{1, "Func2", "Mod2", 2, {{{0, 1}, 2}, {{1, 1}, 1}}};
Map.insert(Func1);
Map.insert(Func2);
// Operand map size is mis-matched, so they're not mergeable.
Map.finalize();
EXPECT_THAT(Map, IsEmpty());
}
TEST(StableFunctionMap, Finalize3) {
StableFunctionMap Map;
StableFunction Func1{1, "Func1", "Mod1", 12, {{{0, 1}, 3}, {{1, 1}, 1}}};
StableFunction Func2{1, "Func2", "Mod2", 12, {{{0, 1}, 2}, {{1, 1}, 1}}};
Map.insert(Func1);
Map.insert(Func2);
// The same operand entry is removed, which is redundant.
Map.finalize();
auto &M = Map.getFunctionMap();
EXPECT_THAT(M, SizeIs(1));
auto &FuncEntries = M.begin()->second;
for (auto &FuncEntry : FuncEntries) {
EXPECT_THAT(*FuncEntry->IndexOperandHashMap, SizeIs(1));
ASSERT_THAT(*FuncEntry->IndexOperandHashMap,
Not(Contains(Key(Pair(1, 1)))));
}
}
} // end namespace
|
