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:
SetUp()21 void SetUp() override {}
22
TearDown()23 void TearDown() override {}
24 };
25
TEST_F(OpenMPContextTest,RoundTripAndAssociation)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
TEST_F(OpenMPContextTest,ValidNesting)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
TEST_F(OpenMPContextTest,ApplicabilityNonConstruct)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(TraitProperty::user_condition_false, "");
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(TraitProperty::device_arch_arm, "");
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(TraitProperty::implementation_vendor_llvm, "");
98 LLVMHostUserCondTrue.addTrait(TraitProperty::device_kind_host, "");
99 LLVMHostUserCondTrue.addTrait(TraitProperty::device_kind_any, "");
100 LLVMHostUserCondTrue.addTrait(TraitProperty::user_condition_true, "");
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(TraitProperty::device_kind_cpu, "");
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(TraitProperty::device_kind_gpu, "");
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(TraitProperty::device_kind_nohost, "");
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
TEST_F(OpenMPContextTest,ApplicabilityAllTraits)131 TEST_F(OpenMPContextTest, ApplicabilityAllTraits) {
132 OMPContext HostLinuxParallelParallel(false, Triple("x86_64-unknown-linux"));
133 HostLinuxParallelParallel.addTrait(
134 TraitProperty::construct_parallel_parallel);
135 HostLinuxParallelParallel.addTrait(
136 TraitProperty::construct_parallel_parallel);
137 OMPContext DeviceLinuxTargetParallel(true, Triple("x86_64-unknown-linux"));
138 DeviceLinuxTargetParallel.addTrait(TraitProperty::construct_target_target);
139 DeviceLinuxTargetParallel.addTrait(
140 TraitProperty::construct_parallel_parallel);
141 OMPContext HostNVPTXFor(false, Triple("nvptx64-nvidia-cuda"));
142 HostNVPTXFor.addTrait(TraitProperty::construct_for_for);
143 OMPContext DeviceNVPTXTargetTeamsParallel(true,
144 Triple("nvptx64-nvidia-cuda"));
145 DeviceNVPTXTargetTeamsParallel.addTrait(
146 TraitProperty::construct_target_target);
147 DeviceNVPTXTargetTeamsParallel.addTrait(TraitProperty::construct_teams_teams);
148 DeviceNVPTXTargetTeamsParallel.addTrait(
149 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(TraitProperty::user_condition_false, "");
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(TraitProperty::device_arch_arm, "");
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(TraitProperty::implementation_vendor_llvm,
182 "");
183 LLVMHostUserCondTrue.addTrait(TraitProperty::device_kind_host, "");
184 LLVMHostUserCondTrue.addTrait(TraitProperty::device_kind_any, "");
185 LLVMHostUserCondTrue.addTrait(TraitProperty::user_condition_true, "",
186 &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(TraitProperty::device_kind_cpu, "");
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(TraitProperty::device_kind_gpu, "");
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(TraitProperty::device_kind_nohost, "");
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(TraitProperty::construct_parallel_parallel,
228 "");
229 DeviceArchArmParallel.addTrait(TraitProperty::device_arch_arm, "");
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 TraitProperty::implementation_vendor_llvm, "");
242 LLVMHostUserCondTrueParallel.addTrait(TraitProperty::device_kind_host, "");
243 LLVMHostUserCondTrueParallel.addTrait(TraitProperty::device_kind_any, "");
244 LLVMHostUserCondTrueParallel.addTrait(TraitProperty::user_condition_true,
245 "");
246 LLVMHostUserCondTrueParallel.addTrait(
247 TraitProperty::construct_parallel_parallel, "");
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 TraitProperty::construct_parallel_parallel, "");
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 TraitProperty::construct_parallel_parallel, "");
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(TraitProperty::construct_target_target, "");
288 GPUTargetTeams.addTrait(TraitProperty::construct_teams_teams, "");
289 GPUTargetTeams.addTrait(TraitProperty::device_kind_gpu, "");
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(TraitProperty::construct_target_target, "");
300 GPUTargetParallel.addTrait(TraitProperty::construct_parallel_parallel, "");
301 GPUTargetParallel.addTrait(TraitProperty::device_kind_gpu, "");
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
TEST_F(OpenMPContextTest,ScoringSimple)312 TEST_F(OpenMPContextTest, ScoringSimple) {
313 // TODO: Add scoring tests (via getBestVariantMatchForContext).
314 }
315
316 } // namespace
317