Ship the CUDA delegate as its own library

[shoumikhin]

The CUDA delegate is compiled into whichever component links it, so a C++
application cannot use it without building from source, and the shim layer it
depends on ends up duplicated across several shipped libraries.

Build the delegate as a shared library and ship it in the wheel, so a process
has one copy and both the Python bindings and a C++ application can link the
same one. The CUDA runtime itself is not bundled; it continues to come from the
environment.

Two things were needed to make that actually reduce duplication:

The platform helper resolved the ExecuTorch core statically, which would give
the delegate its own copy of the backend registry. It now resolves the runtime
from the shared runtime library instead.

The shim library force-links its shim objects so their symbols survive, which is
correct, but it did so as a public link option. That propagated to every
consumer, so each one embedded another copy of the same shim code. Making it
private keeps the symbols in the library that owns them while consumers resolve
against it, which takes a representative shim symbol from three definitions down
to one.

Registration still happens through a static initializer, and the delegate is
retained on the link line so that initializer runs even though no symbol from it
is referenced directly.

This is gated on the existing EXECUTORCH_BUILD_SHARED option, so only the
Linux wheel changes; every other build keeps linking static libraries exactly as
before.

Test plan:

The wheel smoke test now asserts that exactly one shipped library defines the
CUDA delegate, alongside the existing backend-registry, thread-pool, CPU kernel,
and XNNPACK assertions. Because the delegate is only present in wheels built
with CUDA, that assertion skips cleanly when it is absent rather than failing.
All three behaviors were confirmed: it passes on a wheel built with this change,
it fails on a wheel built before it (correctly reporting three definers by
name), and it skips on a wheel built without CUDA.

The delegate's own methods are weak symbols, so the assertion checks a strong
symbol from the shim layer instead.

Built the wheel with CUDA enabled from a clean checkout and verified against a
fresh virtual environment with a normal dependency-resolving install:

• The wheel ships the delegate as its own versioned library next to the runtime,
  the thread pool, the CPU kernels, and the XNNPACK delegate.
• nm -DC across every shipped shared object shows exactly one definition of a
  representative delegate symbol, down from three.
• Only the runtime library defines the backend registry, so the delegate does
  not introduce a second one.
• The thread-pool, CPU kernel, and XNNPACK assertions all still hold with the
  CUDA delegate loaded.
• With EXECUTORCH_BUILD_SHARED off, the delegate remains a static library and
  no new shared object is produced, so every build that does not opt in is
  unaffected.

Note for anyone building with CUDA: the build needs an explicit
CMAKE_CUDA_ARCHITECTURES for compute capability 6.1 or newer, otherwise an
integer dot-product intrinsic used by one of the kernels does not compile. That
is independent of this change.

[shoumikhin]

Stack from ghstack (oldest at bottom):

• -> Ship the CUDA delegate as its own library #21531
• Ship the XNNPACK delegate as its own library #21526
• Ship the merged CPU kernels as their own library #21524
• Ship the thread pool as its own library so a process has one pool #21522
• Ship a linkable shared runtime and make the Python bindings use it #21514

[pytorch-bot]

🔗 Helpful Links

🧪 See artifacts and rendered test results at hud.pytorch.org/pr/pytorch/executorch/21531

• 📄 Preview Python docs built from this PR

Note: Links to docs will display an error until the docs builds have been completed.

❌ 5 New Failures, 156 Pending, 5 Unclassified Failures

As of commit 207b1f6 with merge base 9789eea ():

NEW FAILURES - The following jobs have failed:

• nightly / link-check / lint-urls (gh)
• nightly / link-check / lint-xrefs (gh)
• periodic / test-models-linux (cmake, ds_cnn, portable, linux.2xlarge, 90) / linux-job (gh)
  RuntimeError: Command docker exec -t f12403a7e5e318beabb6375f9a8e62b4e3d0a39a09a5798a45664e42a9798909 /exec failed with exit code 134
• periodic / test-models-linux (cmake, yolo26, portable, linux.2xlarge, 90) / linux-job (gh)
  RuntimeError: Command docker exec -t e180dc916778ba08c1d75db4564c28b56b8676e5e856c3d8c676869d7fce62a8 /exec failed with exit code 1
• pull / unittest / macos / macos-job (gh)
  examples/models/test/test_export.py::ExportTest::test_efficient_sam_export_to_executorch

UNCLASSIFIED FAILURES - DrCI could not classify the following jobs because the workflow did not run on the merge base. The failures may be pre-existing on trunk or introduced by this PR:

• Build Aarch64 Linux Wheels / pytorch/executorch / build-wheel-py3_14-cpu-aarch64 (gh) (this job did not run on the merge base, so DrCI cannot tell whether the failure is pre-existing)
  pyarrow
• Build Linux Wheels / pytorch/executorch / build-manywheel-py3_14-cpu (gh) (this job did not run on the merge base, so DrCI cannot tell whether the failure is pre-existing)
  pyarrow
• Build macOS Wheels / pytorch/executorch / build-wheel-py3_14-cpu (gh) (this job did not run on the merge base, so DrCI cannot tell whether the failure is pre-existing)
  pyarrow
• Build macOS Wheels / pytorch/executorch / upload / upload-wheel-py3_14-cpu (gh) (this job did not run on the merge base, so DrCI cannot tell whether the failure is pre-existing)
  Unable to download artifact(s): Artifact not found
• Build Windows Wheels / pytorch/executorch / build-wheel-py3_14-cpu (gh) (this job did not run on the merge base, so DrCI cannot tell whether the failure is pre-existing)
  pyarrow

This comment was automatically generated by Dr. CI and updates every 15 minutes.