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