1 //===- OMPContext.cpp ------ Collection of helpers for OpenMP contexts ----===// 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 /// \file 9 /// 10 /// This file implements helper functions and classes to deal with OpenMP 11 /// contexts as used by `[begin/end] declare variant` and `metadirective`. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/Frontend/OpenMP/OMPContext.h" 16 #include "llvm/ADT/StringRef.h" 17 #include "llvm/ADT/StringSwitch.h" 18 #include "llvm/Support/Debug.h" 19 #include "llvm/Support/raw_ostream.h" 20 #include "llvm/TargetParser/Triple.h" 21 22 #define DEBUG_TYPE "openmp-ir-builder" 23 24 using namespace llvm; 25 using namespace omp; 26 27 OMPContext::OMPContext(bool IsDeviceCompilation, Triple TargetTriple) { 28 // Add the appropriate device kind trait based on the triple and the 29 // IsDeviceCompilation flag. 30 ActiveTraits.set(unsigned(IsDeviceCompilation 31 ? TraitProperty::device_kind_nohost 32 : TraitProperty::device_kind_host)); 33 switch (TargetTriple.getArch()) { 34 case Triple::arm: 35 case Triple::armeb: 36 case Triple::aarch64: 37 case Triple::aarch64_be: 38 case Triple::aarch64_32: 39 case Triple::loongarch64: 40 case Triple::mips: 41 case Triple::mipsel: 42 case Triple::mips64: 43 case Triple::mips64el: 44 case Triple::ppc: 45 case Triple::ppcle: 46 case Triple::ppc64: 47 case Triple::ppc64le: 48 case Triple::systemz: 49 case Triple::x86: 50 case Triple::x86_64: 51 ActiveTraits.set(unsigned(TraitProperty::device_kind_cpu)); 52 break; 53 case Triple::amdgcn: 54 case Triple::nvptx: 55 case Triple::nvptx64: 56 ActiveTraits.set(unsigned(TraitProperty::device_kind_gpu)); 57 break; 58 default: 59 break; 60 } 61 62 // Add the appropriate device architecture trait based on the triple. 63 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ 64 if (TraitSelector::TraitSelectorEnum == TraitSelector::device_arch) { \ 65 if (TargetTriple.getArch() == TargetTriple.getArchTypeForLLVMName(Str)) \ 66 ActiveTraits.set(unsigned(TraitProperty::Enum)); \ 67 if (StringRef(Str) == "x86_64" && \ 68 TargetTriple.getArch() == Triple::x86_64) \ 69 ActiveTraits.set(unsigned(TraitProperty::Enum)); \ 70 } 71 #include "llvm/Frontend/OpenMP/OMPKinds.def" 72 73 // TODO: What exactly do we want to see as device ISA trait? 74 // The discussion on the list did not seem to have come to an agreed 75 // upon solution. 76 77 // LLVM is the "OpenMP vendor" but we could also interpret vendor as the 78 // target vendor. 79 ActiveTraits.set(unsigned(TraitProperty::implementation_vendor_llvm)); 80 81 // The user condition true is accepted but not false. 82 ActiveTraits.set(unsigned(TraitProperty::user_condition_true)); 83 84 // This is for sure some device. 85 ActiveTraits.set(unsigned(TraitProperty::device_kind_any)); 86 87 LLVM_DEBUG({ 88 dbgs() << "[" << DEBUG_TYPE 89 << "] New OpenMP context with the following properties:\n"; 90 for (unsigned Bit : ActiveTraits.set_bits()) { 91 TraitProperty Property = TraitProperty(Bit); 92 dbgs() << "\t " << getOpenMPContextTraitPropertyFullName(Property) 93 << "\n"; 94 } 95 }); 96 } 97 98 /// Return true if \p C0 is a subset of \p C1. Note that both arrays are 99 /// expected to be sorted. 100 template <typename T> static bool isSubset(ArrayRef<T> C0, ArrayRef<T> C1) { 101 #ifdef EXPENSIVE_CHECKS 102 assert(llvm::is_sorted(C0) && llvm::is_sorted(C1) && 103 "Expected sorted arrays!"); 104 #endif 105 if (C0.size() > C1.size()) 106 return false; 107 auto It0 = C0.begin(), End0 = C0.end(); 108 auto It1 = C1.begin(), End1 = C1.end(); 109 while (It0 != End0) { 110 if (It1 == End1) 111 return false; 112 if (*It0 == *It1) { 113 ++It0; 114 ++It1; 115 continue; 116 } 117 ++It0; 118 } 119 return true; 120 } 121 122 /// Return true if \p C0 is a strict subset of \p C1. Note that both arrays are 123 /// expected to be sorted. 124 template <typename T> 125 static bool isStrictSubset(ArrayRef<T> C0, ArrayRef<T> C1) { 126 if (C0.size() >= C1.size()) 127 return false; 128 return isSubset<T>(C0, C1); 129 } 130 131 static bool isStrictSubset(const VariantMatchInfo &VMI0, 132 const VariantMatchInfo &VMI1) { 133 // If all required traits are a strict subset and the ordered vectors storing 134 // the construct traits, we say it is a strict subset. Note that the latter 135 // relation is not required to be strict. 136 if (VMI0.RequiredTraits.count() >= VMI1.RequiredTraits.count()) 137 return false; 138 for (unsigned Bit : VMI0.RequiredTraits.set_bits()) 139 if (!VMI1.RequiredTraits.test(Bit)) 140 return false; 141 if (!isSubset<TraitProperty>(VMI0.ConstructTraits, VMI1.ConstructTraits)) 142 return false; 143 return true; 144 } 145 146 static int isVariantApplicableInContextHelper( 147 const VariantMatchInfo &VMI, const OMPContext &Ctx, 148 SmallVectorImpl<unsigned> *ConstructMatches, bool DeviceSetOnly) { 149 150 // The match kind determines if we need to match all traits, any of the 151 // traits, or none of the traits for it to be an applicable context. 152 enum MatchKind { MK_ALL, MK_ANY, MK_NONE }; 153 154 MatchKind MK = MK_ALL; 155 // Determine the match kind the user wants, "all" is the default and provided 156 // to the user only for completeness. 157 if (VMI.RequiredTraits.test( 158 unsigned(TraitProperty::implementation_extension_match_any))) 159 MK = MK_ANY; 160 if (VMI.RequiredTraits.test( 161 unsigned(TraitProperty::implementation_extension_match_none))) 162 MK = MK_NONE; 163 164 // Helper to deal with a single property that was (not) found in the OpenMP 165 // context based on the match kind selected by the user via 166 // `implementation={extensions(match_[all,any,none])}' 167 auto HandleTrait = [MK](TraitProperty Property, 168 bool WasFound) -> std::optional<bool> /* Result */ { 169 // For kind "any" a single match is enough but we ignore non-matched 170 // properties. 171 if (MK == MK_ANY) { 172 if (WasFound) 173 return true; 174 return std::nullopt; 175 } 176 177 // In "all" or "none" mode we accept a matching or non-matching property 178 // respectively and move on. We are not done yet! 179 if ((WasFound && MK == MK_ALL) || (!WasFound && MK == MK_NONE)) 180 return std::nullopt; 181 182 // We missed a property, provide some debug output and indicate failure. 183 LLVM_DEBUG({ 184 if (MK == MK_ALL) 185 dbgs() << "[" << DEBUG_TYPE << "] Property " 186 << getOpenMPContextTraitPropertyName(Property, "") 187 << " was not in the OpenMP context but match kind is all.\n"; 188 if (MK == MK_NONE) 189 dbgs() << "[" << DEBUG_TYPE << "] Property " 190 << getOpenMPContextTraitPropertyName(Property, "") 191 << " was in the OpenMP context but match kind is none.\n"; 192 }); 193 return false; 194 }; 195 196 for (unsigned Bit : VMI.RequiredTraits.set_bits()) { 197 TraitProperty Property = TraitProperty(Bit); 198 if (DeviceSetOnly && 199 getOpenMPContextTraitSetForProperty(Property) != TraitSet::device) 200 continue; 201 202 // So far all extensions are handled elsewhere, we skip them here as they 203 // are not part of the OpenMP context. 204 if (getOpenMPContextTraitSelectorForProperty(Property) == 205 TraitSelector::implementation_extension) 206 continue; 207 208 bool IsActiveTrait = Ctx.ActiveTraits.test(unsigned(Property)); 209 210 // We overwrite the isa trait as it is actually up to the OMPContext hook to 211 // check the raw string(s). 212 if (Property == TraitProperty::device_isa___ANY) 213 IsActiveTrait = llvm::all_of(VMI.ISATraits, [&](StringRef RawString) { 214 return Ctx.matchesISATrait(RawString); 215 }); 216 217 if (std::optional<bool> Result = HandleTrait(Property, IsActiveTrait)) 218 return *Result; 219 } 220 221 if (!DeviceSetOnly) { 222 // We could use isSubset here but we also want to record the match 223 // locations. 224 unsigned ConstructIdx = 0, NoConstructTraits = Ctx.ConstructTraits.size(); 225 for (TraitProperty Property : VMI.ConstructTraits) { 226 assert(getOpenMPContextTraitSetForProperty(Property) == 227 TraitSet::construct && 228 "Variant context is ill-formed!"); 229 230 // Verify the nesting. 231 bool FoundInOrder = false; 232 while (!FoundInOrder && ConstructIdx != NoConstructTraits) 233 FoundInOrder = (Ctx.ConstructTraits[ConstructIdx++] == Property); 234 if (ConstructMatches) 235 ConstructMatches->push_back(ConstructIdx - 1); 236 237 if (std::optional<bool> Result = HandleTrait(Property, FoundInOrder)) 238 return *Result; 239 240 if (!FoundInOrder) { 241 LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE << "] Construct property " 242 << getOpenMPContextTraitPropertyName(Property, "") 243 << " was not nested properly.\n"); 244 return false; 245 } 246 247 // TODO: Verify SIMD 248 } 249 250 assert(isSubset<TraitProperty>(VMI.ConstructTraits, Ctx.ConstructTraits) && 251 "Broken invariant!"); 252 } 253 254 if (MK == MK_ANY) { 255 LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE 256 << "] None of the properties was in the OpenMP context " 257 "but match kind is any.\n"); 258 return false; 259 } 260 261 return true; 262 } 263 264 bool llvm::omp::isVariantApplicableInContext(const VariantMatchInfo &VMI, 265 const OMPContext &Ctx, 266 bool DeviceSetOnly) { 267 return isVariantApplicableInContextHelper( 268 VMI, Ctx, /* ConstructMatches */ nullptr, DeviceSetOnly); 269 } 270 271 static APInt getVariantMatchScore(const VariantMatchInfo &VMI, 272 const OMPContext &Ctx, 273 SmallVectorImpl<unsigned> &ConstructMatches) { 274 APInt Score(64, 1); 275 276 unsigned NoConstructTraits = VMI.ConstructTraits.size(); 277 for (unsigned Bit : VMI.RequiredTraits.set_bits()) { 278 TraitProperty Property = TraitProperty(Bit); 279 // If there is a user score attached, use it. 280 if (VMI.ScoreMap.count(Property)) { 281 const APInt &UserScore = VMI.ScoreMap.lookup(Property); 282 assert(UserScore.uge(0) && "Expect non-negative user scores!"); 283 Score += UserScore.getZExtValue(); 284 continue; 285 } 286 287 switch (getOpenMPContextTraitSetForProperty(Property)) { 288 case TraitSet::construct: 289 // We handle the construct traits later via the VMI.ConstructTraits 290 // container. 291 continue; 292 case TraitSet::implementation: 293 // No effect on the score (implementation defined). 294 continue; 295 case TraitSet::user: 296 // No effect on the score. 297 continue; 298 case TraitSet::device: 299 // Handled separately below. 300 break; 301 case TraitSet::invalid: 302 llvm_unreachable("Unknown trait set is not to be used!"); 303 } 304 305 // device={kind(any)} is "as if" no kind selector was specified. 306 if (Property == TraitProperty::device_kind_any) 307 continue; 308 309 switch (getOpenMPContextTraitSelectorForProperty(Property)) { 310 case TraitSelector::device_kind: 311 Score += (1ULL << (NoConstructTraits + 0)); 312 continue; 313 case TraitSelector::device_arch: 314 Score += (1ULL << (NoConstructTraits + 1)); 315 continue; 316 case TraitSelector::device_isa: 317 Score += (1ULL << (NoConstructTraits + 2)); 318 continue; 319 default: 320 continue; 321 } 322 } 323 324 unsigned ConstructIdx = 0; 325 assert(NoConstructTraits == ConstructMatches.size() && 326 "Mismatch in the construct traits!"); 327 for (TraitProperty Property : VMI.ConstructTraits) { 328 assert(getOpenMPContextTraitSetForProperty(Property) == 329 TraitSet::construct && 330 "Ill-formed variant match info!"); 331 (void)Property; 332 // ConstructMatches is the position p - 1 and we need 2^(p-1). 333 Score += (1ULL << ConstructMatches[ConstructIdx++]); 334 } 335 336 LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE << "] Variant has a score of " << Score 337 << "\n"); 338 return Score; 339 } 340 341 int llvm::omp::getBestVariantMatchForContext( 342 const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx) { 343 344 APInt BestScore(64, 0); 345 int BestVMIIdx = -1; 346 const VariantMatchInfo *BestVMI = nullptr; 347 348 for (unsigned u = 0, e = VMIs.size(); u < e; ++u) { 349 const VariantMatchInfo &VMI = VMIs[u]; 350 351 SmallVector<unsigned, 8> ConstructMatches; 352 // If the variant is not applicable its not the best. 353 if (!isVariantApplicableInContextHelper(VMI, Ctx, &ConstructMatches, 354 /* DeviceSetOnly */ false)) 355 continue; 356 // Check if its clearly not the best. 357 APInt Score = getVariantMatchScore(VMI, Ctx, ConstructMatches); 358 if (Score.ult(BestScore)) 359 continue; 360 // Equal score need subset checks. 361 if (Score.eq(BestScore)) { 362 // Strict subset are never best. 363 if (isStrictSubset(VMI, *BestVMI)) 364 continue; 365 // Same score and the current best is no strict subset so we keep it. 366 if (!isStrictSubset(*BestVMI, VMI)) 367 continue; 368 } 369 // New best found. 370 BestVMI = &VMI; 371 BestVMIIdx = u; 372 BestScore = Score; 373 } 374 375 return BestVMIIdx; 376 } 377 378 TraitSet llvm::omp::getOpenMPContextTraitSetKind(StringRef S) { 379 return StringSwitch<TraitSet>(S) 380 #define OMP_TRAIT_SET(Enum, Str) .Case(Str, TraitSet::Enum) 381 #include "llvm/Frontend/OpenMP/OMPKinds.def" 382 .Default(TraitSet::invalid); 383 } 384 385 TraitSet 386 llvm::omp::getOpenMPContextTraitSetForSelector(TraitSelector Selector) { 387 switch (Selector) { 388 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \ 389 case TraitSelector::Enum: \ 390 return TraitSet::TraitSetEnum; 391 #include "llvm/Frontend/OpenMP/OMPKinds.def" 392 } 393 llvm_unreachable("Unknown trait selector!"); 394 } 395 TraitSet 396 llvm::omp::getOpenMPContextTraitSetForProperty(TraitProperty Property) { 397 switch (Property) { 398 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ 399 case TraitProperty::Enum: \ 400 return TraitSet::TraitSetEnum; 401 #include "llvm/Frontend/OpenMP/OMPKinds.def" 402 } 403 llvm_unreachable("Unknown trait set!"); 404 } 405 StringRef llvm::omp::getOpenMPContextTraitSetName(TraitSet Kind) { 406 switch (Kind) { 407 #define OMP_TRAIT_SET(Enum, Str) \ 408 case TraitSet::Enum: \ 409 return Str; 410 #include "llvm/Frontend/OpenMP/OMPKinds.def" 411 } 412 llvm_unreachable("Unknown trait set!"); 413 } 414 415 TraitSelector llvm::omp::getOpenMPContextTraitSelectorKind(StringRef S) { 416 return StringSwitch<TraitSelector>(S) 417 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \ 418 .Case(Str, TraitSelector::Enum) 419 #include "llvm/Frontend/OpenMP/OMPKinds.def" 420 .Default(TraitSelector::invalid); 421 } 422 TraitSelector 423 llvm::omp::getOpenMPContextTraitSelectorForProperty(TraitProperty Property) { 424 switch (Property) { 425 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ 426 case TraitProperty::Enum: \ 427 return TraitSelector::TraitSelectorEnum; 428 #include "llvm/Frontend/OpenMP/OMPKinds.def" 429 } 430 llvm_unreachable("Unknown trait set!"); 431 } 432 StringRef llvm::omp::getOpenMPContextTraitSelectorName(TraitSelector Kind) { 433 switch (Kind) { 434 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \ 435 case TraitSelector::Enum: \ 436 return Str; 437 #include "llvm/Frontend/OpenMP/OMPKinds.def" 438 } 439 llvm_unreachable("Unknown trait selector!"); 440 } 441 442 TraitProperty llvm::omp::getOpenMPContextTraitPropertyKind( 443 TraitSet Set, TraitSelector Selector, StringRef S) { 444 // Special handling for `device={isa(...)}` as we accept anything here. It is 445 // up to the target to decide if the feature is available. 446 if (Set == TraitSet::device && Selector == TraitSelector::device_isa) 447 return TraitProperty::device_isa___ANY; 448 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ 449 if (Set == TraitSet::TraitSetEnum && Str == S) \ 450 return TraitProperty::Enum; 451 #include "llvm/Frontend/OpenMP/OMPKinds.def" 452 return TraitProperty::invalid; 453 } 454 TraitProperty 455 llvm::omp::getOpenMPContextTraitPropertyForSelector(TraitSelector Selector) { 456 return StringSwitch<TraitProperty>( 457 getOpenMPContextTraitSelectorName(Selector)) 458 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ 459 .Case(Str, Selector == TraitSelector::TraitSelectorEnum \ 460 ? TraitProperty::Enum \ 461 : TraitProperty::invalid) 462 #include "llvm/Frontend/OpenMP/OMPKinds.def" 463 .Default(TraitProperty::invalid); 464 } 465 StringRef llvm::omp::getOpenMPContextTraitPropertyName(TraitProperty Kind, 466 StringRef RawString) { 467 if (Kind == TraitProperty::device_isa___ANY) 468 return RawString; 469 switch (Kind) { 470 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ 471 case TraitProperty::Enum: \ 472 return Str; 473 #include "llvm/Frontend/OpenMP/OMPKinds.def" 474 } 475 llvm_unreachable("Unknown trait property!"); 476 } 477 StringRef llvm::omp::getOpenMPContextTraitPropertyFullName(TraitProperty Kind) { 478 switch (Kind) { 479 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ 480 case TraitProperty::Enum: \ 481 return "(" #TraitSetEnum "," #TraitSelectorEnum "," Str ")"; 482 #include "llvm/Frontend/OpenMP/OMPKinds.def" 483 } 484 llvm_unreachable("Unknown trait property!"); 485 } 486 487 bool llvm::omp::isValidTraitSelectorForTraitSet(TraitSelector Selector, 488 TraitSet Set, 489 bool &AllowsTraitScore, 490 bool &RequiresProperty) { 491 AllowsTraitScore = Set != TraitSet::construct && Set != TraitSet::device; 492 switch (Selector) { 493 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \ 494 case TraitSelector::Enum: \ 495 RequiresProperty = ReqProp; \ 496 return Set == TraitSet::TraitSetEnum; 497 #include "llvm/Frontend/OpenMP/OMPKinds.def" 498 } 499 llvm_unreachable("Unknown trait selector!"); 500 } 501 502 bool llvm::omp::isValidTraitPropertyForTraitSetAndSelector( 503 TraitProperty Property, TraitSelector Selector, TraitSet Set) { 504 switch (Property) { 505 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ 506 case TraitProperty::Enum: \ 507 return Set == TraitSet::TraitSetEnum && \ 508 Selector == TraitSelector::TraitSelectorEnum; 509 #include "llvm/Frontend/OpenMP/OMPKinds.def" 510 } 511 llvm_unreachable("Unknown trait property!"); 512 } 513 514 std::string llvm::omp::listOpenMPContextTraitSets() { 515 std::string S; 516 #define OMP_TRAIT_SET(Enum, Str) \ 517 if (StringRef(Str) != "invalid") \ 518 S.append("'").append(Str).append("'").append(" "); 519 #include "llvm/Frontend/OpenMP/OMPKinds.def" 520 S.pop_back(); 521 return S; 522 } 523 524 std::string llvm::omp::listOpenMPContextTraitSelectors(TraitSet Set) { 525 std::string S; 526 #define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp) \ 527 if (TraitSet::TraitSetEnum == Set && StringRef(Str) != "Invalid") \ 528 S.append("'").append(Str).append("'").append(" "); 529 #include "llvm/Frontend/OpenMP/OMPKinds.def" 530 S.pop_back(); 531 return S; 532 } 533 534 std::string 535 llvm::omp::listOpenMPContextTraitProperties(TraitSet Set, 536 TraitSelector Selector) { 537 std::string S; 538 #define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str) \ 539 if (TraitSet::TraitSetEnum == Set && \ 540 TraitSelector::TraitSelectorEnum == Selector && \ 541 StringRef(Str) != "invalid") \ 542 S.append("'").append(Str).append("'").append(" "); 543 #include "llvm/Frontend/OpenMP/OMPKinds.def" 544 if (S.empty()) 545 return "<none>"; 546 S.pop_back(); 547 return S; 548 } 549