copyengine 0.1.0__tar.gz

copyengine-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,135 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  TORCH_CPU_INDEX: https://download.pytorch.org/whl/cpu
+
+jobs:
+  # Core, C ABI and the numpy path: no torch.
+  core:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.10", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python }}
+      - uses: taiki-e/install-action@just
+      - run: sudo apt-get update && sudo apt-get install -y ninja-build
+      - run: pip install scikit-build-core nanobind pytest
+      - run: just test
+
+  # Per torch release: the stable-ABI ops and the interception shim built for
+  # it, the whole suite with the shim and again with the Python mode (the same
+  # semantics must hold), and the shim exported for the release wheel.
+  torch:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        torch: ["2.9.1", "2.10.0", "2.11.0"]
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - uses: taiki-e/install-action@just
+      - run: sudo apt-get update && sudo apt-get install -y ninja-build
+      - run: pip install scikit-build-core nanobind pytest numpy
+      - run: pip install "torch==${{ matrix.torch }}" --index-url "$TORCH_CPU_INDEX"
+      - run: just test
+      - name: Same suite, Python interception mode
+        run: CE_SHIM=0 pytest -q
+      - name: Check both torch layers loaded
+        working-directory: /tmp
+        # The stable-ABI ops need torch >= 2.10; older torch uses the Python path for explicit copies.
+        run: python -c "import torch, copyengine as ce; v = tuple(map(int, torch.__version__.split('+')[0].split('.')[:2])); assert (ce._torch_ops.copy_ is not None) == (v >= (2, 10)), ce._torch_ops.error; assert ce._shim.lib is not None, ce._shim.error"
+
+  # The stable ABI claim and the compile-on-import path: built with the newest
+  # torch, run with the oldest supported one.
+  cross-torch:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - run: sudo apt-get update && sudo apt-get install -y ninja-build
+      - run: pip install scikit-build-core nanobind pytest numpy
+      - run: pip install "torch==2.11.0" --index-url "$TORCH_CPU_INDEX"
+      - run: pip wheel --no-build-isolation --no-deps . -w dist
+      - run: pip install "torch==2.9.1" --index-url "$TORCH_CPU_INDEX"
+      - run: pip install --no-deps dist/*.whl
+      - name: On torch older than the ops' stable ABI, the ops stay off and the shim still loads
+        working-directory: /tmp
+        run: python -c "import copyengine as ce; assert ce._torch_ops.copy_ is None; assert ce._shim.lib is not None, ce._shim.error; print(ce._torch_ops.error); print(ce._shim.lib._name)"
+      - run: pytest -q
+
+  # Release wheels and sdist (docker/build-wheels.sh, which also runs locally):
+  # manylinux_2_28, CUDA kernels for every architecture, a prebuilt shim per
+  # supported torch release. On a v* tag the version must match CMakeLists.txt
+  # and the files are attached to the GitHub release.
+  wheel:
+    if: startsWith(github.ref, 'refs/tags/v') || github.event_name == 'workflow_dispatch'
+    needs: [core, torch, cross-torch]
+    runs-on: ubuntu-24.04
+    timeout-minutes: 120
+    container: quay.io/pypa/manylinux_2_28_x86_64
+    steps:
+      - uses: actions/checkout@v6
+      - name: Tag matches the version
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: |
+          want=$(sed -n 's/^project(copyengine VERSION \([0-9.]*\).*/\1/p' CMakeLists.txt)
+          test "${GITHUB_REF_NAME#v}" = "$want" || { echo "tag $GITHUB_REF_NAME, CMakeLists.txt $want"; exit 1; }
+      - run: docker/build-wheels.sh
+      - uses: actions/upload-artifact@v5
+        with:
+          name: dist
+          path: dist/*
+
+  release:
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [wheel]
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v5
+        with:
+          name: dist
+          path: dist
+      - env:
+          GH_TOKEN: ${{ github.token }}
+        run: gh release create "$GITHUB_REF_NAME" dist/* --repo "$GITHUB_REPOSITORY" --verify-tag --generate-notes
+
+  # PyPI trusted publishing (OIDC): the pypi.org project trusts this workflow
+  # and the `pypi` environment; no token is stored.
+  pypi:
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [wheel]
+    runs-on: ubuntu-24.04
+    environment:
+      name: pypi
+      url: https://pypi.org/project/copyengine/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v5
+        with:
+          name: dist
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@release/v1

copyengine-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+/build/
+/dist/
+*.egg-info/
+__pycache__/
+*.pyc
+.venv/
+compile_commands.json

copyengine-0.1.0/AGENTS.md

@@ -0,0 +1,75 @@
+# copyengine engineering rules
+
+## Layout
+
+- `include/copyengine/copyengine.h` is the stable C ABI (`ce_` prefix). Any
+  incompatible change bumps `CE_ABI_VERSION`. Until the first release, the C
+  ABI, Python API and profile format may change freely; from then on they
+  follow semver.
+- `include/copyengine/*.hpp` + `src/core`: the platform-independent planner
+  (namespace `ce`): IR and lowering (`ir`), planning and dependencies (`plan`),
+  tuner, engine, probe. It must not include torch or CUDA headers.
+- `src/backends/host`: host executor and the conversion table.
+- `src/backends/cuda`: driver loader (dlopen + `cuGetProcAddress` at the
+  header's `CUDA_VERSION`), probe, executor, and `kernels.cu` (AOT fatbin,
+  embedded by `cmake/embed.cmake`).
+- `src/core/convert.hpp` is shared verbatim by host code and CUDA kernels;
+  host and device conversions must stay bit-identical (no FMA: host files use
+  `-ffp-contract=off`, kernels `--fmad=false`).
+- `src/capi` implements the C ABI; `src/python` is the nanobind extension
+  `copyengine._core`; `python/copyengine` is the Python layer.
+- torch integration is layered, and all logic stays in the torch-free core,
+  reached through the `FrontendApi` table that `_core` exports:
+  `src/torch/ops.cpp` on the stable libtorch ABI (descriptors, explicit APIs as
+  custom ops; one build for every torch >= 2.10), and `src/torch/shim.cpp`, the
+  scope interception, holding only dispatch-key registration and redispatch.
+  The shim uses the DeferredInit key, refuses to load if something else holds
+  it, and is admitted only after a verified copy; it is prebuilt for the
+  build-time torch and otherwise compiled on import, cached per torch build.
+  Its fallback is `python/copyengine/_mode.py` (TorchDispatchMode) with
+  identical semantics: behavior may differ only in speed, never in results,
+  and `tests/python/test_scope.py` runs under both.
+- The version lives only in `project(... VERSION ...)` in `CMakeLists.txt`.
+
+## Invariants
+
+- Ops carry absolute element indices (address / itemsize); pure copies are
+  normalized to bytes. Dependencies and merging rely on this.
+- Every Executor strategy must be correct for any group it is offered.
+  `passthrough` (each op as submitted) is always correct, but it is measured
+  only when its call count is bounded: it is never a multi-second baseline.
+- New platform features are admitted only after a verified test copy.
+- Backend tables built per group go in `Group::exec_cache`; hot paths do not
+  re-plan.
+- No regression: the framework's own copy is the baseline. Dominance-safe
+  transforms apply directly; a speculative strategy is used only after it wins
+  a paired A/B against the baseline that counts host and GPU time. Ties keep
+  the baseline. Where no native copy exists there is no original to protect:
+  candidates are explored alike and the fastest locks.
+- Measuring must not stall a run: hopeless candidates are dropped after one
+  sample, and online re-checks only run finalists within 2x of the locked one.
+- A group touches several allocations; no copy call, 2-D block or staged
+  interval may cross an allocation boundary (the driver rejects it).
+- The native baseline is offered only for dtype pairs whose bits match ce's,
+  backed by a test.
+- Hot paths never synchronize; only warmup exploration and validation may.
+- Intercepted `copy_` keeps the caller's `non_blocking` semantics; explicit
+  `ce.copy_` returns with host-side copies complete.
+
+## Scope
+
+- Commit code only: no design notes, benchmark results, or machine-specific
+  data (hostnames, paths, GPU models, driver versions).
+- copyengine is a library; do not add a CLI.
+
+## Verification
+
+- `just test` builds the C++ library, runs ctest, installs the Python package
+  and runs pytest (CUDA tests skip without a GPU).
+- GPU work runs inside `just docker-shell`.
+- `python bench/bench_torch.py` compares against torch on a GPU.
+
+## Commits
+
+- Emoji conventional commits on `master`, for example `✨ feat: add Runs IR`.
+  Rebase, no merge commits.

copyengine-0.1.0/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+copyengine follows [semantic versioning](https://semver.org). From 0.1.0 on,
+the Python API, the C ABI (`CE_ABI_VERSION`) and the tuning profile format
+change incompatibly only in a new minor (0.x) or major release.
+
+## 0.1.0
+
+First release.
+
+- `ce.scope()`: inside it, unchanged torch `copy_` calls are queued, merged
+  and issued together; every other op is ordered after the queued copies it
+  touches. A C++ dispatcher shim does the interception (prebuilt for torch
+  2.9, 2.10 and 2.11, compiled on import for others); a pure-Python
+  interception with the same results is the fallback.
+- Explicit API: `ce.copy_` for any strided views with broadcast,
+  `ce.lazy(...)` views torch cannot express (gather + permute + slice),
+  `ce.gather` / `ce.scatter_`, `ce.segments`, conversions and quantization
+  with `ce.Elementwise`, `Engine.freeze()` replay.
+- Strategies on CUDA: merged and batched DMA (`cuMemcpyBatchAsync`), 2-D
+  copies, vectorized copy and conversion kernels, dense link copies with the
+  reordering done on the GPU, pinned bounce buffers for pageable memory. Host
+  copies run on worker threads.
+- Measured choices: torch's own copy is the baseline; other strategies must
+  win a paired A/B, and locked decisions are re-checked online.
+- dtypes: float64/32/16, bfloat16, int64/32/16/8, uint8, bool. Host and GPU
+  conversions are bit-identical.
+- Platforms: Linux x86_64, Python 3.10+, CUDA 12.x and 13.x drivers (loaded at
+  runtime), torch 2.9+ for `scope()` interception, 2.10+ for the explicit API
+  as torch custom ops (older torch runs it from Python). A stable C ABI and CMake
+  package for C and C++ callers.
+
+Known limits: no fp8 dtypes; copies between two GPUs are implemented but have
+not been tested on a multi-GPU machine; small explicit copies pay a few
+microseconds of host overhead more than torch.

copyengine-0.1.0/CLAUDE.md

@@ -0,0 +1 @@
+@./AGENTS.md

copyengine-0.1.0/CMakeLists.txt

@@ -0,0 +1,203 @@
+cmake_minimum_required(VERSION 3.26)
+project(copyengine VERSION 0.1.0 LANGUAGES C CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+set(CE_CUDA "AUTO" CACHE STRING "Build the CUDA backend: ON, OFF or AUTO (if the toolkit headers are found)")
+option(CE_BUILD_TESTS "Build C++ tests" ${PROJECT_IS_TOP_LEVEL})
+# scikit-build-core sets SKBUILD=2, which option() would read as OFF.
+if(DEFINED SKBUILD)
+  set(_ce_python_default ON)
+else()
+  set(_ce_python_default OFF)
+endif()
+option(CE_BUILD_PYTHON "Build the Python extension" ${_ce_python_default})
+
+configure_file(src/core/config.hpp.in ${CMAKE_CURRENT_BINARY_DIR}/generated/copyengine/config.hpp @ONLY)
+
+# Planner core, host backend and C ABI. Platform backends are added below.
+add_library(copyengine
+  src/core/version.cpp
+  src/core/probe.cpp
+  src/core/ir.cpp
+  src/core/types.cpp
+  src/core/plan.cpp
+  src/core/tuner.cpp
+  src/core/engine.cpp
+  src/core/frontend.cpp
+  src/backends/host/host.cpp
+  src/capi/capi.cpp
+)
+add_library(copyengine::copyengine ALIAS copyengine)
+# Host and device conversions must agree bit for bit: no FMA contraction.
+set_source_files_properties(src/backends/host/host.cpp PROPERTIES COMPILE_OPTIONS "-ffp-contract=off")
+find_package(Threads REQUIRED)
+target_link_libraries(copyengine PRIVATE Threads::Threads)
+target_include_directories(copyengine
+  PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/generated>
+  PRIVATE src
+)
+target_compile_options(copyengine PRIVATE
+  $<$<CXX_COMPILER_ID:GNU,Clang>:-Wall -Wextra -Wpedantic -Werror=return-type>
+  # GCC 13 false positive on std::variant holding std::shared_ptr (core/json.hpp)
+  $<$<CXX_COMPILER_ID:GNU>:-Wno-maybe-uninitialized>
+)
+set_target_properties(copyengine PROPERTIES C_VISIBILITY_PRESET hidden CXX_VISIBILITY_PRESET hidden)
+target_compile_definitions(copyengine PRIVATE CE_BUILDING_LIBRARY)
+
+# CUDA backend: needs only the toolkit headers. The driver is dlopen'ed at
+# runtime, so nothing links against libcuda or cudart.
+set(CE_WITH_CUDA OFF)
+if(NOT CE_CUDA STREQUAL "OFF")
+  find_package(CUDAToolkit QUIET)
+  if(CUDAToolkit_FOUND)
+    set(CE_WITH_CUDA ON)
+  elseif(CE_CUDA STREQUAL "ON")
+    message(FATAL_ERROR "CE_CUDA=ON but the CUDA toolkit was not found")
+  endif()
+endif()
+set(CE_CUDA_KERNELS OFF)
+if(CE_WITH_CUDA)
+  target_sources(copyengine PRIVATE src/backends/cuda/driver.cpp src/backends/cuda/probe.cpp
+    src/backends/cuda/executor.cpp)
+  target_include_directories(copyengine SYSTEM PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
+  target_link_libraries(copyengine PRIVATE ${CMAKE_DL_LIBS})
+
+  # Copy kernels: compiled AOT to a fatbin with nvcc and embedded as a byte
+  # array; loaded at runtime with cuModuleLoadData (no cudart dependency).
+  set(CE_CUDA_ARCHS "75;80;86;89;90;100;120" CACHE STRING
+      "SM architectures for the kernel fatbin (PTX of the last one is added), or 'native'")
+  find_program(CE_NVCC nvcc HINTS ${CUDAToolkit_BIN_DIR})
+  if(CE_NVCC)
+    set(CE_CUDA_KERNELS ON)
+    if(CE_CUDA_ARCHS STREQUAL "native")
+      set(_gencode -arch=native)
+    else()
+      set(_gencode)
+      foreach(a IN LISTS CE_CUDA_ARCHS)
+        list(APPEND _gencode -gencode arch=compute_${a},code=sm_${a})
+        set(_last ${a})
+      endforeach()
+      list(APPEND _gencode -gencode arch=compute_${_last},code=compute_${_last})
+    endif()
+    set(_fatbin ${CMAKE_CURRENT_BINARY_DIR}/ce_kernels.fatbin)
+    set(_embed ${CMAKE_CURRENT_BINARY_DIR}/ce_kernels_fatbin.c)
+    add_custom_command(
+      OUTPUT ${_fatbin}
+      # compress-mode=size: ~27x smaller; needs a CUDA 12.4+ era driver to load,
+      # older drivers fail kernel admission with a clear reason.
+      COMMAND ${CE_NVCC} --fatbin -std=c++17 -O3 --fmad=false --compress-mode=size ${_gencode}
+              -I${CMAKE_CURRENT_SOURCE_DIR}/src -o ${_fatbin} ${CMAKE_CURRENT_SOURCE_DIR}/src/backends/cuda/kernels.cu
+      DEPENDS src/backends/cuda/kernels.cu src/core/convert.hpp
+      COMMENT "Compiling copy kernels (${CE_CUDA_ARCHS})"
+      VERBATIM)
+    add_custom_command(
+      OUTPUT ${_embed}
+      COMMAND ${CMAKE_COMMAND} -DINPUT=${_fatbin} -DOUTPUT=${_embed} -DNAME=ce_kernels_fatbin
+              -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/embed.cmake
+      DEPENDS ${_fatbin} cmake/embed.cmake
+      VERBATIM)
+    target_sources(copyengine PRIVATE ${_embed})
+  else()
+    message(WARNING "nvcc not found: CUDA conversions and kernel strategies will be unavailable")
+  endif()
+endif()
+target_compile_definitions(copyengine PRIVATE CE_CUDA_KERNELS=$<BOOL:${CE_CUDA_KERNELS}>)
+target_compile_definitions(copyengine PRIVATE CE_WITH_CUDA=$<BOOL:${CE_WITH_CUDA}>)
+message(STATUS "copyengine: CUDA backend ${CE_WITH_CUDA}, kernels ${CE_CUDA_KERNELS}")
+
+if(CE_BUILD_TESTS)
+  enable_testing()
+  add_executable(ce_test_smoke tests/cpp/test_smoke.cpp)
+  target_link_libraries(ce_test_smoke PRIVATE copyengine::copyengine)
+  add_test(NAME smoke COMMAND ce_test_smoke)
+  add_executable(ce_test_probe tests/cpp/test_probe.cpp)
+  target_link_libraries(ce_test_probe PRIVATE copyengine::copyengine)
+  add_test(NAME probe COMMAND ce_test_probe)
+  add_executable(ce_test_capi tests/cpp/test_capi.c)
+  target_link_libraries(ce_test_capi PRIVATE copyengine::copyengine)
+  add_test(NAME capi COMMAND ce_test_capi)
+  add_executable(ce_test_convert tests/cpp/test_convert.cpp)
+  target_link_libraries(ce_test_convert PRIVATE copyengine::copyengine)
+  target_include_directories(ce_test_convert PRIVATE src)
+  target_compile_options(ce_test_convert PRIVATE -ffp-contract=off)
+  add_test(NAME convert COMMAND ce_test_convert)
+endif()
+
+if(CE_BUILD_PYTHON)
+  find_package(Python 3.10 REQUIRED
+    COMPONENTS Interpreter Development.Module ${SKBUILD_SABI_COMPONENT})
+  execute_process(
+    COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE nanobind_ROOT)
+  find_package(nanobind CONFIG REQUIRED)
+  nanobind_add_module(_core STABLE_ABI NB_STATIC src/python/module.cpp)
+  target_link_libraries(_core PRIVATE copyengine)
+  install(TARGETS _core LIBRARY DESTINATION copyengine)
+
+  # Interception shim sources, laid out as in the wheel: the runtime compiles
+  # them for any torch the prebuilt shim below does not match.
+  set(_shim_src ${CMAKE_CURRENT_BINARY_DIR}/_shim_src)
+  configure_file(src/torch/shim.cpp ${_shim_src}/shim.cpp COPYONLY)
+  foreach(h frontend engine ir types)
+    configure_file(include/copyengine/${h}.hpp ${_shim_src}/include/copyengine/${h}.hpp COPYONLY)
+  endforeach()
+  install(DIRECTORY ${_shim_src} DESTINATION copyengine)
+
+  # copyengine._torch_stable: explicit APIs as torch custom ops on the stable
+  # libtorch ABI (torch >= 2.10), one binary for every later torch. Optional:
+  # without it the Python layer issues copies itself.
+  set(CE_TORCH "AUTO" CACHE STRING "Build the stable-ABI torch extension: ON, OFF or AUTO (if torch >= 2.10 imports)")
+  if(NOT CE_TORCH STREQUAL "OFF")
+    string(CONCAT _q "import torch; from torch.utils import cpp_extension as c; "
+           "v = tuple(int(x) for x in torch.__version__.split('+')[0].split('.')[:2]); "
+           "assert v >= (2, 10), torch.__version__; ")
+    execute_process(COMMAND "${Python_EXECUTABLE}" -c "${_q}print(';'.join(c.include_paths()), end='')"
+                    RESULT_VARIABLE _torch_rc OUTPUT_VARIABLE _torch_inc ERROR_VARIABLE _torch_err)
+    execute_process(COMMAND "${Python_EXECUTABLE}" -c "${_q}print(';'.join(c.library_paths()), end='')"
+                    OUTPUT_VARIABLE _torch_lib ERROR_QUIET)
+    if(_torch_rc EQUAL 0)
+      find_library(CE_TORCH_CPU torch_cpu PATHS ${_torch_lib} NO_DEFAULT_PATH)
+      find_library(CE_TORCH_C10 c10 PATHS ${_torch_lib} NO_DEFAULT_PATH)
+      add_library(copyengine_torch MODULE src/torch/ops.cpp)
+      target_include_directories(copyengine_torch SYSTEM PRIVATE ${_torch_inc})
+      target_include_directories(copyengine_torch PRIVATE $<TARGET_PROPERTY:copyengine,INTERFACE_INCLUDE_DIRECTORIES>)
+      # Only the stable ABI as of torch 2.10 may be used.
+      target_compile_definitions(copyengine_torch PRIVATE TORCH_TARGET_VERSION=0x020A000000000000)
+      target_link_libraries(copyengine_torch PRIVATE ${CE_TORCH_CPU} ${CE_TORCH_C10} ${CMAKE_DL_LIBS})
+      set_target_properties(copyengine_torch PROPERTIES PREFIX "" OUTPUT_NAME "_torch_stable"
+                            CXX_VISIBILITY_PRESET hidden)
+      install(TARGETS copyengine_torch LIBRARY DESTINATION copyengine)
+      message(STATUS "copyengine: stable-ABI torch extension ON")
+
+      # The interception shim, prebuilt for the build-time torch, under the key
+      # the runtime looks up (python/copyengine/_shim_key.py). CI adds shims
+      # for other torch releases next to it.
+      execute_process(COMMAND "${Python_EXECUTABLE}" -c "import torch; print(int(torch._C._GLIBCXX_USE_CXX11_ABI), end='')"
+                      OUTPUT_VARIABLE _torch_abi)
+      execute_process(COMMAND "${Python_EXECUTABLE}" ${CMAKE_CURRENT_SOURCE_DIR}/python/copyengine/_shim_key.py
+                              ${_shim_src} ${PROJECT_VERSION}
+                      OUTPUT_VARIABLE _shim_key RESULT_VARIABLE _shim_key_rc)
+      find_library(CE_TORCH_LIB torch PATHS ${_torch_lib} NO_DEFAULT_PATH)
+      if(_shim_key_rc EQUAL 0)
+        add_library(copyengine_shim MODULE ${_shim_src}/shim.cpp)
+        target_include_directories(copyengine_shim SYSTEM PRIVATE ${_torch_inc})
+        target_include_directories(copyengine_shim PRIVATE ${_shim_src}/include)
+        target_compile_definitions(copyengine_shim PRIVATE _GLIBCXX_USE_CXX11_ABI=${_torch_abi})
+        target_link_libraries(copyengine_shim PRIVATE ${CE_TORCH_C10} ${CE_TORCH_CPU} ${CE_TORCH_LIB} ${CMAKE_DL_LIBS})
+        set_target_properties(copyengine_shim PROPERTIES PREFIX "" OUTPUT_NAME "libcopyengine_shim" CXX_VISIBILITY_PRESET hidden)
+        install(TARGETS copyengine_shim LIBRARY DESTINATION copyengine/shims/${_shim_key})
+      endif()
+    elseif(CE_TORCH STREQUAL "ON")
+      message(FATAL_ERROR "CE_TORCH=ON but torch >= 2.10 is not importable: ${_torch_err}")
+    else()
+      message(STATUS "copyengine: stable-ABI torch extension OFF (torch >= 2.10 not importable at build time)")
+    endif()
+  endif()
+endif()

copyengine-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.