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