[CUDA] updated CompileCudaWithLLVM.rst

[jlebar]

llvm/docs/CompileCudaWithLLVM.rst

27

Is there a way to query clang (or its source code) to see what versions it supports, so that people don't have to ping us manually? Like, if we write the documentation saying "current release of clang", are we going to update it for every new release?

[tra]

llvm/docs/CompileCudaWithLLVM.rst

27

There's no convenient way at the moment. The easiest way for the user right now is to check __clang_cuda_runtime_wrapper.h

We could enhance CUDA installation detector to issue a warning if it finds and unsupported CUDA version and list supported versions there.

[jlebar]

llvm/docs/CompileCudaWithLLVM.rst

27

Sure, I'm wondering if e.g. we shouldn't point users at __clang_cuda_runtime_wrapper.h?

We could enhance CUDA installation detector to issue a warning if it finds and unsupported CUDA version and list supported versions there.

Something like that might be nice.

llvm/docs/CompileCudaWithLLVM.rst

 <http://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html>`_.
 
 Compiling CUDA Code
 ===================
 
 Prerequisites
 -------------
 
-CUDA is supported in llvm 3.9, but it's still in active development, so we
-recommend you `compile clang/LLVM from HEAD
-<http://llvm.org/docs/GettingStarted.html>`_.
-
-Before you build CUDA code, you'll need to have installed the appropriate
-driver for your nvidia GPU and the CUDA SDK.  See `NVIDIA's CUDA installation
-guide <https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html>`_
-for details.  Note that clang `does not support
-<https://llvm.org/bugs/show_bug.cgi?id=26966>`_ the CUDA toolkit as installed
-by many Linux package managers; you probably need to install nvidia's package.
-
-You will need CUDA 7.0, 7.5, or 8.0 to compile with clang.
-
-CUDA compilation is supported on Linux, on MacOS as of 2016-11-18, and on
-Windows as of 2017-01-05.
+CUDA is supported since llvm 3.9. Current release of clang (7.0.0) supports CUDA
+7.0 through 9.2. If you need support for CUDA 10, you will need to use clang
+built from r342924 or newer.
+
+Before you build CUDA code, you'll need to have installed the appropriate driver
+for your nvidia GPU and the CUDA SDK.  See `NVIDIA's CUDA installation guide
+<https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html>`_ for
+details.  Note that clang `does not support
+<https://llvm.org/bugs/show_bug.cgi?id=26966>`_ the CUDA toolkit as installed by
+many Linux package managers; you probably need to install CUDA in a single
+directory from NVIDIA's package.
+
+CUDA compilation is supported on Linux. Compilation on MacOS and Windows may or
+may not work and currently have no maintainers. Compilation with CUDA-9.x is
+`currently broken on Windows <https://bugs.llvm.org/show_bug.cgi?id=38811>`_.
 
 Invoking clang
 --------------
 
 Invoking clang for CUDA compilation works similarly to compiling regular C++.
 You just need to be aware of a few additional flags.
 
 You can use `this <https://gist.github.com/855e277884eb6b388cd2f00d956c2fd4>`_

 run your program.
 
 * ``<CUDA install path>`` -- the directory where you installed CUDA SDK.
   Typically, ``/usr/local/cuda``.
 
   Pass e.g. ``-L/usr/local/cuda/lib64`` if compiling in 64-bit mode; otherwise,
   pass e.g. ``-L/usr/local/cuda/lib``.  (In CUDA, the device code and host code
   always have the same pointer widths, so if you're compiling 64-bit code for
-  the host, you're also compiling 64-bit code for the device.)
+  the host, you're also compiling 64-bit code for the device.) Note that as of
+  v10.0 CUDA SDK `no longer supports compilation of 32-bit
+  applications<https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#deprecated-features>`_.
 
 * ``<GPU arch>`` -- the `compute capability
   <https://developer.nvidia.com/cuda-gpus>`_ of your GPU. For example, if you
   want to run your program on a GPU with compute capability of 3.5, specify
   ``--cuda-gpu-arch=sm_35``.
 
   Note: You cannot pass ``compute_XX`` as an argument to ``--cuda-gpu-arch``;
   only ``sm_XX`` is currently supported.  However, clang always includes PTX in
   its binaries, so e.g. a binary compiled with ``--cuda-gpu-arch=sm_30`` would be
   forwards-compatible with e.g. ``sm_35`` GPUs.
 
   You can pass ``--cuda-gpu-arch`` multiple times to compile for multiple archs.
 
 The `-L` and `-l` flags only need to be passed when linking.  When compiling,
 you may also need to pass ``--cuda-path=/path/to/cuda`` if you didn't install
-the CUDA SDK into ``/usr/local/cuda``, ``/usr/local/cuda-7.0``, or
-``/usr/local/cuda-7.5``.
+the CUDA SDK into ``/usr/local/cuda`` or ``/usr/local/cuda-X.Y``.
 
 Flags that control numerical code
 ---------------------------------
 
 If you're using GPUs, you probably care about making numerical code run fast.
 GPU hardware allows for more control over numerical operations than most CPUs,
 but this results in more compiler options for you to juggle.
 

 The team at Google published a paper in CGO 2016 detailing the optimizations
 they'd made to clang/LLVM.  Note that "gpucc" is no longer a meaningful name:
 The relevant tools are now just vanilla clang/LLVM.
 
 | `gpucc: An Open-Source GPGPU Compiler <http://dl.acm.org/citation.cfm?id=2854041>`_
 | Jingyue Wu, Artem Belevich, Eli Bendersky, Mark Heffernan, Chris Leary, Jacques Pienaar, Bjarke Roune, Rob Springer, Xuetian Weng, Robert Hundt
 | *Proceedings of the 2016 International Symposium on Code Generation and Optimization (CGO 2016)*
 |
-| `Slides from the CGO talk <http://wujingyue.com/docs/gpucc-talk.pdf>`_
+| `Slides from the CGO talk <http://wujingyue.github.io/docs/gpucc-talk.pdf>`_
 |
-| `Tutorial given at CGO <http://wujingyue.com/docs/gpucc-tutorial.pdf>`_
+| `Tutorial given at CGO <http://wujingyue.github.io/docs/gpucc-tutorial.pdf>`_
 
 Obtaining Help
 ==============
 
 To obtain help on LLVM in general and its CUDA support, see `the LLVM
 community <http://llvm.org/docs/#mailing-lists>`_.