3db8e486e5
Always use cuda.h to detect CUDA version. It's a more universal approach compared to version.txt which is no longer present in recent CUDA versions. Split the 'unknown CUDA version' warning in two: * when detected CUDA version is partially supported by clang. It's expected to work in general, at the feature parity with the latest supported CUDA version. and may be missing support for the new features/instructions/GPU variants. Clang will issue a warning. * when detected version is new. Recent CUDA versions have been working with clang reasonably well, and will likely to work similarly to the partially supported ones above. Or it may not work at all. Clang will issue a warning and proceed as if the latest known CUDA version was detected. Differential Revision: https://reviews.llvm.org/D108247
263 lines
7.0 KiB
C++
263 lines
7.0 KiB
C++
#include "clang/Basic/Cuda.h"
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/VersionTuple.h"
|
|
|
|
namespace clang {
|
|
|
|
const char *CudaVersionToString(CudaVersion V) {
|
|
switch (V) {
|
|
case CudaVersion::UNKNOWN:
|
|
return "unknown";
|
|
case CudaVersion::CUDA_70:
|
|
return "7.0";
|
|
case CudaVersion::CUDA_75:
|
|
return "7.5";
|
|
case CudaVersion::CUDA_80:
|
|
return "8.0";
|
|
case CudaVersion::CUDA_90:
|
|
return "9.0";
|
|
case CudaVersion::CUDA_91:
|
|
return "9.1";
|
|
case CudaVersion::CUDA_92:
|
|
return "9.2";
|
|
case CudaVersion::CUDA_100:
|
|
return "10.0";
|
|
case CudaVersion::CUDA_101:
|
|
return "10.1";
|
|
case CudaVersion::CUDA_102:
|
|
return "10.2";
|
|
case CudaVersion::CUDA_110:
|
|
return "11.0";
|
|
case CudaVersion::CUDA_111:
|
|
return "11.1";
|
|
case CudaVersion::CUDA_112:
|
|
return "11.2";
|
|
case CudaVersion::CUDA_113:
|
|
return "11.3";
|
|
case CudaVersion::CUDA_114:
|
|
return "11.4";
|
|
case CudaVersion::NEW:
|
|
return "";
|
|
}
|
|
llvm_unreachable("invalid enum");
|
|
}
|
|
|
|
CudaVersion CudaStringToVersion(const llvm::Twine &S) {
|
|
return llvm::StringSwitch<CudaVersion>(S.str())
|
|
.Case("7.0", CudaVersion::CUDA_70)
|
|
.Case("7.5", CudaVersion::CUDA_75)
|
|
.Case("8.0", CudaVersion::CUDA_80)
|
|
.Case("9.0", CudaVersion::CUDA_90)
|
|
.Case("9.1", CudaVersion::CUDA_91)
|
|
.Case("9.2", CudaVersion::CUDA_92)
|
|
.Case("10.0", CudaVersion::CUDA_100)
|
|
.Case("10.1", CudaVersion::CUDA_101)
|
|
.Case("10.2", CudaVersion::CUDA_102)
|
|
.Case("11.0", CudaVersion::CUDA_110)
|
|
.Case("11.1", CudaVersion::CUDA_111)
|
|
.Case("11.2", CudaVersion::CUDA_112)
|
|
.Case("11.3", CudaVersion::CUDA_113)
|
|
.Case("11.4", CudaVersion::CUDA_114)
|
|
.Default(CudaVersion::UNKNOWN);
|
|
}
|
|
|
|
namespace {
|
|
struct CudaArchToStringMap {
|
|
CudaArch arch;
|
|
const char *arch_name;
|
|
const char *virtual_arch_name;
|
|
};
|
|
} // namespace
|
|
|
|
#define SM2(sm, ca) \
|
|
{ CudaArch::SM_##sm, "sm_" #sm, ca }
|
|
#define SM(sm) SM2(sm, "compute_" #sm)
|
|
#define GFX(gpu) \
|
|
{ CudaArch::GFX##gpu, "gfx" #gpu, "compute_amdgcn" }
|
|
static const CudaArchToStringMap arch_names[] = {
|
|
// clang-format off
|
|
{CudaArch::UNUSED, "", ""},
|
|
SM2(20, "compute_20"), SM2(21, "compute_20"), // Fermi
|
|
SM(30), SM(32), SM(35), SM(37), // Kepler
|
|
SM(50), SM(52), SM(53), // Maxwell
|
|
SM(60), SM(61), SM(62), // Pascal
|
|
SM(70), SM(72), // Volta
|
|
SM(75), // Turing
|
|
SM(80), SM(86), // Ampere
|
|
GFX(600), // gfx600
|
|
GFX(601), // gfx601
|
|
GFX(602), // gfx602
|
|
GFX(700), // gfx700
|
|
GFX(701), // gfx701
|
|
GFX(702), // gfx702
|
|
GFX(703), // gfx703
|
|
GFX(704), // gfx704
|
|
GFX(705), // gfx705
|
|
GFX(801), // gfx801
|
|
GFX(802), // gfx802
|
|
GFX(803), // gfx803
|
|
GFX(805), // gfx805
|
|
GFX(810), // gfx810
|
|
GFX(900), // gfx900
|
|
GFX(902), // gfx902
|
|
GFX(904), // gfx903
|
|
GFX(906), // gfx906
|
|
GFX(908), // gfx908
|
|
GFX(909), // gfx909
|
|
GFX(90a), // gfx90a
|
|
GFX(90c), // gfx90c
|
|
GFX(1010), // gfx1010
|
|
GFX(1011), // gfx1011
|
|
GFX(1012), // gfx1012
|
|
GFX(1013), // gfx1013
|
|
GFX(1030), // gfx1030
|
|
GFX(1031), // gfx1031
|
|
GFX(1032), // gfx1032
|
|
GFX(1033), // gfx1033
|
|
GFX(1034), // gfx1034
|
|
GFX(1035), // gfx1035
|
|
// clang-format on
|
|
};
|
|
#undef SM
|
|
#undef SM2
|
|
#undef GFX
|
|
|
|
const char *CudaArchToString(CudaArch A) {
|
|
auto result = std::find_if(
|
|
std::begin(arch_names), std::end(arch_names),
|
|
[A](const CudaArchToStringMap &map) { return A == map.arch; });
|
|
if (result == std::end(arch_names))
|
|
return "unknown";
|
|
return result->arch_name;
|
|
}
|
|
|
|
const char *CudaArchToVirtualArchString(CudaArch A) {
|
|
auto result = std::find_if(
|
|
std::begin(arch_names), std::end(arch_names),
|
|
[A](const CudaArchToStringMap &map) { return A == map.arch; });
|
|
if (result == std::end(arch_names))
|
|
return "unknown";
|
|
return result->virtual_arch_name;
|
|
}
|
|
|
|
CudaArch StringToCudaArch(llvm::StringRef S) {
|
|
auto result = std::find_if(
|
|
std::begin(arch_names), std::end(arch_names),
|
|
[S](const CudaArchToStringMap &map) { return S == map.arch_name; });
|
|
if (result == std::end(arch_names))
|
|
return CudaArch::UNKNOWN;
|
|
return result->arch;
|
|
}
|
|
|
|
CudaVersion MinVersionForCudaArch(CudaArch A) {
|
|
if (A == CudaArch::UNKNOWN)
|
|
return CudaVersion::UNKNOWN;
|
|
|
|
// AMD GPUs do not depend on CUDA versions.
|
|
if (IsAMDGpuArch(A))
|
|
return CudaVersion::CUDA_70;
|
|
|
|
switch (A) {
|
|
case CudaArch::SM_20:
|
|
case CudaArch::SM_21:
|
|
case CudaArch::SM_30:
|
|
case CudaArch::SM_32:
|
|
case CudaArch::SM_35:
|
|
case CudaArch::SM_37:
|
|
case CudaArch::SM_50:
|
|
case CudaArch::SM_52:
|
|
case CudaArch::SM_53:
|
|
return CudaVersion::CUDA_70;
|
|
case CudaArch::SM_60:
|
|
case CudaArch::SM_61:
|
|
case CudaArch::SM_62:
|
|
return CudaVersion::CUDA_80;
|
|
case CudaArch::SM_70:
|
|
return CudaVersion::CUDA_90;
|
|
case CudaArch::SM_72:
|
|
return CudaVersion::CUDA_91;
|
|
case CudaArch::SM_75:
|
|
return CudaVersion::CUDA_100;
|
|
case CudaArch::SM_80:
|
|
return CudaVersion::CUDA_110;
|
|
case CudaArch::SM_86:
|
|
return CudaVersion::CUDA_111;
|
|
default:
|
|
llvm_unreachable("invalid enum");
|
|
}
|
|
}
|
|
|
|
CudaVersion MaxVersionForCudaArch(CudaArch A) {
|
|
// AMD GPUs do not depend on CUDA versions.
|
|
if (IsAMDGpuArch(A))
|
|
return CudaVersion::NEW;
|
|
|
|
switch (A) {
|
|
case CudaArch::UNKNOWN:
|
|
return CudaVersion::UNKNOWN;
|
|
case CudaArch::SM_20:
|
|
case CudaArch::SM_21:
|
|
return CudaVersion::CUDA_80;
|
|
case CudaArch::SM_30:
|
|
return CudaVersion::CUDA_110;
|
|
default:
|
|
return CudaVersion::NEW;
|
|
}
|
|
}
|
|
|
|
CudaVersion ToCudaVersion(llvm::VersionTuple Version) {
|
|
int IVer =
|
|
Version.getMajor() * 10 + Version.getMinor().getValueOr(0);
|
|
switch(IVer) {
|
|
case 70:
|
|
return CudaVersion::CUDA_70;
|
|
case 75:
|
|
return CudaVersion::CUDA_75;
|
|
case 80:
|
|
return CudaVersion::CUDA_80;
|
|
case 90:
|
|
return CudaVersion::CUDA_90;
|
|
case 91:
|
|
return CudaVersion::CUDA_91;
|
|
case 92:
|
|
return CudaVersion::CUDA_92;
|
|
case 100:
|
|
return CudaVersion::CUDA_100;
|
|
case 101:
|
|
return CudaVersion::CUDA_101;
|
|
case 102:
|
|
return CudaVersion::CUDA_102;
|
|
case 110:
|
|
return CudaVersion::CUDA_110;
|
|
case 111:
|
|
return CudaVersion::CUDA_111;
|
|
case 112:
|
|
return CudaVersion::CUDA_112;
|
|
case 113:
|
|
return CudaVersion::CUDA_113;
|
|
case 114:
|
|
return CudaVersion::CUDA_114;
|
|
default:
|
|
return CudaVersion::UNKNOWN;
|
|
}
|
|
}
|
|
|
|
bool CudaFeatureEnabled(llvm::VersionTuple Version, CudaFeature Feature) {
|
|
return CudaFeatureEnabled(ToCudaVersion(Version), Feature);
|
|
}
|
|
|
|
bool CudaFeatureEnabled(CudaVersion Version, CudaFeature Feature) {
|
|
switch (Feature) {
|
|
case CudaFeature::CUDA_USES_NEW_LAUNCH:
|
|
return Version >= CudaVersion::CUDA_92;
|
|
case CudaFeature::CUDA_USES_FATBIN_REGISTER_END:
|
|
return Version >= CudaVersion::CUDA_101;
|
|
}
|
|
llvm_unreachable("Unknown CUDA feature.");
|
|
}
|
|
} // namespace clang
|