[CUDA] Print an error if you try to compile with < sm_30 on CUDA 9.

[jlebar]

Summary

CUDA 9's minimum sm is sm_30.

Ideally we should also make sm_30 the default when compiling with CUDA
9, but that seems harder than it should be.

[jlebar]

Fix libdevice files.

[tra]

clang/lib/Driver/ToolChains/Cuda.cpp

211–228 ↗

(On Diff #119625)

Generally speaking, if a user attempts to compile for sm_20 with cuda-9, we can't really tell whether he mistyped --cuda-path argument and pointed us to cuda-9 instead of cuda-8 or mistyped --cuda-gpu-arch and asked for sm_20 instead of sm_30. We'll report _arch_too_low, while in reality it could be the case of "CUDA version too high".

Perhaps it would be better to collapse MinVersionForCudaArch(Arch) and MinArchForCudaVersion(Version) into isSupportedCudaArch(CUDA Version, GPU arch) and just report if particular GPU arch is not supported by this CUDA version. That should be sufficient for user to figure out which of the two parameters were wrong.

[jlebar]

Generally speaking, if a user attempts to compile for sm_20 with cuda-9, we can't really tell whether he mistyped --cuda-path argument and pointed us to cuda-9 instead of cuda-8 or mistyped --cuda-gpu-arch and asked for sm_20 instead of sm_30. We'll report _arch_too_low, while in reality it could be the case of "CUDA version too high".

Agreed, maybe the messages in DiagnosticDriverKinds.td don't have the best names (though I'm struggling to improve them).

But do you think the error message we'll print is bad? For example:

CUDA version 9.0 does not support compiling for GPU archs earlier than sm_30, so cannot compile for sm_20. Use --cuda-gpu-arch to specify a different GPU arch, use --cuda-path to specify a different CUDA install, or pass --no-cuda-version-check.

The other error message you might get is something like

GPU arch sm_70 requires CUDA version at least 9.0, but installation at /usr/local/cuda is 8.0. Use --cuda-path to specify a different CUDA install, or pass --no-cuda-version-check.

For this one we could add a clause mentioning --cuda-gpu-arch, but I'm not sure that's necessary, since if your CUDA arch is too *high*, you're surely specifying --cuda-gpu-arch on the command line.

It seems to me that these two are reasonable error messages, and I'm not sure it makes sense to combine them...

[tra]

The point was that we have two error messages for one problem -- this CUDA version does not support this GPU. The new message you've added (CUDA9, sm20) has to be rather verbose in order to be correct as it must deal with the possibility of either of the relevant arguments being the source of the error. The other end of the problem (CUDA<9, sm_70) should ideally be phrased similarly. But why do we need both? IMO both cases could be reported more consistently with a single message similar to the one you've added -- "CUDA version X does not support compiling for GPU arch Y. Use --cuda-gpu-arch to specify a different GPU arch, use --cuda-path to specify a different CUDA install, or pass --no-cuda-version-check."

Either way, it's a minor nit. If you believe there's some utility in having two different error messages, I'm OK with it.

[jlebar]

I see what you're saying -- makes sense. Let me try to revise the patch.

[jlebar]

Use just one error message for bad cuda arch instead of two.

[tra]

LGTM.

cfe/trunk/include/clang/Basic/Cuda.h

 namespace clang {
 
 enum class CudaVersion {
   UNKNOWN,
   CUDA_70,
   CUDA_75,
   CUDA_80,
   CUDA_90,
+  LATEST = CUDA_90,
 };
 const char *CudaVersionToString(CudaVersion V);
 
 // No string -> CudaVersion conversion function because there's no canonical
 // spelling of the various CUDA versions.
 
 enum class CudaArch {
   UNKNOWN,

 CudaVirtualArch StringToCudaVirtualArch(llvm::StringRef S);
 
 /// Get the compute_xx corresponding to an sm_yy.
 CudaVirtualArch VirtualArchForCudaArch(CudaArch A);
 
 /// Get the earliest CudaVersion that supports the given CudaArch.
 CudaVersion MinVersionForCudaArch(CudaArch A);
 
+/// Get the latest CudaVersion that supports the given CudaArch.
+CudaVersion MaxVersionForCudaArch(CudaArch A);
+
 } // namespace clang
 
 #endif

cfe/trunk/include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_invalid_arch_name : Error<
   "invalid arch name '%0'">;
 def err_drv_cuda_bad_gpu_arch : Error<"Unsupported CUDA gpu architecture: %0">;
 def err_drv_no_cuda_installation : Error<
   "cannot find CUDA installation.  Provide its path via --cuda-path, or pass "
   "-nocudainc to build without CUDA includes.">;
 def err_drv_no_cuda_libdevice : Error<
   "cannot find libdevice for %0. Provide path to different CUDA installation "
   "via --cuda-path, or pass -nocudalib to build without linking with libdevice.">;
-def err_drv_cuda_version_too_low : Error<
-  "GPU arch %1 requires CUDA version at least %3, but installation at %0 is %2. "
-  "Use --cuda-path to specify a different CUDA install, or pass "
+def err_drv_cuda_version_unsupported : Error<
+  "GPU arch %0 is supported by CUDA versions between %1 and %2 (inclusive), "
+  "but installation at %3 is %4.  Use --cuda-path to specify a different CUDA "
+  "install, pass a different GPU arch with --cuda-gpu-arch, or pass "
   "--no-cuda-version-check.">;
 def err_drv_cuda_nvptx_host : Error<"unsupported use of NVPTX for host compilation.">;
 def err_drv_invalid_thread_model_for_target : Error<
   "invalid thread model '%0' in '%1' for this target">;
 def err_drv_invalid_linker_name : Error<
   "invalid linker name in argument '%0'">;
 def err_drv_invalid_pgo_instrumentor : Error<
   "invalid PGO instrumentor in argument '%0'">;

cfe/trunk/lib/Basic/Cuda.cpp

CudaVersion MinVersionForCudaArch(CudaArch A) {
   case CudaArch::SM_62:
     return CudaVersion::CUDA_80;
   case CudaArch::SM_70:
     return CudaVersion::CUDA_90;
   }
   llvm_unreachable("invalid enum");
 }
 
+CudaVersion MaxVersionForCudaArch(CudaArch A) {
+  switch (A) {
+  case CudaArch::UNKNOWN:
+    return CudaVersion::UNKNOWN;
+  case CudaArch::SM_20:
+  case CudaArch::SM_21:
+    return CudaVersion::CUDA_80;
+  default:
+    return CudaVersion::LATEST;
+  }
+}
+
 } // namespace clang

cfe/trunk/lib/Driver/ToolChains/Cuda.h

private:
   std::string BinPath;
   std::string LibPath;
   std::string LibDevicePath;
   std::string IncludePath;
   llvm::StringMap<std::string> LibDeviceMap;
 
   // CUDA architectures for which we have raised an error in
   // CheckCudaVersionSupportsArch.
-  mutable llvm::SmallSet<CudaArch, 4> ArchsWithVersionTooLowErrors;
+  mutable llvm::SmallSet<CudaArch, 4> ArchsWithBadVersion;
 
 public:
   CudaInstallationDetector(const Driver &D, const llvm::Triple &HostTriple,
                            const llvm::opt::ArgList &Args);
 
   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                           llvm::opt::ArgStringList &CC1Args) const;
 

cfe/trunk/lib/Driver/ToolChains/Cuda.cpp

void CudaInstallationDetector::AddCudaIncludeArgs(
   CC1Args.push_back(DriverArgs.MakeArgString(getIncludePath()));
   CC1Args.push_back("-include");
   CC1Args.push_back("__clang_cuda_runtime_wrapper.h");
 }
 
 void CudaInstallationDetector::CheckCudaVersionSupportsArch(
     CudaArch Arch) const {
   if (Arch == CudaArch::UNKNOWN || Version == CudaVersion::UNKNOWN ||
-      ArchsWithVersionTooLowErrors.count(Arch) > 0)
+      ArchsWithBadVersion.count(Arch) > 0)
     return;
 
-  auto RequiredVersion = MinVersionForCudaArch(Arch);
-  if (Version < RequiredVersion) {
-    ArchsWithVersionTooLowErrors.insert(Arch);
-    D.Diag(diag::err_drv_cuda_version_too_low)
-        << InstallPath << CudaArchToString(Arch) << CudaVersionToString(Version)
-        << CudaVersionToString(RequiredVersion);
+  auto MinVersion = MinVersionForCudaArch(Arch);
+  auto MaxVersion = MaxVersionForCudaArch(Arch);
+  if (Version < MinVersion || Version > MaxVersion) {
+    ArchsWithBadVersion.insert(Arch);
+    D.Diag(diag::err_drv_cuda_version_unsupported)
+        << CudaArchToString(Arch) << CudaVersionToString(MinVersion)
+        << CudaVersionToString(MaxVersion) << InstallPath
+        << CudaVersionToString(Version);
   }
 }
 
 void CudaInstallationDetector::print(raw_ostream &OS) const {
   if (isValid())
     OS << "Found CUDA installation: " << InstallPath << ", version "
        << CudaVersionToString(Version) << "\n";
 }

cfe/trunk/test/Driver/Inputs/CUDA_90/usr/local/cuda/version.txt

+CUDA Version 9.0.103

cfe/trunk/test/Driver/cuda-bad-arch.cu

 // Checks errors generated by passing a bad value for --cuda-gpu-arch.
 // REQUIRES: clang-driver
 // REQUIRES: x86-registered-target
 // REQUIRES: nvptx-registered-target
 
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=compute_20 -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix BAD %s
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm20 -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix BAD %s
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm_19 -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix BAD %s
 
 // BAD: error: Unsupported CUDA gpu architecture
 
+// RUN: %clang -### -v --target=x86_64-linux-gnu --cuda-gpu-arch=sm_21 \
+// RUN:   --cuda-path=%S/Inputs/CUDA_90/usr/local/cuda %s 2>&1 \
+// RUN: | FileCheck -check-prefix BAD_CUDA9 %s
+
+// BAD_CUDA9: GPU arch sm_21 is supported by CUDA versions between 7.0 and 8.0
+
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm_20 -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix OK %s
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm_52 -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix OK %s
 // RUN: %clang -### -target x86_64-linux-gnu -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix OK %s
 
 // We don't allow using NVPTX for host compilation.
 // RUN: %clang -### --cuda-host-only -target nvptx-nvidia-cuda -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix HOST_NVPTX %s
 
 // OK-NOT: error: Unsupported CUDA gpu architecture
 // HOST_NVPTX: error: unsupported use of NVPTX for host compilation.