1 | //===- unittest/IR/OpenMPContextTest.cpp - OpenMP Context handling tests --===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "llvm/Frontend/OpenMP/OMPConstants.h" |
10 | #include "llvm/Frontend/OpenMP/OMPContext.h" |
11 | #include "llvm/TargetParser/Triple.h" |
12 | #include "gtest/gtest.h" |
13 | |
14 | using namespace llvm; |
15 | using namespace omp; |
16 | |
17 | namespace { |
18 | |
19 | class OpenMPContextTest : public testing::Test { |
20 | protected: |
21 | void SetUp() override {} |
22 | |
23 | void TearDown() override {} |
24 | }; |
25 | |
26 | TEST_F(OpenMPContextTest, RoundTripAndAssociation) { |
27 | #define OMP_TRAIT_SET(Enum, Str) \ |
28 | EXPECT_EQ(TraitSet::Enum, \ |
29 | getOpenMPContextTraitSetKind( \ |
30 | getOpenMPContextTraitSetName(TraitSet::Enum))); \ |
31 | EXPECT_EQ(Str, \ |
32 | getOpenMPContextTraitSetName(getOpenMPContextTraitSetKind(Str))); |
33 | #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, RequiresProperty) \ |
34 | EXPECT_EQ(TraitSelector::Enum, \ |
35 | getOpenMPContextTraitSelectorKind( \ |
36 | getOpenMPContextTraitSelectorName(TraitSelector::Enum))); \ |
37 | EXPECT_EQ(Str, getOpenMPContextTraitSelectorName( \ |
38 | getOpenMPContextTraitSelectorKind(Str))); |
39 | #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ |
40 | EXPECT_EQ(TraitProperty::Enum, \ |
41 | getOpenMPContextTraitPropertyKind( \ |
42 | TraitSet::TraitSetEnum, TraitSelector::TraitSelectorEnum, \ |
43 | getOpenMPContextTraitPropertyName(TraitProperty::Enum, Str))); \ |
44 | EXPECT_EQ(Str, getOpenMPContextTraitPropertyName( \ |
45 | getOpenMPContextTraitPropertyKind( \ |
46 | TraitSet::TraitSetEnum, \ |
47 | TraitSelector::TraitSelectorEnum, Str), \ |
48 | Str)); \ |
49 | EXPECT_EQ(TraitSet::TraitSetEnum, \ |
50 | getOpenMPContextTraitSetForProperty(TraitProperty::Enum)); \ |
51 | EXPECT_EQ(TraitSelector::TraitSelectorEnum, \ |
52 | getOpenMPContextTraitSelectorForProperty(TraitProperty::Enum)); |
53 | #include "llvm/Frontend/OpenMP/OMPKinds.def" |
54 | } |
55 | |
56 | TEST_F(OpenMPContextTest, ValidNesting) { |
57 | bool AllowsTraitScore, ReqProperty; |
58 | #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, RequiresProperty) \ |
59 | EXPECT_TRUE(isValidTraitSelectorForTraitSet(TraitSelector::Enum, \ |
60 | TraitSet::TraitSetEnum, \ |
61 | AllowsTraitScore, ReqProperty)); \ |
62 | EXPECT_EQ(RequiresProperty, ReqProperty); |
63 | #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ |
64 | EXPECT_TRUE(isValidTraitPropertyForTraitSetAndSelector( \ |
65 | TraitProperty::Enum, TraitSelector::TraitSelectorEnum, \ |
66 | TraitSet::TraitSetEnum)); |
67 | #include "llvm/Frontend/OpenMP/OMPKinds.def" |
68 | } |
69 | |
70 | TEST_F(OpenMPContextTest, ApplicabilityNonConstruct) { |
71 | OMPContext HostLinux(false, Triple("x86_64-unknown-linux" )); |
72 | OMPContext DeviceLinux(true, Triple("x86_64-unknown-linux" )); |
73 | OMPContext HostNVPTX(false, Triple("nvptx64-nvidia-cuda" )); |
74 | OMPContext DeviceNVPTX(true, Triple("nvptx64-nvidia-cuda" )); |
75 | |
76 | VariantMatchInfo Empty; |
77 | EXPECT_TRUE(isVariantApplicableInContext(Empty, HostLinux)); |
78 | EXPECT_TRUE(isVariantApplicableInContext(Empty, DeviceLinux)); |
79 | EXPECT_TRUE(isVariantApplicableInContext(Empty, HostNVPTX)); |
80 | EXPECT_TRUE(isVariantApplicableInContext(Empty, DeviceNVPTX)); |
81 | |
82 | VariantMatchInfo UserCondFalse; |
83 | UserCondFalse.addTrait(Property: TraitProperty::user_condition_false, RawString: "" ); |
84 | EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, HostLinux)); |
85 | EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, DeviceLinux)); |
86 | EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, HostNVPTX)); |
87 | EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, DeviceNVPTX)); |
88 | |
89 | VariantMatchInfo DeviceArchArm; |
90 | DeviceArchArm.addTrait(Property: TraitProperty::device_arch_arm, RawString: "" ); |
91 | EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, HostLinux)); |
92 | EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, DeviceLinux)); |
93 | EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, HostNVPTX)); |
94 | EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, DeviceNVPTX)); |
95 | |
96 | VariantMatchInfo LLVMHostUserCondTrue; |
97 | LLVMHostUserCondTrue.addTrait(Property: TraitProperty::implementation_vendor_llvm, RawString: "" ); |
98 | LLVMHostUserCondTrue.addTrait(Property: TraitProperty::device_kind_host, RawString: "" ); |
99 | LLVMHostUserCondTrue.addTrait(Property: TraitProperty::device_kind_any, RawString: "" ); |
100 | LLVMHostUserCondTrue.addTrait(Property: TraitProperty::user_condition_true, RawString: "" ); |
101 | EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrue, HostLinux)); |
102 | EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrue, DeviceLinux)); |
103 | EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrue, HostNVPTX)); |
104 | EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrue, DeviceNVPTX)); |
105 | |
106 | VariantMatchInfo LLVMHostUserCondTrueCPU = LLVMHostUserCondTrue; |
107 | LLVMHostUserCondTrueCPU.addTrait(Property: TraitProperty::device_kind_cpu, RawString: "" ); |
108 | EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrueCPU, HostLinux)); |
109 | EXPECT_FALSE( |
110 | isVariantApplicableInContext(LLVMHostUserCondTrueCPU, DeviceLinux)); |
111 | EXPECT_FALSE( |
112 | isVariantApplicableInContext(LLVMHostUserCondTrueCPU, HostNVPTX)); |
113 | EXPECT_FALSE( |
114 | isVariantApplicableInContext(LLVMHostUserCondTrueCPU, DeviceNVPTX)); |
115 | |
116 | VariantMatchInfo GPU; |
117 | GPU.addTrait(Property: TraitProperty::device_kind_gpu, RawString: "" ); |
118 | EXPECT_FALSE(isVariantApplicableInContext(GPU, HostLinux)); |
119 | EXPECT_FALSE(isVariantApplicableInContext(GPU, DeviceLinux)); |
120 | EXPECT_TRUE(isVariantApplicableInContext(GPU, HostNVPTX)); |
121 | EXPECT_TRUE(isVariantApplicableInContext(GPU, DeviceNVPTX)); |
122 | |
123 | VariantMatchInfo NoHost; |
124 | NoHost.addTrait(Property: TraitProperty::device_kind_nohost, RawString: "" ); |
125 | EXPECT_FALSE(isVariantApplicableInContext(NoHost, HostLinux)); |
126 | EXPECT_TRUE(isVariantApplicableInContext(NoHost, DeviceLinux)); |
127 | EXPECT_FALSE(isVariantApplicableInContext(NoHost, HostNVPTX)); |
128 | EXPECT_TRUE(isVariantApplicableInContext(NoHost, DeviceNVPTX)); |
129 | } |
130 | |
131 | TEST_F(OpenMPContextTest, ApplicabilityAllTraits) { |
132 | OMPContext HostLinuxParallelParallel(false, Triple("x86_64-unknown-linux" )); |
133 | HostLinuxParallelParallel.addTrait( |
134 | Property: TraitProperty::construct_parallel_parallel); |
135 | HostLinuxParallelParallel.addTrait( |
136 | Property: TraitProperty::construct_parallel_parallel); |
137 | OMPContext DeviceLinuxTargetParallel(true, Triple("x86_64-unknown-linux" )); |
138 | DeviceLinuxTargetParallel.addTrait(Property: TraitProperty::construct_target_target); |
139 | DeviceLinuxTargetParallel.addTrait( |
140 | Property: TraitProperty::construct_parallel_parallel); |
141 | OMPContext HostNVPTXFor(false, Triple("nvptx64-nvidia-cuda" )); |
142 | HostNVPTXFor.addTrait(Property: TraitProperty::construct_for_for); |
143 | OMPContext DeviceNVPTXTargetTeamsParallel(true, |
144 | Triple("nvptx64-nvidia-cuda" )); |
145 | DeviceNVPTXTargetTeamsParallel.addTrait( |
146 | Property: TraitProperty::construct_target_target); |
147 | DeviceNVPTXTargetTeamsParallel.addTrait(Property: TraitProperty::construct_teams_teams); |
148 | DeviceNVPTXTargetTeamsParallel.addTrait( |
149 | Property: TraitProperty::construct_parallel_parallel); |
150 | |
151 | { // non-construct variants |
152 | VariantMatchInfo Empty; |
153 | EXPECT_TRUE(isVariantApplicableInContext(Empty, HostLinuxParallelParallel)); |
154 | EXPECT_TRUE(isVariantApplicableInContext(Empty, DeviceLinuxTargetParallel)); |
155 | EXPECT_TRUE(isVariantApplicableInContext(Empty, HostNVPTXFor)); |
156 | EXPECT_TRUE( |
157 | isVariantApplicableInContext(Empty, DeviceNVPTXTargetTeamsParallel)); |
158 | |
159 | VariantMatchInfo UserCondFalse; |
160 | UserCondFalse.addTrait(Property: TraitProperty::user_condition_false, RawString: "" ); |
161 | EXPECT_FALSE( |
162 | isVariantApplicableInContext(UserCondFalse, HostLinuxParallelParallel)); |
163 | EXPECT_FALSE( |
164 | isVariantApplicableInContext(UserCondFalse, DeviceLinuxTargetParallel)); |
165 | EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, HostNVPTXFor)); |
166 | EXPECT_FALSE(isVariantApplicableInContext(UserCondFalse, |
167 | DeviceNVPTXTargetTeamsParallel)); |
168 | |
169 | VariantMatchInfo DeviceArchArm; |
170 | DeviceArchArm.addTrait(Property: TraitProperty::device_arch_arm, RawString: "" ); |
171 | EXPECT_FALSE( |
172 | isVariantApplicableInContext(DeviceArchArm, HostLinuxParallelParallel)); |
173 | EXPECT_FALSE( |
174 | isVariantApplicableInContext(DeviceArchArm, DeviceLinuxTargetParallel)); |
175 | EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, HostNVPTXFor)); |
176 | EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArm, |
177 | DeviceNVPTXTargetTeamsParallel)); |
178 | |
179 | APInt Score(32, 1000); |
180 | VariantMatchInfo LLVMHostUserCondTrue; |
181 | LLVMHostUserCondTrue.addTrait(Property: TraitProperty::implementation_vendor_llvm, |
182 | RawString: "" ); |
183 | LLVMHostUserCondTrue.addTrait(Property: TraitProperty::device_kind_host, RawString: "" ); |
184 | LLVMHostUserCondTrue.addTrait(Property: TraitProperty::device_kind_any, RawString: "" ); |
185 | LLVMHostUserCondTrue.addTrait(Property: TraitProperty::user_condition_true, RawString: "" , |
186 | Score: &Score); |
187 | EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrue, |
188 | HostLinuxParallelParallel)); |
189 | EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrue, |
190 | DeviceLinuxTargetParallel)); |
191 | EXPECT_TRUE( |
192 | isVariantApplicableInContext(LLVMHostUserCondTrue, HostNVPTXFor)); |
193 | EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrue, |
194 | DeviceNVPTXTargetTeamsParallel)); |
195 | |
196 | VariantMatchInfo LLVMHostUserCondTrueCPU = LLVMHostUserCondTrue; |
197 | LLVMHostUserCondTrueCPU.addTrait(Property: TraitProperty::device_kind_cpu, RawString: "" ); |
198 | EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrueCPU, |
199 | HostLinuxParallelParallel)); |
200 | EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueCPU, |
201 | DeviceLinuxTargetParallel)); |
202 | EXPECT_FALSE( |
203 | isVariantApplicableInContext(LLVMHostUserCondTrueCPU, HostNVPTXFor)); |
204 | EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueCPU, |
205 | DeviceNVPTXTargetTeamsParallel)); |
206 | |
207 | VariantMatchInfo GPU; |
208 | GPU.addTrait(Property: TraitProperty::device_kind_gpu, RawString: "" ); |
209 | EXPECT_FALSE(isVariantApplicableInContext(GPU, HostLinuxParallelParallel)); |
210 | EXPECT_FALSE(isVariantApplicableInContext(GPU, DeviceLinuxTargetParallel)); |
211 | EXPECT_TRUE(isVariantApplicableInContext(GPU, HostNVPTXFor)); |
212 | EXPECT_TRUE( |
213 | isVariantApplicableInContext(GPU, DeviceNVPTXTargetTeamsParallel)); |
214 | |
215 | VariantMatchInfo NoHost; |
216 | NoHost.addTrait(Property: TraitProperty::device_kind_nohost, RawString: "" ); |
217 | EXPECT_FALSE( |
218 | isVariantApplicableInContext(NoHost, HostLinuxParallelParallel)); |
219 | EXPECT_TRUE( |
220 | isVariantApplicableInContext(NoHost, DeviceLinuxTargetParallel)); |
221 | EXPECT_FALSE(isVariantApplicableInContext(NoHost, HostNVPTXFor)); |
222 | EXPECT_TRUE( |
223 | isVariantApplicableInContext(NoHost, DeviceNVPTXTargetTeamsParallel)); |
224 | } |
225 | { // variants with all sets |
226 | VariantMatchInfo DeviceArchArmParallel; |
227 | DeviceArchArmParallel.addTrait(Property: TraitProperty::construct_parallel_parallel, |
228 | RawString: "" ); |
229 | DeviceArchArmParallel.addTrait(Property: TraitProperty::device_arch_arm, RawString: "" ); |
230 | EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArmParallel, |
231 | HostLinuxParallelParallel)); |
232 | EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArmParallel, |
233 | DeviceLinuxTargetParallel)); |
234 | EXPECT_FALSE( |
235 | isVariantApplicableInContext(DeviceArchArmParallel, HostNVPTXFor)); |
236 | EXPECT_FALSE(isVariantApplicableInContext(DeviceArchArmParallel, |
237 | DeviceNVPTXTargetTeamsParallel)); |
238 | |
239 | VariantMatchInfo LLVMHostUserCondTrueParallel; |
240 | LLVMHostUserCondTrueParallel.addTrait( |
241 | Property: TraitProperty::implementation_vendor_llvm, RawString: "" ); |
242 | LLVMHostUserCondTrueParallel.addTrait(Property: TraitProperty::device_kind_host, RawString: "" ); |
243 | LLVMHostUserCondTrueParallel.addTrait(Property: TraitProperty::device_kind_any, RawString: "" ); |
244 | LLVMHostUserCondTrueParallel.addTrait(Property: TraitProperty::user_condition_true, |
245 | RawString: "" ); |
246 | LLVMHostUserCondTrueParallel.addTrait( |
247 | Property: TraitProperty::construct_parallel_parallel, RawString: "" ); |
248 | EXPECT_TRUE(isVariantApplicableInContext(LLVMHostUserCondTrueParallel, |
249 | HostLinuxParallelParallel)); |
250 | EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueParallel, |
251 | DeviceLinuxTargetParallel)); |
252 | EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueParallel, |
253 | HostNVPTXFor)); |
254 | EXPECT_FALSE(isVariantApplicableInContext(LLVMHostUserCondTrueParallel, |
255 | DeviceNVPTXTargetTeamsParallel)); |
256 | |
257 | VariantMatchInfo LLVMHostUserCondTrueParallelParallel = |
258 | LLVMHostUserCondTrueParallel; |
259 | LLVMHostUserCondTrueParallelParallel.addTrait( |
260 | Property: TraitProperty::construct_parallel_parallel, RawString: "" ); |
261 | EXPECT_TRUE(isVariantApplicableInContext( |
262 | LLVMHostUserCondTrueParallelParallel, HostLinuxParallelParallel)); |
263 | EXPECT_FALSE(isVariantApplicableInContext( |
264 | LLVMHostUserCondTrueParallelParallel, DeviceLinuxTargetParallel)); |
265 | EXPECT_FALSE(isVariantApplicableInContext( |
266 | LLVMHostUserCondTrueParallelParallel, HostNVPTXFor)); |
267 | EXPECT_FALSE(isVariantApplicableInContext( |
268 | LLVMHostUserCondTrueParallelParallel, DeviceNVPTXTargetTeamsParallel)); |
269 | |
270 | VariantMatchInfo LLVMHostUserCondTrueParallelParallelParallel = |
271 | LLVMHostUserCondTrueParallelParallel; |
272 | LLVMHostUserCondTrueParallelParallelParallel.addTrait( |
273 | Property: TraitProperty::construct_parallel_parallel, RawString: "" ); |
274 | EXPECT_FALSE(isVariantApplicableInContext( |
275 | LLVMHostUserCondTrueParallelParallelParallel, |
276 | HostLinuxParallelParallel)); |
277 | EXPECT_FALSE(isVariantApplicableInContext( |
278 | LLVMHostUserCondTrueParallelParallelParallel, |
279 | DeviceLinuxTargetParallel)); |
280 | EXPECT_FALSE(isVariantApplicableInContext( |
281 | LLVMHostUserCondTrueParallelParallelParallel, HostNVPTXFor)); |
282 | EXPECT_FALSE(isVariantApplicableInContext( |
283 | LLVMHostUserCondTrueParallelParallelParallel, |
284 | DeviceNVPTXTargetTeamsParallel)); |
285 | |
286 | VariantMatchInfo GPUTargetTeams; |
287 | GPUTargetTeams.addTrait(Property: TraitProperty::construct_target_target, RawString: "" ); |
288 | GPUTargetTeams.addTrait(Property: TraitProperty::construct_teams_teams, RawString: "" ); |
289 | GPUTargetTeams.addTrait(Property: TraitProperty::device_kind_gpu, RawString: "" ); |
290 | EXPECT_FALSE(isVariantApplicableInContext(GPUTargetTeams, |
291 | HostLinuxParallelParallel)); |
292 | EXPECT_FALSE(isVariantApplicableInContext(GPUTargetTeams, |
293 | DeviceLinuxTargetParallel)); |
294 | EXPECT_FALSE(isVariantApplicableInContext(GPUTargetTeams, HostNVPTXFor)); |
295 | EXPECT_TRUE(isVariantApplicableInContext(GPUTargetTeams, |
296 | DeviceNVPTXTargetTeamsParallel)); |
297 | |
298 | VariantMatchInfo GPUTargetParallel; |
299 | GPUTargetParallel.addTrait(Property: TraitProperty::construct_target_target, RawString: "" ); |
300 | GPUTargetParallel.addTrait(Property: TraitProperty::construct_parallel_parallel, RawString: "" ); |
301 | GPUTargetParallel.addTrait(Property: TraitProperty::device_kind_gpu, RawString: "" ); |
302 | EXPECT_FALSE(isVariantApplicableInContext(GPUTargetParallel, |
303 | HostLinuxParallelParallel)); |
304 | EXPECT_FALSE(isVariantApplicableInContext(GPUTargetParallel, |
305 | DeviceLinuxTargetParallel)); |
306 | EXPECT_FALSE(isVariantApplicableInContext(GPUTargetParallel, HostNVPTXFor)); |
307 | EXPECT_TRUE(isVariantApplicableInContext(GPUTargetParallel, |
308 | DeviceNVPTXTargetTeamsParallel)); |
309 | } |
310 | } |
311 | |
312 | TEST_F(OpenMPContextTest, ScoringSimple) { |
313 | // TODO: Add scoring tests (via getBestVariantMatchForContext). |
314 | } |
315 | |
316 | } // namespace |
317 | |