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/ADT/Triple.h"
10 #include "llvm/Frontend/OpenMP/OMPConstants.h"
11 #include "llvm/Frontend/OpenMP/OMPContext.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(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 
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 
312 TEST_F(OpenMPContextTest, ScoringSimple) {
313   // TODO: Add scoring tests (via getBestVariantMatchForContext).
314 }
315 
316 } // namespace
317