Update

[ghstack-poisoned]

Author: shoumikhin

.ci/scripts/wheel/test_cpp_sdk.py

@@ -22,10 +22,12 @@
    on the shipped runtime with a relocatable RUNPATH.
 """
 
+import importlib.util
 import os
 import re
 import shutil
 import subprocess
+import tempfile
 import sys
 from pathlib import Path
 
@@ -284,8 +286,333 @@ def test_python_extensions_import() -> None:
         )
 
 
+_CUSTOM_OP_SOURCE = """\
+// A custom operator, built the way an out-of-tree project builds one: against the
+// shipped Python extension rather than an ExecuTorch source tree.
+#include <executorch/extension/kernel_util/make_boxed_from_unboxed_functor.h>
+#include <executorch/runtime/kernel/kernel_includes.h>
+
+namespace {
+
+executorch::aten::Tensor& custom_double_out(
+    executorch::runtime::KernelRuntimeContext& context,
+    const executorch::aten::Tensor& input,
+    executorch::aten::Tensor& out) {
+  (void)context;
+  const float* in = input.const_data_ptr<float>();
+  float* dst = out.mutable_data_ptr<float>();
+  for (ssize_t i = 0; i < input.numel(); ++i) {
+    dst[i] = in[i] * 2.0f;
+  }
+  return out;
+}
+
+} // namespace
+
+// The registration macro is the point of the check: it has to compile and resolve
+// against the registry the shipped extension provides.
+EXECUTORCH_LIBRARY(wheel_check, "custom_double.out", custom_double_out);
+"""
+
+
+_CUSTOM_OP_CMAKE = """\
+cmake_minimum_required(VERSION 3.28)
+project(custom_op_check CXX)
+
+find_package(executorch REQUIRED)
+
+add_library(custom_op_check SHARED custom_op.cpp)
+# The legacy contract: a custom-op library links the shipped Python extension,
+# which owns the operator registry it registers into.
+target_link_libraries(custom_op_check PRIVATE _portable_lib)
+"""
+
+
+def test_shipped_libraries_load() -> None:
+    """Every shipped library must depend only on things that exist.
+
+    The symbol checks prove each component is defined exactly once, but a library
+    can still be unloadable if it needs something nothing provides, which is a
+    packaging bug rather than a duplication bug.
+
+    A dependency the wheel ships elsewhere is fine even when `ldd` cannot resolve
+    it: some extensions are loaded after `import torch` has already brought their
+    dependencies into the process, so they intentionally carry no path to them.
+    Only a name nothing in the wheel provides is a real problem.
+    """
+    if shutil.which("ldd") is None:
+        print("- ldd not available, skipping the load check")
+        return
+
+    package_dir = _installed_package_dir()
+    libraries = _shipped_shared_objects(package_dir)
+    shipped = {library.name for library in libraries}
+
+    # A dependency is only excusable when the wheel ships it AND the loader can
+    # actually reach it from the library that needs it. Loaded-later extensions
+    # such as the Torch libraries are the real exception: they resolve once the
+    # Python package that owns them is imported. Anything the wheel itself ships
+    # must resolve here, because a RUNPATH applies to the library carrying it and
+    # is not inherited on behalf of a dependency's own dependencies.
+    broken = {}
+    unreachable = {}
+    unresolved = {}
+    for library in libraries:
+        resolved = subprocess.run(
+            # -r resolves data and function symbols too, not just the NEEDED
+            # entries. A SHARED link does not error on undefined symbols, so
+            # without this an under-linked library passes here and fails at first
+            # use instead.
+            ["ldd", "-r", str(library)],
+            capture_output=True,
+            text=True,
+            check=False,
+            # Any LD_LIBRARY_PATH in the build environment would paper over a
+            # RUNPATH the shipped library is actually missing.
+            env={
+                key: value
+                for key, value in os.environ.items()
+                if key != "LD_LIBRARY_PATH"
+            },
+        )
+        # ldd reports missing libraries on stdout but undefined symbols on stderr,
+        # so both streams matter.
+        combined = resolved.stdout + resolved.stderr
+        missing = [
+            line.split("=>")[0].strip()
+            for line in combined.splitlines()
+            if "not found" in line
+        ]
+        # Interpreter symbols are excluded rather than whole files. A library that
+        # is loaded by Python, whether a extension module or an ahead-of-time
+        # plugin, resolves those only once an interpreter is running, so ldd can
+        # never resolve them and their absence says nothing about packaging.
+        # Filtering the symbols rather than guessing from the file name keeps the
+        # check active for everything else those libraries need.
+        undefined = [
+            line.strip()
+            for line in combined.splitlines()
+            if "undefined symbol" in line
+            and not re.search(r"undefined symbol:\s+_?Py", line)
+        ]
+        if undefined:
+            unresolved[str(library.relative_to(package_dir))] = undefined[:5]
+        absent = [name for name in missing if name not in shipped]
+        present_but_unreachable = [name for name in missing if name in shipped]
+        if absent:
+            broken[str(library.relative_to(package_dir))] = absent
+        if present_but_unreachable:
+            unreachable[str(library.relative_to(package_dir))] = present_but_unreachable
+
+    assert not broken, (
+        "shipped libraries need dependencies that nothing provides, so they will "
+        f"fail to load: {broken}"
+    )
+    assert not unreachable, (
+        "shipped libraries need dependencies the wheel ships but the loader "
+        "cannot reach from them, which usually means a missing RUNPATH entry: "
+        f"{unreachable}"
+    )
+    assert not unresolved, (
+        "shipped libraries reference symbols nothing provides, so they will fail "
+        f"at first use rather than at load: {unresolved}"
+    )
+    print("✓ every shipped library resolves in an environment with torch present")
+
+
+def test_shipped_libraries_resolve_without_build_tree() -> None:
+    """A shipped library must resolve using only its relative runtime paths.
+
+    Packaging copies binaries out of the build directory, so they still carry the
+    absolute paths they were linked with. On the machine that produced the wheel
+    those paths exist, which means a library whose relative path is wrong can still
+    resolve and look correct. Anywhere else it would fail.
+
+    Copy each library and its wheel-provided dependencies into a fresh tree that
+    mirrors the wheel layout, drop every absolute runtime path, and check what is
+    left is enough.
+    """
+    if shutil.which("ldd") is None or shutil.which("patchelf") is None:
+        print("- ldd or patchelf unavailable, skipping the relocated load check")
+        return
+
+    package_dir = _installed_package_dir()
+    libraries = _shipped_shared_objects(package_dir)
+    environment = {
+        key: value for key, value in os.environ.items() if key != "LD_LIBRARY_PATH"
+    }
+
+    with tempfile.TemporaryDirectory() as work_dir:
+        root = Path(work_dir) / package_dir.name
+        # Mirror the layout so a relative path such as $ORIGIN/../../lib still
+        # points where it would in a real install.
+        for library in libraries:
+            target = root / library.relative_to(package_dir)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(library, target)
+
+        broken = {}
+        for library in libraries:
+            target = root / library.relative_to(package_dir)
+            current = subprocess.run(
+                ["patchelf", "--print-rpath", str(target)],
+                capture_output=True,
+                text=True,
+                check=False,
+            ).stdout.strip()
+            relative = [
+                entry for entry in current.split(":") if entry.startswith("$ORIGIN")
+            ]
+            subprocess.run(
+                ["patchelf", "--set-rpath", ":".join(relative), str(target)],
+                # A failure here would leave the original absolute build paths in
+                # place, and the check below would then pass by resolving through
+                # them, which is exactly what this test exists to rule out.
+                check=True,
+            )
+            resolved = subprocess.run(
+                ["ldd", str(target)],
+                capture_output=True,
+                text=True,
+                check=False,
+                env=environment,
+            ).stdout
+            shipped = {item.name for item in libraries}
+            all_missing = [
+                line.split("=>")[0].strip()
+                for line in resolved.splitlines()
+                if "not found" in line
+            ]
+            # Only wheel-provided dependencies are asserted on, because an external
+            # one is expected to come from the environment. They are still reported,
+            # since silently dropping them would hide a library that resolves only
+            # through an absolute build path.
+            missing = [name for name in all_missing if name in shipped]
+            external = [name for name in all_missing if name not in shipped]
+            if external:
+                print(
+                    f"- {library.relative_to(package_dir)} also needs "
+                    f"{external} from the environment"
+                )
+            if missing:
+                broken[str(library.relative_to(package_dir))] = missing
+
+        assert not broken, (
+            "shipped libraries only resolve their wheel-provided dependencies "
+            "through absolute build paths, so they would fail on any other "
+            f"machine: {broken}"
+        )
+    print("✓ every shipped library resolves without the build tree")
+
+
+def test_custom_op_compiles(work_dir: Path) -> None:
+    """A custom operator compiles and links against the shipped extension.
+
+    This is how an out-of-tree project adds its own kernels, and it points at the
+    Python extension rather than the runtime, so it is not covered by the consumer
+    check above.
+    """
+    assert shutil.which("cmake") is not None, "cmake is required to build a consumer"
+
+    package_dir = _installed_package_dir()
+    if not list(package_dir.glob("extension/pybindings/_portable_lib*")):
+        print("- the wheel ships no Python extension, skipping the custom op check")
+        return
+
+    source_dir = work_dir / "custom-op"
+    build_dir = work_dir / "custom-op-build"
+    source_dir.mkdir(parents=True, exist_ok=True)
+    (source_dir / "custom_op.cpp").write_text(_CUSTOM_OP_SOURCE)
+    (source_dir / "CMakeLists.txt").write_text(_CUSTOM_OP_CMAKE)
+
+    configure = subprocess.run(
+        [
+            "cmake",
+            "-S",
+            str(source_dir),
+            "-B",
+            str(build_dir),
+            f"-DCMAKE_PREFIX_PATH={package_dir}",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert configure.returncode == 0, (
+        "a custom operator project cannot configure against the wheel: "
+        f"{(configure.stderr or configure.stdout).strip()[-600:]}"
+    )
+
+    compiled = subprocess.run(
+        ["cmake", "--build", str(build_dir)],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert compiled.returncode == 0, (
+        "a custom operator does not compile or link against the shipped extension: "
+        f"{(compiled.stderr or compiled.stdout).strip()[-800:]}"
+    )
+    assert list(build_dir.rglob("libcustom_op_check.so")) or list(
+        build_dir.rglob("custom_op_check.dll")
+    ), "the custom operator library was not produced"
+    print("✓ a custom operator compiles against the shipped Python extension")
+
+
+def test_wheel_platform_tag() -> None:
+    """The wheel's declared platform tag must match what its libraries need.
+
+    A library that quietly picks up a newer dependency, or a newer minimum glibc,
+    makes the wheel unusable on machines the tag says it supports. auditwheel is
+    the tool that decides this, so ask it rather than guessing.
+
+    Only a contradiction between the tag and the contents fails here. Reports about
+    instruction set extensions are left to the caller, because a prebuilt tool that
+    ships in the wheel can legitimately require a newer baseline than the tag
+    implies.
+    """
+    if importlib.util.find_spec("auditwheel") is None:
+        print("- auditwheel unavailable, skipping the platform tag check")
+        return
+
+    wheels = sorted(Path(os.environ.get("WHEEL_DIR", ".")).glob("executorch-*.whl"))
+    if not wheels:
+        print("- no wheel file to inspect, skipping the platform tag check")
+        return
+
+    result = subprocess.run(
+        [sys.executable, "-m", "auditwheel", "show", str(wheels[-1])],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    # auditwheel wraps its verdict across lines, so compare on collapsed
+    # whitespace rather than the literal output.
+    combined = " ".join((result.stdout + result.stderr).split())
+    match = re.search(
+        r'consistent with the following platform tag: "([^"]+)"', combined
+    )
+    assert match, (
+        "auditwheel reported no platform tag for the wheel, so its contents could "
+        f"not be checked against what it claims: {combined[-400:]}"
+    )
+    # The tag auditwheel derives from the contents has to be the one the file name
+    # claims. A wheel that names a stricter tag than its libraries support installs
+    # on machines it cannot actually run on.
+    claimed = wheels[-1].name.split("-")[-1].removesuffix(".whl")
+    assert match.group(1) in claimed, (
+        f"the wheel claims platform tag {claimed} but its contents only support "
+        f"{match.group(1)}"
+    )
+    print(f"✓ the wheel contents match its declared platform tag {match.group(1)}")
+
+
 def run_tests(work_dir: Path) -> None:
     test_single_backend_registry()
     test_python_extensions_import()
+    test_shipped_libraries_load()
+    test_shipped_libraries_resolve_without_build_tree()
+    test_wheel_platform_tag()
+    test_custom_op_compiles(work_dir)
     test_single_threadpool()
     test_cpp_consumer(work_dir)