2-1-cuda_libraries.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "255c1399",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[1m  Activating\u001b[22m\u001b[39m project at `~/cscs2023`\n"
     ]
    }
   ],
   "source": [
    "using Pkg\n",
    "Pkg.activate(@__DIR__)\n",
    "Pkg.instantiate()\n",
    "\n",
    "using CUDA"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b69acf26",
   "metadata": {},
   "source": [
    "# CUDA Libraries\n",
    "\n",
    "CUDA.jl is more than just a GPU compiler, it also interfaces with many CUDA and NVIDIA libraries to facilitate GPU programming. In this notebook, I'll explain how to use some of those libraries, at each level of abstraction."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93114d3a",
   "metadata": {},
   "source": [
    "There are different kinds of CUDA libraries you can use to work with a GPU:\n",
    "\n",
    "- Driver library: low-level library to work with the NVIDIA driver (what CUDA.jl is built on)\n",
    "- Runtime library: same functionality, while managing kernel compilation, context allocation, etc (what CUDA.jl offers)\n",
    "- Application libraries: CUBLAS, CUDNN, CUTENSOR, ..."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "8f78d91c",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ec5b7b1",
   "metadata": {},
   "source": [
    "CUDA.jl provides wrappers for several CUDA libraries that are part of the CUDA toolkit:\n",
    "\n",
    "- Driver library: manage the device, launch kernels, etc.\n",
    "- CUBLAS: linear algebra\n",
    "- CURAND: random number generation\n",
    "- CUFFT: fast fourier transform\n",
    "- CUSPARSE: sparse arrays\n",
    "- CUSOLVER: decompositions & linear systems\n",
    "\n",
    "There's also support for a couple of libraries that aren't part of the CUDA toolkit, but are commonly used:\n",
    "- CUDNN: deep neural networks\n",
    "- CUTENSOR: linear algebra with tensors\n",
    "\n",
    "These are packaged separately from CUDA.jl, respectively in CUDNN.jl and CUTENSOR.jl.\n",
    "\n",
    "Some other libraries part of CUDA are also wrapped, like NVML, CUPTI or NVPTX, but these aren't very useful for end-users."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "446da917",
   "metadata": {},
   "source": [
    "## Application libraries\n",
    "\n",
    "Application libraries like CUBLAS and CURAND can generally be accessed at three levels of abstraction:\n",
    "\n",
    "- auto-generated C wrappers\n",
    "- higher-level Julia wrappers\n",
    "- integrations with Julia libraries\n",
    "\n",
    "As an example, we'll go back to the `axpy` operation we've seen before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6460d708",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Float32}:\n",
       " 44.0\n",
       " 87.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = Float32(42)\n",
    "X = Float32[1, 2]\n",
    "Y = Float32[2, 3]\n",
    "\n",
    "using LinearAlgebra\n",
    "LinearAlgebra.axpy!(a, X, copy(Y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67e7b3c9",
   "metadata": {},
   "source": [
    "The highest-level and most accessible way to perform such an operation on the GPU, is by simply changing the array input types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7859e534",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}:\n",
       " 44.0\n",
       " 87.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dX = CuArray(X)\n",
    "dY = CuArray(Y)\n",
    "\n",
    "LinearAlgebra.axpy!(a, dX, copy(dY))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d5b5113",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <strong>Note</strong>: If CUDA.jl did not implement <code>LinearAlgebra.axpy!</code>, it would fail with either a scalar iteration error (when triggering an <code>AbstractArray</code> fallback) or a pointer conversion error (when attempting to pass a GPU array to a CPU library).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "485707c7",
   "metadata": {},
   "source": [
    "One level below, we can use the CUBLAS library directly by calling the Julia wrapper for the `axpy` family of functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4ed1b413",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}:\n",
       " 44.0\n",
       " 87.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CUBLAS.axpy!(length(dY), a, dX, copy(dY))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73bb3da2-5f3f-487e-af1e-97f24717986a",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <strong>Note</strong>: CUDA.jl also provides a so-called \"native\" implementation of <code>LinearAlgebra.axpy!</code>, in order to support input types that are not supported by CUBLAS.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83e768f3",
   "metadata": {},
   "source": [
    "These lower-level wrappers stick more closely to the CUBLAS APIs they're wrapping, so it often happens that the calling convention is slightly different.\n",
    "\n",
    "Finally, we can use the low-level C wrappers directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6bfb9300",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}:\n",
       "  86.0\n",
       " 171.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "handle = CUBLAS.handle()\n",
    "CUBLAS.cublasSaxpy_v2(handle, length(dY), Ref(a), dX, stride(X, 1), dY, stride(dY, 1))\n",
    "dY"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a895bd94",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <strong>Note</strong>: Many application libraries need an opaque handle object to be passed around. These can generally be obtained by calling the <code>handle()</code> function from the application's module, which returns a task-local handle. More on that task-local property later.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0e6daf7",
   "metadata": {},
   "source": [
    "Generally, there's no reason to use the C wrappers directly, unless you're writing a new Julia wrapper. However, it may be very useful while porting existing C code to Julia, as it allows you to incrementally port your code to Julia."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1216da7f",
   "metadata": {},
   "source": [
    "\n",
    "## CUDA driver library\n",
    "\n",
    "The driver library, `libcuda`, is used to interface with the NVIDIA driver. It contains the functionality you would get in CUDA C by including `cuda.h`, and is very similar to the more common runtime library (`libcudart`, `cudart.h`). Functionality from the driver library is available directly in the `CUDA` module, so it generally doesn't need any additional imports. Most high-level wrappers are prefixed by `Cu` and are exported."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69dc4e72",
   "metadata": {},
   "source": [
    "Once again, the functionality can be accessed using autogenerated C wrappers, and using more high-level Julia functionality. I'll only focus on the latter, and illustrate some of the functionality from the driver library that could be useful to more seasoned GPU application developers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4506f3b7",
   "metadata": {},
   "source": [
    "### Devices\n",
    "\n",
    "Devices are represented by `CuDevice` objects, and are commonly used to inspect properties to influence a kernel: Does this device support X? How many of Y does it have? etc. The `CuDevice` constructor takes a device number, which matches the output of `CUDA.versioninfo()`. The number **does not** match the PCI-based numbering of `nvidia-smi`, so always verify your device selection!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fdff7ba",
   "metadata": {},
   "source": [
    "```\n",
    "$ nvidia-smi -L                                                                                                                                                                                  \n",
    "GPU 0: NVIDIA GeForce GTX TITAN (UUID: GPU-e478cabe-ac84-7cb9-388e-fb68ed4c9721)\n",
    "GPU 1: Quadro RTX 5000 (UUID: GPU-b8d5e790-ea4d-f962-e0c3-0448f69f2e23)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ba8844f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CUDA.DeviceIterator() for 1 devices:\n",
       "0. Tesla P100-PCIE-16GB"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "devices()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4daf394e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuDevice(0): Tesla P100-PCIE-16GB"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dev = CuDevice(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "780abf47",
   "metadata": {},
   "source": [
    "There are convenience functions to fetch common properties of the device (refer to [the CUDA.jl documentation](https://cuda.juliagpu.org/dev/lib/driver/#Device-Management)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ef802791",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "v\"6.0.0\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "capability(dev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6148fe0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"15.899 GiB\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "totalmem(dev) |> Base.format_bytes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "253b7693",
   "metadata": {},
   "source": [
    "But in general the `attribute` function is used to query device properties, passing along an `CUdevice_attribute` enum instance to indicate which property to fetch (refer to [the CUDA documentation](https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html#group__CUDA__TYPES_1ge12b8a782bebe21b1ac0091bf9f4e2a3)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cc162b7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "attribute(dev, CUDA.DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2685e0b4",
   "metadata": {},
   "source": [
    "Enum values are generally not exported, but available in the CUDA module without the `CU` prefix (i.e. `CUDA.DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK` instead of `CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK` in C)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd623e0a",
   "metadata": {},
   "source": [
    "### Contexts\n",
    "\n",
    "A CUDA context is like a CPU process, and contains all state that's related to an active GPU application on a GPU device. Destroying a context thus involves anything GPU-related that's been done using that context on that device."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eae425ec",
   "metadata": {},
   "source": [
    "Contexts can be created using the `CuContext` constructor, and are immediately active. They need to be manually disposed of, so do-block syntax is a good candidate for that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cd7c372d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuContext(0x000000000441ec20, instance 17c430844452787c)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "CuContext(dev) do ctx\n",
    "    display(ctx)\n",
    "end;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3eeba29",
   "metadata": {},
   "source": [
    "It's generally not necessary, or even supported (!) to create your own contexts. Instead, **CUDA.jl manages contexts for you**, automatically creating one when necessary (i.e. when initially calling a CUDA API function, or when switching devices) much like how the CUDA Runtime libraries does. These automatically-created contexts are also of the primary type -- a special kind of context that enables interoperability with other applications, e.g. in another programming language, as long as they use primary contexts too. The active managed context can be queried as follows;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "239f438a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuContext(0x00000000021e7ac0, instance 7ca2925f71124df8)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ctx = context()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "376c335c",
   "metadata": {},
   "source": [
    "Each context is tied to a single device, so the current device is also mananged by CUDA.jl:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f50b321c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuDevice(0): Tesla P100-PCIE-16GB"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51fbc5c0",
   "metadata": {},
   "source": [
    "Observe how switching devices using CUDA.jl's `device!` function automatically switches to a different context:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ca220c0d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuContext(0x000000000625dc80, instance b1061472916d385)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "device!(1) do\n",
    "    display(context())\n",
    "end;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9ff9c60",
   "metadata": {},
   "source": [
    "To make it possible to tear down the GPU context, CUDA.jl provides the `device_reset!` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "81053dc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "device_reset!()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b85472a3",
   "metadata": {},
   "source": [
    "This destroys the device's previous primary contexts, and all state tied to it. Subsequent API calls will be using a fresh context:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bbbfde8b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "context() == ctx"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c106778a",
   "metadata": {},
   "source": [
    "This is a dangerous function; using an array that had been allocated in a destroyed context will result in fatal memory errors!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3da173c",
   "metadata": {},
   "source": [
    "Generally, there's not much of a need for user code to deal with CUDA contexts. Settings that apply context-wide, like the shared memory or cache configuration, are implicitly using the currently-active context:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "64414bfb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CU_FUNC_CACHE_PREFER_NONE::CUfunc_cache_enum = 0x00000000"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cache_config()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b0cbcc5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CuDevice(1) cache config: CU_FUNC_CACHE_PREFER_SHARED\n",
      "CuDevice(0) cache config: CU_FUNC_CACHE_PREFER_NONE\n"
     ]
    }
   ],
   "source": [
    "device!(1) do\n",
    "    cache_config!(CUDA.FUNC_CACHE_PREFER_SHARED)\n",
    "    println(\"$(device()) cache config: $(cache_config())\")\n",
    "end\n",
    "println(\"$(device()) cache config: $(cache_config())\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "285fa346",
   "metadata": {},
   "source": [
    "Accessing the wrong device will throw an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "2f4a6ba8",
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "CUDA error: invalid device ordinal (code 101, ERROR_INVALID_DEVICE)",
     "output_type": "error",
     "traceback": [
      "CUDA error: invalid device ordinal (code 101, ERROR_INVALID_DEVICE)",
      "",
      "Stacktrace:",
      " [1] throw_api_error(res::CUDA.cudaError_enum)",
      "   @ CUDA ~/.julia/packages/CUDA/nIZkq/lib/cudadrv/libcuda.jl:27",
      " [2] check",
      "   @ CUDA ~/.julia/packages/CUDA/nIZkq/lib/cudadrv/libcuda.jl:34 [inlined]",
      " [3] cuDeviceGet",
      "   @ CUDA ~/.julia/packages/CUDA/nIZkq/lib/utils/call.jl:26 [inlined]",
      " [4] CuDevice(ordinal::Int64)",
      "   @ CUDA ~/.julia/packages/CUDA/nIZkq/lib/cudadrv/devices.jl:17",
      " [5] top-level scope",
      "   @ In[17]:1"
     ]
    }
   ],
   "source": [
    "CuDevice(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae038ab9",
   "metadata": {},
   "source": [
    "If you're getting a similar error when accessing a correct device, it might be that your GPU is configured in so-called 'compute exclusive' mode, only allowing a single context (and thus single process) to be using the GPU. In that case, make sure you don't have any other active application, Julia session, or notebook using the GPU. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e6d34ce",
   "metadata": {},
   "source": [
    "### Streams\n",
    "\n",
    "Streams are used to order GPU computations:\n",
    "- operations on the same stream: executed in-order, for correctness\n",
    "- operations on different streams: independent, so execution can overlap for better performance\n",
    "\n",
    "By default, everything is queued on a task-local stream:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b32377ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuStream(0x0000000001b654e0, CuContext(0x00000000021e7ac0, instance 7ca2925f71124df8)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stream()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fd50acb",
   "metadata": {},
   "source": [
    "To use a different stream, in CUDA C you'd typically allocate a stream object and take care to pass that object to every API and interface that takes a stream argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f7df303e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuStream(0x00000000018b6a20, CuContext(0x00000000023a3c80, instance 72803b0e4ddbd7d4)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = CuStream()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "87af6427",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CUDA.HostKernel for identity(Nothing)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@cuda stream=s identity(nothing)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f8adc69",
   "metadata": {},
   "source": [
    "However, once more CUDA.jl manages streams for you, and allocates a separate stream for each Julia task:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "86b08b75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuStream(0x0000000000cacd70, CuContext(0x00000000023a3c80, instance 72803b0e4ddbd7d4)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stream()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "2b56fe32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuStream(0x00000000051d1980, CuContext(0x00000000023a3c80, instance 72803b0e4ddbd7d4)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fetch(@async stream())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f28786da",
   "metadata": {},
   "source": [
    "This greatly simplifies using streams, as it obviates the need to pass stream objects, and makes it much easier to group independent operations. More on all that later."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "746a7bf4",
   "metadata": {},
   "source": [
    "Synchronization is also handled at the stream level: calling `synchronize` will wait until the current stream is done:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f967570c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA.isdone(stream()) = false\n",
      "  0.000009 seconds\n",
      "CUDA.isdone(stream()) = true\n"
     ]
    }
   ],
   "source": [
    "CUDA.rand(10000,10000) * CUDA.rand(10000,10000)\n",
    "@show CUDA.isdone(stream())\n",
    "@time synchronize()\n",
    "@show CUDA.isdone(stream());"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "148df20d",
   "metadata": {},
   "source": [
    "For more fine-grained control on how operations on multiple streams behave, it's possible to set the priority by passing a keyword argument to the stream constructor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "eec55ecf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0:-1:-5"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "priority_range()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1fd94083",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "priority(stream())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0eb4bfba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuStream(0x00000000073bd380, CuContext(0x00000000023a3c80, instance 72803b0e4ddbd7d4)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = CuStream(; priority=-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7bf61fe",
   "metadata": {},
   "source": [
    "To avoid having to pass this specific stream object to every function, it's then recommended to use this stream as the default one for a specific task:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f53915ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fetch(@async begin\n",
    "    stream!(s)\n",
    "    priority(stream())\n",
    "end)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f179eb57",
   "metadata": {},
   "source": [
    "### Events\n",
    "\n",
    "CUDA events are used to record when a stream reaches a specific point in its queue of operations. They are mainly used to:\n",
    "- time operations: recording the elapsed time between events\n",
    "- force dependencies between independent streams"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efb2a4d3",
   "metadata": {},
   "source": [
    "#### Timing\n",
    "Timing operations requires creating and recording two events, and then determining the time elapsed between the two events. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e4a5ba04",
   "metadata": {},
   "outputs": [],
   "source": [
    "t0, t1 = CuEvent(), CuEvent()\n",
    "record(t0)\n",
    "CUDA.rand(10000,10000) * CUDA.rand(10000,10000)\n",
    "record(t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47b4b48b",
   "metadata": {},
   "source": [
    "We then can synchronize on the event, which is more fine-grained than synchronizing the entire stream, and determine the elapsed time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c407bb63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.20899431f0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "synchronize(t1)\n",
    "elapsed(t0, t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3c39e2e",
   "metadata": {},
   "source": [
    "CUDA.jl provides a convenience macro for these operations: `CUDA.@elapsed`, resembling `Base.@elapsed`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9fa26c97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.054163456f0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CUDA.@elapsed CUDA.rand(10000,10000) * CUDA.rand(10000,10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78c6a7f4",
   "metadata": {},
   "source": [
    "#### Dependencies\n",
    "\n",
    "Using events to force unrelated streams to wait on each other, builds on the `wait` function which makes a stream wait for an event to be recorded on another stream (as opposed to `synchronize`, which makes the CPU wait). To illustrate, we'll use the `launch` function which makes possible to launch a host function as an operation on a stream:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8a6bd47b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CUDA.isdone(stream())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5b8b999a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The stream got here\n"
     ]
    }
   ],
   "source": [
    "launch() do\n",
    "    println(\"The stream got here\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15bccaf7",
   "metadata": {},
   "source": [
    "Initially, an event queries as idle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d7e54007",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dep = CuEvent()\n",
    "CUDA.isdone(dep)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbc0d17c",
   "metadata": {},
   "source": [
    "To indicate we reach an event, we use the `record` function. Before that happens, the event will query as busy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c4986136",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CUDA.rand(10000,10000) * CUDA.rand(10000,10000)\n",
    "record(dep)\n",
    "CUDA.isdone(dep)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2dde459",
   "metadata": {},
   "source": [
    "Now we can use this mechanism to have a stream `wait` on this event. For example, let's illustrate by doing so from another task, where we'll be using a different stream (for more details, see the concurrent GPU computing notebook):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b6c2ad7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting expensive operation\n",
      "CUDA.isdone(dep) = false\n",
      "Submitted all work\n",
      "Expensive operation has completed, unrelated task can proceed\n"
     ]
    }
   ],
   "source": [
    "println(\"Submitting expensive operation\")\n",
    "CUDA.rand(10000,10000) * CUDA.rand(10000,10000)\n",
    "record(dep)\n",
    "@show CUDA.isdone(dep)\n",
    "\n",
    "@sync @async begin\n",
    "    CUDA.wait(dep)\n",
    "    launch() do\n",
    "        println(\"Expensive operation has completed, unrelated task can proceed\")\n",
    "    end\n",
    "end\n",
    "\n",
    "# both wait and launch are asynchronous operations,\n",
    "# so the @sync completes before the launch executes\n",
    "println(\"Submitted all work\")\n",
    "device_synchronize()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1ef4c75",
   "metadata": {},
   "source": [
    "### Computational graphs\n",
    "\n",
    "Some applications require launching several short kernels, which often results in inefficient GPU usage since the time to launch may exceed the time it takes to execute a kernel. Computational graphs are a solution to this, allowing to record a sequence of CUDA operations and replay them using a single API interaction.\n",
    "\n",
    "For example, a simple sequence of kernels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "61049704",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}:\n",
       " 9.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = CUDA.zeros(1)\n",
    "A .+= 1\n",
    "A .+= 2\n",
    "A .*= 3\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "798014ba",
   "metadata": {},
   "source": [
    "We can record these launches into a graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "14edc1c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CuGraph(Ptr{CUDA.CUgraph_st} @0x0000000011599f78, CuContext(0x00000000021e7ac0, instance 7ca2925f71124df8))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graph = capture() do\n",
    "    A .+= 1\n",
    "    A .+= 2\n",
    "    A .*= 3\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "369bcd73",
   "metadata": {},
   "source": [
    "Recording a graph doesn't mutate the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3e43fae2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}:\n",
       " 9.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5309d789",
   "metadata": {},
   "source": [
    "To execute these operations, we need to instantiate the graph (a costly operation) and execute it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6e9aa816",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}:\n",
       " 36.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exec = instantiate(graph)\n",
    "launch(exec)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "277fb87d",
   "metadata": {},
   "source": [
    "Now the array has been updated as expected. Of course, we'll often want to execute this graph on a different set of inputs. In that case, we need to capture a new graph, but we can update the existing instantiation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f7a11e02",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}:\n",
       " 9.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = CUDA.zeros(1)\n",
    "graph = capture() do\n",
    "    B .+= 1\n",
    "    B .+= 2\n",
    "    B .*= 3\n",
    "end\n",
    "update(exec, graph)\n",
    "launch(exec)\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3edaaa19",
   "metadata": {},
   "source": [
    "This has saved us from re-instantiating the graph, which is a costly operation. It does however require that the new graph is not too different from the previous one. For example, changing the dimensionality of the broadcast will require different kernels which are incompatible with the recorded graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7213c374",
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "CUDA error: operation failed due to a previous error during capture (code 901, ERROR_STREAM_CAPTURE_INVALIDATED)",
     "output_type": "error",
     "traceback": [
      "CUDA error: operation failed due to a previous error during capture (code 901, ERROR_STREAM_CAPTURE_INVALIDATED)",
      "",
      "Stacktrace:",
      " [1] throw_api_error(res::CUDA.cudaError_enum)",
      "   @ CUDA /scratch/snx3000/julia/tbesard/daint-gpu/packages/CUDA/hfp7r/lib/cudadrv/libcuda.jl:27",
      " [2] capture(f::var\"#11#12\"; flags::CUDA.CUstreamCaptureMode_enum, throw_error::Bool)",
      "   @ CUDA /scratch/snx3000/julia/tbesard/daint-gpu/packages/CUDA/hfp7r/lib/cudadrv/graph.jl:44",
      " [3] capture(f::Function)",
      "   @ CUDA /scratch/snx3000/julia/tbesard/daint-gpu/packages/CUDA/hfp7r/lib/cudadrv/graph.jl:31",
      " [4] top-level scope",
      "   @ In[29]:2"
     ]
    }
   ],
   "source": [
    "C = CUDA.zeros(1,1)\n",
    "graph = capture() do\n",
    "    C .+= 1\n",
    "    C .+= 2\n",
    "    C .*= 3\n",
    "end\n",
    "update(exec, graph)\n",
    "launch(exec)\n",
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "805a7be0",
   "metadata": {},
   "source": [
    "Since these operations are so common, CUDA.jl provides a helper macro that performs all these steps automatically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "23890b07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}:\n",
       " 36.0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = CUDA.zeros(1)\n",
    "for i in 1:2\n",
    "    @captured begin\n",
    "        D .+= 1\n",
    "        D .+= 2\n",
    "        D .*= 3\n",
    "    end\n",
    "end\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "743981e4",
   "metadata": {},
   "source": [
    "Each invocation of the `@captured` macro will lexically correspond to a unique graph. It's typical to put the macro in a loop; the initial instantiation of a graph is fairly expensive, much more than just the individual kernels, and it requires multiple evaluations for graph construction to pay off."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a45e5e2b",
   "metadata": {},
   "source": [
    "### Other\n",
    "\n",
    "The CUDA driver API offers many more functions, some of which wrapped by CUDA.jl:\n",
    "\n",
    "- kernel management: compile, link and launch kernels; generally not directly useful for users, and exposed using the `@cuda` macro\n",
    "- occupancy API: more details in the kernel optimization notebook.\n",
    "- memory management: more details in a separate notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "389a5692",
   "metadata": {},
   "source": [
    "Other APIs may not be wrapped by CUDA.jl, in that there aren't any specific high-level wrappers. But there is always the C API, exposing all of the CUDA driver library to user programs. In addition, the way these APIs have been wrapped makes them compatible with objects from the high-level wrappers. For example, you can pass a `CuDevice` objects to C API functions expecting a `CUdevice` handle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "e7074641",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CUDA.DeviceIterator() for 2 devices:\n",
       "0. Quadro RTX 5000\n",
       "1. NVIDIA GeForce GTX TITAN"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "devices()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "bf470a78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "canAccessPeer = Ref{Cint}()\n",
    "CUDA.cuDeviceCanAccessPeer(canAccessPeer, CuDevice(0), CuDevice(1))\n",
    "canAccessPeer[]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06df91c7",
   "metadata": {},
   "source": [
    "## NVIDIA Management Library\n",
    "\n",
    "One last noteworthy library that CUDA.jl supports, is [NVML](https://docs.nvidia.com/deploy/nvml-api/index.html). Where the driver API already exposes properties of the device that matter to GPU computing (like the launch configuration, memory configuration, etc), with NVML it's possible to inspect lower-level hardware properties and even modify the system configuration.\n",
    "\n",
    "For example, to inspect the current device:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d49a7018",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CUDA.DeviceIterator() for 1 devices:\n",
       "0. Tesla P100-PCIE-16GB"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "devices()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c25dc4fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NVML.Device(0): Tesla P100-PCIE-16GB"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cuda_dev = device()\n",
    "nvml_dev = NVML.Device(parent_uuid(cuda_dev))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb0984be",
   "metadata": {},
   "source": [
    "Note that the device index of NVML *does* match that of `nvidia-smi`, as both tools use PCI-ordering.\n",
    "\n",
    "We can now query some interesting device properties:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "30bc4439",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33.611"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NVML.power_usage(nvml_dev) # in watt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "45c2a95d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(compute = 0.0, memory = 0.0)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NVML.utilization_rates(nvml_dev) # in percent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "88c3bd02",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Int64, @NamedTuple{used_gpu_memory::Int64}} with 1 entry:\n",
       "  8270 => (used_gpu_memory = 2767192064,)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NVML.compute_processes(nvml_dev)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7f23a2e",
   "metadata": {},
   "source": [
    "Since this is a system-level library that's of not much use to most users, the wrappers are underdeveloped and you will have to use the C API for many queries."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.10.0-rc1",
   "language": "julia",
   "name": "julia-1.10"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}