Update

[ghstack-poisoned]

Author: shoumikhin

.ci/scripts/wheel/test_shared_libraries.py

@@ -74,6 +74,13 @@
     "aoti_torch_empty_strided",
     "aoti_torch_delete_tensor_object",
     "executorch::backends::cuda::CUDAStreamGuard::create",
+    # From the CUDA sources rather than the C++ ones. The build drops every .cu file when no working
+    # compiler is found, and the library is still produced from its .cpp sources, so a check that
+    # names only C++ symbols passes on a library missing every kernel it was gated for.
+    "aoti_torch_cuda__weight_int4pack_mm",
+    "aoti_torch_cuda_sort_stable",
+    "aoti_torch_cuda_rand",
+    "aoti_torch_cuda_randint_low_out",
 )
 
 _QUANTIZED_KERNEL_SYMBOLS = (

backends/cuda/CMakeLists.txt

@@ -160,8 +160,8 @@ endif()
 # retention.
 if(_cuda_is_msvc_toolchain)
   target_link_libraries(
-    aoti_cuda_shims PRIVATE cuda_platform CUDA::cudart CUDA::curand
-                            extension_cuda ${CMAKE_DL_LIBS}
+    aoti_cuda_shims PRIVATE cuda_platform CUDA::cudart extension_cuda
+                            ${CMAKE_DL_LIBS}
   )
   # Link object library directly so symbols are pulled exactly once while
   # avoiding duplicate static/object inclusion and interface leakage.
@@ -177,7 +177,7 @@ else()
     aoti_cuda_shims
     PRIVATE cuda_platform -Wl,--whole-archive aoti_common_shims_slim
             -Wl,--no-whole-archive
-    PUBLIC CUDA::cudart CUDA::curand extension_cuda ${CMAKE_DL_LIBS}
+    PUBLIC CUDA::cudart extension_cuda ${CMAKE_DL_LIBS}
   )
 endif()
 

devtools/etdump/CMakeLists.txt

@@ -69,16 +69,14 @@ if(EXECUTORCH_BUILD_SHARED)
   # name something a consumer cannot link. Scoped to the shared build so a build
   # that does not opt in keeps the parent's public dependency.
   target_link_libraries(etdump PRIVATE flatccrt executorch_shared)
-else()
-  target_link_libraries(etdump PUBLIC flatccrt)
-  target_link_libraries(etdump PRIVATE executorch)
-endif()
-if(EXECUTORCH_BUILD_SHARED)
   set_target_properties(etdump PROPERTIES OUTPUT_NAME executorch_etdump)
   executorch_target_soname_policy(etdump)
   # Ships beside libexecutorch.so in the wheel's lib/ directory, and needs it,
   # so it has to be able to find it from wherever the package is installed.
   executorch_target_shipped_runtime_path(etdump)
+else()
+  target_link_libraries(etdump PUBLIC flatccrt)
+  target_link_libraries(etdump PRIVATE executorch)
 endif()
 
 target_include_directories(

install_utils.py

@@ -10,6 +10,7 @@
 import platform
 import re
 import shlex
+import shutil
 import subprocess
 import sys
 from typing import List, Optional
@@ -159,14 +160,18 @@ def _selected_nvcc() -> List[str]:
         explicit = os.environ.get("CUDACXX")
     if explicit:
         return [explicit, "--version"]
-    # CUDA_PATH is honoured by CMake's own compiler search, and /usr/local/cuda is the route
-    # FindCUDAToolkit resolves through when nothing else is set. Skipping both meant packaging could
-    # report no toolkit while the build compiled with one, which disables the mismatch guard.
-    for root in (
-        os.environ.get("CUDAToolkit_ROOT"),
-        os.environ.get("CUDA_PATH"),
-        "/usr/local/cuda",
-    ):
+    # Follow CMake's COMPILER search, since that is what decides which nvcc compiles the sources:
+    # CUDACXX above, then PATH, then CUDA_PATH, then the conventional symlink. PATH has to come
+    # before the others. Measured with only PATH pointing at 13.0 on a box whose /usr/local/cuda is
+    # 12.8, CMake compiles with 13.0, so consulting the symlink first reported 12.8 and produced
+    # metadata for a train the binaries were not built with.
+    #
+    # CUDAToolkit_ROOT is deliberately absent: it steers find_package(CUDAToolkit) but CMake's
+    # compiler search ignores it, so reading it here names a compiler that will not be used.
+    on_path = shutil.which("nvcc")
+    if on_path:
+        return [on_path, "--version"]
+    for root in (os.environ.get("CUDA_PATH"), "/usr/local/cuda"):
         if not root:
             continue
         candidate = os.path.join(root, "bin", "nvcc")

setup.py

@@ -216,14 +216,8 @@ def _minimal_packages() -> List[str]:
 # the CUDA runtime and cuRAND and nothing else, and the generated model library embeds its kernels
 # rather than compiling them at run time, so there is no runtime compiler to satisfy either.
 _CUDA_RUNTIME_PACKAGES = {
-    "12": (
-        "nvidia-cuda-runtime-cu12",
-        "nvidia-curand-cu12",
-    ),
-    "13": (
-        "nvidia-cuda-runtime",
-        "nvidia-curand",
-    ),
+    "12": ("nvidia-cuda-runtime-cu12",),
+    "13": ("nvidia-cuda-runtime",),
 }
 
 # Where each train installs its libraries under site-packages. CUDA 13 collects them in
@@ -234,10 +228,7 @@ def _minimal_packages() -> List[str]:
 # searches what is recorded here, so a missing directory leaves a shipped library unable to find
 # a package that is installed, and an extra one implies a dependency the wheel does not have.
 _CUDA_LIBRARY_DIRECTORIES = {
-    "12": (
-        "nvidia/cuda_runtime/lib",
-        "nvidia/curand/lib",
-    ),
+    "12": ("nvidia/cuda_runtime/lib",),
     "13": ("nvidia/cu13/lib",),
 }
 

tools/cmake/executorch-wheel-config.cmake

@@ -41,6 +41,10 @@
 # A consumer using these variables has to set it, because a compiler defaulting
 # to an older standard cannot parse them.
 #
+# EXECUTORCH_RUNTIME_LIBRARY_DIR -- Where the shipped libraries live. A consumer
+# that installs its own binary elsewhere adds this to its INSTALL_RPATH, because
+# CMake removes the entry it recorded while building.
+#
 # EXECUTORCH_LIBRARIES    -- Libraries to link against: the prebuilt runtime and
 # the components the wheel shipped, except the ones documented below as opt in.
 # Not the Python extension, which carries unresolved interpreter symbols that
@@ -184,6 +188,16 @@ if(EXISTS "${_executorch_version_file}")
 endif()
 unset(_executorch_version_file)
 
+# Where the shipped libraries live. Computed here rather than beside the Python
+# extension, because a consumer on the older variables route is told to put this
+# in its INSTALL_RPATH, and a package built without that extension would
+# otherwise hand it an empty string and produce a binary that cannot start.
+if(_executorch_runtime_library)
+  get_filename_component(
+    EXECUTORCH_RUNTIME_LIBRARY_DIR "${_executorch_runtime_library}" DIRECTORY
+  )
+endif()
+
 set(EXECUTORCH_INCLUDE_DIRS "${_executorch_package_root}/include"
                             "${_executorch_c10_include}"
 )
@@ -746,12 +760,6 @@ if(_portable_lib_LIBRARY)
     # every consumer and survives install, which would bake this machine's
     # package location into a library the consumer ships onward. A consumer that
     # installs elsewhere adds these to its own INSTALL_RPATH.
-    get_filename_component(
-      EXECUTORCH_RUNTIME_LIBRARY_DIR "${_executorch_runtime_library}" DIRECTORY
-    )
-    get_filename_component(
-      EXECUTORCH_PYTHON_EXTENSION_DIR "${_portable_lib_LIBRARY}" DIRECTORY
-    )
   endif()
 endif()
 

tools/cmake/preset/pybind.cmake

@@ -21,6 +21,12 @@ set_overridable_option(EXECUTORCH_BUILD_EXTENSION_RUNNER_UTIL ON)
 set_overridable_option(EXECUTORCH_BUILD_KERNELS_LLM ON)
 set_overridable_option(EXECUTORCH_BUILD_KERNELS_LLM_AOT ON)
 set_overridable_option(EXECUTORCH_BUILD_KERNELS_OPTIMIZED ON)
+# The wheel ships the profiler library and documents it as usable, so the tracer
+# has to be compiled in. Left off, every recording hook is preprocessed away and
+# a caller gets an empty trace with no error. The devtools directory is already
+# built for a shared or pybind build, which is all this option requires.
+set_overridable_option(EXECUTORCH_ENABLE_EVENT_TRACER ON)
+set_overridable_option(EXECUTORCH_BUILD_DEVTOOLS ON)
 set_overridable_option(EXECUTORCH_BUILD_EXTENSION_FLAT_TENSOR ON)
 set_overridable_option(EXECUTORCH_BUILD_EXTENSION_DATA_LOADER ON)
 set_overridable_option(EXECUTORCH_BUILD_EXTENSION_MODULE ON)