Deploy doc preview for PR 1972 (bcf5683)

Author: cuda-python-bot

docs/pr-preview/pr-1972/cuda-bindings/latest/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file records the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 24f700c83f1e43e45cad77d0056d7d36
+config: d3ef2eba0d62819a718b215ccbc581b3
 tags: 645f666f9bcd5a90fca523b33c5a78b7

docs/pr-preview/pr-1972/cuda-bindings/latest/_sources/api.rst.txt

@@ -15,6 +15,7 @@ CUDA Python API Reference
    module/nvjitlink
    module/nvvm
    module/nvfatbin
+   module/cudla
    module/cufile
    module/nvml
    module/utils

docs/pr-preview/pr-1972/cuda-bindings/latest/_sources/examples.rst.txt

@@ -5,64 +5,61 @@ Examples
 ========
 
 This page links to the ``cuda.bindings`` examples shipped in the
-`cuda-python repository <https://github.com/NVIDIA/cuda-python/tree/|cuda_bindings_github_ref|/cuda_bindings/examples>`_.
+:cuda-bindings-examples:`cuda-python repository </>`.
 Use it as a quick index when you want a runnable sample for a specific API area
 or CUDA feature.
 
 Introduction
 ------------
 
-- `clock_nvrtc.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/0_Introduction/clock_nvrtc.py>`_
+- :cuda-bindings-example:`clock_nvrtc.py <0_Introduction/clock_nvrtc.py>`
   uses NVRTC-compiled CUDA code and the device clock to time a reduction
   kernel.
-- `simple_cubemap_texture.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/0_Introduction/simple_cubemap_texture.py>`_
+- :cuda-bindings-example:`simple_cubemap_texture.py <0_Introduction/simple_cubemap_texture.py>`
   demonstrates cubemap texture sampling and transformation.
-- `simple_p2p.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/0_Introduction/simple_p2p.py>`_
+- :cuda-bindings-example:`simple_p2p.py <0_Introduction/simple_p2p.py>`
   shows peer-to-peer memory access and transfers between multiple GPUs.
-- `simple_zero_copy.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/0_Introduction/simple_zero_copy.py>`_
+- :cuda-bindings-example:`simple_zero_copy.py <0_Introduction/simple_zero_copy.py>`
   uses zero-copy mapped host memory for vector addition.
-- `system_wide_atomics.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/0_Introduction/system_wide_atomics.py>`_
+- :cuda-bindings-example:`system_wide_atomics.py <0_Introduction/system_wide_atomics.py>`
   demonstrates system-wide atomic operations on managed memory.
-- `vector_add_drv.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/0_Introduction/vector_add_drv.py>`_
+- :cuda-bindings-example:`vector_add_drv.py <0_Introduction/vector_add_drv.py>`
   uses the CUDA Driver API and unified virtual addressing for vector addition.
-- `vector_add_mmap.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/0_Introduction/vector_add_mmap.py>`_
+- :cuda-bindings-example:`vector_add_mmap.py <0_Introduction/vector_add_mmap.py>`
   uses virtual memory management APIs such as ``cuMemCreate`` and
   ``cuMemMap`` for vector addition.
 
 Concepts and techniques
 -----------------------
 
-- `stream_ordered_allocation.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/2_Concepts_and_Techniques/stream_ordered_allocation.py>`_
+- :cuda-bindings-example:`stream_ordered_allocation.py <2_Concepts_and_Techniques/stream_ordered_allocation.py>`
   demonstrates ``cudaMallocAsync`` and ``cudaFreeAsync`` together with
   memory-pool release thresholds.
 
 CUDA features
 -------------
 
-- `global_to_shmem_async_copy.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/3_CUDA_Features/global_to_shmem_async_copy.py>`_
+- :cuda-bindings-example:`global_to_shmem_async_copy.py <3_CUDA_Features/global_to_shmem_async_copy.py>`
   compares asynchronous global-to-shared-memory copy strategies in matrix
   multiplication kernels.
-- `simple_cuda_graphs.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/3_CUDA_Features/simple_cuda_graphs.py>`_
+- :cuda-bindings-example:`simple_cuda_graphs.py <3_CUDA_Features/simple_cuda_graphs.py>`
   shows both manual CUDA graph construction and stream-capture-based replay.
 
 Libraries and tools
 -------------------
 
-- `conjugate_gradient_multi_block_cg.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/4_CUDA_Libraries/conjugate_gradient_multi_block_cg.py>`_
+- :cuda-bindings-example:`conjugate_gradient_multi_block_cg.py <4_CUDA_Libraries/conjugate_gradient_multi_block_cg.py>`
   implements a conjugate-gradient solver with cooperative groups and
   multi-block synchronization.
-- `nvidia_smi.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/4_CUDA_Libraries/nvidia_smi.py>`_
+- :cuda-bindings-example:`nvidia_smi.py <4_CUDA_Libraries/nvidia_smi.py>`
   uses NVML to implement a Python subset of ``nvidia-smi``.
 
 Advanced and interoperability
 -----------------------------
 
-- `iso_fd_modelling.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/extra/iso_fd_modelling.py>`_
+- :cuda-bindings-example:`iso_fd_modelling.py <extra/iso_fd_modelling.py>`
   runs isotropic finite-difference wave propagation across multiple GPUs with
   peer-to-peer halo exchange.
-- `jit_program.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/extra/jit_program.py>`_
+- :cuda-bindings-example:`jit_program.py <extra/jit_program.py>`
   JIT-compiles a SAXPY kernel with NVRTC and launches it through the Driver
   API.
-- `numba_emm_plugin.py <https://github.com/NVIDIA/cuda-python/blob/|cuda_bindings_github_ref|/cuda_bindings/examples/extra/numba_emm_plugin.py>`_
-  shows how to back Numba's EMM interface with the NVIDIA CUDA Python Driver
-  API.

docs/pr-preview/pr-1972/cuda-bindings/latest/_sources/install.rst.txt

@@ -12,7 +12,7 @@ Runtime Requirements
 * Linux (x86-64, arm64) and Windows (x86-64)
 * Python 3.10 - 3.14
 * Driver: Linux (580.65.06 or later) Windows (580.88 or later)
-* Optionally, NVRTC, nvJitLink, NVVM, and cuFile from CUDA Toolkit 13.x
+* Optionally, NVRTC, nvJitLink, nvFatBin, NVVM, cuFile, and cuDLA from CUDA Toolkit 13.x
 
 .. note::
 
@@ -52,10 +52,12 @@ Where the optional dependencies include:
 
 * ``nvidia-cuda-nvrtc`` (NVRTC runtime compilation library)
 * ``nvidia-nvjitlink`` (nvJitLink library)
+* ``nvidia-nvfatbin`` (nvFatBin library)
 * ``nvidia-nvvm`` (NVVM library)
 * ``nvidia-cufile`` (cuFile library, Linux only)
+* ``nvidia-cudla`` (cuDLA library, Linux aarch64 only)
 
-These are now installed through the ``cuda-toolkit`` metapackage for improved dependency resolution.
+These are now installed through the ``cuda-toolkit`` metapackage, where available, for improved dependency resolution.
 
 Installing from Conda
 ---------------------
@@ -74,6 +76,10 @@ For example:
 
    $ conda install -c conda-forge cuda-python cuda-version=13
 
+.. note::
+
+   Tegra users can install the cuDLA conda package from conda-forge through ``conda install -c conda-forge libcudla cuda-version=13``, if it does not already exist on the system.
+
 Installing from Source
 ----------------------
 

docs/pr-preview/pr-1972/cuda-bindings/latest/_sources/module/cudla.rst.txt

@@ -0,0 +1,64 @@
+.. SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+.. SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+.. default-role:: cpp:any
+
+cudla
+=====
+
+Note
+----
+
+The cuDLA bindings require a Jetson platform with DLA hardware (Xavier or Orin).
+cuDLA is not available on desktop GPUs.
+
+Functions
+---------
+
+cuDLA defines the following functions for DLA device management and inference.
+
+.. autofunction:: cuda.bindings.cudla.get_version
+.. autofunction:: cuda.bindings.cudla.device_get_count
+.. autofunction:: cuda.bindings.cudla.create_device
+.. autofunction:: cuda.bindings.cudla.destroy_device
+.. autofunction:: cuda.bindings.cudla.mem_register
+.. autofunction:: cuda.bindings.cudla.mem_unregister
+.. autofunction:: cuda.bindings.cudla.module_load_from_memory
+.. autofunction:: cuda.bindings.cudla.module_get_attributes
+.. autofunction:: cuda.bindings.cudla.module_unload
+.. autofunction:: cuda.bindings.cudla.submit_task
+.. autofunction:: cuda.bindings.cudla.device_get_attribute
+.. autofunction:: cuda.bindings.cudla.get_last_error
+.. autofunction:: cuda.bindings.cudla.set_task_timeout_in_ms
+
+Types
+-----
+
+.. autoclass:: cuda.bindings.cudla.ExternalMemoryHandleDesc
+.. autoclass:: cuda.bindings.cudla.ExternalSemaphoreHandleDesc
+.. autoclass:: cuda.bindings.cudla.ModuleTensorDescriptor
+.. autoclass:: cuda.bindings.cudla.Fence
+.. autoclass:: cuda.bindings.cudla.DevAttribute
+.. autoclass:: cuda.bindings.cudla.ModuleAttribute
+.. autoclass:: cuda.bindings.cudla.WaitEvents
+.. autoclass:: cuda.bindings.cudla.SignalEvents
+.. autoclass:: cuda.bindings.cudla.Task
+
+Enums
+-----
+
+.. autoclass:: cuda.bindings.cudla.Status
+
+   .. autoattribute:: cuda.bindings.cudla.Status.Success
+
+.. autoclass:: cuda.bindings.cudla.Mode
+
+   .. autoattribute:: cuda.bindings.cudla.Mode.CUDA_DLA
+   .. autoattribute:: cuda.bindings.cudla.Mode.STANDALONE
+
+.. autoclass:: cuda.bindings.cudla.ModuleAttributeType
+.. autoclass:: cuda.bindings.cudla.FenceType
+.. autoclass:: cuda.bindings.cudla.ModuleLoadFlags
+.. autoclass:: cuda.bindings.cudla.SubmissionFlags
+.. autoclass:: cuda.bindings.cudla.AccessPermissionFlags
+.. autoclass:: cuda.bindings.cudla.DevAttributeType