clang/lib/Basic/Cuda.cpp

   1 #include "clang/Basic/Cuda.h"
   2
   3 #include "llvm/ADT/StringRef.h"
   4 #include "llvm/ADT/StringSwitch.h"
   5 #include "llvm/ADT/Twine.h"
   6 #include "llvm/Support/ErrorHandling.h"
   7 #include "llvm/Support/VersionTuple.h"
   8
   9 namespace clang {
  10
  11 const char *CudaVersionToString(CudaVersion V) {
  12   switch (V) {
  13   case CudaVersion::UNKNOWN:
  14     return "unknown";
  15   case CudaVersion::CUDA_70:
  16     return "7.0";
  17   case CudaVersion::CUDA_75:
  18     return "7.5";
  19   case CudaVersion::CUDA_80:
  20     return "8.0";
  21   case CudaVersion::CUDA_90:
  22     return "9.0";
  23   case CudaVersion::CUDA_91:
  24     return "9.1";
  25   case CudaVersion::CUDA_92:
  26     return "9.2";
  27   case CudaVersion::CUDA_100:
  28     return "10.0";
  29   case CudaVersion::CUDA_101:
  30     return "10.1";
  31   case CudaVersion::CUDA_102:
  32     return "10.2";
  33   case CudaVersion::CUDA_110:
  34     return "11.0";
  35   case CudaVersion::CUDA_111:
  36     return "11.1";
  37   case CudaVersion::CUDA_112:
  38     return "11.2";
  39   case CudaVersion::CUDA_113:
  40     return "11.3";
  41   case CudaVersion::CUDA_114:
  42     return "11.4";
  43   case CudaVersion::CUDA_115:
  44     return "11.5";
  45   case CudaVersion::NEW:
  46     return "";
  47   }
  48   llvm_unreachable("invalid enum");
  49 }
  50
  51 CudaVersion CudaStringToVersion(const llvm::Twine &S) {
  52   return llvm::StringSwitch<CudaVersion>(S.str())
  53       .Case("7.0", CudaVersion::CUDA_70)
  54       .Case("7.5", CudaVersion::CUDA_75)
  55       .Case("8.0", CudaVersion::CUDA_80)
  56       .Case("9.0", CudaVersion::CUDA_90)
  57       .Case("9.1", CudaVersion::CUDA_91)
  58       .Case("9.2", CudaVersion::CUDA_92)
  59       .Case("10.0", CudaVersion::CUDA_100)
  60       .Case("10.1", CudaVersion::CUDA_101)
  61       .Case("10.2", CudaVersion::CUDA_102)
  62       .Case("11.0", CudaVersion::CUDA_110)
  63       .Case("11.1", CudaVersion::CUDA_111)
  64       .Case("11.2", CudaVersion::CUDA_112)
  65       .Case("11.3", CudaVersion::CUDA_113)
  66       .Case("11.4", CudaVersion::CUDA_114)
  67       .Case("11.5", CudaVersion::CUDA_115)
  68       .Default(CudaVersion::UNKNOWN);
  69 }
  70
  71 namespace {
  72 struct CudaArchToStringMap {
  73   CudaArch arch;
  74   const char *arch_name;
  75   const char *virtual_arch_name;
  76 };
  77 } // namespace
  78
  79 #define SM2(sm, ca)                                                            \
  80   { CudaArch::SM_##sm, "sm_" #sm, ca }
  81 #define SM(sm) SM2(sm, "compute_" #sm)
  82 #define GFX(gpu)                                                               \
  83   { CudaArch::GFX##gpu, "gfx" #gpu, "compute_amdgcn" }
  84 static const CudaArchToStringMap arch_names[] = {
  85     // clang-format off
  86     {CudaArch::UNUSED, "", ""},
  87     SM2(20, "compute_20"), SM2(21, "compute_20"), // Fermi
  88     SM(30), SM(32), SM(35), SM(37),  // Kepler
  89     SM(50), SM(52), SM(53),          // Maxwell
  90     SM(60), SM(61), SM(62),          // Pascal
  91     SM(70), SM(72),                  // Volta
  92     SM(75),                          // Turing
  93     SM(80), SM(86),                  // Ampere
  94     GFX(600),  // gfx600
  95     GFX(601),  // gfx601
  96     GFX(602),  // gfx602
  97     GFX(700),  // gfx700
  98     GFX(701),  // gfx701
  99     GFX(702),  // gfx702
 100     GFX(703),  // gfx703
 101     GFX(704),  // gfx704
 102     GFX(705),  // gfx705
 103     GFX(801),  // gfx801
 104     GFX(802),  // gfx802
 105     GFX(803),  // gfx803
 106     GFX(805),  // gfx805
 107     GFX(810),  // gfx810
 108     GFX(900),  // gfx900
 109     GFX(902),  // gfx902
 110     GFX(904),  // gfx903
 111     GFX(906),  // gfx906
 112     GFX(908),  // gfx908
 113     GFX(909),  // gfx909
 114     GFX(90a),  // gfx90a
 115     GFX(90c),  // gfx90c
 116     GFX(940),  // gfx940
 117     GFX(1010), // gfx1010
 118     GFX(1011), // gfx1011
 119     GFX(1012), // gfx1012
 120     GFX(1013), // gfx1013
 121     GFX(1030), // gfx1030
 122     GFX(1031), // gfx1031
 123     GFX(1032), // gfx1032
 124     GFX(1033), // gfx1033
 125     GFX(1034), // gfx1034
 126     GFX(1035), // gfx1035
 127     GFX(1036), // gfx1036
 128     {CudaArch::Generic, "generic", ""},
 129     // clang-format on
 130 };
 131 #undef SM
 132 #undef SM2
 133 #undef GFX
 134
 135 const char *CudaArchToString(CudaArch A) {
 136   auto result = std::find_if(
 137       std::begin(arch_names), std::end(arch_names),
 138       [A](const CudaArchToStringMap &map) { return A == map.arch; });
 139   if (result == std::end(arch_names))
 140     return "unknown";
 141   return result->arch_name;
 142 }
 143
 144 const char *CudaArchToVirtualArchString(CudaArch A) {
 145   auto result = std::find_if(
 146       std::begin(arch_names), std::end(arch_names),
 147       [A](const CudaArchToStringMap &map) { return A == map.arch; });
 148   if (result == std::end(arch_names))
 149     return "unknown";
 150   return result->virtual_arch_name;
 151 }
 152
 153 CudaArch StringToCudaArch(llvm::StringRef S) {
 154   auto result = std::find_if(
 155       std::begin(arch_names), std::end(arch_names),
 156       [S](const CudaArchToStringMap &map) { return S == map.arch_name; });
 157   if (result == std::end(arch_names))
 158     return CudaArch::UNKNOWN;
 159   return result->arch;
 160 }
 161
 162 CudaVersion MinVersionForCudaArch(CudaArch A) {
 163   if (A == CudaArch::UNKNOWN)
 164     return CudaVersion::UNKNOWN;
 165
 166   // AMD GPUs do not depend on CUDA versions.
 167   if (IsAMDGpuArch(A))
 168     return CudaVersion::CUDA_70;
 169
 170   switch (A) {
 171   case CudaArch::SM_20:
 172   case CudaArch::SM_21:
 173   case CudaArch::SM_30:
 174   case CudaArch::SM_32:
 175   case CudaArch::SM_35:
 176   case CudaArch::SM_37:
 177   case CudaArch::SM_50:
 178   case CudaArch::SM_52:
 179   case CudaArch::SM_53:
 180     return CudaVersion::CUDA_70;
 181   case CudaArch::SM_60:
 182   case CudaArch::SM_61:
 183   case CudaArch::SM_62:
 184     return CudaVersion::CUDA_80;
 185   case CudaArch::SM_70:
 186     return CudaVersion::CUDA_90;
 187   case CudaArch::SM_72:
 188     return CudaVersion::CUDA_91;
 189   case CudaArch::SM_75:
 190     return CudaVersion::CUDA_100;
 191   case CudaArch::SM_80:
 192     return CudaVersion::CUDA_110;
 193   case CudaArch::SM_86:
 194     return CudaVersion::CUDA_111;
 195   default:
 196     llvm_unreachable("invalid enum");
 197   }
 198 }
 199
 200 CudaVersion MaxVersionForCudaArch(CudaArch A) {
 201   // AMD GPUs do not depend on CUDA versions.
 202   if (IsAMDGpuArch(A))
 203     return CudaVersion::NEW;
 204
 205   switch (A) {
 206   case CudaArch::UNKNOWN:
 207     return CudaVersion::UNKNOWN;
 208   case CudaArch::SM_20:
 209   case CudaArch::SM_21:
 210     return CudaVersion::CUDA_80;
 211   case CudaArch::SM_30:
 212     return CudaVersion::CUDA_110;
 213   default:
 214     return CudaVersion::NEW;
 215   }
 216 }
 217
 218 CudaVersion ToCudaVersion(llvm::VersionTuple Version) {
 219   int IVer =
 220       Version.getMajor() * 10 + Version.getMinor().getValueOr(0);
 221   switch(IVer) {
 222   case 70:
 223     return CudaVersion::CUDA_70;
 224   case 75:
 225     return CudaVersion::CUDA_75;
 226   case 80:
 227     return CudaVersion::CUDA_80;
 228   case 90:
 229     return CudaVersion::CUDA_90;
 230   case 91:
 231     return CudaVersion::CUDA_91;
 232   case 92:
 233     return CudaVersion::CUDA_92;
 234   case 100:
 235     return CudaVersion::CUDA_100;
 236   case 101:
 237     return CudaVersion::CUDA_101;
 238   case 102:
 239     return CudaVersion::CUDA_102;
 240   case 110:
 241     return CudaVersion::CUDA_110;
 242   case 111:
 243     return CudaVersion::CUDA_111;
 244   case 112:
 245     return CudaVersion::CUDA_112;
 246   case 113:
 247     return CudaVersion::CUDA_113;
 248   case 114:
 249     return CudaVersion::CUDA_114;
 250   case 115:
 251     return CudaVersion::CUDA_115;
 252   default:
 253     return CudaVersion::UNKNOWN;
 254   }
 255 }
 256
 257 bool CudaFeatureEnabled(llvm::VersionTuple  Version, CudaFeature Feature) {
 258   return CudaFeatureEnabled(ToCudaVersion(Version), Feature);
 259 }
 260
 261 bool CudaFeatureEnabled(CudaVersion Version, CudaFeature Feature) {
 262   switch (Feature) {
 263   case CudaFeature::CUDA_USES_NEW_LAUNCH:
 264     return Version >= CudaVersion::CUDA_92;
 265   case CudaFeature::CUDA_USES_FATBIN_REGISTER_END:
 266     return Version >= CudaVersion::CUDA_101;
 267   }
 268   llvm_unreachable("Unknown CUDA feature.");
 269 }
 270 } // namespace clang