diff --git a/.github/workflows/build-kernel.yml b/.github/workflows/build-kernel.yml new file mode 100644 index 0000000..623f8b3 --- /dev/null +++ b/.github/workflows/build-kernel.yml @@ -0,0 +1,77 @@ +name: Build kernel and wheel +# Rebuild the two binaries the site and the cppjit CI job install from a release of this repository: the browser kernel +# (xeus-cpp + cppjit + CppInterOp with Clad on wasm32, as kernel-overlay-.tar.gz) and the native cppjit wheel with +# Clad inside. Everything comes from tools/build-wasm-kernel.sh, the locks and the patches in the repository; the runner's +# 16 GB cover binaryen's wasm-opt pass (about 11.5 GB). About an hour. The digests go back as a pull request, because the +# Pages and cppjit jobs verify the assets against lite/kernel/SHA256SUMS in the repository, not against a file beside them. +on: + workflow_dispatch: + inputs: + tag: + description: release tag to create or update (kernel-YYYY-MM-DD) + required: true + default: kernel-2026-11-03 +permissions: + contents: write + pull-requests: write +jobs: + build: + runs-on: ubuntu-24.04 + timeout-minutes: 300 + env: + SP: ${{ github.workspace }}/.kernel-build + steps: + - uses: actions/checkout@v4 + - name: micromamba (pinned, digest checked, the same as tools/setup-lite-env.sh) + run: | + mkdir -p "$SP/bin" + curl -sSL -o "$SP/bin/micromamba" https://github.com/mamba-org/micromamba-releases/releases/download/2.9.0-0/micromamba-linux-64 + (cd "$SP/bin" && echo "366cd9cd8be14df1ab8ed50352a82111082a36686b2d389fdb79a92c3fafb3e3 micromamba" | sha256sum -c -) && chmod +x "$SP/bin/micromamba" + - name: emsdk 4.0.9 + run: | + git clone -q --depth 1 https://github.com/emscripten-core/emsdk.git "$SP/emsdk" + (cd "$SP/emsdk" && ./emsdk install 4.0.9 >/dev/null && ./emsdk activate 4.0.9 >/dev/null) + echo "EMSDK=$SP/emsdk" >> "$GITHUB_ENV" + - name: Environments (wasm32 from the lock, native LLVM 23 tools) + run: bash tools/build-wasm-kernel.sh envs + - name: Sources at the pins, patches applied + run: bash tools/build-wasm-kernel.sh sources + - name: Kernel (CppInterOp with Clad, cppjit, xeus-cpp; linked at -O1) + run: bash tools/build-wasm-kernel.sh build + - name: wasm-opt -Oz (binaryen, about 11.5 GB) + run: bash tools/build-wasm-kernel.sh wasm-opt + - name: Kernel overlay + run: bash tools/build-wasm-kernel.sh overlay "${{ inputs.tag }}" + - name: cppjit wheel with Clad + run: bash tools/build-wasm-kernel.sh wheel + - name: Digests + run: | + mkdir -p out && cp "$SP"/kernel-overlay-*.tar.gz "$SP"/cppjit-*.whl out/ + (cd out && sha256sum kernel-overlay-*.tar.gz cppjit-*.whl | tee SHA256SUMS) + - uses: actions/upload-artifact@v4 + with: + name: kernel-and-wheel-${{ inputs.tag }} + path: out/ + - name: Release assets + if: ${{ !env.ACT }} + env: + GH_TOKEN: ${{ github.token }} + run: | + gh release view "${{ inputs.tag }}" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1 \ + || gh release create "${{ inputs.tag }}" --repo "$GITHUB_REPOSITORY" --title "Browser kernel and cppjit wheel with Clad, ${{ inputs.tag }}" --notes "Built by the Build kernel and wheel workflow from tools/build-wasm-kernel.sh; see lite/kernel/README.md." + gh release upload "${{ inputs.tag }}" --repo "$GITHUB_REPOSITORY" --clobber out/kernel-overlay-*.tar.gz out/cppjit-*.whl out/SHA256SUMS + - name: Pull request with the new digests + if: ${{ !env.ACT }} + env: + GH_TOKEN: ${{ github.token }} + run: | + cp out/SHA256SUMS lite/kernel/SHA256SUMS + sed -i "s/KERNEL_RELEASE: kernel-[0-9-]*/KERNEL_RELEASE: ${{ inputs.tag }}/" .github/workflows/deploy-pages.yml + sed -i "s/gh release download kernel-[0-9-]* /gh release download ${{ inputs.tag }} /" .github/workflows/check-notebooks.yml + git config user.name "github-actions[bot]"; git config user.email "github-actions[bot]@users.noreply.github.com" + git checkout -b "digests/${{ inputs.tag }}" + git commit -am "Kernel and wheel digests for release ${{ inputs.tag }}" + git push -u origin "digests/${{ inputs.tag }}" + gh pr create --repo "$GITHUB_REPOSITORY" --base "${{ github.ref_name }}" --head "digests/${{ inputs.tag }}" \ + --title "Kernel and wheel digests for ${{ inputs.tag }}" \ + --body "Built by the Build kernel and wheel workflow (run ${{ github.run_id }}); the assets are on release ${{ inputs.tag }}. Merging this makes the Pages and cppjit jobs use them." diff --git a/.github/workflows/check-notebooks.yml b/.github/workflows/check-notebooks.yml index d0ef8b9..80fa200 100644 --- a/.github/workflows/check-notebooks.yml +++ b/.github/workflows/check-notebooks.yml @@ -122,3 +122,42 @@ jobs: name: executed-cuda-notebooks path: executed/ if-no-files-found: ignore + + execute-notebooks-cppjit: + name: cppjit + runs-on: ubuntu-latest + defaults: + run: + shell: bash -el {0} + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Set up micromamba environment + uses: mamba-org/setup-micromamba@v2 + with: + environment-file: environment.yml + cache-environment: true + - name: List available kernels + run: jupyter kernelspec list + - name: cppjit wheel with Clad from the release (digest checked against lite/kernel/SHA256SUMS) + # Under nektos/act (ACT=true) the wheel is expected in lite/kernel-artifacts already; see lite/README-build.md. + env: + GH_TOKEN: ${{ github.token }} + run: | + mkdir -p lite/kernel-artifacts + if [ -z "$ACT" ]; then + gh release download kernel-2026-11-03 --repo "$GITHUB_REPOSITORY" --dir lite/kernel-artifacts --pattern 'cppjit-*.whl' + fi + (cd lite/kernel-artifacts && sha256sum -c --ignore-missing ../kernel/SHA256SUMS) + $CONDA_PREFIX/bin/pip install lite/kernel-artifacts/cppjit-*.whl + - name: Run cppjit notebook tests (Python kernel, C++ compiled by cppjit) + run: | + mkdir -p executed + $CONDA_PREFIX/bin/pytest tests/test_notebooks.py::CppjitNotebookTests -sv + - name: Upload executed cppjit notebooks as artifact + if: always() + uses: actions/upload-artifact@v4 + with: + name: executed-cppjit-notebooks + path: executed/ + if-no-files-found: ignore diff --git a/.github/workflows/deploy-pages.yml b/.github/workflows/deploy-pages.yml new file mode 100644 index 0000000..867a5c6 --- /dev/null +++ b/.github/workflows/deploy-pages.yml @@ -0,0 +1,71 @@ +name: Pages +# Build the JupyterLite site (the C++ series and the cppjit series running in the browser) and publish it on GitHub Pages. +# The kernel binaries come from a release of this repository (see lite/kernel/README.md); everything else is rebuilt here. +on: + push: + branches: [master] + paths: ['cppjit/**', 'xeus-cpp/**', 'lite/**', 'tools/**', '.github/workflows/deploy-pages.yml'] + workflow_dispatch: +permissions: + contents: read + pages: write + id-token: write +concurrency: + group: pages + cancel-in-progress: false +env: + KERNEL_RELEASE: kernel-2026-11-03 +jobs: + build: + runs-on: ubuntu-24.04 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - name: Kernel binaries from the release + # Under nektos/act (ACT=true) the assets are expected in lite/kernel-artifacts already; see lite/README-build.md. + if: ${{ !env.ACT }} + env: + GH_TOKEN: ${{ github.token }} + run: | + mkdir -p lite/kernel-artifacts + gh release download "$KERNEL_RELEASE" --repo "$GITHUB_REPOSITORY" --dir lite/kernel-artifacts \ + --pattern 'kernel-overlay-*.tar.gz' + - name: Verify the kernel binaries against the digests committed in lite/kernel/SHA256SUMS + run: (cd lite/kernel-artifacts && sha256sum -c --ignore-missing ../kernel/SHA256SUMS) && ls -la lite/kernel-artifacts + - name: Build environment (micromamba, host venv, wasm32 env from the lock, kernel overlay) + run: SP="$RUNNER_TEMP/lite" bash tools/setup-lite-env.sh + - name: Build the site + run: SP="$RUNNER_TEMP/lite" OUT="$PWD/lite/dist" bash tools/build-lite-site.sh + - name: The lazy packages are all there + run: test "$(ls lite/dist/lazy/*.tar.gz | wc -l)" -eq "$(grep -v '^#' lite/env/lazy-remove.txt | wc -w)" + - name: Smoke test in a headless browser (cppjit notebooks 1 and 3, the second one with SciPy, matplotlib and a figure) + run: | + "$RUNNER_TEMP/lite/site-venv/bin/pip" install -q playwright==1.63.0 + "$RUNNER_TEMP/lite/site-venv/bin/playwright" install --with-deps chromium + # serve one level up so the site sits under /dist/, a sub-path like the Pages URL, not the domain root + (cd lite && python3 -m http.server 8942 >/dev/null 2>&1 &) + sleep 2 + for nb in 1_call_it 3_fit_it; do + python3 - "$nb" <<'PY' + import json, sys; nb = json.load(open(f"lite/content/cppjit/{sys.argv[1]}.ipynb")) + json.dump([''.join(c['source']) for c in nb['cells'] if c['cell_type'] == 'code'], open("cells.json", "w")) + PY + "$RUNNER_TEMP/lite/site-venv/bin/python" tools/lite_run.py --site http://127.0.0.1:8942/dist --cells cells.json --timeout 600 | tee run.log + grep -q '"text": "Traceback' run.log && exit 1 || true + done + - uses: actions/upload-pages-artifact@v3 + if: ${{ !env.ACT }} + with: + path: lite/dist + deploy: + needs: build + if: ${{ !github.event.act }} + runs-on: ubuntu-latest + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - id: deployment + uses: actions/deploy-pages@v4 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5d5f3f0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +lite/dist/ +lite/content/ +lite/labext/ +lite/lazy-packages/ +lite/kernel-artifacts/ +lite/.jupyterlite.doit.db +executed/ +__pycache__/ diff --git a/README.md b/README.md index 963b2bc..91c5d55 100644 --- a/README.md +++ b/README.md @@ -20,9 +20,29 @@ An introduction to modern C++ through live, interactive examples. Topics include ### OpenMP (`openmp/`) CPU parallelism using OpenMP pragmas. Covers `#pragma omp parallel`, loop-level parallelism, reductions, and thread synchronization using the OpenMP-enabled `xeus-cpp` kernel. The notebooks guide you step-by-step from foundational concepts like spawning threads and managing shared vs. private data variables, all the way to advanced patterns like task-based parallelism, critical sections, and optimizing performance loops directly in an interactive environment. +### cppjit (`cppjit/`) +The other direction: a Python kernel with a C++ compiler inside it. `cppjit` carries Clang and LLVM, reads a C++ header +the way a compiler does, and lets Python call what it finds. Five notebooks from the SC26 tutorial: call a header from +Python, use the derivative Clad wrote for it, fit a C++ simulator with SciPy on that gradient, fit the Higgs mass on CMS +open data without ROOT, and calibrate a sixty-line tumour twin. one wheel is the whole setup (the release's `cppjit-*.whl`, Clad inside; see `cppjit/README.md`). + ### CUDA (`cuda/`) GPU programming from first principles using CUDA C++. This section explores how to accelerate compute-heavy workloads by utilizing graphics cards. It covers essential GPU architecture concepts, kernel declarations, memory allocation (`cudaMalloc`), host-to-device data transfers, and thread organization across grids and blocks to give you hands-on experience writing raw parallel code optimized for parallel hardware. +## Licences + +This repository is Apache-2.0. The cppjit notebooks use [Clad](https://github.com/vgvassilev/clad) (LGPL-3.0) through +the compiler they run on: the browser kernel and the cppjit wheel of this repository's release carry it inside +CppInterOp; nothing of Clad is kept here. + +## In the browser + +The C++ and cppjit series also run with nothing installed, on GitHub Pages: +https://compiler-research.org/live-cpp-tutorials/ . The kernel is xeus-cpp compiled to WebAssembly (LLVM 23), hosting +Python through cppjit for the cppjit series, with Clad built in: a C++ cell can call `clad::gradient` and a Python cell +can do the same through `cppjit.cppdef`. The first visit downloads the compiler once (about 42 MB), after that +everything runs in the tab. OpenMP and CUDA need the native kernels below. How the site is built: `lite/README-build.md`. + ## Installation To ensure a clean setup, install `live-cpp-tutorials` inside a fresh environment using Micromamba. diff --git a/cppjit/1_call_it.ipynb b/cppjit/1_call_it.ipynb new file mode 100644 index 0000000..79d0f84 --- /dev/null +++ b/cppjit/1_call_it.ipynb @@ -0,0 +1,271 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f717b577", + "metadata": {}, + "source": [ + "# 1. Call it\n", + "\n", + "**One Python session, with a C++ compiler inside it.** `cppjit` carries Clang and LLVM. It reads a C++ header the way a compiler does, and lets Python call what it finds, with no bindings written by anyone.\n", + "\n", + "The header below is the one that runs through the whole SC26 talk: one explicit-Euler step of logistic growth, templated on the number type. We include the file as it is on disk. Its checksum is printed so you can see nothing was pasted or rewritten." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "81ce8661", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:06.419051Z", + "iopub.status.busy": "2026-11-03T09:50:06.418769Z", + "iopub.status.idle": "2026-11-03T09:50:07.583218Z", + "shell.execute_reply": "2026-11-03T09:50:07.580614Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cppjit 0.1.0b1.dev0\n", + "// logistic_step.h -- one explicit-Euler step of logistic growth, dN/dt = r*N*(1 - N/K):\n", + "//\n", + "// N_{t+1} = N_t + r * N_t * (1 - N_t / K)\n", + "//\n", + "// The one header the whole tutorial runs on: called from Python through cppjit, differentiated by Clad, and the\n", + "// proliferation law inside the tumour twin. Templated on the scalar type so one source serves float and double and\n", + "// so Clad differentiates the generic body, not a type-erased wrapper.\n", + "#ifndef SC26_KERNEL_LOGISTIC_STEP_H\n", + "#define SC26_KERNEL_LOGISTIC_STEP_H\n", + "\n", + "template \n", + "T logistic_step(T N, T r, T K) {\n", + " T growth = r * N * (T(1) - N / K);\n", + " return N + growth;\n", + "}\n", + "\n", + "#endif // SC26_KERNEL_LOGISTIC_STEP_H\n", + "\n", + "sha256 78e29d87fcb7b428\n" + ] + } + ], + "source": [ + "import hashlib, time\n", + "import cppjit\n", + "print(\"cppjit\", cppjit.__version__)\n", + "print(open(\"kernel/logistic_step.h\").read())\n", + "print(\"sha256\", hashlib.sha256(open(\"kernel/logistic_step.h\", \"rb\").read()).hexdigest()[:16])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e8382b64", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:07.585808Z", + "iopub.status.busy": "2026-11-03T09:50:07.585440Z", + "iopub.status.idle": "2026-11-03T09:50:07.616534Z", + "shell.execute_reply": "2026-11-03T09:50:07.614602Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1999.999842435456\n" + ] + } + ], + "source": [ + "cppjit.add_include_path(\"kernel\")\n", + "cppjit.include(\"logistic_step.h\") # the header, as written: parsed by Clang inside the session\n", + "N = 50.0\n", + "for _ in range(60):\n", + " N = cppjit.gbl.logistic_step[\"double\"](N, 0.30, 2000.0)\n", + "print(N) # 1999.999842435456 in every rung of the talk\n", + "assert N == 1999.999842435456" + ] + }, + { + "cell_type": "markdown", + "id": "136d6fcf", + "metadata": {}, + "source": [ + "## The template, instantiated on demand\n", + "\n", + "`logistic_step` is a template. Asking for `[\"float\"]` makes the compiler instantiate it at `float`, now, in the session. Nothing was rebuilt. The float trajectory drifts from the double one: the same law, a different number type." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "346a751a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:07.619137Z", + "iopub.status.busy": "2026-11-03T09:50:07.618898Z", + "iopub.status.idle": "2026-11-03T09:50:07.636897Z", + "shell.execute_reply": "2026-11-03T09:50:07.634542Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "double 1999.999842435456\n", + "float 1999.9998779296875\n", + "diff -3.549e-05\n" + ] + } + ], + "source": [ + "Nd, Nf = 50.0, 50.0\n", + "for _ in range(60):\n", + " Nd = cppjit.gbl.logistic_step[\"double\"](Nd, 0.30, 2000.0)\n", + " Nf = cppjit.gbl.logistic_step[\"float\"](Nf, 0.30, 2000.0)\n", + "print(f\"double {Nd!r}\\nfloat {Nf!r}\\ndiff {Nd - Nf:.3e}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2839d2c9", + "metadata": {}, + "source": [ + "## Zero-copy: NumPy and C++ share the memory\n", + "\n", + "A `std::vector` made on the C++ side is viewed by NumPy without a copy. A write on either side is visible on the other. This is what lets a Python session drive a C++ model without moving its state around." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a451b035", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:07.639405Z", + "iopub.status.busy": "2026-11-03T09:50:07.639157Z", + "iopub.status.idle": "2026-11-03T09:50:07.797241Z", + "shell.execute_reply": "2026-11-03T09:50:07.793711Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "owns its data: False | same address: True\n", + "[ 50. 64.625 83.38604141 107.35886904 137.83764074] ... 1999.999842435456\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "cppjit.cppdef('''\n", + "#include \n", + "std::vector trajectory(double N0, double r, double K, int steps) {\n", + " std::vector out(steps + 1); out[0] = N0;\n", + " for (int i = 0; i < steps; ++i) out[i + 1] = logistic_step(out[i], r, K);\n", + " return out;\n", + "}''')\n", + "vec = cppjit.gbl.trajectory(50.0, 0.30, 2000.0, 60)\n", + "view = np.asarray(vec.data()) # a NumPy view over the C++ buffer\n", + "print(\"owns its data:\", view.flags[\"OWNDATA\"], \"| same address:\", hex(view.ctypes.data) == hex(cppjit.addressof(vec.data())))\n", + "view[0] = -1.0; assert vec[0] == -1.0 # a NumPy write, seen from C++\n", + "vec[0] = 50.0; assert view[0] == 50.0 # a C++ write, seen from NumPy\n", + "print(view[:5], \"...\", view[-1])" + ] + }, + { + "cell_type": "markdown", + "id": "22330762", + "metadata": {}, + "source": [ + "## What the boundary costs, and what it buys\n", + "\n", + "Crossing from Python into compiled code costs about a microsecond per call, whichever way the binding was made; for a one-line law that is more than the arithmetic itself. The point of calling C++ is to put the *loop* on the other side of the boundary: one call, a million steps." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e97603c0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:07.799795Z", + "iopub.status.busy": "2026-11-03T09:50:07.799457Z", + "iopub.status.idle": "2026-11-03T09:50:08.401394Z", + "shell.execute_reply": "2026-11-03T09:50:08.398974Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1,000,000 steps: pure Python loop 318.5 ms | one call into C++ 17.4 ms (18x)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "and the boundary itself: 1.29 us per call when every step is its own call\n" + ] + } + ], + "source": [ + "def step_py(N, r, K): return N + r * N * (1 - N / K)\n", + "STEPS = 1_000_000\n", + "t0 = time.perf_counter(); n = 50.0\n", + "for _ in range(STEPS): n = step_py(n, 0.30, 2000.0)\n", + "t_py = time.perf_counter() - t0\n", + "t0 = time.perf_counter(); v = cppjit.gbl.trajectory(50.0, 0.30, 2000.0, STEPS); t_cpp = time.perf_counter() - t0\n", + "print(f\"{STEPS:,} steps: pure Python loop {t_py * 1e3:7.1f} ms | one call into C++ {t_cpp * 1e3:7.1f} ms ({t_py / t_cpp:.0f}x)\")\n", + "t0 = time.perf_counter(); n = 50.0\n", + "for _ in range(200_000): n = cppjit.gbl.logistic_step[\"double\"](n, 0.30, 2000.0)\n", + "print(f\"and the boundary itself: {(time.perf_counter() - t0) / 200_000 * 1e6:.2f} us per call when every step is its own call\")" + ] + }, + { + "cell_type": "markdown", + "id": "48f3f0b1", + "metadata": {}, + "source": [ + "## Play with it\n", + "\n", + "- Change `r` or `K` and watch the fixed point. Change the number of steps.\n", + "- Instantiate the template at `long double` (`[\"long double\"]`), or write your own header and `cppjit.include` it.\n", + "- Everything you declared in `cppjit.cppdef` is a real C++ symbol: `cppjit.gbl.trajectory` is callable from any later cell.\n", + "\n", + "Next: the compiler writes the derivative of this header, `2_transform_it.ipynb`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cppjit/2_transform_it.ipynb b/cppjit/2_transform_it.ipynb new file mode 100644 index 0000000..a6c0532 --- /dev/null +++ b/cppjit/2_transform_it.ipynb @@ -0,0 +1,316 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1adb90e4", + "metadata": {}, + "source": [ + "# 2. Transform it\n", + "\n", + "Machine learning gave Python the derivative of anything written *inside a framework*. The header from notebook 1 is not inside a framework. A tracer cannot enter a compiled function. **Clad**, a Clang plugin, reads the function's own source and writes its derivative as C++ source.\n", + "\n", + "At home there is one catch: the Clad plugin must match the Clang inside `cppjit` (21.1.8), and no package ships that pairing yet. So this notebook does what the talk's slide 6 does: it shows the C++ source Clad wrote for this header, verbatim, and compiles that in the session. The file says how it was generated. If you have the plugin, the last cell regenerates it live." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fe4baaa2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:09.190004Z", + "iopub.status.busy": "2026-11-03T09:50:09.189660Z", + "iopub.status.idle": "2026-11-03T09:50:10.498195Z", + "shell.execute_reply": "2026-11-03T09:50:10.495754Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " SC26_KERNEL_LOGISTIC_STEP_H\n", + "#define SC26_KERNEL_LOGISTIC_STEP_H\n", + "\n", + "template \n", + "T logistic_step(T N, T r, T K) {\n", + " T growth = r * N * (T(1) - N / K);\n", + " return N + growth;\n", + "}\n", + "\n", + "#endif // SC26\n" + ] + } + ], + "source": [ + "import cppjit, numpy as np, hashlib\n", + "cppjit.add_include_path(\"kernel\"); cppjit.include(\"logistic_step.h\")\n", + "print(open(\"kernel/logistic_step.h\").read().split(\"#ifndef\")[1][:200]) # the function being differentiated" + ] + }, + { + "cell_type": "markdown", + "id": "656580e9", + "metadata": {}, + "source": [ + "## Why the tracer cannot do it\n", + "\n", + "Try the usual thing. If JAX is installed, `jax.grad` fails on the compiled call: it sees an opaque Python callable, not a traceable computation. (Skip this cell if JAX is not installed.)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6540fb21", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:10.501281Z", + "iopub.status.busy": "2026-11-03T09:50:10.500856Z", + "iopub.status.idle": "2026-11-03T09:50:10.511482Z", + "shell.execute_reply": "2026-11-03T09:50:10.509150Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "JAX not installed; the point stands: a tracer needs the law rewritten in its own language\n" + ] + } + ], + "source": [ + "try:\n", + " import jax, jax.numpy as jnp\n", + " def step_jax(N, r, K): return N + r * N * (1 - N / K) # the law, rewritten in JAX: fine\n", + " print(\"JAX on its own copy of the law: d/dr =\", jax.grad(step_jax, argnums=1)(50.0, 0.3, 2000.0))\n", + " try:\n", + " jax.grad(lambda r: cppjit.gbl.logistic_step[\"double\"](50.0, r, 2000.0))(0.3)\n", + " except Exception as e:\n", + " print(\"JAX on the C++ as written:\", type(e).__name__, \"-- the tracer cannot enter a compiled function; it has no graph to differentiate\")\n", + "except ImportError:\n", + " print(\"JAX not installed; the point stands: a tracer needs the law rewritten in its own language\")" + ] + }, + { + "cell_type": "markdown", + "id": "65a0cac5", + "metadata": {}, + "source": [ + "## The derivative Clad wrote\n", + "\n", + "Clad lives inside this kernel's compiler. Two requests (`kernel/derivatives.py`) make it write two functions from `logistic_step`, in the session: the forward-mode derivative with respect to `r`, and the reverse-mode gradient with respect to all three arguments. Read what it wrote: it is the chain rule applied line by line to the header's body." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e92f4711", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:10.514031Z", + "iopub.status.busy": "2026-11-03T09:50:10.513735Z", + "iopub.status.idle": "2026-11-03T09:50:11.401130Z", + "shell.execute_reply": "2026-11-03T09:50:11.399034Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "double logistic_step_darg1(double N, double r, double K) {\n", + " double _d_N = 0;\n", + " double _d_r = 1;\n", + " double _d_K = 0;\n", + " double _t0 = r * N;\n", + " double _t1 = (double(1) - N / K);\n", + " double _d_growth = (_d_r * N + r * _d_N) * _t1 + _t0 * (0. - ((_d_N * K - N * _d_K) / (K * K)));\n", + " double growth = _t0 * _t1;\n", + " return _d_N + _d_growth;\n", + "}\n", + "\n", + "void logistic_step_grad(double N, double r, double K, double *_d_N, double *_d_r, double *_d_K) {\n", + " double _d_growth = 0.;\n", + " double growth = r * N * (double(1) - N / K);\n", + " {\n", + " *_d_N += 1;\n", + " _d_growth += 1;\n", + " }\n", + " {\n", + " *_d_r += _d_growth * (double(1) - N / K) * N;\n", + " *_d_N += r * _d_growth * (double(1) - N / K);\n", + " *_d_N += -r * N * _d_growth / K;\n", + " double _r0 = -r * N * _d_growth * -(N / (K * K));\n", + " *_d_K += _r0;\n", + " }\n", + "}\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[clad] logistic_step_darg1, logistic_step_grad: generated by the Clad inside this kernel\n" + ] + } + ], + "source": [ + "from kernel import derivatives\n", + "print(derivatives.code(\"logistic_step\")) # the source Clad generated, from the session" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "59c3ad8e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:11.404015Z", + "iopub.status.busy": "2026-11-03T09:50:11.403675Z", + "iopub.status.idle": "2026-11-03T09:50:11.489865Z", + "shell.execute_reply": "2026-11-03T09:50:11.487286Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Clad, forward mode, d/dr : 48.75\n", + "Clad, reverse mode, grad : (np.float64(1.285), np.float64(48.75), np.float64(0.0001875))\n", + "closed form : (1.285, 48.75, 0.0001875)\n" + ] + } + ], + "source": [ + "derivatives.load(\"logistic_step\") # the two functions, under clad_generated\n", + "g = cppjit.gbl.clad_generated\n", + "N, r, K = 50.0, 0.30, 2000.0\n", + "print(\"Clad, forward mode, d/dr :\", g.logistic_step_darg1(N, r, K))\n", + "dN, dr, dK = (np.zeros(1) for _ in range(3)); g.logistic_step_grad(N, r, K, dN, dr, dK)\n", + "print(\"Clad, reverse mode, grad :\", (dN[0], dr[0], dK[0]))\n", + "print(\"closed form :\", (1 + r * (1 - 2 * N / K), N * (1 - N / K), r * N * N / K**2))" + ] + }, + { + "cell_type": "markdown", + "id": "ac2da60e", + "metadata": {}, + "source": [ + "## \"Wrong, not slow\"\n", + "\n", + "Finite differences are the alternative that needs no compiler. They are not slow here; they are *uncertain*. The error depends on a step size nobody knows in advance, and the best step moves with the function. Clad's number is the derivative of the code, to rounding." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0c4c0362", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:11.492496Z", + "iopub.status.busy": "2026-11-03T09:50:11.492204Z", + "iopub.status.idle": "2026-11-03T09:50:11.580211Z", + "shell.execute_reply": "2026-11-03T09:50:11.577281Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " step h central FD error\n", + " 1e-01 48.750000000000 0.0e+00\n", + " 1e-02 48.750000000000 2.8e-13\n", + " 1e-04 48.749999999984 1.6e-11\n", + " 1e-06 48.749999997710 2.3e-09\n", + " 1e-08 48.750000303244 3.0e-07\n", + " 1e-10 48.750052883406 5.3e-05\n", + " 1e-12 48.743231673143 6.8e-03\n", + " Clad 48.750000000000 0.0e+00\n" + ] + } + ], + "source": [ + "f = lambda rr: cppjit.gbl.logistic_step[\"double\"](N, rr, K)\n", + "exact = N * (1 - N / K)\n", + "print(f\"{'step h':>10s} {'central FD':>18s} {'error':>10s}\")\n", + "for h in (1e-1, 1e-2, 1e-4, 1e-6, 1e-8, 1e-10, 1e-12):\n", + " fd = (f(r + h) - f(r - h)) / (2 * h); print(f\"{h:10.0e} {fd:18.12f} {abs(fd - exact):10.1e}\")\n", + "print(f\"{'Clad':>10s} {g.logistic_step_darg1(N, r, K):18.12f} {abs(g.logistic_step_darg1(N, r, K) - exact):10.1e}\")" + ] + }, + { + "cell_type": "markdown", + "id": "76354357", + "metadata": {}, + "source": [ + "## If you have the plugin\n", + "\n", + "With Clad built against the same Clang as cppjit, the derivative is generated in the session: three lines, as the talk's slide 8 says. Set `CLAD_PLUGIN` to the plugin's path and `CLAD_INCLUDE` to its include directory **before** importing cppjit (so this cell only works in a fresh kernel started with those variables). Otherwise, the quickest way to watch Clad write a derivative is Compiler Explorer: paste the header at godbolt.org and add `-fplugin=libclad.so`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "eba5d17e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:11.583339Z", + "iopub.status.busy": "2026-11-03T09:50:11.582930Z", + "iopub.status.idle": "2026-11-03T09:50:11.591291Z", + "shell.execute_reply": "2026-11-03T09:50:11.588512Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "no CLAD_PLUGIN in the environment; the generated source above was produced exactly this way (see its header comment)\n" + ] + } + ], + "source": [ + "import os\n", + "if os.environ.get(\"CLAD_PLUGIN\"):\n", + " cppjit.add_include_path(os.environ[\"CLAD_INCLUDE\"]); cppjit.include(\"clad/Differentiator/Differentiator.h\")\n", + " cppjit.cppdef('auto live = clad::differentiate(logistic_step, \"r\");')\n", + " print(cppjit.gbl.live.execute(50.0, 0.30, 2000.0)); print(cppjit.gbl.live.getCode())\n", + "else:\n", + " print(\"no CLAD_PLUGIN in the environment; the generated source above was produced exactly this way (see its header comment)\")" + ] + }, + { + "cell_type": "markdown", + "id": "f101ee79", + "metadata": {}, + "source": [ + "Next: a simulator with a loop, a clamp and a branch, and a fit through it, `3_fit_it.ipynb`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cppjit/3_fit_it.ipynb b/cppjit/3_fit_it.ipynb new file mode 100644 index 0000000..b40d3b6 --- /dev/null +++ b/cppjit/3_fit_it.ipynb @@ -0,0 +1,307 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "55d6ceab", + "metadata": {}, + "source": [ + "# 3. If you can simulate it, you can fit it\n", + "\n", + "A ball is dropped from two metres. Air drag slows it; the floor takes a fraction of its speed at every bounce. We measure the apex heights of the first three bounces: **0.955, 0.526 and 0.308 m**. Two dials are unknown: the restitution `e` and the drag `k`.\n", + "\n", + "The simulator is 12 lines of C++ with a loop of 20,000 steps, a clamp and a branch (`kernel/ball.h`). No tracer enters it. Clad does, inside the compiler, and writes the gradient of a least-squares loss *through the whole simulation*. With that gradient, a standard optimiser finds both dials in a handful of steps." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ca9c0583", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:12.381207Z", + "iopub.status.busy": "2026-11-03T09:50:12.380845Z", + "iopub.status.idle": "2026-11-03T09:50:14.616558Z", + "shell.execute_reply": "2026-11-03T09:50:14.614783Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "#include \n", + "inline double apex(double e, double k, int n) {\n", + " double y = 2.0, v = 0.0, dt = 1e-3, top = 0.0; int bounces = 0;\n", + " for (int i = 0; i < 20000; ++i) {\n", + " v -= (9.81 + k * v * std::fabs(v)) * dt; // gravity and air drag\n", + " y += v * dt;\n", + " if (y < 0.0) { y = 0.0; v = -e * v; ++bounces; } // the floor: a clamp and a branch\n", + " if (bounces == n && v > 0.0 && y > top) top = y; // the apex of bounce n\n", + " if (bounces > n) break;\n", + " }\n", + " return top;\n", + "}\n", + "// p = {e, k}; obs = the apex heights of bounces 1..3\n", + "inline double loss(double* p, const double* obs) {\n", + " double L = 0; for (int n = 1; n <= 3; ++n) { double d = apex(p[0], p[1], n) - obs[n-1]; L += d * d; } return L; }\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[clad] loss_grad_0: generated by the Clad inside this kernel\n" + ] + } + ], + "source": [ + "import cppjit, numpy as np, time\n", + "cppjit.add_include_path(\"kernel\"); cppjit.include(\"ball.h\")\n", + "from kernel import derivatives; derivatives.load(\"ball\") # Clad writes the gradient of the loss, in the session\n", + "print(open(\"kernel/ball.h\").read().split(\"#pragma once\")[1])\n", + "g = cppjit.gbl.clad_generated" + ] + }, + { + "cell_type": "markdown", + "id": "ffad6fbf", + "metadata": {}, + "source": [ + "## The measurements\n", + "\n", + "Three apex heights. Here they come from the simulator itself at a hidden truth, `e = 0.80, k = 0.10`, so the fit can be checked; replace `obs` with heights you measured from a video of a real ball." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5a2c4984", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:14.619024Z", + "iopub.status.busy": "2026-11-03T09:50:14.618739Z", + "iopub.status.idle": "2026-11-03T09:50:14.698679Z", + "shell.execute_reply": "2026-11-03T09:50:14.696508Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "observed apex heights (m): [0.955, 0.5259, 0.3078]\n" + ] + } + ], + "source": [ + "TRUE = (0.80, 0.10)\n", + "obs = np.array([cppjit.gbl.apex(TRUE[0], TRUE[1], n) for n in (1, 2, 3)])\n", + "print(\"observed apex heights (m):\", np.round(obs, 4).tolist())\n", + "def L(p): return float(cppjit.gbl.loss(np.ascontiguousarray(p, dtype=np.float64), obs))\n", + "def dL(p): d = np.zeros(2); g.loss_grad_0(np.ascontiguousarray(p, dtype=np.float64), obs, d); return d" + ] + }, + { + "cell_type": "markdown", + "id": "494bd526", + "metadata": {}, + "source": [ + "## Check the gradient before trusting it\n", + "\n", + "Clad's gradient against central finite differences at a wrong starting point. The two agree to many digits; the finite difference needed 4 extra runs of the simulator and a guessed step size." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f1be45d7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:14.701277Z", + "iopub.status.busy": "2026-11-03T09:50:14.700828Z", + "iopub.status.idle": "2026-11-03T09:50:14.806789Z", + "shell.execute_reply": "2026-11-03T09:50:14.804016Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Clad : [-1.43449738 0.80292728] (52.81 ms, one call: value and both partials)\n", + "FD : [-1.43449738 0.80292728] max rel diff 2.2e-10\n" + ] + } + ], + "source": [ + "p0 = np.array([0.60, 0.30])\n", + "fd = np.array([(L(p0 + h) - L(p0 - h)) / (2 * 1e-6) for h in (np.array([1e-6, 0]), np.array([0, 1e-6]))])\n", + "t0 = time.perf_counter(); gr = dL(p0); t1 = time.perf_counter() - t0\n", + "print(\"Clad :\", gr, f\" ({t1 * 1e3:.2f} ms, one call: value and both partials)\"); print(\"FD :\", fd, f\" max rel diff {np.abs(gr - fd).max() / np.abs(fd).max():.1e}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5154a08b", + "metadata": {}, + "source": [ + "## Fit it\n", + "\n", + "SciPy's BFGS, given the loss and Clad's gradient. Every step the optimiser takes is recorded so we can draw the path." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c5087bc6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:14.809527Z", + "iopub.status.busy": "2026-11-03T09:50:14.809276Z", + "iopub.status.idle": "2026-11-03T09:50:15.253365Z", + "shell.execute_reply": "2026-11-03T09:50:15.251119Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "e = 0.8000 k = 0.1000 (truth 0.8, 0.1) loss 1.23e-29 10 iterations, 17 loss and 16 gradient evaluations, 0.05 s\n" + ] + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "path = [p0.copy()]\n", + "t0 = time.perf_counter()\n", + "res = minimize(L, p0, jac=dL, method=\"BFGS\", callback=lambda p: path.append(p.copy()), options={\"gtol\": 1e-10})\n", + "path = np.array(path)\n", + "print(f\"e = {res.x[0]:.4f} k = {res.x[1]:.4f} (truth {TRUE[0]}, {TRUE[1]}) loss {res.fun:.2e} {res.nit} iterations, {res.nfev} loss and {res.njev} gradient evaluations, {time.perf_counter() - t0:.2f} s\")" + ] + }, + { + "cell_type": "markdown", + "id": "a64fa8ea", + "metadata": {}, + "source": [ + "## See it" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a7e93a0d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:15.256316Z", + "iopub.status.busy": "2026-11-03T09:50:15.255887Z", + "iopub.status.idle": "2026-11-03T09:50:15.989780Z", + "shell.execute_reply": "2026-11-03T09:50:15.988073Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "E = np.linspace(0.5, 0.95, 31); Kd = np.linspace(0.02, 0.42, 29)\n", + "LL = np.array([[L(np.array([e, k])) for e in E] for k in Kd])\n", + "fig, ax = plt.subplots(figsize=(7, 4.6)); cs = ax.contourf(E, Kd, np.log10(LL + 1e-12), levels=24, cmap=\"viridis\"); fig.colorbar(cs, label=\"log10 loss\")\n", + "ax.plot(path[:, 0], path[:, 1], \"-o\", color=\"white\", ms=4, lw=1.4); ax.plot(*TRUE, \"*\", color=\"white\", ms=14, markeredgecolor=\"black\")\n", + "ax.annotate(\"start\", path[0], textcoords=\"offset points\", xytext=(6, 6), color=\"white\"); ax.annotate(\"truth\", TRUE, textcoords=\"offset points\", xytext=(8, -14), color=\"white\")\n", + "ax.set_xlabel(\"restitution e\"); ax.set_ylabel(\"drag k\"); ax.set_title(\"BFGS on Clad's gradient of the C++ simulator\"); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "14211de7", + "metadata": {}, + "source": [ + "## Keep your framework (optional, needs `pip install jax optimistix`)\n", + "\n", + "The same loss as a JAX primitive whose backward pass is Clad's gradient, minimised by a JAX optimiser. JAX never sees the C++; it sees a function with a derivative. This is the \"compose it\" of the talk." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "08b2a0d2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:15.992967Z", + "iopub.status.busy": "2026-11-03T09:50:15.992578Z", + "iopub.status.idle": "2026-11-03T09:50:16.002450Z", + "shell.execute_reply": "2026-11-03T09:50:16.000196Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "jax / optimistix not installed: skipped\n" + ] + } + ], + "source": [ + "try:\n", + " import jax, jax.numpy as jnp, optimistix as optx\n", + " jax.config.update(\"jax_enable_x64\", True)\n", + " @jax.custom_vjp\n", + " def loss_jax(p): return jax.pure_callback(lambda q: np.float64(L(np.asarray(q))), jax.ShapeDtypeStruct((), jnp.float64), p)\n", + " loss_jax.defvjp(lambda p: jax.pure_callback(lambda q: (np.float64(L(np.asarray(q))), dL(np.asarray(q))), (jax.ShapeDtypeStruct((), jnp.float64), jax.ShapeDtypeStruct((2,), jnp.float64)), p), lambda gr, ct: (ct * gr,))\n", + " sol = optx.minimise(lambda p, a: loss_jax(p), optx.BFGS(rtol=1e-10, atol=1e-12), jnp.asarray(p0), max_steps=200, throw=False)\n", + " print(\"JAX/optimistix:\", np.asarray(sol.value), \"in\", int(sol.stats[\"num_steps\"]), \"steps\")\n", + "except ImportError:\n", + " print(\"jax / optimistix not installed: skipped\")" + ] + }, + { + "cell_type": "markdown", + "id": "7877c0c8", + "metadata": {}, + "source": [ + "## Play with it\n", + "\n", + "- Add a fourth bounce to the loss (edit `kernel/ball.h`; Clad regenerates the gradient from the edited header on the next `derivatives.load`).\n", + "- Start the optimiser far away (`p0 = [0.95, 0.4]`) and watch the path.\n", + "- Replace `obs` with real measurements. Two numbers come out, with the loss telling you how well a ball with constant restitution and quadratic drag explains them.\n", + "\n", + "Next: the same recipe on 28 real events from the LHC, `4_higgs_open_data.ipynb`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cppjit/4_higgs_open_data.ipynb b/cppjit/4_higgs_open_data.ipynb new file mode 100644 index 0000000..0db1317 --- /dev/null +++ b/cppjit/4_higgs_open_data.ipynb @@ -0,0 +1,332 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "88c5c789", + "metadata": {}, + "source": [ + "# 4. The Higgs boson, from open data, at home\n", + "\n", + "In 2012 CMS recorded events with four leptons. CERN opened them. ROOT's tutorial `df103` applies the published selection; the talk ran it and found 28 candidates with a four-lepton mass between 110 and 150 GeV, fitted a Gaussian signal over an exponential background with RooFit, Clad's gradient and Minuit2, and got **m_H = 124.7 ± 1.0 GeV** at 3.1σ local significance.\n", + "\n", + "This notebook does the same fit without ROOT. `data/higgs4l.npz` holds the four-lepton masses after that selection (data, and the simulated signal and ZZ background with their weights), derived from CMS open data (CC0). `data/higgs4l_roofit_reference.json` holds the RooFit result to compare with. The likelihood is seven lines of NumPy; SciPy minimises it. If JAX is installed, JAX differentiates it; if not, SciPy estimates the gradient. Either way the physics is the same: the ball of notebook 3, at scale." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "53dc9faf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:17.002476Z", + "iopub.status.busy": "2026-11-03T09:50:17.001864Z", + "iopub.status.idle": "2026-11-03T09:50:17.532518Z", + "shell.execute_reply": "2026-11-03T09:50:17.530080Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4mu : 83 data candidates, 9109 simulated signal, 30562 simulated ZZ\n", + "4el : 44 data candidates, 5525 simulated signal, 15197 simulated ZZ\n", + "2el2mu : 91 data candidates, 12061 simulated signal, 13414 simulated ZZ\n", + "218 four-lepton candidates in 70-180 GeV\n" + ] + } + ], + "source": [ + "import json, numpy as np, matplotlib.pyplot as plt\n", + "z = np.load(\"data/higgs4l.npz\"); ref = json.load(open(\"data/higgs4l_roofit_reference.json\"))\n", + "chans = (\"4mu\", \"4el\", \"2el2mu\") # masses as float32 (the precision CMS stored), simulation kept in 70-182 GeV, one weight per simulated sample\n", + "data = np.concatenate([z[f\"data_{c}\"] for c in chans]).astype(float)\n", + "sig = np.concatenate([z[f\"sig_{c}\"] for c in chans]).astype(float); sig_w = np.concatenate([np.full(len(z[f\"sig_{c}\"]), float(z[f\"sigw_{c}\"])) for c in chans])\n", + "bkg = np.concatenate([z[f\"bkg_{c}\"] for c in chans]).astype(float); bkg_w = np.concatenate([np.full(len(z[f\"bkg_{c}\"]), float(z[f\"bkgw_{c}\"])) for c in chans])\n", + "for c in chans: print(f\"{c:7s}: {len(z[f'data_{c}']):3d} data candidates, {len(z[f'sig_{c}'])} simulated signal, {len(z[f'bkg_{c}'])} simulated ZZ\")\n", + "print(len(data), \"four-lepton candidates in 70-180 GeV\")" + ] + }, + { + "cell_type": "markdown", + "id": "a08976b0", + "metadata": {}, + "source": [ + "## Look at it first\n", + "\n", + "The data as dots, the simulation of what the Standard Model expects as bars: ZZ production, and a Higgs boson at 125 GeV decaying to four leptons." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "af0bae3f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:17.535052Z", + "iopub.status.busy": "2026-11-03T09:50:17.534680Z", + "iopub.status.idle": "2026-11-03T09:50:17.821388Z", + "shell.execute_reply": "2026-11-03T09:50:17.819129Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "edges = np.arange(70, 182, 2); fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "hb, _ = np.histogram(bkg, bins=edges, weights=bkg_w); hs, _ = np.histogram(sig, bins=edges, weights=sig_w); cnt, _ = np.histogram(data, bins=edges)\n", + "ax.bar(edges[:-1], hb, width=2, align=\"edge\", color=\"#9bb7d4\", label=\"ZZ (simulation)\"); ax.bar(edges[:-1], hs, width=2, bottom=hb, align=\"edge\", color=\"#e3a7b0\", label=\"Higgs, 125 GeV (simulation)\")\n", + "ax.errorbar(edges[:-1] + 1, cnt, yerr=np.sqrt(np.maximum(cnt, 1)), fmt=\"o\", color=\"black\", ms=4, label=\"CMS 2012 open data\")\n", + "ax.set_xlabel(\"four-lepton invariant mass (GeV)\"); ax.set_ylabel(\"events / 2 GeV\"); ax.legend(frameon=False); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "99c59dc5", + "metadata": {}, + "source": [ + "## The likelihood\n", + "\n", + "An unbinned extended likelihood on the window 110-150 GeV: a Gaussian signal whose width is the detector resolution, taken from the simulated signal and held fixed, over an exponential background. Four free parameters: the Higgs mass, the background slope, and the two yields. Each event contributes the log of the density at its mass; the Poisson term for the total count makes it \"extended\"." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "aa132bbd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:17.824043Z", + "iopub.status.busy": "2026-11-03T09:50:17.823646Z", + "iopub.status.idle": "2026-11-03T09:50:18.203793Z", + "shell.execute_reply": "2026-11-03T09:50:18.201127Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "28 candidates in the window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "signal width from simulation: sigma = 2.69 GeV (RooFit got 2.68); fixed from here on\n" + ] + } + ], + "source": [ + "WLO, WHI = 110.0, 150.0; m = data[(data > WLO) & (data < WHI)]; print(len(m), \"candidates in the window\")\n", + "# the signal width from the simulation (weighted Gaussian fit in 115-135, as the talk does with RooFit)\n", + "from scipy.optimize import minimize\n", + "mm = (sig > 115) & (sig < 135); x_mc, w_mc = sig[mm], sig_w[mm]\n", + "nll_mc = lambda q: -np.sum(w_mc * (-0.5 * ((x_mc - q[0]) / q[1])**2 - np.log(q[1])))\n", + "mu_mc, sigma = minimize(nll_mc, [125.0, 2.0], method=\"Nelder-Mead\").x\n", + "print(f\"signal width from simulation: sigma = {sigma:.2f} GeV (RooFit got {ref['sigma_fixed']:.2f}); fixed from here on\")\n", + "def nll(theta): # theta = (mH, slope, nsig, nbkg)\n", + " mH, slope, ns, nb = theta\n", + " gauss = np.exp(-0.5 * ((m - mH) / sigma)**2) / (sigma * np.sqrt(2 * np.pi))\n", + " expo = slope * np.exp(slope * (m - WLO)) / (np.exp(slope * (WHI - WLO)) - 1.0) # normalised on the window\n", + " return -np.sum(np.log(ns * gauss + nb * expo)) + (ns + nb) # extended: + N_expected\n", + "START = np.array([120.0, -0.01, 5.0, 15.0]); BOUNDS = [(115, 140), (-0.2, 0.2), (0, 60), (0, 200)]" + ] + }, + { + "cell_type": "markdown", + "id": "8eb86654", + "metadata": {}, + "source": [ + "## Fit 1: SciPy on the NumPy likelihood\n", + "\n", + "If JAX is present the gradient is JAX's; otherwise SciPy differentiates numerically. Errors come from the curvature at the minimum (a numerical Hessian). Compare with RooFit's numbers." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b474e9da", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:18.206645Z", + "iopub.status.busy": "2026-11-03T09:50:18.206277Z", + "iopub.status.idle": "2026-11-03T09:50:18.258699Z", + "shell.execute_reply": "2026-11-03T09:50:18.257160Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "numerical gradient: 210 evaluations\n", + " mH = 124.6949 +- 1.0385 RooFit: 124.6967 +- 1.0345\n", + " slope = 0.0488 +- 0.0245 RooFit: 0.0487 +- 0.0244\n", + " nsig = 9.0376 +- 3.6314 RooFit: 9.0329 +- 3.6109\n", + " nbkg = 18.9625 +- 4.8075 RooFit: 18.9383 +- 4.7960\n", + "NLL at the minimum 32.4216 (RooFit 32.4125; the two likelihoods differ by a constant, their differences do not)\n" + ] + } + ], + "source": [ + "try:\n", + " import jax, jax.numpy as jnp\n", + " jax.config.update(\"jax_enable_x64\", True)\n", + " mj, sj = jnp.asarray(m), float(sigma)\n", + " def nll_j(t):\n", + " mH, slope, ns, nb = t\n", + " gauss = jnp.exp(-0.5 * ((mj - mH) / sj)**2) / (sj * jnp.sqrt(2 * jnp.pi))\n", + " expo = slope * jnp.exp(slope * (mj - WLO)) / (jnp.exp(slope * (WHI - WLO)) - 1.0)\n", + " return -jnp.sum(jnp.log(ns * gauss + nb * expo)) + (ns + nb)\n", + " grad = jax.jit(jax.grad(nll_j)); hess = jax.jit(jax.hessian(nll_j)); how = \"JAX gradient\"\n", + "except ImportError:\n", + " grad = None; how = \"numerical gradient\"\n", + " def hess(t, h=1e-3):\n", + " H = np.zeros((4, 4)); e = np.eye(4)\n", + " for i in range(4):\n", + " for j in range(4):\n", + " H[i, j] = (nll(t + h*e[i] + h*e[j]) - nll(t + h*e[i] - h*e[j]) - nll(t - h*e[i] + h*e[j]) + nll(t - h*e[i] - h*e[j])) / (4 * h * h)\n", + " return H\n", + "res = minimize(nll, START, jac=(lambda t: np.asarray(grad(t))) if grad else None, method=\"L-BFGS-B\", bounds=BOUNDS)\n", + "err = np.sqrt(np.diag(np.linalg.inv(np.asarray(hess(res.x)))))\n", + "names = (\"mH\", \"slope\", \"nsig\", \"nbkg\")\n", + "print(f\"{how}: {res.nfev} evaluations\")\n", + "for i, n in enumerate(names): print(f\" {n:6s} = {res.x[i]:9.4f} +- {err[i]:.4f} RooFit: {ref[n][0]:9.4f} +- {ref[n][1]:.4f}\")\n", + "print(f\"NLL at the minimum {res.fun:.4f} (RooFit {ref['nll_min']:.4f}; the two likelihoods differ by a constant, their differences do not)\")" + ] + }, + { + "cell_type": "markdown", + "id": "09246a78", + "metadata": {}, + "source": [ + "## How significant? The likelihood ratio against \"no signal\"\n", + "\n", + "Fix `nsig = 0`, refit the rest, and compare: `q0 = 2 (NLL_0 - NLL_min)`; its square root is the local significance in standard deviations." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6517936a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:18.263148Z", + "iopub.status.busy": "2026-11-03T09:50:18.262550Z", + "iopub.status.idle": "2026-11-03T09:50:18.280290Z", + "shell.execute_reply": "2026-11-03T09:50:18.279187Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0 = 9.87 -> local significance 3.1 sigma (RooFit: q0 = 9.89, 3.1 sigma)\n" + ] + } + ], + "source": [ + "nll0 = lambda t: nll(np.array([t[0], t[1], 0.0, t[2]]))\n", + "res0 = minimize(nll0, np.array([START[0], START[1], START[3]]), method=\"L-BFGS-B\", bounds=[BOUNDS[0], BOUNDS[1], BOUNDS[3]])\n", + "q0 = 2 * (res0.fun - res.fun)\n", + "print(f\"q0 = {q0:.2f} -> local significance {np.sqrt(max(q0, 0)):.1f} sigma (RooFit: q0 = {ref['q0']:.2f}, {np.sqrt(ref['q0']):.1f} sigma)\")" + ] + }, + { + "cell_type": "markdown", + "id": "f9285376", + "metadata": {}, + "source": [ + "## The picture" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ed740f40", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:18.283015Z", + "iopub.status.busy": "2026-11-03T09:50:18.282512Z", + "iopub.status.idle": "2026-11-03T09:50:18.589446Z", + "shell.execute_reply": "2026-11-03T09:50:18.587173Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mH, slope, ns, nb = res.x; xs = np.linspace(WLO, WHI, 400)\n", + "curve = (ns * np.exp(-0.5 * ((xs - mH) / sigma)**2) / (sigma * np.sqrt(2 * np.pi)) + nb * slope * np.exp(slope * (xs - WLO)) / (np.exp(slope * (WHI - WLO)) - 1.0)) * 2\n", + "edges = np.arange(WLO, WHI + 2, 2); mw = (sig > WLO) & (sig < WHI); mb = (bkg > WLO) & (bkg < WHI)\n", + "fig, ax = plt.subplots(figsize=(8, 5)); hb, _ = np.histogram(bkg[mb], bins=edges, weights=bkg_w[mb]); hs, _ = np.histogram(sig[mw], bins=edges, weights=sig_w[mw]); cnt, _ = np.histogram(m, bins=edges)\n", + "ax.bar(edges[:-1], hb, width=2, align=\"edge\", color=\"#9bb7d4\", label=\"ZZ (simulation)\"); ax.bar(edges[:-1], hs, width=2, bottom=hb, align=\"edge\", color=\"#e3a7b0\", label=\"Higgs at 125 GeV (simulation)\")\n", + "ax.errorbar(edges[:-1] + 1, cnt, yerr=np.sqrt(np.maximum(cnt, 1)), fmt=\"o\", color=\"black\", ms=5, label=\"CMS 2012 open data, 11.6 fb$^{-1}$\")\n", + "ax.plot(xs, curve, color=\"#2a7f62\", lw=2.2, label=f\"fit: m$_H$ = {mH:.1f} ± {err[0]:.1f} GeV, {np.sqrt(max(q0, 0)):.1f}σ\")\n", + "ax.set_xlabel(\"four-lepton invariant mass (GeV)\"); ax.set_ylabel(\"events / 2 GeV\"); ax.set_xlim(WLO, WHI); ax.legend(frameon=False, fontsize=9); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "90018c61", + "metadata": {}, + "source": [ + "## What this is and is not\n", + "\n", + "Local significance, one window, one selection, 28 events. The 2012 observation combined more channels and more data. What you did reproduce: the mass, within a GeV, from the events themselves, with a likelihood you can read in full.\n", + "\n", + "In the talk, the likelihood was not written by hand: RooFit emitted it as C++ and Clad wrote its gradient, so Minuit2 and JAX both ran on the physicists' own model. That path needs ROOT; it is in `../notebooks/nb5_higgs_open_data.ipynb`.\n", + "\n", + "## Play with it\n", + "\n", + "- Move the window (`WLO, WHI`) or free the signal width and see what 28 events can and cannot pin down.\n", + "- Replace the exponential with a flat background. Does the mass move? Does the significance?\n", + "- Fit each channel (`4mu`, `4el`, `2el2mu`) on its own.\n", + "\n", + "Next: a tiny model with the cancer model's shape, stepped, steered and calibrated from Python, `5_tiny_twin.ipynb`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cppjit/5_tiny_twin.ipynb b/cppjit/5_tiny_twin.ipynb new file mode 100644 index 0000000..be2a42f --- /dev/null +++ b/cppjit/5_tiny_twin.ipynb @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "719ee92b", + "metadata": {}, + "source": [ + "# 5. A tiny twin: the cancer model's shape, on a laptop\n", + "\n", + "The talk's second case is a tumour organoid under CAR T-cell therapy: thousands of cells, each an agent, on an oxygen field, in C++ on BioDynaMo. That stack does not install at home. This notebook keeps its *shape* in sixty lines of C++ (`kernel/twin.h`): cells on a line that grow by the header of notebook 1 at a rate set by the oxygen they get; oxygen that diffuses in from the edges and is consumed by the cells; two knobs the real model also has, the consumption rate and the edge oxygen.\n", + "\n", + "The three verbs again. **Call it**: step the model from Python. **Compose it**: a Python function is handed to C++ and runs inside the loop, seeding a second colony mid-run. **Transform it**: the smooth part (oxygen) is restated as one function; Clad's gradient of it (`kernel/twin_clad.h`) calibrates both knobs from a few measurements, with the cells frozen, exactly as the talk calibrates the real model." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5a52df7d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:19.623296Z", + "iopub.status.busy": "2026-11-03T09:50:19.622887Z", + "iopub.status.idle": "2026-11-03T09:50:22.072380Z", + "shell.execute_reply": "2026-11-03T09:50:22.070220Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t a rate\n", + "// set by the oxygen there and spreads to its neighbours, so the colony's front advances. Oxygen diffuses along the line from both edges, which are held at o_edge (the medium),\n", + "// and is consumed by the cells. Two knobs the real model also has: the consumption rate `cons` and the edge\n", + "// oxygen `o_edge`. The smooth part (oxygen) is restated below as one function the compiler can differentiate,\n", + "// exactly as the talk restates the real model's oxygen update.\n", + "#pragma once\n", + "#include \n", + "#include \n", + "#include \n", + "#include \"logistic_step.h\"\n", + "\n", + "constexpr int kMaxSites = 256;\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[clad] oxygen_after_grad_2_3: generated by the Clad inside this kernel\n" + ] + } + ], + "source": [ + "import cppjit, numpy as np, matplotlib.pyplot as plt, time\n", + "cppjit.add_include_path(\"kernel\"); cppjit.include(\"twin.h\")\n", + "from kernel import derivatives; derivatives.load(\"twin\") # Clad writes the oxygen gradient in its two knobs, in the session\n", + "print(open(\"kernel/twin.h\").read().split(\"struct Twin\")[0][-600:])" + ] + }, + { + "cell_type": "markdown", + "id": "43064855", + "metadata": {}, + "source": [ + "## Call it: run the twin and look at it" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e736f57f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:22.075488Z", + "iopub.status.busy": "2026-11-03T09:50:22.075169Z", + "iopub.status.idle": "2026-11-03T09:50:24.237602Z", + "shell.execute_reply": "2026-11-03T09:50:24.235264Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "134525 cells after 300 steps; mean oxygen at the cells 8.25 of 38 at the edges\n" + ] + } + ], + "source": [ + "def profiles(t): return np.asarray(t.c.data()).copy(), np.asarray(t.o.data()).copy() # zero-copy views, copied for keeping\n", + "twin = cppjit.gbl.Twin(100, 38.0) # 100 sites, 38 units of oxygen at both edges; a 5-site colony in the middle\n", + "snap = {}\n", + "for step in range(0, 301):\n", + " if step in (0, 60, 120, 180, 240, 300): snap[step] = profiles(twin)\n", + " if step < 300: twin.step()\n", + "fig, ax = plt.subplots(1, 2, figsize=(11, 3.6))\n", + "for s, (c, o) in snap.items(): ax[0].plot(c, label=f\"step {s}\"); ax[1].plot(o, label=f\"step {s}\")\n", + "ax[0].set_title(\"cells per site: the colony's front advances\"); ax[1].set_title(\"oxygen: eaten where the cells are\"); ax[0].legend(fontsize=8); ax[0].set_xlabel(\"site\"); ax[1].set_xlabel(\"site\"); plt.show()\n", + "print(f\"{twin.total_cells():.0f} cells after 300 steps; mean oxygen at the cells {twin.mean_oxygen_at_cells():.2f} of 38 at the edges\")" + ] + }, + { + "cell_type": "markdown", + "id": "22d699d0", + "metadata": {}, + "source": [ + "## Compose it: a Python function inside the C++ loop\n", + "\n", + "`run(twin, steps, hook)` takes a `std::function`. A Python function is a valid one. The scheduler calls it before every step; at step 150 it seeds a second colony at the far end. Nothing in the C++ knows Python exists." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dceff946", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:24.239970Z", + "iopub.status.busy": "2026-11-03T09:50:24.239733Z", + "iopub.status.idle": "2026-11-03T09:50:26.843739Z", + "shell.execute_reply": "2026-11-03T09:50:26.841477Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total cells at steps 0, 50, ...: [(0, 50), (50, 10201), (100, 36420), (150, 59983), (200, 92569), (250, 136090)]\n" + ] + } + ], + "source": [ + "twin2 = cppjit.gbl.Twin(100, 38.0)\n", + "log = []\n", + "def hook(step, t):\n", + " if step == 150:\n", + " c = np.asarray(t.c.data()); c[80:85] = 10.0 # the Python-side intervention, through the shared memory\n", + " if step % 50 == 0: log.append((step, round(t.total_cells())))\n", + "cppjit.gbl.run(twin2, 300, hook) # C++ loop, Python hook inside it\n", + "c, o = profiles(twin2)\n", + "fig, ax = plt.subplots(1, 2, figsize=(11, 3.6)); ax[0].plot(c); ax[0].set_title(\"cells after 300 steps; a second colony seeded at step 150 from Python\"); ax[1].plot(o); ax[1].set_title(\"oxygen\"); plt.show()\n", + "print(\"total cells at steps 0, 50, ...:\", log)" + ] + }, + { + "cell_type": "markdown", + "id": "4733fe70", + "metadata": {}, + "source": [ + "## Transform it: calibrate the two oxygen knobs from a few measurements\n", + "\n", + "Suppose the twin were a real organoid and we could only measure the mean oxygen at the cells at five times, with the cell profiles known (from images). The oxygen sub-model is smooth, so it has a derivative. `oxygen_after(cells, ...)` restates it: from a uniform field, run the oxygen substeps over the *frozen* cells, return the mean. Clad wrote its gradient with respect to the two knobs. Levenberg-Marquardt on that gradient recovers both knobs from a 20 % wrong start in a handful of evaluations, with no simulation in the loop. (The cells are frozen as they were when the oxygen was computed: in `Twin::step` the oxygen substeps come first.)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "68e98e45", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:26.846777Z", + "iopub.status.busy": "2026-11-03T09:50:26.846543Z", + "iopub.status.idle": "2026-11-03T09:50:31.349762Z", + "shell.execute_reply": "2026-11-03T09:50:31.347533Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "measured mean oxygen at the cells: [19.607 10.944 8.395 7.367 7.216]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "start: cons 1.44e-05, o_edge 30.40 (truth 1.20e-05, 38.00)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fit: cons 1.1961e-05, o_edge 38.0552 in 7 evaluations of the oxygen model, 2.6 s; rms misfit 8.5e-03\n", + "relative error: cons 3.2e-03, o_edge 1.5e-03\n" + ] + } + ], + "source": [ + "# the \"measurements\": from a run at a hidden truth, read at five checkpoints\n", + "TRUE = dict(cons=1.2e-5, o_edge=38.0)\n", + "ref = cppjit.gbl.Twin(100, TRUE[\"o_edge\"]); ref.cons = TRUE[\"cons\"]; checkpoints = (60, 120, 180, 240, 300); cells_at, obs = [], []\n", + "for step in range(1, 301):\n", + " before = np.asarray(ref.c.data()).copy() # the cells the oxygen of this step is computed on\n", + " ref.step()\n", + " if step in checkpoints: cells_at.append(before); obs.append(ref.mean_oxygen_at_cells())\n", + "obs = np.array(obs); print(\"measured mean oxygen at the cells:\", np.round(obs, 3))\n", + "g = cppjit.gbl.clad_generated; n = ref.n; D, dto, ITERS = ref.D, ref.dto, 8000 # 8000 substeps: the steady state for these cells\n", + "def resid(x): # x = (cons in units of 1e-5, o_edge): the two knobs, scaled to order one\n", + " return np.array([cppjit.gbl.oxygen_after(c, n, x[0] * 1e-5, x[1], D, dto, ITERS) for c in cells_at]) - obs\n", + "def jac(x): # Clad's gradient of oxygen_after with respect to the two knobs, per checkpoint\n", + " J = np.zeros((len(obs), 2))\n", + " for i, c in enumerate(cells_at):\n", + " dc, doe = np.zeros(1), np.zeros(1); g.oxygen_after_grad_2_3(c, n, x[0] * 1e-5, x[1], D, dto, ITERS, dc, doe); J[i] = (dc[0] * 1e-5, doe[0])\n", + " return J\n", + "from scipy.optimize import least_squares\n", + "x0 = np.array([TRUE[\"cons\"] * 1e5 * 1.2, TRUE[\"o_edge\"] * 0.8]); print(f\"start: cons {x0[0]*1e-5:.2e}, o_edge {x0[1]:.2f} (truth {TRUE['cons']:.2e}, {TRUE['o_edge']:.2f})\")\n", + "t0 = time.time(); fit = least_squares(resid, x0, jac=jac, method=\"lm\", xtol=1e-12, ftol=1e-12)\n", + "print(f\"fit: cons {fit.x[0]*1e-5:.4e}, o_edge {fit.x[1]:.4f} in {fit.nfev} evaluations of the oxygen model, {time.time() - t0:.1f} s; rms misfit {np.sqrt(np.mean(fit.fun**2)):.1e}\")\n", + "print(f\"relative error: cons {abs(fit.x[0]*1e-5 / TRUE['cons'] - 1):.1e}, o_edge {abs(fit.x[1] / TRUE['o_edge'] - 1):.1e}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0d2e23f7", + "metadata": {}, + "source": [ + "## Does the frozen answer hold in the live model?\n", + "\n", + "Put the fitted knobs into a fresh twin and run it; compare the live mean oxygen with the measurements." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "31e01999", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-03T09:50:31.352536Z", + "iopub.status.busy": "2026-11-03T09:50:31.352197Z", + "iopub.status.idle": "2026-11-03T09:50:32.848284Z", + "shell.execute_reply": "2026-11-03T09:50:32.845902Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "measured : [19.6069 10.9438 8.3948 7.3671 7.2164]\n", + "live refit: [19.6611 10.982 8.426 7.3955 7.2446]\n", + "max abs difference: 5.4e-02\n" + ] + } + ], + "source": [ + "live = cppjit.gbl.Twin(100, fit.x[1]); live.cons = fit.x[0] * 1e-5; got = []\n", + "for step in range(1, 301):\n", + " live.step()\n", + " if step in checkpoints: got.append(live.mean_oxygen_at_cells())\n", + "print(\"measured :\", np.round(obs, 4)); print(\"live refit:\", np.round(got, 4)); print(\"max abs difference:\", f\"{np.abs(np.array(got) - obs).max():.1e}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fafe11c8", + "metadata": {}, + "source": [ + "## What this stands in for\n", + "\n", + "| here | the talk's model |\n", + "|---|---|\n", + "| 100 sites on a line, cells as counts | 3,957 to 24,000 agents in 3-D on BioDynaMo |\n", + "| oxygen: explicit diffusion, 60 lines | oxygen and a signal field, implicit solver on a 50³ grid |\n", + "| growth: the header of notebook 1, oxygen-dependent | division, death and killing as per-cell rules |\n", + "| the hook seeds a colony | a Python class scheduled as a BioDynaMo operation seeds a second organoid |\n", + "| two knobs fitted on frozen cells in a handful of evaluations | the same, on the real model, in 5 steps of a minute |\n", + "\n", + "What does not carry over: the random parts. Cell division, death and killing in the real model are dice rolls; no compiler differentiates those, and the talk measures their response with paired runs instead.\n", + "\n", + "## Play with it\n", + "\n", + "- Make the line longer or the colony bigger; find the consumption at which the core goes hypoxic.\n", + "- Measure only at one checkpoint. Can two knobs be recovered from one number? (The Jacobian tells you: look at its rank.)\n", + "- Give the hook a schedule: a \"dose\" that removes cells at a site, every 100 steps." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cppjit/README.md b/cppjit/README.md new file mode 100644 index 0000000..9bb15bd --- /dev/null +++ b/cppjit/README.md @@ -0,0 +1,46 @@ +# cppjit: one Python session with a C++ compiler inside it + +Five notebooks from the SC26 tutorial *The Compiler Is in the Room*. The kernel is Python; `cppjit` carries Clang +and LLVM, reads a C++ header the way a compiler does, and lets Python call what it finds, with no bindings written by +anyone. Two small C++ models (a logistic step, a bouncing ball), one real dataset (the Higgs from CMS open data) and a +sixty-line "tiny twin" of a tumour model carry the three verbs of the talk: call it, compose it, transform it. + +| notebook | what it does | +|---|---| +| `1_call_it.ipynb` | a C++ header called from Python, timed against pure Python | +| `2_transform_it.ipynb` | the derivative Clad wrote for that header, checked three ways, and why a tracer cannot do it | +| `3_fit_it.ipynb` | a bouncing-ball simulator in C++ fitted to data with BFGS on Clad's exact gradient | +| `4_higgs_open_data.ipynb` | the four-lepton Higgs mass fitted on CMS 2012 open data without ROOT, checked against RooFit | +| `5_tiny_twin.ipynb` | the cancer model's shape in sixty lines of C++: called, composed with Python, calibrated | + +## In the browser, nothing installed + +The same five notebooks run on this repository's GitHub Pages site, on the xeus-cpp kernel compiled to WebAssembly +hosting Python through cppjit: `https://compiler-research.org/live-cpp-tutorials/lab/index.html?path=cppjit/1_call_it.ipynb` +and so on (the C++ series of this repository is there too, under `cpp/`). The first load downloads the compiler once +(about 45 MB); after that everything runs in the tab. How the site is built: `lite/README-build.md`. + +## On a laptop + +```sh +pip install cppjit-*.whl numpy scipy matplotlib jupyter # the wheel of this repository's release: cppjit with Clad inside, Python 3.12, Linux x86_64 +# (the PyPI cppjit runs the notebooks' C++ too, but has no Clad plugin yet, so the derivative cells need the wheel) +jupyter lab +``` + +Open the notebooks in this directory with the Python kernel. No Clad, no ROOT, no BioDynaMo needed. + +## What is shipped and why + +- `kernel/logistic_step.h`, `kernel/ball.h`, `kernel/twin.h`: the C++ the notebooks call, as written. +- `kernel/derivatives.py`: where the notebooks get Clad's derivatives. The kernel's compiler carries Clad (the browser + kernel, and the cppjit wheel of this repository's release, whose CppInterOp is built with the plugin), so the + derivatives are generated in the session from three requests and land in `clad_generated` under the names the + notebooks use; `derivatives.code()` returns the source Clad wrote. The PyPI cppjit has no Clad yet: install the wheel + from the release (`pip install cppjit-*.whl`, Python 3.12) or open the notebooks in the browser. +- `kernel/lazy.py`, `kernel/lazy.json`: used only in the browser, where SciPy and matplotlib load on first import. +- `data/higgs4l.npz` (214 KB): four-lepton invariant masses from CMS 2012 open data (CC0) after ROOT's df103 selection, + with the simulated signal and ZZ background in 70-182 GeV; `data/higgs4l_roofit_reference.json`: the RooFit result + the talk quotes, so you can check your fit against it. + +The notebooks are developed in the SC26 tutorial repository; this is the hand-out copy. diff --git a/cppjit/data/higgs4l.npz b/cppjit/data/higgs4l.npz new file mode 100644 index 0000000..7408894 Binary files /dev/null and b/cppjit/data/higgs4l.npz differ diff --git a/cppjit/data/higgs4l_roofit_reference.json b/cppjit/data/higgs4l_roofit_reference.json new file mode 100644 index 0000000..1b68bb5 --- /dev/null +++ b/cppjit/data/higgs4l_roofit_reference.json @@ -0,0 +1,28 @@ +{ + "mH": [ + 124.69666534767093, + 1.034494892461403 + ], + "slope": [ + 0.0487431420762921, + 0.024372183521951002 + ], + "nsig": [ + 9.032917043932107, + 3.6108882414094707 + ], + "nbkg": [ + 18.938324052996553, + 4.795975657782446 + ], + "sigma_fixed": 2.6834562217797195, + "nll_min": 32.41251994098245, + "nll_nosignal": 37.35862935095844, + "q0": 9.892218819951978, + "n_window": 28, + "window": [ + 110.0, + 150.0 + ], + "source": "CMS 2012 open data, ROOT tutorial df103 selection, RooFit Codegen + Clad + Minuit2" +} \ No newline at end of file diff --git a/cppjit/kernel/ball.h b/cppjit/kernel/ball.h new file mode 100644 index 0000000..8a4b1c1 --- /dev/null +++ b/cppjit/kernel/ball.h @@ -0,0 +1,19 @@ +// ball.h -- a ball dropped from 2 m with air drag; the apex height of bounce n, and a least-squares loss. +// The same simulator as the SC26 talk's "Simulate and fit it" slide. 20,000 time steps, a floor with a clamp +// and a branch: nothing a tracing autodiff framework can enter, everything a compiler can differentiate. +#pragma once +#include +inline double apex(double e, double k, int n) { + double y = 2.0, v = 0.0, dt = 1e-3, top = 0.0; int bounces = 0; + for (int i = 0; i < 20000; ++i) { + v -= (9.81 + k * v * std::fabs(v)) * dt; // gravity and air drag + y += v * dt; + if (y < 0.0) { y = 0.0; v = -e * v; ++bounces; } // the floor: a clamp and a branch + if (bounces == n && v > 0.0 && y > top) top = y; // the apex of bounce n + if (bounces > n) break; + } + return top; +} +// p = {e, k}; obs = the apex heights of bounces 1..3 +inline double loss(double* p, const double* obs) { + double L = 0; for (int n = 1; n <= 3; ++n) { double d = apex(p[0], p[1], n) - obs[n-1]; L += d * d; } return L; } diff --git a/cppjit/kernel/derivatives.py b/cppjit/kernel/derivatives.py new file mode 100644 index 0000000..129468f --- /dev/null +++ b/cppjit/kernel/derivatives.py @@ -0,0 +1,55 @@ +"""The derivatives Clad writes for the notebooks, generated in the session. + +The kernel's compiler carries Clad: in the browser kernel and in the cppjit wheel this repository releases (CppInterOp +built with the Clad plugin). `load(name)` makes the requests that the notebooks need and aliases the generated functions +into namespace clad_generated; `code(name)` returns the source Clad generated, as text. +""" +import sys +import cppjit + +# name -> (the header, Clad's requests, the generated functions the notebooks call) +REQUESTS = { + "logistic_step": ("logistic_step.h", + 'auto _clad_ls_dr = clad::differentiate(logistic_step, "r");\n' + 'auto _clad_ls_grad = clad::gradient(logistic_step);', + ["logistic_step_darg1", "logistic_step_grad"], ["_clad_ls_dr", "_clad_ls_grad"]), + "ball": ("ball.h", 'auto _clad_loss = clad::gradient(loss, "p");', ["loss_grad_0"], ["_clad_loss"]), + "twin": ("twin.h", 'auto _clad_oxy = clad::gradient(oxygen_after, "cons, o_edge");', ["oxygen_after_grad_2_3"], ["_clad_oxy"]), +} +_loaded = set() +_plugin = None + + +def clad_in_kernel(): + """True when the interpreter's Clang carries the Clad plugin (the headers alone generate nothing). Probed once.""" + global _plugin + if _plugin is None: + cppjit.cppdef('#include "clad/Differentiator/Differentiator.h"') + # Declared silently: without the plugin Clad's header stops on its own static_assert. + ok = cppjit.gbl.Cpp.Declare('double _clad_probe(double x) { return x * x; }\n' + 'auto _clad_probe_d = clad::differentiate(_clad_probe, "x");', True) == 0 + _plugin = ok and getattr(cppjit.gbl, "_clad_probe_darg0", None) is not None + return _plugin + + +def load(name): + """Generate the derivatives of `name` and expose them as clad_generated::.""" + if name in _loaded: + return + header, requests, functions, objects = REQUESTS[name] + if not clad_in_kernel(): + raise RuntimeError("this cppjit has no Clad plugin; install the cppjit wheel of the live-cpp-tutorials release " + "(README.md), or open the notebook in the browser") + cppjit.cppdef(f'#include "{header}"\n{requests}') + cppjit.cppdef("namespace clad_generated { " + " ".join(f"using ::{f};" for f in functions) + " }") + # getCode() of each request, reachable from Python through a plain function (a CladFunction object is not bindable) + cppjit.cppdef(f'#include \nstd::string _clad_code_{name}() {{ return ' + + ' + "\\n" + '.join(f"std::string({o}.getCode())" for o in objects) + '; }') + _loaded.add(name) + print(f"[clad] {', '.join(functions)}: generated by the Clad inside this kernel", file=sys.stderr) + + +def code(name): + """The source Clad generated for `name`, as Clad prints it.""" + load(name) + return str(getattr(cppjit.gbl, f"_clad_code_{name}")()) diff --git a/cppjit/kernel/lazy.json b/cppjit/kernel/lazy.json new file mode 100644 index 0000000..09fa5ea --- /dev/null +++ b/cppjit/kernel/lazy.json @@ -0,0 +1,25 @@ +{ + "scipy": [ + "scipy" + ], + "matplotlib": [ + "matplotlib-base", + "pillow", + "fonttools", + "contourpy", + "cycler", + "kiwisolver", + "pyparsing", + "python-dateutil", + "python-tzdata", + "pytz", + "packaging", + "qhull" + ], + "PIL": [ + "pillow" + ], + "fontTools": [ + "fonttools" + ] +} \ No newline at end of file diff --git a/cppjit/kernel/lazy.py b/cppjit/kernel/lazy.py new file mode 100644 index 0000000..0a568e3 --- /dev/null +++ b/cppjit/kernel/lazy.py @@ -0,0 +1,147 @@ +"""Load SciPy and matplotlib on first import instead of at kernel start (browser kernel only). + +The JupyterLite xeus kernel unpacks every package of its environment before the first cell runs. This module keeps +the environment at python + numpy and fetches the rest when a notebook first imports it: + + * `install()` registers an import hook and starts background downloads of the package tarballs (a `fetch` in the + kernel's worker; it completes while the reader works through the first cells). + * on `import scipy` / `import matplotlib` the hook takes the downloaded tarball, or downloads it synchronously if + it has not arrived yet, extracts it into the kernel filesystem and lets the import proceed. + +Fetching goes through `emscripten_run_script_string` from a tiny C++ helper compiled with cppjit, because the kernel's +Python has no sockets. The tarballs are the ones the site build packed, served under `/lazy/`. +Native Python never imports this file: the notebooks only use it through the browser bootstrap cell.""" +import sys, os, json, time, tarfile, importlib, importlib.abc, importlib.machinery + +GROUPS = {} # top-level module name -> list of tarball file names (lazy.json names packages; lazy/index.json, + # written by the site build from the tarballs it packed, maps a package to its file) +_cpp_ready = False +_state = {} # tarball -> "fetched" | "extracted" + +_CPP = r''' +#include +extern "C" char* emscripten_run_script_string(const char* script); +extern "C" void emscripten_run_script(const char* script); +namespace sc26lazy { + std::string base() { return emscripten_run_script_string("self.location.href.split('/extensions/')[0]"); } + // synchronous XHR (allowed in a worker) into the kernel filesystem; returns the byte count or an error text + std::string fetch_sync(const std::string& url, const std::string& path) { + std::string js = "(function(){ try { var x = new XMLHttpRequest(); x.open('GET', '" + url + "', false);" + " x.responseType = 'arraybuffer'; x.send(null); if (x.status != 200) return 'http ' + x.status;" + " FS.writeFile('" + path + "', new Uint8Array(x.response)); return String(x.response.byteLength); }" + " catch (e) { return 'error ' + String(e); } })()"; + return emscripten_run_script_string(js.c_str()); + } + // background fetch: the worker's event loop runs between cells, so the file appears while the reader works + void fetch_async(const std::string& url, const std::string& path) { + std::string js = "fetch('" + url + "').then(r => { if (!r.ok) throw new Error('http ' + r.status); return r.arrayBuffer(); })" + ".then(b => { if (FS.analyzePath('" + path + ".done').exists) return; FS.writeFile('" + path + ".part', new Uint8Array(b)); FS.rename('" + path + ".part', '" + path + "'); })" + ".catch(e => { console.log('sc26 lazy prefetch failed', '" + url + "', String(e)); });"; + emscripten_run_script(js.c_str()); + } +} +''' + +CACHE = "/tmp/sc26-lazy" + + +def _cpp(): + global _cpp_ready + if not _cpp_ready: + import cppjit + cppjit.cppdef(_CPP); _cpp_ready = True + import cppjit + return cppjit.gbl.sc26lazy + + +import re as _re +_NAME = _re.compile(r"^[A-Za-z0-9][A-Za-z0-9._+-]*\.(tar\.gz|json)$") +_BASE = _re.compile(r"^https?://[A-Za-z0-9.:_/%+-]*$") + + +def _url(tarball): + """The tarball URL. Both parts end up inside a JavaScript string literal, so only plain characters are allowed.""" + base = str(_cpp().base()) # cppjit hands back a std::string proxy + if not _NAME.match(tarball): raise ImportError(f"sc26 lazy: refusing tarball name {tarball!r}") + if not _BASE.match(base): raise ImportError(f"sc26 lazy: refusing site base {base!r}") + return base + "/lazy/" + tarball + + +def prefetch(names=None): + """Start background downloads for the given top-level modules (default: all known).""" + os.makedirs(CACHE, exist_ok=True) + for name in (names or list(GROUPS)): + for tb in GROUPS[name]: + path = os.path.join(CACHE, tb) + if not _NAME.match(tb): continue + if not os.path.exists(path) and _state.get(tb) is None: + _cpp().fetch_async(_url(tb), path); _state[tb] = "fetching" + + +def ensure(name, verbose=True): + """Make the top-level module `name` importable: download what is missing, extract, done.""" + if name not in GROUPS: return + t0 = time.time(); fetched = 0 + for tb in GROUPS[name]: + if _state.get(tb) == "extracted": continue + path = os.path.join(CACHE, tb) + if not os.path.exists(path): + r = str(_cpp().fetch_sync(_url(tb), path)) + if not r.isdigit(): raise ImportError(f"sc26 lazy: could not fetch {tb}: {r}") + fetched += int(r) + with tarfile.open(path) as t: t.extractall("/", filter="data") + os.remove(path); open(path + ".done", "w").close(); _state[tb] = "extracted" + importlib.invalidate_caches() + if verbose: + how = f"{fetched / 1048576:.1f} MB downloaded now" if fetched else "already downloaded in the background" + print(f"[browser] {name} unpacked in {time.time() - t0:.1f} s ({how})", file=sys.stderr) + + +class _Finder(importlib.abc.MetaPathFinder): + """On the first import of a lazy top-level module, fetch and extract it, then defer to the normal finders.""" + def find_spec(self, fullname, path=None, target=None): + top = fullname.split(".")[0] + if top in GROUPS and any(_state.get(tb) != "extracted" for tb in GROUPS[top]): + ensure(top) + return None # the regular path finder now finds the extracted package + + +def install(show_png=None): + """Register the hook, start the background downloads, and make matplotlib draw into the notebook.""" + here = os.path.dirname(os.path.abspath(__file__)) + groups = json.load(open(os.path.join(here, "lazy.json"))) + os.makedirs(CACHE, exist_ok=True) + index_path = os.path.join(CACHE, "index.json") + r = str(_cpp().fetch_sync(_url("index.json"), index_path)) + index = json.load(open(index_path)) if r.isdigit() else {} + if not index: print("[browser] sc26 lazy: no lazy/index.json on the site, on-demand packages unavailable", file=sys.stderr) + for mod, pkgs in groups.items(): + files = [] + for pk in pkgs: + if pk.endswith(".tar.gz"): files.append(pk) # an explicit file name passes through + elif pk in index: files.append(index[pk]) + # a package the environment no longer has is simply not part of the group + if files: GROUPS[mod] = files + sys.meta_path.insert(0, _Finder()) + os.environ.setdefault("MPLBACKEND", "Agg"); os.environ.setdefault("MPLCONFIGDIR", "/tmp/mpl") + if show_png is not None: + # matplotlib has no Jupyter backend in this kernel: plt.show() saves a PNG and the C++ helper displays it. + _patch_pyplot(show_png) + prefetch() + + +def _patch_pyplot(show_png): + class PyplotPatch(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname != "matplotlib.pyplot": return None + spec = importlib.machinery.PathFinder.find_spec(fullname, path) + if spec is None or spec.loader is None: return None + real_exec = spec.loader.exec_module + def exec_module(module): + real_exec(module) + def _show(*a, **k): + module.savefig("/tmp/_fig.png", dpi=90, bbox_inches="tight"); module.close("all"); show_png("/tmp/_fig.png") + module.show = _show + spec.loader.exec_module = exec_module + return spec + sys.meta_path.insert(0, PyplotPatch()) diff --git a/cppjit/kernel/logistic_step.h b/cppjit/kernel/logistic_step.h new file mode 100644 index 0000000..e9ac027 --- /dev/null +++ b/cppjit/kernel/logistic_step.h @@ -0,0 +1,17 @@ +// logistic_step.h -- one explicit-Euler step of logistic growth, dN/dt = r*N*(1 - N/K): +// +// N_{t+1} = N_t + r * N_t * (1 - N_t / K) +// +// The one header the whole tutorial runs on: called from Python through cppjit, differentiated by Clad, and the +// proliferation law inside the tumour twin. Templated on the scalar type so one source serves float and double and +// so Clad differentiates the generic body, not a type-erased wrapper. +#ifndef SC26_KERNEL_LOGISTIC_STEP_H +#define SC26_KERNEL_LOGISTIC_STEP_H + +template +T logistic_step(T N, T r, T K) { + T growth = r * N * (T(1) - N / K); + return N + growth; +} + +#endif // SC26_KERNEL_LOGISTIC_STEP_H diff --git a/cppjit/kernel/twin.h b/cppjit/kernel/twin.h new file mode 100644 index 0000000..76136be --- /dev/null +++ b/cppjit/kernel/twin.h @@ -0,0 +1,77 @@ +// twin.h -- a tiny tumour twin: the cancer model's shape in sixty lines, for a laptop. +// +// N sites on a line. Each site holds a cell count c[i] that grows by the SC26 header's logistic step at a rate +// set by the oxygen there and spreads to its neighbours, so the colony's front advances. Oxygen diffuses along the line from both edges, which are held at o_edge (the medium), +// and is consumed by the cells. Two knobs the real model also has: the consumption rate `cons` and the edge +// oxygen `o_edge`. The smooth part (oxygen) is restated below as one function the compiler can differentiate, +// exactly as the talk restates the real model's oxygen update. +#pragma once +#include +#include +#include +#include "logistic_step.h" + +constexpr int kMaxSites = 256; + +struct Twin { + int n; // sites + std::vector c, o; // cells and oxygen per site + double r = 0.15, K = 2000.0; // growth: rate at full oxygen, carrying capacity per site + double spread = 0.03; // cells: fraction exchanged with each neighbour per step (the colony's front advances) + double D = 4.5, cons = 1e-5; // oxygen: diffusion per substep, consumption per cell per substep + double o_edge = 38.0; // oxygen at the two edges (the medium) + int substeps = 2000; double dto = 0.1; // oxygen substeps per step: the field settles within one growth step + long steps_done = 0; + explicit Twin(int sites, double edge = 38.0) : n(sites), c(sites, 0.0), o(sites, edge), o_edge(edge) { + for (int i = n / 2 - 2; i <= n / 2 + 2; ++i) c[i] = 10.0; // a small colony in the middle + } + void oxygen_substep() { + double prev = o[0]; + for (int i = 1; i < n - 1; ++i) { + double cur = o[i]; + o[i] += dto * (D * (prev - 2 * cur + o[i + 1]) - cons * c[i] * cur); + if (o[i] < 0) o[i] = 0; + prev = cur; + } + o[0] = o_edge; o[n - 1] = o_edge; + } + void step() { + for (int s = 0; s < substeps; ++s) oxygen_substep(); + for (int i = 0; i < n; ++i) { + double rate = r * o[i] / (o[i] + 5.0); // Michaelis-Menten in the oxygen + c[i] = logistic_step(c[i], rate, K); // the header, as written, as the growth law + } + double prev = c[0]; + for (int i = 1; i < n - 1; ++i) { // the cells spread to their neighbours + double cur = c[i]; c[i] += spread * (prev - 2 * cur + c[i + 1]); prev = cur; + } + ++steps_done; + } + double total_cells() const { double s = 0; for (double x : c) s += x; return s; } + double mean_oxygen_at_cells() const { + double s = 0, w = 0; for (int i = 0; i < n; ++i) { s += c[i] * o[i]; w += c[i]; } return w > 0 ? s / w : 0; } +}; + +// Run `steps` steps; `hook(step, twin)` is called before each one. A Python function can be the hook. +inline void run(Twin& t, int steps, std::function hook) { + for (int s = 0; s < steps; ++s) { hook(s, t); t.step(); } +} + +// The smooth part, restated for the compiler: from a uniform field at o_edge, `iters` oxygen substeps over FIXED cells, +// then the cell-weighted mean oxygen. The derivative of this with respect to (cons, o_edge) is what calibrates the twin. +inline double oxygen_after(const double* cells, int n, double cons, double o_edge, double D, double dto, int iters) { + double o[kMaxSites]; + for (int i = 0; i < n; ++i) o[i] = o_edge; + for (int it = 0; it < iters; ++it) { + double prev = o[0]; + for (int i = 1; i < n - 1; ++i) { + double cur = o[i]; + o[i] += dto * (D * (prev - 2 * cur + o[i + 1]) - cons * cells[i] * cur); + prev = cur; + } + o[0] = o_edge; o[n - 1] = o_edge; + } + double s = 0, w = 0; + for (int i = 0; i < n; ++i) { s += cells[i] * o[i]; w += cells[i]; } + return s / w; +} diff --git a/cppjit/requirements.txt b/cppjit/requirements.txt new file mode 100644 index 0000000..d6af9d8 --- /dev/null +++ b/cppjit/requirements.txt @@ -0,0 +1,8 @@ +cppjit==0.1.0a1 +numpy +scipy +matplotlib +jupyter +# optional, notebooks 3 and 4: +# jax +# optimistix diff --git a/environment.yml b/environment.yml index 6bb4cd0..2cc5a3a 100644 --- a/environment.yml +++ b/environment.yml @@ -3,7 +3,7 @@ channels: - conda-forge - nvidia dependencies: - - python>=3.11 + - python=3.12.* # the cppjit wheel of the release is built for 3.12 - xeus-cpp - jupyter - nbconvert @@ -13,3 +13,10 @@ dependencies: - cuda-cudart-dev - papermill - pytest + # cppjit series: the Python kernel compiles C++ through cppjit, installed by the workflow from this repository's + # release (the wheel carries CppInterOp built with the Clad plugin; the PyPI wheel has no Clad yet) + - numpy + - scipy + - matplotlib-base + - ipykernel + - pip diff --git a/lite/README-build.md b/lite/README-build.md new file mode 100644 index 0000000..dab9740 --- /dev/null +++ b/lite/README-build.md @@ -0,0 +1,186 @@ +# The notebooks in the browser: how the JupyterLite site is built + +Built and verified 2026-11-03 (kernel rebuilt on the LLVM 23 line with Clad inside). The five `cppjit/` notebooks run in +the browser with no install, in the xcpp23 kernel (clang-repl on WebAssembly) that hosts Python through cppjit: Python +cells call C++ in the same process, exactly the pairing the tutorial is about, and `clad::gradient` works live in both. +Output: `lite/dist/` (285 MB on disk). + +## What is in it + +| part | content | +|---|---| +| kernel | xeus-cpp + cppjit + CppInterOp with Clad built in, on CppInterOp, cppjit and xeus-cpp main of 2026-10/11 (`tools/build-wasm-kernel.sh`, emsdk 4.0.9, emscripten-forge llvm 23.1.2; `lite/kernel/README.md`, `PATCHES.md`) | +| Python packages | python 3.13.1, numpy 2.5.4, scipy 1.18.0, matplotlib-base 3.11.2, pillow 13.0.0 and their dependencies: 31 packages, 24 MB on the wire (the upstream site ships 94 packages, 59 MB) | +| mounts | `cppjit/kernel` at `/cppjit/kernel` (the three headers, `derivatives.py`) and `cppjit/data` at `/cppjit/data` (the Higgs masses) | +| Clad | built into the kernel: notebooks 2, 3 and 5 generate their derivatives live (`kernel/derivatives.py`, the same requests that produced the shipped sources); a C++ cell can call `clad::gradient` directly | +| notebooks | the five home notebooks converted by `tools/home2lite.py`: Python cells become `%%python` cells; two cells at the top set the working directory to `/cppjit` and route `plt.show()` through a C++ display helper | +| extensions | only the xeus kernel extension and the notebook UI (no pyodide, javascript, p5 kernels, no widgets) | + +## SciPy and matplotlib on first import, not at start + +The xeus kernel unpacks every package of its environment before the first cell runs. The site keeps that start-up +set at python + numpy (20 packages, 6.2 MB) and loads the rest on demand: `cppjit/kernel/lazy.py`, mounted with the +kernel files, registers an import hook and starts background downloads of the SciPy and matplotlib tarballs from the +bootstrap cell (a `fetch` in the kernel's worker through `emscripten_run_script`; the worker's event loop runs between +cells, so the files arrive while the reader works). On the first `import scipy` or `import matplotlib` the hook extracts +the downloaded tarball into the kernel filesystem (about 1 s), or downloads it synchronously first (an XHR, allowed in +a worker) if the reader got there before the background did. The tarballs are served under `lazy/` (18 MB, the same +files the pack step produces; `cppjit/kernel/lazy.json` maps top-level modules to them). `plt.show()` is routed to the +C++ display helper by a second hook that patches `matplotlib.pyplot` as it loads. SciPy stays SciPy in the notebooks. + +## Traffic, measured end to end (2026-11-03) + +`tools/lite_wire.py`: a local server that compresses like nginx (`gzip` for wasm, js, json, html, so, data; `.tar.gz` +untouched), headless Chromium opening the notebook in the Lab UI and running all cells, every response body counted as +received, kernel worker included (`lite/wire-ledger.json`, `lite/wire-ledger-nb1.json`): + +| component | notebook 1 (no SciPy, no plots) | notebook 4 (SciPy, matplotlib, data) | +|---|---:|---:| +| C++ kernel: `xcpp.wasm` (LLVM, Clang, lld, Clad, CppInterOp inside: 97.6 MB raw) 30.8, `xcpp.data` 4.8, glue | 35.8 | 35.8 | +| app shell, extensions, notebook files | 7.8 | 7.8 | +| Python packages at start (python, numpy, 18 small ones) | 6.1 | 6.1 | +| shared libraries on first use (openblas, zlib, xeus) | 0.1 | 2.7 | +| lazy packages on first import (SciPy, the matplotlib group) | 0 | 17.3 | +| **total** | **49.8 MB** | **69.8 MB** | +| kernel ready / last output | 4 s / 13 s | 4 s / 43 s | + +September, for comparison (LLVM 22 kernel, CppInterOp as a separate 19.8 MB module): 44.8 MB and 64.4 MB. The LLVM 23 +line builds CppInterOp as a static library, so one `xcpp.wasm` carries LLVM, Clang, lld, Clad and CppInterOp: 30.8 MB +gzip after `wasm-opt -Oz` (119.9 MB raw at link, 97.6 after binaryen), against 4.9 + 19.8 MB for the two September +pieces. The growth is LLVM 23 itself (its archives are 13 % larger than 22's), Clad (6 MB raw) and the lld and ORC code +the static layout keeps; `MAIN_MODULE=2` with an export list was tried and dropped: it saves 6 MB raw, 0.5 MB gzip, and +risks a missing export for JIT-compiled cells. The old double fetch of the CppInterOp module is gone with the module. + +Run All Cells is the worst case for the lazy loader: the first `import scipy` comes before the background download +has finished, so SciPy (9.9 MB) is downloaded a second time synchronously; measured that way notebook 4 is 79.7 MB. +Reading the notebook at a human pace, the background copy wins and the total is the 69.8 MB above. 220 KB come from `raw.githubusercontent.com` (jupyterlite-xeus' parselmouth mapping), the only request that +leaves the host. A host serving Brotli would take 15 to 20 % more off the wasm and JS; one serving uncompressed would +send the raw sizes (about 170 MB), so check the server's compression once deployed. + +## The C++ series in the browser + +The repository's `xeus-cpp/` notebooks go into the site unchanged apart from the kernel name (`cpp/`). Checked headlessly +on 2026-11-02: 01, 02, 04 to 09, the project report and the visual guide run; 03 stops at its intentional +redefinition error, as it should; 10 is left out because its lambda named `log` collides with `std::log`, which the +browser kernel's preamble puts in scope (the native kernel does not). + +## Two things the kernel needed + +**Shared libraries.** Python extension modules that depend on a shared library (numpy on `libopenblas.so`, pillow on +`libz.so`) failed to import with `need to see wasm magic number`. The kernel's dynamic loader resolves a module's +needed libraries by URL next to the kernel script (`extensions/@jupyterlite/xeus-extension/static/`), not through the +in-memory filesystem where the packages put them; jupyterlite-xeus 5.0 preloads shared libraries only for Emscripten +< 4, and this kernel is Emscripten 4.0.9. The 404 page comes back as the "wasm". The upstream deployment has the same +defect: numpy imports there only because its numpy build has no such dependency, and matplotlib fails on pillow. +The fix in `tools/build-lite-site.sh` is to serve `libopenblas.so` and `libz.so` at that URL (fetched once, on first +use) and to leave them out of the packed packages so they are not transferred twice. Worth reporting to +jupyterlite-xeus with the kernel's `emscriptenMajorVersion` branch as the pointer. + +**Figures.** matplotlib has no Jupyter backend inside this kernel. The C++ helper cell defines `show_png(path)`, which +reads a PNG and publishes it with `xcpp::display`; the Python bootstrap replaces `plt.show()` with save-then-show. +`xcpp::display` needs ``, which the upstream pack configuration excluded; the slim configuration keeps +that one header. + +## Rebuild from scratch (verified 2026-11-01, 21:30 Sofia) + +Everything the site needs is in the repository, except the kernel binaries, which take about an hour to rebuild (plus a +binaryen pass that needs 12 GB of memory) and live as one saved artifact. Two commands, about ten minutes, network to +GitHub, PyPI and prefix.dev, no sudo: + +```sh +SP=/some/empty/dir bash tools/setup-lite-env.sh # micromamba, host venv, wasm32 env from the lock, kernel overlay, slim/lazy envs +SP=/some/empty/dir OUT=lite/dist bash tools/build-lite-site.sh +``` + +| piece | where | what | +|---|---|---| +| host side | `lite/env/site-env.requirements.txt` + `build-env.pip-freeze.txt` | jupyterlite-core 0.8.3, jupyterlite-xeus 5.0.0, empack 6.0.1, notebook 7.6.2, pinned to the 2026-09-20 build environment | +| wasm32 environment | `lite/env/xeus-kernels.explicit.txt` | micromamba explicit list, 40 packages with md5, emscripten-forge-4x (llvm 23.1.2, emscripten-abi 4.0.9) | +| derived environments | `lite/env/{slim,lazy,kernelspecs}-remove.txt` | build-time-only packages dropped; the lazy ones are packed once from xeus-slim into `lite/lazy-packages/` | +| kernel overlay | `release asset kernel-overlay-2026-11-03.tar.gz` (35.8 MB) | the files of the kernel build that no package owns: `xcpp.{js,wasm,data}` and the `xcpp23` kernel spec | +| kernel source patches and pins | `lite/kernel/`, `tools/build-wasm-kernel.sh` | the 27 third-party patches (CppInterOp 4, cppjit 5, xeus-cpp 18, listed in PATCHES.md) plus our WebGPU patch, Vipul's `deploy.yml`, `environment.yml`, `build-environment.yml`, the upstream pack config; `tools/build-wasm-kernel.sh` rebuilds the kernel from them | + +The explicit-lock environment carries no channel history, so the build passes `--XeusAddon.default_channels` +explicitly. The September scratchpad under `/tmp` is no longer needed. + +## Building the binaries on a GitHub runner + +`.github/workflows/build-kernel.yml` (manual dispatch, input: the release tag) rebuilds both binaries from the repository +alone: micromamba and emsdk 4.0.9 pinned, the wasm32 and native environments from the locks, the sources at the pins with +the patches of `lite/kernel/`, then kernel, `wasm-opt -Oz` (the runner's 16 GB cover binaryen's 11.5 GB), overlay and +wheel. It attaches them with `SHA256SUMS` to the release and opens a pull request that puts the digests into +`lite/kernel/SHA256SUMS` and the release name into the two workflows that download from it: the Pages and cppjit jobs +verify the assets against the repository, never against a file served beside them, so a rebuilt release becomes the +deployed one only through that pull request. About an hour. Under act the release and pull-request steps are skipped +and the files land in the artifact (`act workflow_dispatch -W .github/workflows/build-kernel.yml -j build --input +tag= ...`). + +## Testing the workflows locally with nektos/act + +```sh +mkdir -p lite/kernel-artifacts && cp lite/kernel-artifacts/ +act -W .github/workflows/deploy-pages.yml -j build -P ubuntu-24.04=catthehacker/ubuntu:act-24.04 \ + --use-gitignore=false --artifact-server-path /tmp/act-artifacts +act -W .github/workflows/check-notebooks.yml -j execute-notebooks-cppjit -P ubuntu-latest=catthehacker/ubuntu:act-24.04 \ + --artifact-server-path /tmp/act-artifacts +``` + +`--use-gitignore=false` matters: act copies the checkout into the container honouring `.gitignore`, and +`lite/kernel-artifacts/` is ignored, so without it the digest check finds no files. `--artifact-server-path` lets the +upload-artifact steps succeed. Under act the release download and the Pages upload/deploy steps are skipped (`ACT=true`); +everything else runs as on GitHub: environment from the locks, site build, headless browser smoke test under a sub-path. +Verified on 2026-11-02 on a 56-core machine: the cppjit CI job in about 10 minutes, the Pages build in about 15. + +## Deploy + +Any static host serves it; GitHub Pages is the upstream pattern (its `deploy.yml` uploads the `dist` directory as the +Pages artifact). Serve with gzip (Brotli where possible: another 15 to 20 % off the wasm). The links to hand out are +`/lab/index.html?path=cppjit/1_call_it.ipynb` and so on, or `/notebooks/index.html?path=...` for the single-notebook +view. Nothing in the site phones home. + +## The LLVM 23 line (2026-11-02/03) + +The September kernel was 27 third-party patches on CppInterOp, cppjit and xeus-cpp commits of August, with CppInterOp as +a separate wasm module and no Clad. The kernel now builds from the three projects' main branches plus CppInterOp pull +request 1167 (Clad in wasm) and Clad 90a623d6, with the patches in `lite/kernel/PATCHES.md`. Found on the way, fixed +in our patches and worth sending upstream: + +- PR 1167's clad cross-build fails under emsdk 4.0.9 (`-fwasm-exceptions` before LLVM's `-fno-exceptions`), its static + library's CMake config does not export the Clad archives, and wrapping them in `--whole-archive` strips libc for an + Emscripten main module (numpy then fails to load for want of `acosf`). +- Clad's plugin discarded the consumer calls of a failed input only for clang < 22, citing llvm/llvm-project#182044, + which is about virtual files for `input_line_N`, not about this: on clang 23 in wasm the failed input's + `TopLevelStmtDecl` was replayed into CodeGen on the next cell and the kernel hung after any parse error (found here + with a Node harness of the kernel's interpreter stack and the inspector's pause). Fixed upstream the same day by + vgvassilev/clad#2453 (90a623d6), which the pin now includes. +- cppjit's string converters must be keyed on the typedef spellings (Vipul's `cppjit-003`): libc++ spells + `std::string` out, and without it a `std::string` argument from Python fails to convert. + +The module's size is the compiler's: Clang 40 MB, target-independent LLVM 38 MB and the X86 and AArch64 backends 18 MB +of the 126 MB link (linker map), all from emscripten-forge's llvm package, which is built at -O3 with three targets and +as plain wasm objects, so link-time optimisation cannot reach it. Building LLVM ourselves with the ci-workflows +`llvm-wasm` recipe (WebAssembly target only, -Oz, LTO; emsdk 4.0.9 needs `-mtail-call`, and clang 23 needs +emscripten-forge's two interpreter patches) gives 69.4 MB raw / 23.7 MB gzipped after wasm-opt against 103.4 / 32.5, +with cell times unchanged within noise (measured on the z840 builds of 2026-11-04 across -Oz, -Os, -O2, with and without +LTO). `tools/build-wasm-kernel.sh` takes that install through `LLVM_WASM_DIR`, and the release `kernel-2026-11-03` +carries that kernel (the -Oz + LTO build of 2026-11-04, verified twice in the browser on the smoke cells and the five +notebooks). `build-kernel.yml` still builds against the conda package: until the LLVM install is published as a cell or +release asset it can download, a rerun of that workflow proposes the larger kernel's digest. With the smaller kernel the +wire figures in the table above drop by 8.2 MB (the module's gzip size, 32.5 to 24.3 MB): about 41.6 MB for the first +notebook, 61.6 MB with SciPy and matplotlib loaded; to be re-measured on the public site. + +The preloaded filesystem (`xcpp.data`) left out what a notebook kernel never includes (the sysroot's SDL, GL, X11 and +sanitizer headers, the other architectures' intrinsics in clang's resource directory, `pydoc_data`): 46.5 to 27.5 MB raw, +6.5 to 4.8 MB gzip, patch `xeus-cpp-023`; a cell including the common C++, emscripten and WebGPU headers and the Python +standard library imports the notebooks use still runs. + +The module cannot be optimised in a 7 GB container: binaryen needs about 11.5 GB for this module, so the kernel is linked +at `-O1` and `wasm-opt -Oz` runs as a separate stage on a bigger machine (five minutes on 56 cores). + +## What would make it smaller still + +| lever | saves | cost | +|---|---:|---| +| ORC out of the wasm interpreter (llvm/llvm-project#175910 is in LLVM main, not 23.x): a backport into the emscripten-forge llvm package or ci-workflows' `llvm-wasm` recipe | 3 to 8 MB | an LLVM rebuild for wasm32 | +| Brotli precompression on the server | 6 to 8 MB | none, server-side | +| matplotlib-base: keep only the Agg backend files | about 0.5 MB | pack rules | diff --git a/lite/README.md b/lite/README.md new file mode 100644 index 0000000..484413a --- /dev/null +++ b/lite/README.md @@ -0,0 +1,15 @@ +# SC26 at home, in the browser + +Five notebooks from the SC26 Python tutorial and the C++ series of live-cpp-tutorials, running here without any install. The kernel is C++ (clang-repl compiled +to WebAssembly); Python runs inside it and calls the C++ through cppjit, which is the pairing the tutorial is about. + +1. `1_call_it.ipynb`: call a C++ header from Python, time it against pure Python. +2. `2_transform_it.ipynb`: the derivative Clad wrote for that header, checked three ways. +3. `3_fit_it.ipynb`: a bouncing ball in C++, fitted to data with BFGS on Clad's exact gradient. +4. `4_higgs_open_data.ipynb`: the four-lepton Higgs mass on CMS 2012 open data, without ROOT, checked against RooFit. +5. `5_tiny_twin.ipynb`: the cancer model's shape in sixty lines of C++, called, composed with Python, calibrated. + +Run the cells top to bottom (the first two cells of each notebook set the browser up). The first start downloads the +compiler and the Python packages once; after that everything runs locally in your browser tab. The same notebooks +for a laptop (`pip install cppjit numpy scipy matplotlib`) are in `cppjit/` of this repository, and the C++ series under +`cpp/` here is the repository's `xeus-cpp/` series, unchanged. diff --git a/lite/empack_config.yaml b/lite/empack_config.yaml new file mode 100644 index 0000000..ef09854 --- /dev/null +++ b/lite/empack_config.yaml @@ -0,0 +1,229 @@ +# From Vipul-Cariappa/jupyterlite-deploy, slimmed for the sc26 home notebooks (see tools/build-lite-site.sh): +# nlohmann_json's header kept (xcpp::display needs it); openblas/zlib/xz/openssl not packed (shared libraries are fetched by URL, +# see the build script); fonts, tests and tools the notebooks never touch left out. +packages: + setuptools: + exclude_patterns: + - pattern: '**/_distutils_hack/**' + - pattern: '**/distutils-precedence.pth' + - pattern: '**/setuptools/**' + - pattern: '**/pkg_resources/_vendor/**' + widgetsnbextension: + exclude_patterns: + - pattern: '**' + llvm: + exclude_patterns: + - pattern: '**' + pyjs-dev: + exclude_patterns: + - pattern: '**' + nlohmann_json: + exclude_patterns: + - pattern: '**/cmake/**' + - pattern: '**/pkgconfig/**' + - pattern: '**/share/**' + nlohmann_json-abi: + exclude_patterns: + - pattern: '**' + cpp-argparse: + exclude_patterns: + - pattern: '**' + pugixml: + exclude_patterns: + - pattern: '**' + doctest: + exclude_patterns: + - pattern: '**' + xtl: + exclude_patterns: + - pattern: '**' + pybind11: + exclude_patterns: + - pattern: '**' + pybind11_json: + exclude_patterns: + - pattern: '**' + emscripten-abi: + exclude_patterns: + - pattern: '**' + python_abi: + exclude_patterns: + - pattern: '**' + pytest: + exclude_patterns: + - pattern: '**' + openblas: + exclude_patterns: + - pattern: '**' + zlib: + exclude_patterns: + - pattern: '**' + xz: + exclude_patterns: + - pattern: '**' + openssl: + exclude_patterns: + - pattern: '**' + matplotlib-base: + exclude_patterns: + - &id001 + pattern: bin/** + - &id002 + pattern: '**/bin/**' + - &id003 + pattern: tests/** + - &id004 + pattern: '**/tests/**' + - &id005 + pattern: '**/*.ini' + - &id006 + pattern: '**/*.exe' + - &id007 + pattern: '**/*.c' + - &id008 + pattern: '**/*.pxd' + - &id009 + pattern: '**/*.pyx' + - &id010 + pattern: '**/*.pyc' + - &id011 + pattern: '**/*.typed' + - &id012 + pattern: '**/*.egg-info' + - &id013 + pattern: '**/site-packages/pip/_vendor/**' + - &id022 + pattern: '**/idlelib/**' + - &id023 + pattern: '**/ensurepip/**' + - &id014 + pattern: Scripts/* + - &id015 + pattern: share/jupyter/nbextensions/** + - &id016 + pattern: share/jupyter/labextensions/** + - &id017 + pattern: etc/jupyter/nbconfig/** + - &id018 + pattern: '**/*.a' + - &id019 + pattern: lib/cmake/** + - &id020 + pattern: share/cmake/** + - &id021 + pattern: '**/*.pc' + - pattern: '**/mpl-data/fonts/ttf/DejaVuSerif*' + - pattern: '**/mpl-data/fonts/ttf/DejaVuSansMono*' + - pattern: '**/mpl-data/fonts/ttf/DejaVuSansDisplay*' + - pattern: '**/mpl-data/fonts/ttf/STIX*' + - pattern: '**/mpl-data/fonts/ttf/cm*.ttf' + - pattern: '**/mpl-data/fonts/afm/**' + - pattern: '**/mpl-data/fonts/pdfcorefonts/**' + - pattern: '**/mpl-data/sample_data/**' + - pattern: '**/matplotlib/tests/**' + - pattern: '**/mpl_toolkits/*/tests/**' + python: + exclude_patterns: + - *id001 + - *id002 + - *id003 + - *id004 + - *id005 + - *id006 + - *id007 + - *id008 + - *id009 + - *id010 + - *id011 + - *id012 + - *id013 + - *id014 + - *id015 + - *id016 + - *id017 + - *id018 + - *id019 + - *id020 + - *id021 + - pattern: '**/idlelib/**' + - pattern: '**/tkinter/**' + - pattern: '**/turtledemo/**' + - pattern: '**/turtle.py' + - pattern: '**/ensurepip/**' + - pattern: '**/pydoc_data/**' + - pattern: '**/lib/python3.13/test/**' + scipy: + exclude_patterns: + - *id001 + - *id002 + - *id003 + - *id005 + - *id006 + - *id007 + - *id008 + - *id009 + - *id010 + - *id011 + - *id012 + - *id013 + - *id022 + - *id023 + - *id014 + - *id015 + - *id016 + - *id017 + - *id018 + - *id019 + - *id020 + - *id021 + - pattern: '**/tests/**' + numpy: + exclude_patterns: + - *id001 + - *id002 + - *id003 + - *id005 + - *id006 + - *id007 + - *id008 + - *id013 + - *id022 + - *id023 + - *id014 + - *id015 + - *id016 + - *id017 + - *id018 + - *id019 + - *id020 + - *id021 + - pattern: '**/*.pyx' + - pattern: '**/*.pyc' + - pattern: '**/*.typed' + - pattern: '**/*.egg-info' + - pattern: '**/tests/**' +default: + exclude_patterns: + - *id001 + - *id002 + - *id003 + - *id004 + - *id005 + - *id006 + - *id007 + - *id008 + - *id009 + - *id010 + - *id011 + - *id012 + - *id013 + - *id022 + - *id023 + - *id014 + - *id015 + - *id016 + - *id017 + - *id018 + - *id019 + - *id020 + - *id021 diff --git a/lite/env/build-env.pip-freeze.txt b/lite/env/build-env.pip-freeze.txt new file mode 100644 index 0000000..57606c6 --- /dev/null +++ b/lite/env/build-env.pip-freeze.txt @@ -0,0 +1,116 @@ +annotated-doc==0.0.5 +anyio==4.15.1 +argon2-cffi==25.1.0 +argon2-cffi-bindings==26.1.0 +arrow==1.4.0 +asttokens==3.0.2 +async-lru==2.3.0 +attrs==26.1.0 +babel==2.18.0 +beautifulsoup4==4.15.0 +bleach==6.4.0 +cached-property==2.0.1 +certifi==2026.7.22 +cffi==2.1.1 +charset-normalizer==3.5.1 +click==8.1.8 +comm==0.2.3 +debugpy==1.8.22 +defusedxml==0.7.1 +doit==0.37.0 +empack==6.0.1 +executing==2.2.1 +fastjsonschema==2.22.2 +fqdn==1.5.1 +h11==0.16.0 +httpcore==1.0.9 +httpx==0.28.1 +idna==3.19 +importlib_metadata==9.0.1 +ipykernel==7.3.0 +ipython==9.17.1 +ipython_pygments_lexers==1.1.1 +isoduration==20.11.0 +jedi==0.20.0 +Jinja2==3.1.6 +json5==0.15.0 +jsonpointer==3.1.1 +jsonschema==4.26.0 +jsonschema-specifications==2025.9.1 +jupyter_builder==1.2.3 +jupyter_client==8.10.0 +jupyter_core==5.9.1 +jupyter-events==0.12.1 +jupyter-lsp==2.3.1 +jupyter_server==2.21.1 +jupyter_server_terminals==0.5.4 +jupyterlab==4.6.3 +jupyterlab_night==0.5.2 +jupyterlab_pygments==0.3.0 +jupyterlab_server==2.28.1 +jupyterlite-core==0.8.3 +jupyterlite_javascript_kernel==0.3.0 +jupyterlite-p5-kernel==0.3.0 +jupyterlite-pyodide-kernel==0.8.5 +jupyterlite_xeus==5.0.0 +lark==1.3.1 +markdown-it-py==4.2.0 +MarkupSafe==3.0.3 +matplotlib-inline==0.2.2 +mdurl==0.1.2 +mistune==3.3.4 +nbclient==0.11.0 +nbconvert==7.17.1 +nbformat==5.11.1 +nest-asyncio2==1.7.2 +networkx==3.6.1 +notebook==7.6.2 +notebook_shim==0.2.4 +overrides==7.7.0 +packaging==26.3 +pandocfilters==1.5.0 +parso==0.8.7 +pexpect==4.9.0 +pip==26.2.1 +pkginfo==1.13 +platformdirs==4.11.8 +prometheus_client==0.26.0 +prompt_toolkit==3.0.53 +psutil==7.2.2 +ptyprocess==0.7.0 +pure_eval==0.2.4 +pycparser==3.0 +Pygments==2.21.0 +python-dateutil==2.9.0.post0 +python-json-logger==4.2.0 +PyYAML==6.0.3 +pyzmq==27.2.0 +referencing==0.37.0 +requests==2.34.2 +rfc3339_validator==0.1.4 +rfc3986-validator==0.1.1 +rfc3987-syntax==1.1.0 +rich==15.0.0 +rpds-py==2026.6.3 +Send2Trash==2.1.0 +setuptools==84.0.0 +shellingham==1.5.4 +six==1.17.0 +soupsieve==2.9.2 +stack-data==0.6.3 +terminado==0.18.1 +tinycss2==1.4.0 +tornado==6.5.8 +traitlets==5.16.1 +typer==0.27.2 +typing_extensions==4.16.0 +typing_utils==0.1.0 +tzdata==2026.3 +uri-template==1.3.0 +urllib3==2.8.0 +wcwidth==0.8.4 +webcolors==25.10.0 +webencodings==0.5.1 +websocket-client==1.9.2 +wheel==0.48.0 +zipp==4.1.0 diff --git a/lite/env/kernelspecs-remove.txt b/lite/env/kernelspecs-remove.txt new file mode 100644 index 0000000..186d491 --- /dev/null +++ b/lite/env/kernelspecs-remove.txt @@ -0,0 +1,2 @@ +# kernel specs removed from the derived environments (the overlay ships xcpp23 only; xc23 is listed for a prefix that still has it) +xc23 diff --git a/lite/env/lazy-remove.txt b/lite/env/lazy-remove.txt new file mode 100644 index 0000000..3ac1794 --- /dev/null +++ b/lite/env/lazy-remove.txt @@ -0,0 +1,15 @@ +# packages the browser loads on first import (cppjit/kernel/lazy.py), not at kernel start: SciPy, matplotlib, pillow and +# what only they depend on (dependency closure of the three minus the start-up set, 2026-11-03) +scipy +matplotlib-base +pillow +contourpy +cycler +fonttools +kiwisolver +packaging +pyparsing +python-dateutil +python-tzdata +pytz +qhull diff --git a/lite/env/site-env.requirements.txt b/lite/env/site-env.requirements.txt new file mode 100644 index 0000000..b18d02a --- /dev/null +++ b/lite/env/site-env.requirements.txt @@ -0,0 +1,10 @@ +# host side of the site build (jupyter lite build + empack), pinned to the 2026-09-20 build environment +jupyterlite-core==0.8.3 +jupyterlite_xeus==5.0.0 +empack==6.0.1 +jupyterlab==4.6.3 +notebook==7.6.2 +jupyterlab_pygments==0.3.0 +jupyterlab_night==0.5.2 +jupyter_server==2.21.1 +libarchive-c==5.3 diff --git a/lite/env/slim-remove.txt b/lite/env/slim-remove.txt new file mode 100644 index 0000000..a6ec1b0 --- /dev/null +++ b/lite/env/slim-remove.txt @@ -0,0 +1,11 @@ +# conda-meta entries dropped from the kernel environment before packing (tools/setup-lite-env.sh): build-time only, +# nothing of them is needed by the running kernel (headers, CMake packages, the LLVM the kernel was linked against) +llvm +cpp-argparse +doctest +pugixml +pybind11 +pybind11_json +xtl +pip +pyjs-dev diff --git a/lite/env/xeus-kernels.explicit.txt b/lite/env/xeus-kernels.explicit.txt new file mode 100644 index 0000000..13bae82 --- /dev/null +++ b/lite/env/xeus-kernels.explicit.txt @@ -0,0 +1,44 @@ +# emscripten-wasm32 environment of the kernel build, 2026-11-03 (micromamba explicit list): emscripten-forge-4x llvm 23.1.2, +# emscripten-abi 4.0.9, python 3.13.1, numpy 2.5.4, scipy 1.18.0, matplotlib-base 3.11.2, pillow 13.0.0, xeus 6.0.6, xeus-lite 5.0.0 +# micromamba create -p --platform emscripten-wasm32 -f this-file +@EXPLICIT +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/bzip2-1.0.8-h8b79025_8.tar.bz2#8325fee5b7e0d2a1d75af8397687cf9b +https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.10.23-hbd8a1cb_0.conda#3fd02989038a1e1cee627c14c2d73f29 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/contourpy-1.4.0-py313hb0228bc_0.tar.bz2#eea2f1f6ca27c09a220d9fc74efa2194 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/cpp-argparse-3.2-h0b0027f_0.tar.bz2#126e5511c6576b4d7cf2856ccb088a15 +https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda#4c2a8fef270f6c69591889b93f9f55c1 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/doctest-2.5.3-hc780342_0.tar.bz2#348a3baeabcc1f7bc1e21f1659b2faa9 +https://prefix.dev/emscripten-forge-4x/noarch/emscripten-abi-4.0.9-h267e887_9.tar.bz2#25efc842dad2785871310cfa3499ca33 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/fonttools-4.39.4-py313h6d8a2ba_2.tar.bz2#b87eb6d771533c8ea7e530724e6e5679 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/kiwisolver-1.5.1-py313hb42c9ef_0.tar.bz2#f7b8e8ff6e83617f247af0326fa6db99 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/libffi-3.4.6-hb2bca66_0.tar.bz2#8dc6585ff5e0b995eb34366150cdb07b +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/llvm-23.1.2-hd68d874_0.tar.bz2#ab52f4094b96ae12f3ad13e9695cef7d +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/matplotlib-base-3.11.2-np23py313h397d816_2.tar.bz2#a068087926375a16f97297aa131e94cf +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/nlohmann_json-3.12.0-h0b0027f_0.tar.bz2#f37ddad2267d4f29f31984b28dd258cb +https://conda.anaconda.org/conda-forge/noarch/nlohmann_json-abi-3.12.0-h0f90c79_2.conda#849b8852621992c3f3a1901c939a0399 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/numpy-2.5.4-py313h9242c33_0.tar.bz2#9f9420971f9cd680414d980c47b2b473 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/openblas-0.3.34-h69b678e_4.tar.bz2#095501d496cd69a1c930dc9ede0f5508 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/openssl-3.6.2-hb2bca66_0.tar.bz2#3b3a27dc5fa52e897a7c766a2c1019ea +https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda#936687ed80f295a1f5dbcf8bd34c252c +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/pillow-13.0.0-py313hd87ed1a_0.tar.bz2#4829cd9d0bf7ac39ffa0a756ccf942d6 +https://conda.anaconda.org/conda-forge/noarch/pip-26.2.2-pyh145f28c_1.conda#63f4cc1f78c0da07623849c916ce71d7 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/pugixml-1.16-hc780342_0.tar.bz2#d6d96794651a1fe4cd4ed0fa56a3933e +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/pybind11-2.13.6-py313h313682a_1.tar.bz2#d9dc163913748c2b5498124953fdaa35 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/pybind11_json-0.2.15-py313h313682a_0.tar.bz2#d0e0c35efe155deece7956556bb39e88 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/pyjs-4.1.0-hc286ada_0.tar.bz2#c6baa0e6b2c0d96a013e11607bba1f2f +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/pyjs-dev-4.1.0-py313h06ab7c0_0.tar.bz2#bc2a013721c9937a8a00c5075482d8b5 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/pyjs-rt-4.1.0-py313h06ab7c0_0.tar.bz2#5865be596065b3c69ba0c8d9cd027130 +https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.3-pyh5ded981_0.conda#8bf43ae1312e9b966063459e04c20fa7 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/python-3.13.1-h_2efca29_11_cp313.tar.bz2#6541a249de9b863533e745bdeeb6d346 +https://conda.anaconda.org/conda-forge/noarch/python-dateutil-4.0.0-pyh5ded981_0.conda#32ce63457e76085c204f2db1ec8fef01 +https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2026.6-pyh5ded981_0.conda#cddcce875e2021c3a5b9dbecffb70d92 +https://conda.anaconda.org/conda-forge/noarch/python_abi-3.13-9_cp313.conda#c5abc97af551bc12d71305852392f75c +https://conda.anaconda.org/conda-forge/noarch/pytz-2026.6-pyh5ded981_0.conda#9b60b8aadafa78f7581c49a057764e7f +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/qhull-2020.2-h0b0027f_1.tar.bz2#d7d859c9b2182b224d795b6c9a6644d3 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/scipy-1.18.0-np23py313h8db5e5d_4.tar.bz2#ae860beb98ed1376f64408992991bbe1 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/sqlite-3.47.2-h640cba9_1.tar.bz2#6a126ba50f20242797e57ce7252ec1d1 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/xeus-6.0.6-hc780342_0.tar.bz2#02920c9fadcc096f6654223f19e3f3d0 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/xeus-lite-5.0.0-h0b0027f_0.tar.bz2#6389e93eac7ac6da67f1b54df37c7c31 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/xtl-0.8.2-h0b0027f_0.tar.bz2#0f1ab5cae41a48c05fa736a942ae5c81 +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/xz-5.8.4-hb9d79b4_0.tar.bz2#594cae2a66d8a0476a93a183448cba5a +https://prefix.dev/emscripten-forge-4x/emscripten-wasm32/zlib-1.3.2-h8b79025_0.tar.bz2#651e098a93f31fe5302c19a912944d5d diff --git a/lite/kernel/PATCHES.md b/lite/kernel/PATCHES.md new file mode 100644 index 0000000..95dbc77 --- /dev/null +++ b/lite/kernel/PATCHES.md @@ -0,0 +1,75 @@ +# The browser kernel's source patches + +The kernel and the native cppjit wheel are built from CppInterOp, cppjit, xeus-cpp and Clad at the commits in `README.md` +(Clad at 90a623d6, which carries vgvassilev/clad#2453: without it the kernel hung after any parse error), +with the patches below (`tools/build-wasm-kernel.sh` applies them with `git am -3`, in this order per project; the wheel +adds the three CppInterOp follow-ups of #830 that install Clad's runtime headers next to the library). + +**Not copied here.** The patches by Vipul Cariappa were written for `Vipul-Cariappa/jupyterlite-deploy` (commit 3379385, +2026-08-25), a repository without a licence file; the build script fetches them from +`https://github.com/Vipul-Cariappa/jupyterlite-deploy/tree/3379385/patches` (`PATCHES=` points at a local copy). Aaron +Jomy's change is CppInterOp pull request 1167; its diff (head of 2026-11-02) is `patches/cppinterop-000-...diff`, carried here +because CppInterOp is Apache-2.0 with LLVM exceptions. Of Vipul's CppInterOp patches, 002 is upstream +(#1157) and is skipped; his cppjit 001, 002, 004 and 005 are superseded on cppjit main (the external-CppInterOp path, the +RTLD_GLOBAL preload) and replaced by our `cppjit-001`; his 003 still applies and is used. + +**In `patches/`, under the repository licence** (ours): + +| patch | what it does | +|---|---| +| `cppinterop-000` | CppInterOp PR 1167, Enable Clad plugin in WASM (Aaron Jomy, Apache-2.0 with LLVM exceptions): Clad cross-built with a host clad-tblgen, headers at `/include` in the wasm filesystem | +| `cppinterop-001` | the clad cross-build no longer receives `-fwasm-exceptions` before LLVM's `-fno-exceptions` (emcc rejected the pair) | +| `cppinterop-002` | the static Emscripten library's CMake config carries the Clad archives, without a `--whole-archive` pair (which strips libc) | +| `cppjit-001` | libcppjit as a wasm side module against an external CppInterOp: wasm Python headers, `SIDE_MODULE`, virtual-filesystem paths | +| `cppjit-002` | `CPPJIT_ENABLE_CLAD`: the bundled CppInterOp built with the Clad plugin, its runtime headers shipped under `interop/include/clad` (the native wheel of the release) | +| `xeus-cpp-019` | WebGPU linked into the kernel, device handed over from `post.js` | +| `xeus-cpp-020` | cppjit's package layout (`cppjit/libcppjit.so`) and the Clad runtime headers preloaded at `/include/clad` | +| `xeus-cpp-021` | `libclangCppInterOp.so` listed in the kernel spec only when CppInterOp is a shared library | +| `xeus-cpp-022` | `XEUS_CPP_WASM_LINK_OPTIONS`, link options applied after xeus-lite's defaults | +| `xeus-cpp-023` | the preloaded filesystem leaves out the sysroot's graphics and audio headers, other architectures' intrinsics and a few stdlib modules (about 16 MB raw) | +| `cppinterop-followup-001`, `-002` | for the native wheel only: Clad's runtime headers found next to the installed library and installed with it (the three follow-ups of CppInterOp #830, less the Clad pin the build overrides); tests for the parse-error path, the gradient and `getCode` | + +**Referenced** (third party, applied by the build script): + +| patch | subject | author | +|---|---|---| +| `CppInterOp-001` | Let `Declare` target a specific interpreter | Vipul Cariappa | +| `CppInterOp-003` | Look symbols up by IR name when the linker name misses | Vipul Cariappa | +| `CppInterOp-004` | Do not inspect a nonexistent executable when initializing the dyld | Vipul Cariappa | +| `cppjit-003` | Key the string converters on the typedef spellings too | Vipul Cariappa | +| `xeus-cpp-001` | supporting cppyy | Vipul Cariappa | +| `xeus-cpp-002` | implement sub-interpreters | Vipul Cariappa | +| `xeus-cpp-003` | add example notebook | Vipul Cariappa | +| `xeus-cpp-004` | supporting cppyy | Vipul Cariappa | +| `xeus-cpp-005` | update the kernels.json.in | Vipul Cariappa | +| `xeus-cpp-006` | Drive the `%%python` magic with cppjit | Vipul Cariappa | +| `xeus-cpp-007` | Migrate to CppInterOp's typed handle API | Vipul Cariappa | +| `xeus-cpp-008` | Don't end a stream capture the failure path never began | Vipul Cariappa | +| `xeus-cpp-009` | Flush Python's stream buffers before ending the capture | Vipul Cariappa | +| `xeus-cpp-010` | Point the wasm kernel's embedded Python at cppjit | Vipul Cariappa | +| `xeus-cpp-011` | Say why `%%python` failed, and let Python run when cppjit will not | Vipul Cariappa | +| `xeus-cpp-012` | Stop a magic's argument from swallowing the cell's first line | Vipul Cariappa | +| `xeus-cpp-013` | Preload the CppInterOp headers the interpreter is told to use | Vipul Cariappa | +| `xeus-cpp-014` | Track the preloaded python files as link dependencies | Vipul Cariappa | +| `xeus-cpp-015` | Echo the value of a `%%python` cell's last expression | Vipul Cariappa | +| `xeus-cpp-016` | Preload the Python C-API headers | Vipul Cariappa | +| `xeus-cpp-017` | Ship only the C++23 and C23 kernels in the wasm build | Vipul Cariappa | +| `xeus-cpp-018` | Keep other kernels out of the wasm filesystem image | Vipul Cariappa | + +## Upstream status, checked 2026-11-03 + +Against the GitHub `main` branches (CppInterOp 8bf7250, cppjit 0332d76, xeus-cpp 65584a8, the pins) and the three +repositories' pull-request lists, by content, not by memory: + +| patch | upstream | +|---|---| +| Clad: discard after a repl error on clang >= 22 | merged, vgvassilev/clad#2453 (90a623d6, 2026-10-31); the pin includes it, nothing carried | +| Vipul `CppInterOp-002` (CppInterOp already in the process) | merged, compiler-research/CppInterOp#1157; not applied | +| `cppinterop-000` (PR 1167, Clad in wasm) | open, head b6411e3, unchanged since the copy; its CI rows fail (the next two rows) | +| `cppinterop-001`, `cppinterop-002` | not upstream; fixes for #1167, to go on that pull request. #1168 (open) moves `-flto` into the all-targets flags, which `cppinterop-001` strips for clad as well; compatible | +| `cppinterop-followup-001`, `-002` | not upstream (follow-ups of #830, still to be filed) | +| Vipul `CppInterOp-003` (symbol lookup by IR name) | open as compiler-research/CppInterOp#1158, grown beyond the referenced patch (DynamicLibraryManagerSymbol, tests); the referenced 2026-08 version is what the build applies | +| Vipul `CppInterOp-001`, `-004` | no pull request | +| `cppjit-001`, `cppjit-002`, Vipul `cppjit-003` | not upstream; cppjit main has no Emscripten support and no Clad option | +| `xeus-cpp-001` to `-018` (Vipul), `-019` to `-023` (ours) | not upstream; xeus-cpp main has no cppjit-hosted `%%python`, no sub-interpreters, no WebGPU link. compiler-research/xeus-cpp#499 (open) builds xeus-cpp as an LLVM external project for Emscripten and is unrelated | + diff --git a/lite/kernel/README.md b/lite/kernel/README.md new file mode 100644 index 0000000..a885b5d --- /dev/null +++ b/lite/kernel/README.md @@ -0,0 +1,21 @@ +# The browser kernel + +The xcpp23 kernel of the site is xeus-cpp on wasm32 hosting Python through cppjit, with Clad built into CppInterOp: a C++ +cell can call `clad::gradient` and a Python cell can do the same through `cppjit.cppdef`. Built on 2026-11-04 by +`tools/build-wasm-kernel.sh` with emsdk 4.0.9 against an LLVM 23 (release/23.x, 2875c607) built for wasm32 with the +ci-workflows `llvm-wasm` recipe: WebAssembly target only, -Oz, full LTO, `-mtail-call`, and emscripten-forge's two Clang +interpreter patches (`LLVM_WASM_DIR` in the script; `lite/README-build.md` has the measurements). The environment lock is +`lite/env/xeus-kernels.explicit.txt`; its emscripten-forge llvm package is what the script uses when `LLVM_WASM_DIR` is +unset, and what `build-kernel.yml` builds today (a kernel 8 MB larger on the wire, otherwise the same). + +Pins: CppInterOp main 8bf7250 (2026-10-31) plus pull request 1167, cppjit main 0332d76, xeus-cpp main 65584a8, Clad +90a623d6 (2026-10-31, the merge of vgvassilev/clad#2453). Patches: `PATCHES.md`. CppInterOp is a static library in this line (its #1149), so LLVM, Clang, +lld and Clad are inside `xcpp.wasm` and there is no separate CppInterOp module to fetch. + +The built kernel is the release asset `kernel-overlay-2026-11-03.tar.gz` of this repository: the files no conda package +owns (`xcpp.js`, `xcpp.wasm`, `xcpp.data`, the `xcpp23` kernel spec). `tools/setup-lite-env.sh` lays it over the locked +environment after checking it against `SHA256SUMS` here. The site itself never rebuilds the kernel. + +`xcpp.wasm` is linked at `-O1` and then passed through binaryen's `wasm-opt -Oz` on a machine with 12 GB of memory +(`tools/build-wasm-kernel.sh wasm-opt`); the two steps are separate because wasm-opt needs more memory than the build +container has. Numbers in `lite/README-build.md`. diff --git a/lite/kernel/SHA256SUMS b/lite/kernel/SHA256SUMS new file mode 100644 index 0000000..7f8f7d0 --- /dev/null +++ b/lite/kernel/SHA256SUMS @@ -0,0 +1,2 @@ +9c863ec09ddc44d6fc86e1817a5d0103fcc5dae08050f376ad6331b8f8421c17 kernel-overlay-2026-11-03.tar.gz +5aef1530c20ac6ddbfad6f1b78cd5926c7f92b45abbf88ad76a2ce13f3240808 cppjit-0.1.0b1.dev0-cp312-cp312-linux_x86_64.whl diff --git a/lite/kernel/patches/cppinterop-000-pr1167-enable-clad-plugin-in-wasm.diff b/lite/kernel/patches/cppinterop-000-pr1167-enable-clad-plugin-in-wasm.diff new file mode 100644 index 0000000..f2eeccc --- /dev/null +++ b/lite/kernel/patches/cppinterop-000-pr1167-enable-clad-plugin-in-wasm.diff @@ -0,0 +1,209 @@ +diff --git a/.github/actions/Build_and_Test_CppInterOp/action.yml b/.github/actions/Build_and_Test_CppInterOp/action.yml +index e603f791c..339a5a845 100644 +--- a/.github/actions/Build_and_Test_CppInterOp/action.yml ++++ b/.github/actions/Build_and_Test_CppInterOp/action.yml +@@ -312,6 +312,15 @@ runs: + echo "CPPINTEROP_TBLGEN_EXE=$CPPINTEROP_TBLGEN_EXE" >> $GITHUB_ENV + popd + ++ # clad-tblgen renders clad's option tables and cannot run in the cross build. ++ CLAD_TAG=$(sed -n 's/.*GIT_TAG \(.*\))$/\1/p' plugins/clad/CMakeLists.txt) ++ git clone --depth 1 --branch "$CLAD_TAG" https://github.com/vgvassilev/clad.git clad-src ++ CLAD_SOURCE_DIR=$PWD/clad-src ++ cmake -G Ninja -S $CLAD_SOURCE_DIR/utils/clad-tblgen -B clad_tblgen_build \ ++ -DLLVM_DIR=$NATIVE_LLVM_BUILD_DIR/lib/cmake/llvm ++ cmake --build clad_tblgen_build --target clad-tblgen ++ CLAD_TBLGEN_EXE=$PWD/clad_tblgen_build/clad-tblgen ++ + # Build CppInterOp next to cling and llvm-project. + # See native-shared site above re: stale build/ on local repro. + rm -rf build +@@ -333,6 +342,9 @@ runs: + -DLLVM_ENABLE_WERROR=On \ + -DSYSROOT_PATH=$SYSROOT_PATH \ + -DCPPINTEROP_TABLEGEN_EXE=$CPPINTEROP_TBLGEN_EXE \ ++ -DCPPINTEROP_ENABLE_CLAD=ON \ ++ -DCLAD_SOURCE_DIR=$CLAD_SOURCE_DIR \ ++ -DCLAD_TABLEGEN_EXE=$CLAD_TBLGEN_EXE \ + ../ + else + emcmake cmake -G Ninja -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }} \ +@@ -347,6 +359,9 @@ runs: + -DLLVM_ENABLE_WERROR=On \ + -DSYSROOT_PATH=$SYSROOT_PATH \ + -DCPPINTEROP_TABLEGEN_EXE=$CPPINTEROP_TBLGEN_EXE \ ++ -DCPPINTEROP_ENABLE_CLAD=ON \ ++ -DCLAD_SOURCE_DIR=$CLAD_SOURCE_DIR \ ++ -DCLAD_TABLEGEN_EXE=$CLAD_TBLGEN_EXE \ + ../ + fi + emmake ninja check-cppinterop +@@ -592,6 +607,15 @@ runs: + echo "CPPINTEROP_TBLGEN_EXE=$env:CPPINTEROP_TBLGEN_EXE" >> $env:GITHUB_ENV + popd + ++ # clad-tblgen renders clad's option tables and cannot run in the cross build. ++ $env:CLAD_TAG=(Select-String -Path plugins\clad\CMakeLists.txt -Pattern 'GIT_TAG (\S+)\)').Matches[0].Groups[1].Value ++ git clone --depth 1 --branch $env:CLAD_TAG https://github.com/vgvassilev/clad.git clad-src ++ $env:CLAD_SOURCE_DIR="$env:PWD_DIR/clad-src" ++ cmake -G Ninja -S "$env:CLAD_SOURCE_DIR/utils/clad-tblgen" -B clad_tblgen_build ` ++ -DLLVM_DIR="$env:NATIVE_LLVM_BUILD_DIR\lib\cmake\llvm" ++ cmake --build clad_tblgen_build --target clad-tblgen ++ $env:CLAD_TBLGEN_EXE = (Get-ChildItem -Path clad_tblgen_build -Recurse -Filter "clad-tblgen.exe" | Select-Object -First 1).FullName ++ + # Build CppInterOp next to cling and llvm-project. + # See bash sites above re: stale build/ on local repro paths. + # -G Ninja: emcmake's default on Windows is MinGW Makefiles, whose +@@ -617,6 +641,9 @@ runs: + -DLLVM_ENABLE_WERROR=On ` + -DSYSROOT_PATH="$env:SYSROOT_PATH" ` + -DCPPINTEROP_TABLEGEN_EXE="$env:CPPINTEROP_TBLGEN_EXE" ` ++ -DCPPINTEROP_ENABLE_CLAD=ON ` ++ -DCLAD_SOURCE_DIR="$env:CLAD_SOURCE_DIR" ` ++ -DCLAD_TABLEGEN_EXE="$env:CLAD_TBLGEN_EXE" ` + ..\ + } + else +@@ -633,6 +660,9 @@ runs: + -DLLVM_ENABLE_WERROR=On ` + -DSYSROOT_PATH="$env:SYSROOT_PATH" ` + -DCPPINTEROP_TABLEGEN_EXE="$env:CPPINTEROP_TBLGEN_EXE" ` ++ -DCPPINTEROP_ENABLE_CLAD=ON ` ++ -DCLAD_SOURCE_DIR="$env:CLAD_SOURCE_DIR" ` ++ -DCLAD_TABLEGEN_EXE="$env:CLAD_TBLGEN_EXE" ` + ..\ + } + function Error-OnFailure { +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 15105584d..4154fd5a5 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -34,9 +34,6 @@ endif() + # Clad plugin options + option(CPPINTEROP_ENABLE_CLAD "Enable the Clad automatic differentiation plugin." OFF) + set(CLAD_BUILD_TYPE "Release" CACHE STRING "Build type for clad plugins") +-if(EMSCRIPTEN AND CPPINTEROP_ENABLE_CLAD) +- message(FATAL_ERROR "CPPINTEROP_ENABLE_CLAD is not supported for Emscripten builds yet.") +-endif() + + if (CPPINTEROP_USE_CLING AND CPPINTEROP_USE_REPL) + message(FATAL_ERROR "We can only use Cling (${CPPINTEROP_USE_CLING}=On) or Repl (CPPINTEROP_USE_REPL=On), but not both of them.") +diff --git a/lib/CppInterOp/CMakeLists.txt b/lib/CppInterOp/CMakeLists.txt +index f5e6d1879..eea9adf8a 100644 +--- a/lib/CppInterOp/CMakeLists.txt ++++ b/lib/CppInterOp/CMakeLists.txt +@@ -423,9 +423,15 @@ set_source_files_properties(CppInterOp.cpp PROPERTIES COMPILE_DEFINITIONS + ) + + if(CPPINTEROP_ENABLE_CLAD) ++ if(EMSCRIPTEN) ++ # Wasm consumers stage the clad headers at /include in the Emscripten VFS. ++ set(_clad_runtime_include_dir "/include") ++ else() ++ set(_clad_runtime_include_dir "${CMAKE_BINARY_DIR}/plugins/clad/include/") ++ endif() + set_property(SOURCE CppInterOp.cpp APPEND PROPERTY COMPILE_DEFINITIONS + "CPPINTEROP_ENABLE_CLAD=1" +- "CLAD_INCLUDE_DIRS=\"${CMAKE_BINARY_DIR}/plugins/clad/include/\"" ++ "CLAD_INCLUDE_DIRS=\"${_clad_runtime_include_dir}\"" + ) + endif() + +diff --git a/plugins/clad/CMakeLists.txt b/plugins/clad/CMakeLists.txt +index ad3839eb5..3bef5edaf 100644 +--- a/plugins/clad/CMakeLists.txt ++++ b/plugins/clad/CMakeLists.txt +@@ -58,25 +58,50 @@ set(_clad_extra_settings + if (DEFINED CLAD_SOURCE_DIR) + message(STATUS "Using local clad source directory: ${CLAD_SOURCE_DIR}") + list(APPEND _clad_extra_settings SOURCE_DIR ${CLAD_SOURCE_DIR}) ++ set(_clad_source_dir ${CLAD_SOURCE_DIR}) + else() + list(APPEND _clad_extra_settings GIT_REPOSITORY https://github.com/vgvassilev/clad.git) + list(APPEND _clad_extra_settings GIT_TAG v2.5) ++ set(_clad_source_dir ${CMAKE_CURRENT_BINARY_DIR}/clad-prefix/src/clad) ++endif() ++ ++set(_clad_cmake_args ++ -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} ++ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} ++ -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} ++ -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} ++ -DCMAKE_CXX_FLAGS=${CLAD_CXX_FLAGS} ++ -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG} ++ -DCMAKE_INSTALL_PREFIX=${clad_install_dir} ++ -DLLVM_DIR=${LLVM_DIR} ++ -DClang_DIR=${CLANG_CMAKE_DIR} ++ ${_clad_extra_cmake_args} ++) ++ ++if(EMSCRIPTEN) ++ # clad renders its option and analysis tables with clad-tblgen, which a wasm ++ # build cannot run. Same contract as CPPINTEROP_TABLEGEN_EXE: hand the cross ++ # build a host tool, configured from clad's utils/clad-tblgen. ++ if(NOT CLAD_TABLEGEN_EXE) ++ message(FATAL_ERROR "Cross-compiling clad needs a native clad-tblgen: set " ++ "CLAD_TABLEGEN_EXE to one configured from clad's utils/clad-tblgen.") ++ endif() ++ list(APPEND _clad_cmake_args -DCLAD_TBLGEN=${CLAD_TABLEGEN_EXE}) ++ # The emscripten clangInterpreter links lldWasm; clad must find LLD before Clang. ++ set(_clad_configure ++ CONFIGURE_COMMAND emcmake${EMCC_SUFFIX} cmake -G ${CMAKE_GENERATOR} ++ -S ${_clad_source_dir} ++ -B ${CMAKE_CURRENT_BINARY_DIR}/clad-prefix/src/clad-build ++ -DLLD_DIR=${LLD_DIR} ++ ${_clad_cmake_args}) ++else() ++ set(_clad_configure CMAKE_ARGS -G ${CMAKE_GENERATOR} ${_clad_cmake_args}) + endif() + + ExternalProject_Add( + clad + UPDATE_COMMAND "" +- CMAKE_ARGS -G ${CMAKE_GENERATOR} +- -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} +- -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} +- -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} +- -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} +- -DCMAKE_CXX_FLAGS=${CLAD_CXX_FLAGS} +- -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG} +- -DCMAKE_INSTALL_PREFIX=${clad_install_dir} +- -DLLVM_DIR=${LLVM_DIR} +- -DClang_DIR=${CLANG_CMAKE_DIR} +- ${_clad_extra_cmake_args} ++ ${_clad_configure} + BUILD_COMMAND ${CMAKE_COMMAND} --build . ${EXTRA_BUILD_ARGS} --parallel + INSTALL_COMMAND ${CMAKE_COMMAND} --build . ${EXTRA_BUILD_ARGS} --target install + BUILD_BYPRODUCTS ${CLAD_BYPRODUCTS} +diff --git a/unittests/CppInterOp/CMakeLists.txt b/unittests/CppInterOp/CMakeLists.txt +index d86419207..c40a795c3 100644 +--- a/unittests/CppInterOp/CMakeLists.txt ++++ b/unittests/CppInterOp/CMakeLists.txt +@@ -36,6 +36,12 @@ if (EMSCRIPTEN) + "SHELL:--preload-file ${ESCAPED_SYSROOT_PATH}/include@/include" + "SHELL:--emrun" + ) ++ if (CPPINTEROP_ENABLE_CLAD) ++ string(REPLACE "@" "@@" ESCAPED_CLAD_INCLUDE_PATH "${CMAKE_BINARY_DIR}/plugins/clad/include") ++ list(APPEND CPPINTEROP_COMMON_WASM_TEST_LINK_FLAGS ++ "SHELL:--preload-file ${ESCAPED_CLAD_INCLUDE_PATH}@/include" ++ ) ++ endif() + endif() + + add_cppinterop_unittest(CppInterOpTests +diff --git a/unittests/CppInterOp/CladTest.cpp b/unittests/CppInterOp/CladTest.cpp +index 4e3efd24d..36ce16c04 100644 +--- a/unittests/CppInterOp/CladTest.cpp ++++ b/unittests/CppInterOp/CladTest.cpp +@@ -9,7 +9,9 @@ + using namespace TestUtils; + + TYPED_TEST(CPPINTEROP_TEST_MODE, CladTest_Sanity) { +- Cpp::CreateInterpreter({"-std=c++17"}, {}); ++ // clad headers reach libc++ locale internals under the sysroot compat dir. ++ Cpp::CreateInterpreter( ++ {"-std=c++17", "-Xclang", "-iwithsysroot/include/compat"}, {}); + + std::string code = R"( + #include "clad/Differentiator/Differentiator.h" diff --git a/lite/kernel/patches/cppinterop-001-Do-not-hand-the-wasm-exception-flags-to-the-clad-cro.patch b/lite/kernel/patches/cppinterop-001-Do-not-hand-the-wasm-exception-flags-to-the-clad-cro.patch new file mode 100644 index 0000000..16f1448 --- /dev/null +++ b/lite/kernel/patches/cppinterop-001-Do-not-hand-the-wasm-exception-flags-to-the-clad-cro.patch @@ -0,0 +1,48 @@ +From de7e25188185e5107b7676ecf402bd5ea7c54974 Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Mon, 2 Nov 2026 18:26:58 +0000 +Subject: [PATCH 1/2] Do not hand the wasm exception flags to the clad + cross-build + +Follow-up to 'Enable Clad plugin in WASM' (PR 1167). With emsdk 4.0.9 the +clad sub-build fails on every object: CMAKE_CXX_FLAGS carries +-fwasm-exceptions, add_llvm_library appends -fno-exceptions after it, emcc +takes the last word, selects the emscripten setjmp/longjmp lowering, and +clang rejects '-fwasm-exceptions' alongside '-enable-emscripten-sjlj'. +clangCppInterOp does not hit this because its flag is added per target, +after LLVM's. The ExternalProject logs hide the error (LOG_BUILD ON), so +the CI row only reports the exit code. + +Build clad as LLVM itself is built, without exceptions; the exception model +belongs to the link of clangCppInterOp and the kernel. + +Co-Authored-By: Claude Fable 5.1 +--- + plugins/clad/CMakeLists.txt | 11 +++++++++++ + 1 file changed, 11 insertions(+) + +diff --git a/plugins/clad/CMakeLists.txt b/plugins/clad/CMakeLists.txt +index 3bef5ed..4965514 100644 +--- a/plugins/clad/CMakeLists.txt ++++ b/plugins/clad/CMakeLists.txt +@@ -5,6 +5,17 @@ set(clad_install_dir ${CMAKE_BINARY_DIR}/plugins/clad/) + set(CLAD_INCLUDE_DIRS ${clad_install_dir}) + # Clad Libraries + set(CLAD_CXX_FLAGS ${CMAKE_CXX_FLAGS}) ++if(EMSCRIPTEN AND CPPINTEROP_EXTRA_WASM_FLAGS) ++ # clad's archives are LLVM-style targets: add_llvm_library appends ++ # -fno-exceptions after these flags, and emcc then reads exceptions as ++ # disabled while -fwasm-exceptions is still on the line, picks the ++ # emscripten setjmp/longjmp lowering and clang rejects the pair ++ # ("-fwasm-exceptions not allowed with -enable-emscripten-sjlj"). Build ++ # clad as LLVM itself is built, without exceptions; the exception model ++ # is decided where clangCppInterOp and the kernel are linked. ++ string(REPLACE "${CPPINTEROP_EXTRA_WASM_FLAGS}" "" CLAD_CXX_FLAGS "${CLAD_CXX_FLAGS}") ++ string(STRIP "${CLAD_CXX_FLAGS}" CLAD_CXX_FLAGS) ++endif() + set(_clad_build_type ${CLAD_BUILD_TYPE}) + if(MSVC AND NOT CMAKE_GENERATOR MATCHES Ninja) + if (winrtdebug) +-- +2.55.0 + diff --git a/lite/kernel/patches/cppinterop-002-Carry-the-Clad-archives-in-the-static-Emscripten-lin.patch b/lite/kernel/patches/cppinterop-002-Carry-the-Clad-archives-in-the-static-Emscripten-lin.patch new file mode 100644 index 0000000..65c132d --- /dev/null +++ b/lite/kernel/patches/cppinterop-002-Carry-the-Clad-archives-in-the-static-Emscripten-lin.patch @@ -0,0 +1,76 @@ +From 448c002f0d5cdb796a819998cc8ce75c5d02707d Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Mon, 2 Nov 2026 18:47:27 +0000 +Subject: [PATCH 2/2] Carry the Clad archives in the static Emscripten link + interface + +Follow-up to 'Enable Clad plugin in WASM' (PR 1167). The shared library +links cladPlugin and cladDifferentiator whole-archive itself; the static +Emscripten library leaves that to its consumer, but CppInterOpConfig.cmake +listed only the LLVM and Clang archives, so an external kernel linked +without the plugin and nothing registered it. The unit tests do not notice: +they link the target inside the build tree, where LINK_LIBS propagates. + +Put the two archives at the front of the exported link interface and +install them beside libclangCppInterOp.a. They go in without a +--whole-archive pair: emcc wraps a MAIN_MODULE=1 or SIDE_MODULE=1 link in +one --whole-archive of its own and the flags do not nest, so a +--no-whole-archive in the middle strips every system library after it down +to the referenced members, and numpy's extension then fails to load for +want of acosf. A consumer that links without LINKABLE wraps the two +archives itself. + +Co-Authored-By: Claude Fable 5.1 +--- + lib/CppInterOp/CMakeLists.txt | 15 +++++++++++++++ + plugins/clad/CMakeLists.txt | 9 +++++++++ + 2 files changed, 24 insertions(+) + +diff --git a/lib/CppInterOp/CMakeLists.txt b/lib/CppInterOp/CMakeLists.txt +index eea9adf..8c7512b 100644 +--- a/lib/CppInterOp/CMakeLists.txt ++++ b/lib/CppInterOp/CMakeLists.txt +@@ -370,6 +370,21 @@ if(EMSCRIPTEN) + endfunction() + + get_recursive_interface_libs(_cppinterop_interface_libs ${link_libs}) ++ if(CPPINTEROP_ENABLE_CLAD) ++ # A shared clangCppInterOp links the plugin archives whole-archive itself; ++ # a static one hands that duty to its consumer, so the link interface has ++ # to carry them, ahead of the LLVM and Clang archives they draw on. The ++ # archives install beside the library (plugins/clad). No --whole-archive ++ # pair here: emcc wraps a MAIN_MODULE=1 / SIDE_MODULE=1 link in one ++ # --whole-archive of its own and the flags do not nest, so a ++ # --no-whole-archive in the middle would strip every system library that ++ # follows down to the referenced members (numpy then fails to load for ++ # want of acosf). A consumer that links without LINKABLE must wrap these ++ # two archives itself so the plugin's static registration survives. ++ list(PREPEND _cppinterop_interface_libs ++ "${CMAKE_INSTALL_PREFIX}/lib${LLVM_LIBDIR_SUFFIX}/${CMAKE_STATIC_LIBRARY_PREFIX}cladPlugin${CMAKE_STATIC_LIBRARY_SUFFIX}" ++ "${CMAKE_INSTALL_PREFIX}/lib${LLVM_LIBDIR_SUFFIX}/${CMAKE_STATIC_LIBRARY_PREFIX}cladDifferentiator${CMAKE_STATIC_LIBRARY_SUFFIX}") ++ endif() + set(CPPINTEROP_CONFIG_INTERFACE_LIBS + "INTERFACE_LINK_LIBRARIES \"${_cppinterop_interface_libs}\"" CACHE INTERNAL + "Link interface of the static Emscripten clangCppInterOp") +diff --git a/plugins/clad/CMakeLists.txt b/plugins/clad/CMakeLists.txt +index 4965514..3d3275a 100644 +--- a/plugins/clad/CMakeLists.txt ++++ b/plugins/clad/CMakeLists.txt +@@ -125,5 +125,14 @@ foreach (lib cladPlugin cladDifferentiator) + add_dependencies(${lib} clad) + endforeach() + ++# A static clangCppInterOp (Emscripten) leaves the whole-archive link of the ++# plugin to its consumer; the archives have to be where its CMake config says. ++if(CPPINTEROP_INSTALL AND NOT BUILD_SHARED_LIBS) ++ install(FILES ++ ${_CLAD_LIBRARY_PATH}/${CMAKE_STATIC_LIBRARY_PREFIX}cladPlugin${CMAKE_STATIC_LIBRARY_SUFFIX} ++ ${_CLAD_LIBRARY_PATH}/${CMAKE_STATIC_LIBRARY_PREFIX}cladDifferentiator${CMAKE_STATIC_LIBRARY_SUFFIX} ++ DESTINATION lib${LLVM_LIBDIR_SUFFIX}) ++endif() ++ + set_property(TARGET cladPlugin PROPERTY IMPORTED_LOCATION ${_CLAD_LIBRARY_PATH}/${CMAKE_STATIC_LIBRARY_PREFIX}cladPlugin${CMAKE_STATIC_LIBRARY_SUFFIX}) + set_property(TARGET cladDifferentiator PROPERTY IMPORTED_LOCATION ${_CLAD_LIBRARY_PATH}/${CMAKE_STATIC_LIBRARY_PREFIX}cladDifferentiator${CMAKE_STATIC_LIBRARY_SUFFIX}) +-- +2.55.0 + diff --git a/lite/kernel/patches/cppinterop-followup-001-Clad-plugin-find-Clad-s-runtime-headers-next-to-the-.patch b/lite/kernel/patches/cppinterop-followup-001-Clad-plugin-find-Clad-s-runtime-headers-next-to-the-.patch new file mode 100644 index 0000000..7fc0b01 --- /dev/null +++ b/lite/kernel/patches/cppinterop-followup-001-Clad-plugin-find-Clad-s-runtime-headers-next-to-the-.patch @@ -0,0 +1,82 @@ +From 65d4ebfd7915927fd66c9a5d794f9e49c3b1ed94 Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Sat, 31 Oct 2026 17:10:56 +0000 +Subject: [PATCH 1/2] Clad plugin: find Clad's runtime headers next to the + installed library, and install them + +CLAD_INCLUDE_DIRS is the build tree's staging directory; once the library is installed or packaged (a wheel, a +kernel) that path no longer exists. CreateInterpreter now prefers the configure-time directory when it exists and +otherwise looks for /include/clad relative to the library's own location, the way the Clang resource +directory is found. The headers are installed with the library under CPPINTEROP_INSTALL. + +Verified: a program linked against the installed tree, with the build tree's headers removed, includes +clad/Differentiator/Differentiator.h and differentiates; without the installed headers it fails as expected. + +Co-Authored-By: Claude Fable 5.1 +--- + CMakeLists.txt | 6 ++++++ + lib/CppInterOp/CppInterOp.cpp | 24 +++++++++++++++++++++++- + 2 files changed, 29 insertions(+), 1 deletion(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 4154fd5..420ccf9 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -629,6 +629,12 @@ if(CPPINTEROP_ENABLE_CLAD) + message(STATUS "Clad build type: ${CLAD_BUILD_TYPE}") + add_subdirectory(plugins/clad) + endif() ++if(CPPINTEROP_ENABLE_CLAD AND CPPINTEROP_INSTALL) ++ # Clad's runtime headers travel with the library: CreateInterpreter finds ++ # them next to it (/include/clad) when the build tree is gone. ++ install(DIRECTORY ${CMAKE_BINARY_DIR}/plugins/clad/include/clad ++ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) ++endif() + add_subdirectory(lib) + + configure_file( +diff --git a/lib/CppInterOp/CppInterOp.cpp b/lib/CppInterOp/CppInterOp.cpp +index 6082d35..be2e789 100644 +--- a/lib/CppInterOp/CppInterOp.cpp ++++ b/lib/CppInterOp/CppInterOp.cpp +@@ -5868,6 +5868,28 @@ static bool exec(const char* cmd, std::vector& outputs) { + return true; + } + ++#ifdef CPPINTEROP_ENABLE_CLAD ++// Clad is linked in statically and attaches to the frontend through its own ++// plugin registration; only its runtime headers need to be found. Prefer the ++// configure-time location (the build tree); when the library has been ++// installed or packaged elsewhere, look next to it: /lib/ ++// -> /include/clad. ++static std::string CladIncludeDir() { ++ if (llvm::sys::fs::is_directory(CLAD_INCLUDE_DIRS)) ++ return CLAD_INCLUDE_DIRS; ++ void* Addr = (void*)(intptr_t)&CladIncludeDir; ++ std::string Lib = llvm::sys::fs::getMainExecutable(/*argv0=*/nullptr, Addr); ++ llvm::SmallString<256> P( ++ llvm::sys::path::parent_path(llvm::sys::path::parent_path(Lib))); ++ llvm::sys::path::append(P, "include"); ++ llvm::SmallString<256> Probe(P); ++ llvm::sys::path::append(Probe, "clad", "Differentiator", "Differentiator.h"); ++ if (llvm::sys::fs::exists(Probe)) ++ return std::string(P.str()); ++ return CLAD_INCLUDE_DIRS; ++} ++#endif ++ + InterpRef CreateInterpreter(const std::vector& Args /*={}*/, + const std::vector& GpuArgs /*={}*/) { + INTEROP_TRACE(Args, GpuArgs); +@@ -6067,7 +6089,7 @@ InterpRef CreateInterpreter(const std::vector& Args /*={}*/, + // clad is linked in statically and attaches to the frontend via its + // AddAfterMainAction plugin registration; its runtime headers are staged + // in the build tree (plugins/clad/include), not on any default path. +- I->AddIncludePath(CLAD_INCLUDE_DIRS); ++ I->AddIncludePath(CladIncludeDir().c_str()); + #endif + return INTEROP_RETURN(I); + } +-- +2.55.0 + diff --git a/lite/kernel/patches/cppinterop-followup-002-Clad-plugin-tests-for-the-paths-that-crashed-parse-e.patch b/lite/kernel/patches/cppinterop-followup-002-Clad-plugin-tests-for-the-paths-that-crashed-parse-e.patch new file mode 100644 index 0000000..49f6926 --- /dev/null +++ b/lite/kernel/patches/cppinterop-followup-002-Clad-plugin-tests-for-the-paths-that-crashed-parse-e.patch @@ -0,0 +1,55 @@ +From 543bf0bf622cb16cc2ed6f24a828be0870f2b70e Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Sat, 31 Oct 2026 17:10:56 +0000 +Subject: [PATCH 2/2] Clad plugin: tests for the paths that crashed (parse + error, then differentiate), the gradient and getCode + +Co-Authored-By: Claude Fable 5.1 +--- + unittests/CppInterOp/CladTest.cpp | 33 +++++++++++++++++++++++++++++++ + 1 file changed, 33 insertions(+) + +diff --git a/unittests/CppInterOp/CladTest.cpp b/unittests/CppInterOp/CladTest.cpp +index 36ce16c..72ea9b9 100644 +--- a/unittests/CppInterOp/CladTest.cpp ++++ b/unittests/CppInterOp/CladTest.cpp +@@ -23,3 +23,36 @@ TYPED_TEST(CPPINTEROP_TEST_MODE, CladTest_Sanity) { + .unbox(), + 6.); + } ++ ++TYPED_TEST(CPPINTEROP_TEST_MODE, CladTest_AfterParseError) { ++ // a parse error discards the current PTU; Clad's queued calls must not be ++ // replayed over it (clad #1944, LLVM #182044) ++ Cpp::CreateInterpreter({"-std=c++17"}, {}); ++ EXPECT_EQ(Cpp::Declare(R"( ++ #include "clad/Differentiator/Differentiator.h" ++ static double poly(double x, double y) { return x * x * y + 3.0 * y; } ++ )"), ++ 0); ++ EXPECT_NE(Cpp::Declare("double broken( { return 1; }"), 0); ++ EXPECT_EQ(Cpp::Evaluate(R"(clad::differentiate(poly, "y").execute(2.0, 5.0))") ++ .unbox(), ++ 7.); ++} ++ ++TYPED_TEST(CPPINTEROP_TEST_MODE, CladTest_GradientAndCode) { ++ Cpp::CreateInterpreter({"-std=c++17"}, {}); ++ EXPECT_EQ(Cpp::Declare(R"( ++ #include "clad/Differentiator/Differentiator.h" ++ #include ++ static double poly(double x, double y) { return x * x * y + 3.0 * y; } ++ auto g = clad::gradient(poly); ++ double gx = 0, gy = 0; ++ std::string code = clad::differentiate(poly, "x").getCode(); ++ )"), ++ 0); ++ EXPECT_EQ(Cpp::Process("g.execute(2.0, 5.0, &gx, &gy);"), 0); ++ EXPECT_EQ(Cpp::Evaluate("gx").unbox(), 20.); ++ EXPECT_EQ(Cpp::Evaluate("gy").unbox(), 7.); ++ EXPECT_EQ(Cpp::Evaluate("code.find(\"poly_darg0\") != std::string::npos").unbox(), ++ true); ++} +-- +2.55.0 + diff --git a/lite/kernel/patches/cppjit-001-wasm-side-module.patch b/lite/kernel/patches/cppjit-001-wasm-side-module.patch new file mode 100644 index 0000000..4a1e04d --- /dev/null +++ b/lite/kernel/patches/cppjit-001-wasm-side-module.patch @@ -0,0 +1,162 @@ +From efeed25acd988e5db0282a434f41ea10482a10c4 Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Mon, 2 Nov 2026 18:21:22 +0000 +Subject: [PATCH] Build libcppjit as a wasm side module against an external + CppInterOp + +A cross build to emscripten cannot satisfy three host assumptions. Python: +find_package(Python ... Development.Module) resolves the host interpreter, +whose headers are the wrong architecture; take the headers from the wasm +CPython in the emscripten prefix and link no libpython -- a side module +leaves the CPython symbols for the embedding main module to resolve. +Target: emscripten's CMake platform module declares no shared-library +support, so a SHARED target would quietly become static; libcppjit.so is a +SIDE_MODULE with the exception model CppInterOp and the kernel use. Paths: +inside the kernel the CppInterOp library is the name the main module +records its dependency under, and the headers are where the kernel preloaded +them, not host paths of the configure-time prefix. + +The external-CppInterOp path (CppInterOp_DIR / CMAKE_PREFIX_PATH) already +exists; this reuses it and only replaces the baked runtime coordinates. +Under emscripten the libstdc++ lookup is skipped: the standard library is +libc++ linked into the hosting module, and the name would resolve to a 404 +page the loader then rejects. + +Rewrites Vipul Cariappa's patches 001, 002, 004 (August 2026, cppjit 5a33027) +over the restructured CppInterOp acquisition on main. + +Co-Authored-By: Claude Fable 5.1 +--- + CMakeLists.txt | 81 +++++++++++++++++++++++++++++---- + src/interop/interop_wrapper.cxx | 6 +++ + 2 files changed, 79 insertions(+), 8 deletions(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 62b656f..fe19000 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -15,16 +15,49 @@ set(CPPINTEROP_GIT_TAG "d3c8cf7aff7796e1539582f8e52910f351a48977" CACHE STRING " + set(CPPINTEROP_SOURCE_DIR "" CACHE PATH + "Override default CppInterOp built by ExternalProject_Add, with a path to local CppInterOp source") + +-# The full Development component requires libpython, which manylinux +-# images do not ship and extension modules do not need. +-set(Python_FIND_VIRTUALENV ONLY) +-find_package(Python COMPONENTS Interpreter Development.Module) +-if(NOT Python_FOUND) ++if(EMSCRIPTEN) ++ # Cross-compiling: the host interpreter only answers cmake-time queries. ++ # The headers to compile against are the wasm CPython's in the emscripten ++ # prefix, and a side module links no libpython at all -- the CPython ++ # symbols stay undefined for the main module that embeds the interpreter. + set(Python_FIND_VIRTUALENV STANDARD) ++ find_package(Python COMPONENTS Interpreter REQUIRED) ++ set(CPPJIT_WASM_PYTHON_INCLUDE_DIR "" CACHE PATH ++ "Include directory of the wasm CPython to compile against; searched under CMAKE_PREFIX_PATH when empty") ++ if(NOT CPPJIT_WASM_PYTHON_INCLUDE_DIR) ++ foreach(_prefix IN LISTS CMAKE_PREFIX_PATH CMAKE_SYSTEM_PREFIX_PATH) ++ file(GLOB _candidates "${_prefix}/include/python3.*") ++ foreach(_candidate IN LISTS _candidates) ++ if(EXISTS "${_candidate}/Python.h") ++ set(CPPJIT_WASM_PYTHON_INCLUDE_DIR "${_candidate}") ++ break() ++ endif() ++ endforeach() ++ if(CPPJIT_WASM_PYTHON_INCLUDE_DIR) ++ break() ++ endif() ++ endforeach() ++ endif() ++ if(NOT CPPJIT_WASM_PYTHON_INCLUDE_DIR) ++ message(FATAL_ERROR ++ "No wasm CPython headers found. Install a python package for " ++ "emscripten-wasm32 into the prefix on CMAKE_PREFIX_PATH, or pass " ++ "-DCPPJIT_WASM_PYTHON_INCLUDE_DIR=/include/python3.x") ++ endif() ++ message(STATUS "Wasm CPython headers: ${CPPJIT_WASM_PYTHON_INCLUDE_DIR}") ++ set(Python_INCLUDE_DIRS "${CPPJIT_WASM_PYTHON_INCLUDE_DIR}") ++else() ++ # The full Development component requires libpython, which manylinux ++ # images do not ship and extension modules do not need. ++ set(Python_FIND_VIRTUALENV ONLY) + find_package(Python COMPONENTS Interpreter Development.Module) +-endif() +-if(NOT Python_Development.Module_FOUND) +- message(FATAL_ERROR "Python development headers not found") ++ if(NOT Python_FOUND) ++ set(Python_FIND_VIRTUALENV STANDARD) ++ find_package(Python COMPONENTS Interpreter Development.Module) ++ endif() ++ if(NOT Python_Development.Module_FOUND) ++ message(FATAL_ERROR "Python development headers not found") ++ endif() + endif() + + # The LLVM range the pinned CppInterOp supports. Update it with the tag. +@@ -55,6 +88,26 @@ set(CPPINTEROP_STAGE_DIR "${CMAKE_BINARY_DIR}/interop") + include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/AddCppInterOp.cmake) + cppjit_add_cppinterop() + ++if(EMSCRIPTEN) ++ # Inside the kernel the coordinates are virtual-filesystem paths, not the ++ # host paths of the prefix cppjit was configured against. The library is ++ # named the way the kernel's main module records its dependency, so dlopen ++ # hands back that module instead of loading a second copy of CppInterOp ++ # (and with it a second interpreter); the headers live where the kernel ++ # preloaded them. No anchor: an empty prefix leaves the names bare. ++ if(NOT TARGET CppInterOp) ++ set(CPPINTEROP_INSTALL_PREFIX "") ++ set(CPPJIT_INTEROP_LIBRARY "libclangCppInterOp.so" CACHE STRING ++ "Library name cppjit dlopens CppInterOp through inside the wasm kernel") ++ set(CPPJIT_INTEROP_RUNTIME_INCLUDES "/include" CACHE STRING ++ "Include directories (':'-joined) cppjit hands the interpreter inside the wasm kernel") ++ set(CPPJIT_INTEROP_CLANG_DIR "") ++ endif() ++ # The emscripten CMake platform module declares no shared-library support, ++ # so a SHARED target would silently become static. ++ set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS TRUE) ++endif() ++ + # this libcppjit.so merges both cpyrt and the interop wrapper + file(GLOB CPYRT_SOURCES CONFIGURE_DEPENDS src/cpyrt/*.cxx) + set(INTEROP_SOURCES +@@ -67,6 +120,18 @@ if(TARGET CppInterOp) + add_dependencies(cppjit CppInterOp) + endif() + ++if(EMSCRIPTEN) ++ # libcppjit.so is a wasm side module the kernel's embedded CPython dlopens. ++ # Its libpython and CppInterOp symbols stay undefined on purpose: the main ++ # module carries both. The exception model has to match the one CppInterOp ++ # and the kernel were built with, or the tables do not line up. ++ set(CPPJIT_WASM_FLAGS "-fPIC;-fwasm-exceptions" CACHE STRING ++ "Compiler and linker flags of the wasm side module") ++ target_compile_options(cppjit PRIVATE ${CPPJIT_WASM_FLAGS}) ++ target_link_options(cppjit PRIVATE ${CPPJIT_WASM_FLAGS} -sSIDE_MODULE=1) ++ set_target_properties(cppjit PROPERTIES SUFFIX ".so") ++endif() ++ + # The wrapper anchors these coordinates at its own load location, falling + # back to the install prefix (see cppinterop_paths()); the clang major + # names the versioned compiler probed for the runtime resource dir. +diff --git a/src/interop/interop_wrapper.cxx b/src/interop/interop_wrapper.cxx +index 822983b..2f0a9fd 100644 +--- a/src/interop/interop_wrapper.cxx ++++ b/src/interop/interop_wrapper.cxx +@@ -232,7 +232,13 @@ static void configureInterpreter(const InterOpPaths& Paths) { + + for (const std::string& dir : Paths.IncludeDirs) + Cpp::AddIncludePath(dir.c_str()); ++#ifndef __EMSCRIPTEN__ ++ // Nothing to load under emscripten: the standard library there is libc++, ++ // linked into the hosting module. The name would also resolve to something ++ // fetchable that is not wasm (a 404 page), so the loader reports "need to ++ // see wasm magic number" and leaves a failed entry behind. + Cpp::LoadLibrary("libstdc++", /* lookup= */ true); ++#endif + } + + static bool preloadHeaders() { +-- +2.55.0 + diff --git a/lite/kernel/patches/cppjit-002-Build-the-bundled-CppInterOp-with-Clad-on-request.patch b/lite/kernel/patches/cppjit-002-Build-the-bundled-CppInterOp-with-Clad-on-request.patch new file mode 100644 index 0000000..6983c7d --- /dev/null +++ b/lite/kernel/patches/cppjit-002-Build-the-bundled-CppInterOp-with-Clad-on-request.patch @@ -0,0 +1,69 @@ +From e926f961ae35569a552abd5d7ef3f61f7a66a07d Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Tue, 3 Nov 2026 09:18:00 +0000 +Subject: [PATCH] Build the bundled CppInterOp with Clad on request + +CPPJIT_ENABLE_CLAD forwards CPPINTEROP_ENABLE_CLAD (and CPPJIT_CLAD_SOURCE_DIR +as CLAD_SOURCE_DIR) to the CppInterOp sub-build and runs its whole install, +since the plugin's runtime headers belong to no install component; they +then ship under interop/include/clad and clad::gradient works in the +session of a pip-installed cppjit. Off by default; an external CppInterOp +is left to its own build. + +Co-Authored-By: Claude Fable 5.1 +--- + cmake/AddCppInterOp.cmake | 20 +++++++++++++++++--- + 1 file changed, 17 insertions(+), 3 deletions(-) + +diff --git a/cmake/AddCppInterOp.cmake b/cmake/AddCppInterOp.cmake +index 59b397b..8acdc8a 100644 +--- a/cmake/AddCppInterOp.cmake ++++ b/cmake/AddCppInterOp.cmake +@@ -23,6 +23,10 @@ endif() + + # Developer toggle: Cling from either ROOT or standalone supplies LLVM_DIR/Clang_DIR + option(CPPJIT_USE_CLING "Build CppInterOp against a prebuilt Cling C++ Interpreter (ROOT)" OFF) ++# Clad inside the bundled CppInterOp (CPPINTEROP_ENABLE_CLAD): clad::gradient works in the session and the Clad ++# runtime headers ship under interop/include/clad. Not for an external CppInterOp (its build decides). ++option(CPPJIT_ENABLE_CLAD "Build the bundled CppInterOp with the Clad plugin" OFF) ++set(CPPJIT_CLAD_SOURCE_DIR "" CACHE PATH "Clad checkout for the plugin; CppInterOp's pinned Clad when empty") + mark_as_advanced(CPPJIT_USE_CLING) + + set(Cling_DIR "" CACHE PATH "Cling CMake config dir; derived from LLVM_DIR when empty (cling mode only)") +@@ -161,6 +165,12 @@ function(cppjit_add_cppinterop) + if(Clang_DIR) + list(APPEND _args -DClang_DIR=${Clang_DIR}) + endif() ++ if(CPPJIT_ENABLE_CLAD) ++ list(APPEND _args -DCPPINTEROP_ENABLE_CLAD=ON) ++ if(CPPJIT_CLAD_SOURCE_DIR) ++ list(APPEND _args -DCLAD_SOURCE_DIR=${CPPJIT_CLAD_SOURCE_DIR}) ++ endif() ++ endif() + if(CMAKE_C_COMPILER) + list(APPEND _args -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}) + endif() +@@ -201,13 +211,17 @@ function(cppjit_add_cppinterop) + string(APPEND _install_lib_target "-stripped") + endif() + +- # Install only the library and headers, not CppInterOp's full install tree. ++ # Install only the library and headers, not CppInterOp's full install tree. With Clad the plugin's runtime ++ # headers (include/clad) belong to no install component, so the whole install runs. ++ set(_install_targets ${_install_lib_target} install-cppinterop-headers) ++ if(CPPJIT_ENABLE_CLAD) ++ set(_install_targets install/strip) ++ endif() + ExternalProject_Add(CppInterOp + ${_source_args} + PREFIX "${CMAKE_BINARY_DIR}/CppInterOp" + CMAKE_ARGS ${_args} +- INSTALL_COMMAND ${CMAKE_COMMAND} --build +- --target ${_install_lib_target} install-cppinterop-headers ++ INSTALL_COMMAND ${CMAKE_COMMAND} --build --target ${_install_targets} + BUILD_BYPRODUCTS + "${CPPINTEROP_STAGE_DIR}/lib/libclangCppInterOp${CMAKE_SHARED_LIBRARY_SUFFIX}" + ${_log_args} +-- +2.55.0 + diff --git a/lite/kernel/patches/xeus-cpp-019-webgpu.patch b/lite/kernel/patches/xeus-cpp-019-webgpu.patch new file mode 100644 index 0000000..e69a32f --- /dev/null +++ b/lite/kernel/patches/xeus-cpp-019-webgpu.patch @@ -0,0 +1,93 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Sun, 20 Sep 2026 08:32:00 +0000 +Subject: [PATCH] Link WebGPU into the wasm kernel and hand a device over from + post.js + +A cell compiled in the browser is a side module that resolves against the +kernel's exports, and this main module exports everything it links. It links +WebGL today and no WebGPU, so wgpu* is unreachable from any cell even though + is already in the preloaded sysroot. + +Add -sUSE_WEBGPU=1 to the xcpp link -- the legacy library_webgpu.js that +emsdk 4.0.9 ships; the emdawnwebgpu port would need a newer emsdk and move +emscripten-abi for the whole environment -- and request adapter and device in +post.js, in the kernel's worker, storing the device where +emscripten_webgpu_get_device() looks for it. Module.webgpuReady lets a cell +tell "no WebGPU here" from "not ready yet". + +WGSL is f32-only. Untested at runtime from the authoring machine, which has no +navigator.gpu; see the SC26 tree's act3/webgpu_logistic.cpp for the cell. +--- + CMakeLists.txt | 10 ++++++++++ + wasm_patches/post.js | 38 +++++++++++++++++++++++++++++++++++++- + 2 files changed, 47 insertions(+), 1 deletion(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 47e3af2..e66efb9 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -516,6 +516,16 @@ if(EMSCRIPTEN) + xeus_cpp_set_kernel_options(xcpp) + xeus_wasm_compile_options(xcpp) + xeus_wasm_link_options(xcpp "web,worker") ++ # Rung 2 (SC26): link Emscripten's WebGPU binding into the main module so a ++ # JIT'd cell -- a side module resolving against these exports -- can reach ++ # wgpu* through , which the preloaded sysroot already ++ # carries. On emsdk 4.0.9 this is the legacy library_webgpu.js; the ++ # emdawnwebgpu port needs a newer emsdk and would move emscripten-abi for ++ # the whole environment. The device is handed over from post.js. ++ target_link_options(xcpp PUBLIC "SHELL: -sUSE_WEBGPU=1") ++ # post.js is a link input (--post-js); without this, editing it does not ++ # relink and a rebuilt kernel silently ships the old glue. ++ set_property(TARGET xcpp APPEND PROPERTY LINK_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/wasm_patches/post.js") + string(REPLACE "@" "@@" ESCAPED_SYSROOT_PATH "${SYSROOT_PATH}") + string(REPLACE "@" "@@" ESCAPED_XEUS_CPP_RESOURCE_DIR "${XEUS_CPP_RESOURCE_DIR}") + string(REPLACE "\\" "/" ESCAPED_XEUS_CPP_RESOURCE_DIR "${ESCAPED_XEUS_CPP_RESOURCE_DIR}") +diff --git a/wasm_patches/post.js b/wasm_patches/post.js +index 8c0acd1..529bf13 100644 +--- a/wasm_patches/post.js ++++ b/wasm_patches/post.js +@@ -9,4 +9,40 @@ Module.getDylinkMetadata = getDylinkMetadata + Module.loadDynamicLibrary = loadDynamicLibrary + + Module.UTF8ToString = UTF8ToString; +-Module.ERRNO_CODES = ERRNO_CODES; +\ No newline at end of file ++Module.ERRNO_CODES = ERRNO_CODES; ++ ++// WebGPU device hand-off for library_webgpu.js (emsdk 4.0.9). The C++ side ++// calls emscripten_webgpu_get_device(), which returns whatever is stored in ++// Module.preinitializedWebGPUDevice -- so request adapter and device here, in ++// the kernel's worker, before any cell can ask. Module.webgpuReady resolves to ++// true when a device is available and false when this browser has no WebGPU; ++// a cell that runs before it settles gets a null device and should say so. ++Module.preinitializedWebGPUDevice = null; ++// library_webgpu.js's emscripten_webgpu_get_device() dereferences the ++// pre-initialised device without checking it, so on a browser without WebGPU ++// the exception escapes the JIT'd cell and the kernel hangs. A cell compiled in ++// the browser is a side module that resolves JS-library imports through ++// wasmImports, and post.js runs before any cell can be compiled -- so guard the ++// import here: no device, no handle (0), and C++ can say "no WebGPU device". ++if (typeof wasmImports !== 'undefined' && wasmImports.emscripten_webgpu_get_device) { ++ const _getDevice = wasmImports.emscripten_webgpu_get_device; ++ wasmImports.emscripten_webgpu_get_device = () => Module.preinitializedWebGPUDevice ? _getDevice() : 0; ++} ++// The reason is recorded where a C++ cell can read it (MEMFS) and in the console, ++// so "no device" can be told apart: no-navigator-gpu / no-adapter / error / pending. ++const _webgpuStatus = (s) => { Module.webgpuStatus = s; try { FS.writeFile('/tmp/webgpu-status.txt', s); } catch (e) {} console.warn('[webgpu] ' + s); }; ++_webgpuStatus('pending'); ++Module.webgpuReady = (async () => { ++ try { ++ if (typeof navigator === 'undefined' || !navigator.gpu) { _webgpuStatus('no-navigator-gpu (no WebGPU in this worker, or not a secure context)'); return false; } ++ const adapter = await navigator.gpu.requestAdapter(); ++ if (!adapter) { _webgpuStatus('no-adapter (requestAdapter() returned null: GPU blocklisted or unsupported)'); return false; } ++ Module.preinitializedWebGPUDevice = await adapter.requestDevice(); ++ const info = adapter.info || {}; ++ _webgpuStatus('ok (' + [info.vendor, info.architecture, info.description].filter(Boolean).join(' / ') + ')'); ++ return true; ++ } catch (e) { ++ _webgpuStatus('error: ' + e); ++ return false; ++ } ++})(); diff --git a/lite/kernel/patches/xeus-cpp-020-Follow-cppjit-s-package-layout-and-stage-the-Clad-he.patch b/lite/kernel/patches/xeus-cpp-020-Follow-cppjit-s-package-layout-and-stage-the-Clad-he.patch new file mode 100644 index 0000000..542f4c4 --- /dev/null +++ b/lite/kernel/patches/xeus-cpp-020-Follow-cppjit-s-package-layout-and-stage-the-Clad-he.patch @@ -0,0 +1,82 @@ +From 28edb1330bb27e191966b4d7714c75f074747a38 Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Mon, 2 Nov 2026 18:22:07 +0000 +Subject: [PATCH 20/22] Follow cppjit's package layout and stage the Clad + headers in the wasm kernel + +cppjit now assembles its package under /python/cppjit with the +extension inside it (import cppjit.libcppjit) and no longer ships a +cppjit_backend directory; preload that one tree. A CppInterOp built with +Clad adds /include to the interpreter's search path for the Clad runtime +headers; XEUS_CPP_CLAD_INCLUDE_DIR names the directory whose clad/ is +preloaded there. + +Co-Authored-By: Claude Fable 5.1 +--- + CMakeLists.txt | 29 +++++++++++++++++++++-------- + 1 file changed, 21 insertions(+), 8 deletions(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index e66efb9..51f5f1f 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -87,8 +87,10 @@ if(EMSCRIPTEN) + # magic imports cppjit from. Has to match the python package installed for + # emscripten-wasm32 in CMAKE_PREFIX_PATH. + set(XEUS_CPP_WASM_PYTHON_VERSION "3.13" CACHE STRING "Version of the wasm CPython to embed") +- set(CPPJIT_SOURCE_DIR "" CACHE PATH "cppjit checkout supplying the python packages and cpyrt headers") +- set(CPPJIT_BUILD_DIR "" CACHE PATH "cppjit wasm build directory holding libcppjit.so") ++ set(CPPJIT_SOURCE_DIR "" CACHE PATH "cppjit checkout supplying the cpyrt headers") ++ set(CPPJIT_BUILD_DIR "" CACHE PATH "cppjit wasm build directory; its python/cppjit tree holds the package and libcppjit.so") ++ set(XEUS_CPP_CLAD_INCLUDE_DIR "" CACHE PATH ++ "Directory holding clad/ (the Clad runtime headers), preloaded at /include/clad for a CppInterOp built with Clad") + endif() + + # Dependencies +@@ -565,9 +567,10 @@ if(EMSCRIPTEN) + PUBLIC "SHELL: --preload-file ${ESCAPED_XEUS_CPP_RESOURCE_DIR}@/${CMAKE_INSTALL_LIBDIR}/clang/${CPPINTEROP_LLVM_VERSION_MAJOR}" + PUBLIC "SHELL: --preload-file ${CPPJIT_SOURCE_DIR}/src/cpyrt@/include/cpyrt" + PUBLIC "SHELL: --preload-file ${CPPINTEROP_INSTALL_PREFIX}/include/CppInterOp@/include/CppInterOp" +- PUBLIC "SHELL: --preload-file ${CPPJIT_BUILD_DIR}/libcppjit.so@/lib/python${XEUS_CPP_WASM_PYTHON_VERSION}/site-packages/libcppjit.so" +- PUBLIC "SHELL: --preload-file ${CPPJIT_SOURCE_DIR}/python/cppjit@/lib/python${XEUS_CPP_WASM_PYTHON_VERSION}/site-packages/cppjit" +- PUBLIC "SHELL: --preload-file ${CPPJIT_SOURCE_DIR}/python/cppjit_backend@/lib/python${XEUS_CPP_WASM_PYTHON_VERSION}/site-packages/cppjit_backend" ++ # cppjit's build tree assembles the package under python/cppjit with ++ # the extension inside it (import cppjit.libcppjit), the layout the ++ # wheel ships. ++ PUBLIC "SHELL: --preload-file ${CPPJIT_BUILD_DIR}/python/cppjit@/lib/python${XEUS_CPP_WASM_PYTHON_VERSION}/site-packages/cppjit" + PUBLIC "SHELL: --preload-file ${XEUS_CPP_WASM_STDLIB_STAGE}@/lib/python${XEUS_CPP_WASM_PYTHON_VERSION}" + # The Python C-API headers, at the path sysconfig reports inside the + # kernel (`{prefix}/include/python3.x`), so cppjit puts them on the +@@ -578,6 +581,16 @@ if(EMSCRIPTEN) + PUBLIC "SHELL: --preload-file ${CMAKE_PREFIX_PATH}/include/python${XEUS_CPP_WASM_PYTHON_VERSION}@/include/python${XEUS_CPP_WASM_PYTHON_VERSION}" + PUBLIC "SHELL: --post-js ${CMAKE_CURRENT_SOURCE_DIR}/wasm_patches/post.js" + ) ++ # A CppInterOp built with Clad adds /include to the interpreter's search ++ # path for the Clad runtime headers (CLAD_INCLUDE_DIRS in its wasm build); ++ # stage them there. ++ if(XEUS_CPP_CLAD_INCLUDE_DIR) ++ if(NOT EXISTS "${XEUS_CPP_CLAD_INCLUDE_DIR}/clad/Differentiator/Differentiator.h") ++ message(FATAL_ERROR "No clad/Differentiator/Differentiator.h under XEUS_CPP_CLAD_INCLUDE_DIR (${XEUS_CPP_CLAD_INCLUDE_DIR})") ++ endif() ++ target_link_options(xcpp ++ PUBLIC "SHELL: --preload-file ${XEUS_CPP_CLAD_INCLUDE_DIR}/clad@/include/clad") ++ endif() + # --preload-file arguments are opaque to CMake, so rebuilding libcppjit.so + # on its own leaves xcpp.data holding the previous copy and the kernel + # silently keeps running the old code. Name the ones that get rebuilt during +@@ -588,9 +601,9 @@ if(EMSCRIPTEN) + # kernel runs code that no longer exists in the source tree -- a fix can + # then appear not to work when it was simply never deployed. + set_property(TARGET xcpp APPEND PROPERTY LINK_DEPENDS +- "${CPPJIT_BUILD_DIR}/libcppjit.so" +- "${CPPJIT_SOURCE_DIR}/python/cppjit/__init__.py" +- "${CPPJIT_SOURCE_DIR}/python/cppjit/_cpython_cppjit.py" ++ "${CPPJIT_BUILD_DIR}/python/cppjit/libcppjit.so" ++ "${CPPJIT_BUILD_DIR}/python/cppjit/__init__.py" ++ "${CPPJIT_BUILD_DIR}/python/cppjit/_cpython_cppjit.py" + "${CPPJIT_SOURCE_DIR}/src/cpyrt/API.h") + endif() + # Tests +-- +2.55.0 + diff --git a/lite/kernel/patches/xeus-cpp-021-List-libclangCppInterOp.so-in-the-wasm-kernel-spec-o.patch b/lite/kernel/patches/xeus-cpp-021-List-libclangCppInterOp.so-in-the-wasm-kernel-spec-o.patch new file mode 100644 index 0000000..348fe62 --- /dev/null +++ b/lite/kernel/patches/xeus-cpp-021-List-libclangCppInterOp.so-in-the-wasm-kernel-spec-o.patch @@ -0,0 +1,96 @@ +From 0bfe4f074ab623d4a570ddc28b62ad473c6a132c Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Mon, 2 Nov 2026 18:56:10 +0000 +Subject: [PATCH 21/22] List libclangCppInterOp.so in the wasm kernel spec only + when it is a shared library + +jupyterlite-xeus copies every entry of metadata.shared out of the prefix; +with CppInterOp built static (the Emscripten line since CppInterOp #1149) +the file does not exist and the site build fails. Emit the entry from the +CppInterOp config's CPPINTEROP_SHARED_LIB. + +Co-Authored-By: Claude Fable 5.1 +--- + CMakeLists.txt | 6 ++++++ + share/jupyter/kernels/xc23/wasm_kernel.json.in | 3 +-- + share/jupyter/kernels/xcpp17/wasm_kernel.json.in | 3 +-- + share/jupyter/kernels/xcpp20/wasm_kernel.json.in | 3 +-- + share/jupyter/kernels/xcpp23/wasm_kernel.json.in | 3 +-- + 5 files changed, 10 insertions(+), 8 deletions(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 51f5f1f..54813e9 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -143,6 +143,12 @@ function(configure_kernel kernel) + foreach(arg IN LISTS XEUS_CPP_WASM_KERNEL_EXTRA_ARGS) + string(APPEND XEUS_CPP_WASM_KERNEL_EXTRA_ARGS_JSON "\"${arg}\", ") + endforeach() ++ # The side modules the loader serves next to the kernel. A CppInterOp built ++ # as a static library is inside xcpp.wasm and has no file to list. ++ set(XEUS_CPP_WASM_SHARED_JSON "\"libxeus.so\": \"lib/libxeus.so\"") ++ if(CPPINTEROP_SHARED_LIB) ++ string(APPEND XEUS_CPP_WASM_SHARED_JSON ",\n \"libclangCppInterOp.so\": \"lib/libclangCppInterOp.so\"") ++ endif() + else() + set(XEUS_CPP_INCLUDE_DIR ${CMAKE_INSTALL_PREFIX}/include) + if(${kernel} MATCHES "omp/$") +diff --git a/share/jupyter/kernels/xc23/wasm_kernel.json.in b/share/jupyter/kernels/xc23/wasm_kernel.json.in +index 7dd2bd3..0a83e04 100644 +--- a/share/jupyter/kernels/xc23/wasm_kernel.json.in ++++ b/share/jupyter/kernels/xc23/wasm_kernel.json.in +@@ -13,8 +13,7 @@ + "metadata": { + "debugger": false, + "shared": { +- "libxeus.so": "lib/libxeus.so", +- "libclangCppInterOp.so": "lib/libclangCppInterOp.so" ++ @XEUS_CPP_WASM_SHARED_JSON@ + } + } + } +diff --git a/share/jupyter/kernels/xcpp17/wasm_kernel.json.in b/share/jupyter/kernels/xcpp17/wasm_kernel.json.in +index 02ec059..7b98fbd 100644 +--- a/share/jupyter/kernels/xcpp17/wasm_kernel.json.in ++++ b/share/jupyter/kernels/xcpp17/wasm_kernel.json.in +@@ -12,8 +12,7 @@ + "metadata": { + "debugger": false, + "shared": { +- "libxeus.so": "lib/libxeus.so", +- "libclangCppInterOp.so": "lib/libclangCppInterOp.so" ++ @XEUS_CPP_WASM_SHARED_JSON@ + } + } + } +diff --git a/share/jupyter/kernels/xcpp20/wasm_kernel.json.in b/share/jupyter/kernels/xcpp20/wasm_kernel.json.in +index 015bd5a..d49f91e 100644 +--- a/share/jupyter/kernels/xcpp20/wasm_kernel.json.in ++++ b/share/jupyter/kernels/xcpp20/wasm_kernel.json.in +@@ -12,8 +12,7 @@ + "metadata": { + "debugger": false, + "shared": { +- "libxeus.so": "lib/libxeus.so", +- "libclangCppInterOp.so": "lib/libclangCppInterOp.so" ++ @XEUS_CPP_WASM_SHARED_JSON@ + } + } + } +diff --git a/share/jupyter/kernels/xcpp23/wasm_kernel.json.in b/share/jupyter/kernels/xcpp23/wasm_kernel.json.in +index 2de544f..510fd63 100644 +--- a/share/jupyter/kernels/xcpp23/wasm_kernel.json.in ++++ b/share/jupyter/kernels/xcpp23/wasm_kernel.json.in +@@ -12,8 +12,7 @@ + "metadata": { + "debugger": false, + "shared": { +- "libxeus.so": "lib/libxeus.so", +- "libclangCppInterOp.so": "lib/libclangCppInterOp.so" ++ @XEUS_CPP_WASM_SHARED_JSON@ + } + } + } +-- +2.55.0 + diff --git a/lite/kernel/patches/xeus-cpp-022-Let-a-deployment-append-link-options-after-xeus-lite.patch b/lite/kernel/patches/xeus-cpp-022-Let-a-deployment-append-link-options-after-xeus-lite.patch new file mode 100644 index 0000000..f8a1588 --- /dev/null +++ b/lite/kernel/patches/xeus-cpp-022-Let-a-deployment-append-link-options-after-xeus-lite.patch @@ -0,0 +1,38 @@ +From 7684eb0a89d20dd0879fc0a3d9037837fb9e0f5b Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Mon, 2 Nov 2026 20:16:24 +0000 +Subject: [PATCH 22/22] Let a deployment append link options after xeus-lite's + wasm defaults + +XEUS_CPP_WASM_LINK_OPTIONS is applied after xeus_wasm_link_options, so a +later -s setting overrides the default: a site that knows which symbols +its side modules and JIT-compiled code import can link the kernel as +MAIN_MODULE=2 with a wasm-ld response file of --export-if-defined lines +and let the linker drop what nothing reaches. + +Co-Authored-By: Claude Fable 5.1 +--- + CMakeLists.txt | 7 +++++++ + 1 file changed, 7 insertions(+) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 54813e9..c6ea894 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -524,6 +524,13 @@ if(EMSCRIPTEN) + xeus_cpp_set_kernel_options(xcpp) + xeus_wasm_compile_options(xcpp) + xeus_wasm_link_options(xcpp "web,worker") ++ # Link options a deployment appends after xeus-lite's defaults, so a later ++ # -s setting wins over the default (e.g. -sMAIN_MODULE=2 with an export list ++ # from a wasm-ld response file, in place of MAIN_MODULE=1's export-all). ++ set(XEUS_CPP_WASM_LINK_OPTIONS "" CACHE STRING "Extra link options for the wasm kernel, applied after xeus-lite's") ++ if(XEUS_CPP_WASM_LINK_OPTIONS) ++ target_link_options(xcpp PUBLIC "SHELL:${XEUS_CPP_WASM_LINK_OPTIONS}") ++ endif() + # Rung 2 (SC26): link Emscripten's WebGPU binding into the main module so a + # JIT'd cell -- a side module resolving against these exports -- can reach + # wgpu* through , which the preloaded sysroot already +-- +2.55.0 + diff --git a/lite/kernel/patches/xeus-cpp-023-Leave-out-of-the-wasm-kernel-s-preloaded-filesystem-.patch b/lite/kernel/patches/xeus-cpp-023-Leave-out-of-the-wasm-kernel-s-preloaded-filesystem-.patch new file mode 100644 index 0000000..b29a281 --- /dev/null +++ b/lite/kernel/patches/xeus-cpp-023-Leave-out-of-the-wasm-kernel-s-preloaded-filesystem-.patch @@ -0,0 +1,73 @@ +From 4d675494243ad726ae0f0811ca04c46cba956664 Mon Sep 17 00:00:00 2001 +From: Vassil Vassilev +Date: Mon, 2 Nov 2026 21:19:18 +0000 +Subject: [PATCH] Leave out of the wasm kernel's preloaded filesystem what a + notebook never includes + +The sysroot headers and clang's builtin headers were preloaded whole. A +notebook kernel never includes SDL, GL, X11 or the sanitizer interfaces, +nor the intrinsics of other architectures (arm_neon.h alone is 3 MB, the +AVX family 2 MB); together about 16 MB of the 46 MB image. Stage filtered +copies; the exclude lists are cache variables. The Python standard library +also drops pydoc_data, ensurepip and venv. + +Co-Authored-By: Claude Fable 5.1 +--- + CMakeLists.txt | 31 +++++++++++++++++++++++++++++-- + 1 file changed, 29 insertions(+), 2 deletions(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index c6ea894..b4284b8 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -561,9 +561,36 @@ if(EMSCRIPTEN) + PATTERN "idlelib" EXCLUDE + PATTERN "tkinter" EXCLUDE + PATTERN "turtledemo" EXCLUDE ++ PATTERN "pydoc_data" EXCLUDE ++ PATTERN "ensurepip" EXCLUDE ++ PATTERN "venv" EXCLUDE + PATTERN "__pycache__" EXCLUDE + ) + ++ # The sysroot headers and clang's builtin headers are preloaded whole by default; a notebook kernel never includes ++ # the graphics and audio APIs of the former or the other architectures' intrinsics of the latter (arm_neon.h alone ++ # is 3 MB). Stage filtered copies. The lists are cache variables, so a deployment that needs SDL or X86 intrinsics ++ # puts them back. ++ set(XEUS_CPP_WASM_SYSROOT_EXCLUDE "SDL;GL;GLES;GLES2;GLES3;GLFW;EGL;KHR;X11;AL;fakesdl;sanitizer;webgl;uuid" CACHE STRING ++ "Sub-directories of the sysroot include/ left out of the kernel's preloaded filesystem") ++ set(XEUS_CPP_WASM_RESOURCE_EXCLUDE "arm_*;avx*;amx*;*intrin.h;*intrin*.h;altivec.h;opencl-c*.h;hexagon*;hvx*;riscv*;sifive*;velintrin*;ppc_wrappers;larchintrin.h;lsx*;lasx*;__clang_cuda*;__clang_hip*;cuda_wrappers;openmp_wrappers;llvm_libc_wrappers;ptrauth.h;cpuid.h;x86gprintrin.h;keylockerintrin.h;mm_malloc.h;mwaitxintrin.h;s390intrin.h;htmintrin.h;htmxlintrin.h" CACHE STRING ++ "Glob patterns of clang resource-dir headers left out of the kernel's preloaded filesystem") ++ set(XEUS_CPP_WASM_SYSROOT_STAGE "${CMAKE_CURRENT_BINARY_DIR}/wasm_sysroot_include") ++ set(XEUS_CPP_WASM_RESOURCE_STAGE "${CMAKE_CURRENT_BINARY_DIR}/wasm_resource_dir") ++ file(REMOVE_RECURSE "${XEUS_CPP_WASM_SYSROOT_STAGE}" "${XEUS_CPP_WASM_RESOURCE_STAGE}") ++ set(_sysroot_excludes "") ++ foreach(_d IN LISTS XEUS_CPP_WASM_SYSROOT_EXCLUDE) ++ list(APPEND _sysroot_excludes PATTERN "${_d}" EXCLUDE) ++ endforeach() ++ file(COPY "${SYSROOT_PATH}/include/" DESTINATION "${XEUS_CPP_WASM_SYSROOT_STAGE}" ${_sysroot_excludes}) ++ set(_resource_excludes "") ++ foreach(_g IN LISTS XEUS_CPP_WASM_RESOURCE_EXCLUDE) ++ list(APPEND _resource_excludes PATTERN "${_g}" EXCLUDE) ++ endforeach() ++ file(COPY "${XEUS_CPP_RESOURCE_DIR}/" DESTINATION "${XEUS_CPP_WASM_RESOURCE_STAGE}" ${_resource_excludes}) ++ string(REPLACE "@" "@@" ESCAPED_SYSROOT_STAGE "${XEUS_CPP_WASM_SYSROOT_STAGE}") ++ string(REPLACE "@" "@@" ESCAPED_RESOURCE_STAGE "${XEUS_CPP_WASM_RESOURCE_STAGE}") ++ + # Clang's own API headers, for a notebook that means to #include clang. They + # are 32MB of xcpp.data, so a deployment that only runs C++ leaves them out. + option(XEUS_CPP_WASM_PRELOAD_CLANG_HEADERS +@@ -576,8 +603,8 @@ if(EMSCRIPTEN) + endif() + + target_link_options(xcpp +- PUBLIC "SHELL: --preload-file ${ESCAPED_SYSROOT_PATH}/include@/include" +- PUBLIC "SHELL: --preload-file ${ESCAPED_XEUS_CPP_RESOURCE_DIR}@/${CMAKE_INSTALL_LIBDIR}/clang/${CPPINTEROP_LLVM_VERSION_MAJOR}" ++ PUBLIC "SHELL: --preload-file ${ESCAPED_SYSROOT_STAGE}@/include" ++ PUBLIC "SHELL: --preload-file ${ESCAPED_RESOURCE_STAGE}@/${CMAKE_INSTALL_LIBDIR}/clang/${CPPINTEROP_LLVM_VERSION_MAJOR}" + PUBLIC "SHELL: --preload-file ${CPPJIT_SOURCE_DIR}/src/cpyrt@/include/cpyrt" + PUBLIC "SHELL: --preload-file ${CPPINTEROP_INSTALL_PREFIX}/include/CppInterOp@/include/CppInterOp" + # cppjit's build tree assembles the package under python/cppjit with +-- +2.55.0 + diff --git a/lite/wire-ledger-nb1.json b/lite/wire-ledger-nb1.json new file mode 100644 index 0000000..43a2f5f --- /dev/null +++ b/lite/wire-ledger-nb1.json @@ -0,0 +1,13 @@ +{ + "notebook": "cppjit/1_call_it.ipynb", + "total_bytes": 52212097, + "groups": { + "app shell, extensions, files": 8209852, + "C++ kernel": 37523689, + "shared libraries on demand": 85897, + "Python packages at start": 6392659 + }, + "ui_s": 4.253089666366577, + "done_s": 12.64185619354248, + "done": true +} \ No newline at end of file diff --git a/lite/wire-ledger.json b/lite/wire-ledger.json new file mode 100644 index 0000000..a1f68af --- /dev/null +++ b/lite/wire-ledger.json @@ -0,0 +1,14 @@ +{ + "notebook": "cppjit/4_higgs_open_data.ipynb", + "total_bytes": 83568854, + "groups": { + "app shell, extensions, files": 8211666, + "C++ kernel": 37523689, + "shared libraries on demand": 2875981, + "Python packages at start": 6399573, + "lazy packages (first import)": 28557945 + }, + "ui_s": 4.211324453353882, + "done_s": 40.83511710166931, + "done": true +} \ No newline at end of file diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index e66bf5a..ceacd6d 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -59,6 +59,9 @@ def sanitize_and_sort_output(text): else: # parse dynamic speedups like "18.9x" or "6.4x" into "x.xx" cleaned = re.sub(r'\d+(\.\d+)?x', 'x.xx', cleaned) + + # optimiser counters depend on the SciPy version: "10 iterations, 17 loss and 16 gradient evaluations" + cleaned = re.sub(r'\b\d+ (iterations?|evaluations?|loss and|gradient evaluations?|evals?)\b', r'x \1', cleaned) # parse floats/integers attached to execution seconds (e.g., "0.1241 s", "2 s") cleaned = re.sub(r'\d+(\.\d+)?\s*ms\b', 'x.x ms', cleaned) @@ -69,6 +72,10 @@ def sanitize_and_sort_output(text): # general float / timing cleanup fallback cleaned = re.sub(r'\d+\.\d+(e\+\d+)?|\d+e\+\d+', 'x.x', cleaned) + + # width-formatted numbers ("{t:7.1f} ms") leave padding that depends on the digit count, so a slower + # machine prints " 318.5 ms" where a faster one prints " 17.4 ms": the x.x above keeps the padding + cleaned = re.sub(r'[ \t]{2,}', ' ', cleaned) # if the line was a table header separator line (e.g., "------------"), # compress it to prevent spaces from altering the alphabetical sort order @@ -203,6 +210,13 @@ class CudaNotebookTests(BaseNotebookTests): should_sort_parallel_outputs = True # uses parallel filters skip_gpu_hardware_cells = True +class CppjitNotebookTests(BaseNotebookTests): + __test__ = True + kernel_name = 'python3' # the Python kernel; the C++ is compiled inside it by cppjit + notebook_dir = 'cppjit' + # timings, speed-ups and fitted values vary by machine: compare the shape of the output, not the digits + should_sort_parallel_outputs = True + if __name__ == '__main__': unittest.main() diff --git a/tools/build-lite-site.sh b/tools/build-lite-site.sh new file mode 100644 index 0000000..1550e62 --- /dev/null +++ b/tools/build-lite-site.sh @@ -0,0 +1,98 @@ +#!/usr/bin/env bash +# Build the slim JupyterLite site for the home notebooks: the rebuilt xcpp23 kernel (C++ hosting Python through cppjit), +# python + numpy in the kernel's start-up set (SciPy and matplotlib on first import), cppjit/kernel and cppjit/data +# mounted at /cppjit, and the repository's C++ series alongside. +# +# SP= OUT= bash tools/build-lite-site.sh +# +# $SP holds site-venv (jupyter lite build, empack) and mamba/envs/{xeus-kernels,xeus-slim,xeus-lazy}; see +# tools/setup-lite-env.sh for how they are made and lite/README-build.md for the design. +set -euo pipefail +: "${SP:?}" +REPO=${REPO:-$(cd "$(dirname "$0")/.." && pwd)} +SERIES=${SERIES:-$REPO/cppjit} # the notebooks, kernel/ and data/ that go into the site +OUT=${OUT:-$REPO/lite/dist} +BUILD_ENV=${BUILD_ENV:-$SP/site-venv}; [ -x "$BUILD_ENV/bin/jupyter" ] || BUILD_ENV=$SP/mamba/envs/build-env # the September layout +PREFIX=${PREFIX:-$SP/mamba/envs/xeus-lazy} # xeus-slim minus the packages kernel/lazy.py fetches on first import +CONTENT=${CONTENT:-$REPO/lite/content} +export PATH="$BUILD_ENV/bin:$PATH" +for d in "$OUT" "$CONTENT"; do # the two directories this script deletes and recreates + case "$d" in ""|/|/home|/home/*/|"$HOME"|"$HOME"/) echo "refusing to use '$d' as an output directory"; exit 2;; esac +done + +echo "[content] notebooks -> xcpp23 notebooks" +rm -rf "$CONTENT" && mkdir -p "$CONTENT" +"$BUILD_ENV/bin/python" "$REPO/tools/home2lite.py" "$SERIES" "$CONTENT/cppjit" +# the repository's own C++ series runs in the browser kernel as it is (kernel name mapped to the one the site ships) +"$BUILD_ENV/bin/python" - "$REPO/xeus-cpp" "$CONTENT/cpp" <<'PY' +import json, sys, pathlib +src, dst = pathlib.Path(sys.argv[1]), pathlib.Path(sys.argv[2]); dst.mkdir(parents=True, exist_ok=True) +# 10_modular_notebook_design defines a lambda named `log`; the browser kernel already has std::log at global scope +# (its preamble includes ), so the cell does not compile there. Left out of the site until the notebook or the +# kernel preamble changes; it stays in the native series. +EXCLUDE = {"10_modular_notebook_design.ipynb"} +for nb in sorted(src.glob("*.ipynb")): + if nb.name in EXCLUDE: continue + d = json.load(open(nb)); d["metadata"]["kernelspec"] = {"display_name": "C++23", "language": "cpp", "name": "xcpp23"} + json.dump(d, open(dst / nb.name, "w"), indent=1, ensure_ascii=False) +print(f"[content] {len(list(dst.glob('*.ipynb')))} C++ notebooks -> {dst}") +PY +cp "$REPO/lite/README.md" "$CONTENT/README.md" + +# lite/labext holds symlinks to the two extensions the site needs (the xeus kernel extension and the notebook UI); the +# build environment's other extensions (pyodide, javascript, p5 kernels, themes) stay out. +mkdir -p "$REPO/lite/labext/@jupyterlite" "$REPO/lite/labext/@jupyter-notebook" +ln -sfn "$BUILD_ENV/share/jupyter/labextensions/@jupyterlite/xeus" "$REPO/lite/labext/@jupyterlite/xeus" +ln -sfn "$BUILD_ENV/share/jupyter/labextensions/@jupyter-notebook/lab-extension" "$REPO/lite/labext/@jupyter-notebook/lab-extension" +# The lazy packages (SciPy, matplotlib and friends) are the pack step's own tarballs: harvest them once from a build +# against xeus-slim (which still contains them), then build the site against xeus-lazy (which does not). +# The harvest is keyed on the environment lock: a lock change (new builds of SciPy, matplotlib) invalidates it. +LOCKSUM=$(sha256sum "$REPO/lite/env/xeus-kernels.explicit.txt" | cut -c1-16) +if [ ! -f "$REPO/lite/lazy-packages/.lock-$LOCKSUM" ]; then + echo "[site] harvesting the lazy package tarballs from a pack of xeus-slim (lock $LOCKSUM)" + rm -rf "$OUT-harvest" "$REPO/lite/.jupyterlite.doit.db"; mkdir -p "$REPO/lite/lazy-packages" + rm -f "$REPO"/lite/lazy-packages/*.tar.gz "$REPO"/lite/lazy-packages/.lock-* + (cd "$REPO/lite" && jupyter lite build --contents "$CONTENT" --output-dir "$OUT-harvest" \ + --XeusAddon.prefix="$SP/mamba/envs/xeus-slim" --XeusAddon.empack_config="$REPO/lite/empack_config.yaml" --XeusAddon.default_channels="https://prefix.dev/emscripten-forge-4x" --XeusAddon.default_channels="conda-forge" \ + --LiteBuildConfig.ignore_sys_prefix=True --FederatedExtensionAddon.extra_labextensions_path="$REPO/lite/labext" >/dev/null) + for p in $(grep -v '^#' "$REPO/lite/env/lazy-remove.txt"); do cp "$OUT-harvest"/xeus/*/kernel_packages/"$p"-[0-9]*.tar.gz "$REPO/lite/lazy-packages/" 2>/dev/null || true; done + rm -rf "$OUT-harvest"; touch "$REPO/lite/lazy-packages/.lock-$LOCKSUM"; ls "$REPO"/lite/lazy-packages/*.tar.gz | wc -l | xargs echo " lazy tarballs:" +fi + +echo "[site] jupyter lite build -> $OUT" +rm -rf "$OUT" "$REPO/lite/.jupyterlite.doit.db" +cd "$REPO/lite" +jupyter lite build --contents "$CONTENT" --output-dir "$OUT" \ + --XeusAddon.prefix="$PREFIX" --XeusAddon.empack_config="$REPO/lite/empack_config.yaml" --XeusAddon.default_channels="https://prefix.dev/emscripten-forge-4x" --XeusAddon.default_channels="conda-forge" \ + --XeusAddon.mounts="$SERIES/kernel:/cppjit/kernel" --XeusAddon.mounts="$SERIES/data:/cppjit/data" \ + --LiteBuildConfig.ignore_sys_prefix=True \ + --FederatedExtensionAddon.extra_labextensions_path="$REPO/lite/labext" + +# The kernel's dynamic loader resolves a module's needed shared libraries (libopenblas.so for numpy, libz.so for pillow) +# by URL next to the kernel script, not through its filesystem; serve them there. Fetched only when first needed. +echo "[site] shared libraries next to the kernel script" +STATIC="$OUT/extensions/@jupyterlite/xeus-extension/static" +for so in libopenblas.so libz.so; do cp -L "$PREFIX/lib/$so" "$STATIC/$so"; done +ls -la "$STATIC"/*.so | awk '{printf " %7.2f MB %s\n",$5/1048576,$9}' + +# Packages loaded on first import by kernel/lazy.py (not in the start-up set): the tarballs packed from xeus-slim. +echo "[site] lazy packages -> $OUT/lazy/" +mkdir -p "$OUT/lazy" && cp "$REPO"/lite/lazy-packages/*.tar.gz "$OUT/lazy/" && du -sh "$OUT/lazy" | cut -f1 | xargs echo " lazy packages:" +# package name -> tarball file, read by kernel/lazy.py at start (lazy.json names packages, not builds) +"$BUILD_ENV/bin/python" - "$OUT/lazy" <<'PY' +import json, pathlib, re, sys +d = pathlib.Path(sys.argv[1]); index = {} +for f in sorted(d.glob("*.tar.gz")): + m = re.match(r"^(.+?)-\d[^-]*-[^-]+\.tar\.gz$", f.name) + if m: index[m.group(1)] = f.name +json.dump(index, open(d / "index.json", "w"), indent=1); print(f" lazy/index.json: {len(index)} packages") +PY + + +# GitHub Pages: no Jekyll processing (it would skip files and folders it considers special) +touch "$OUT/.nojekyll" + +echo "[site] kernels: $(cat "$OUT/xeus/kernels.json")" +echo "[site] kernel packages: $(ls "$OUT"/xeus/*/kernel_packages/*.tar.gz | wc -l), $(du -shc "$OUT"/xeus/*/kernel_packages/*.tar.gz | tail -1 | cut -f1)" +du -sh "$OUT" | cut -f1 | xargs echo "[site] total on disk:" +echo "SITE_DONE" diff --git a/tools/build-wasm-kernel.sh b/tools/build-wasm-kernel.sh new file mode 100644 index 0000000..179ee97 --- /dev/null +++ b/tools/build-wasm-kernel.sh @@ -0,0 +1,144 @@ +#!/usr/bin/env bash +# Build the browser kernel: xeus-cpp + cppjit + CppInterOp (with Clad) on wasm32, LLVM 23 line, 2026-11-03. +# +# SP= bash tools/build-wasm-kernel.sh envs # micromamba envs: wasm32 kernel env from the lock, native LLVM 23 tools +# SP= bash tools/build-wasm-kernel.sh sources # clone at the pins, apply the patches (lite/kernel/PATCHES.md) +# SP= bash tools/build-wasm-kernel.sh build # tblgen tools, CppInterOp (+Clad), cppjit, xeus-cpp -> $SP/mamba/envs/xeus-kernels +# SP= bash tools/build-wasm-kernel.sh wasm-opt # binaryen -Oz over xcpp.wasm (needs ~12 GB of memory; may run elsewhere) +# SP= bash tools/build-wasm-kernel.sh overlay # kernel-overlay-.tar.gz + its SHA-256 line +# SP= bash tools/build-wasm-kernel.sh wheel # the native cppjit wheel with Clad inside (Python 3.12, Linux x86_64) +# +# Needs: emsdk 4.0.9 at $EMSDK (emsdk install 4.0.9 && emsdk activate 4.0.9), $SP/bin/micromamba (tools/setup-lite-env.sh +# puts one there), git, curl. Patches by Vipul Cariappa are fetched from his repository (PATCHES= for a local copy); the +# rest, Aaron Jomy's PR 1167 diff included, is lite/kernel/patches/. About an hour on 4 cores (.github/workflows/build-kernel.yml +# runs exactly this on a GitHub runner and attaches the results to a release). +set -euo pipefail +: "${SP:?set SP to the scratch directory}" "${EMSDK:?set EMSDK to an emsdk 4.0.9 checkout}" +REPO=${REPO:-$(cd "$(dirname "$0")/.." && pwd)} +OURS=$REPO/lite/kernel/patches +PATCHES=${PATCHES:-} # directory with Vipul Cariappa's CppInterOp-*/cppjit-*/xeus-cpp-*.patch; fetched when empty +THIRD_PARTY_URL=https://raw.githubusercontent.com/Vipul-Cariappa/jupyterlite-deploy/3379385/patches +# CppInterOp pull request 1167 (Aaron Jomy, "Enable Clad plugin in WASM") as the diff of its head on 2026-11-02; CppInterOp is +# Apache-2.0 with LLVM exceptions, so the diff is carried here rather than fetched from a moving pull request. +PR1167_DIFF=$OURS/cppinterop-000-pr1167-enable-clad-plugin-in-wasm.diff +CPPINTEROP_COMMIT=8bf7250bb4cd9d10d733eb3bc0841daa9ac1388f # main, 2026-10-31 +CPPJIT_COMMIT=0332d7688e17e93b0e8735ba54ca0e3d7f0fbaaf # main, 2026-11-02 +XEUS_CPP_COMMIT=65584a89c9c81f26466abcad7f498f3da3917eb2 # main, 2026-10-21 +CLAD_COMMIT=90a623d62891b044575c0c7d425b216e17deb2ef # 2026-10-31, merge of vgvassilev/clad#2453 (discard after a repl error on all clang versions) +CLANG_MAJOR=23 +export MAMBA_ROOT_PREFIX=$SP/mamba +PREFIX=$SP/mamba/envs/xeus-kernels; NATIVE=$SP/mamba/envs/native-llvm; W=$SP/kernel-work +SYSROOT_PATH=$EMSDK/upstream/emscripten/cache/sysroot +JOBS=${JOBS:-$(nproc)} +# LLVM_WASM_DIR: an LLVM/Clang/lld install for wasm32 to build against instead of the environment's emscripten-forge llvm +# package (for example a ci-workflows llvm-wasm recipe tree: WebAssembly target only, -Oz; see lite/README-build.md). +LLVM_WASM_DIR=${LLVM_WASM_DIR:-} +LLVM_ROOT=${LLVM_WASM_DIR:-$PREFIX} +MM=$SP/bin/micromamba +G="-c user.name=kernel-build -c user.email=kernel-build@localhost" +stage=${1:-} + +envs() { + [ -d "$PREFIX/conda-meta" ] || "$MM" create -y -q -p "$PREFIX" --platform emscripten-wasm32 -f "$REPO/lite/env/xeus-kernels.explicit.txt" + [ -d "$NATIVE/conda-meta" ] || "$MM" create -y -q -p "$NATIVE" -c conda-forge python=3.12 cmake ninja "llvmdev=23.1" "clangdev=23.1" zlib zstd libxml2 + echo "envs ready: $(ls "$PREFIX"/conda-meta/*.json | wc -l) wasm32 packages, native llvm $("$NATIVE/bin/llvm-config" --version)" +} + +fetch_third_party() { + if [ -z "$PATCHES" ]; then + PATCHES=$W/third-party-patches; mkdir -p "$PATCHES" + for p in CppInterOp-001 CppInterOp-003 CppInterOp-004 cppjit-003 $(seq -f 'xeus-cpp-%03g' 1 18); do + [ -f "$PATCHES/$p.patch" ] || curl -sSL --retry 3 -o "$PATCHES/$p.patch" "$THIRD_PARTY_URL/$p.patch" + done + fi +} + +clone_at() { # clone_at + [ -d "$W/$1" ] || git clone -q "$2" "$W/$1" + git -C "$W/$1" checkout -q "$3" +} + +sources() { + mkdir -p "$W"; fetch_third_party + clone_at CppInterOp https://github.com/compiler-research/CppInterOp.git "$CPPINTEROP_COMMIT" + clone_at cppjit https://github.com/compiler-research/cppjit.git "$CPPJIT_COMMIT" + clone_at xeus-cpp https://github.com/compiler-research/xeus-cpp.git "$XEUS_CPP_COMMIT" + clone_at clad https://github.com/vgvassilev/clad.git "$CLAD_COMMIT" + # CppInterOp: PR 1167 (Clad in wasm), Vipul's 001/003/004 (002 is upstream), ours + (cd "$W/CppInterOp" && git apply "$PR1167_DIFF" && git $G commit -qam "CppInterOp PR 1167: Enable Clad plugin in WASM (Aaron Jomy)" \ + && git $G am -3 -q "$PATCHES"/CppInterOp-001.patch "$PATCHES"/CppInterOp-003.patch "$PATCHES"/CppInterOp-004.patch \ + && git $G am -q "$OURS"/cppinterop-00[1-9]-*.patch) # the follow-ups are for the native wheel only + (cd "$W/cppjit" && git $G am -q "$OURS"/cppjit-00[1-9]-*.patch && git $G am -3 -q "$PATCHES"/cppjit-003.patch) + (cd "$W/xeus-cpp" && git $G am -3 -q "$PATCHES"/xeus-cpp-0{01..18}.patch && git $G am -q "$OURS"/xeus-cpp-0{19,20,21,22,23}-*.patch) + for d in CppInterOp cppjit xeus-cpp clad; do echo "[$d] now at $(git -C "$W/$d" rev-parse --short HEAD), $(git -C "$W/$d" log --oneline | wc -l) commits"; done +} + +build() { + source "$EMSDK/emsdk_env.sh" >/dev/null 2>&1 + export PATH=$NATIVE/bin:$PATH + cd "$W" + echo "[tblgen] host tools against the native LLVM" + cmake -S CppInterOp -B tblgen -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH="$NATIVE" -DLLVM_DIR="$NATIVE/lib/cmake/llvm" \ + -DCPPINTEROP_ENABLE_TESTING=OFF -DCMAKE_CXX_STANDARD=17 -DCPPINTEROP_BUILD_TABLEGEN_ONLY=ON >/dev/null + cmake --build tblgen --target cppinterop-tblgen -j "$JOBS" >/dev/null + cmake -S clad/utils/clad-tblgen -B clad-tblgen -G Ninja -DCMAKE_BUILD_TYPE=Release -DLLVM_DIR="$NATIVE/lib/cmake/llvm" >/dev/null + cmake --build clad-tblgen -j "$JOBS" >/dev/null + echo "[cppinterop] static wasm library with Clad" + emcmake cmake -S CppInterOp -B build-cppinterop -G Ninja -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_PREFIX_PATH="$PREFIX" -DCMAKE_INSTALL_PREFIX="$PREFIX" \ + -DLLVM_DIR="$LLVM_ROOT/lib/cmake/llvm" -DLLD_DIR="$LLVM_ROOT/lib/cmake/lld" -DClang_DIR="$LLVM_ROOT/lib/cmake/clang" \ + -DBUILD_SHARED_LIBS=OFF -DCPPINTEROP_ENABLE_TESTING=OFF -DCMAKE_CXX_STANDARD=17 \ + -DSYSROOT_PATH="$SYSROOT_PATH" -DCPPINTEROP_TABLEGEN_EXE="$W/tblgen/utils/TableGen/cppinterop-tblgen" \ + -DCPPINTEROP_ENABLE_CLAD=ON -DCLAD_SOURCE_DIR="$W/clad" -DCLAD_TABLEGEN_EXE="$W/clad-tblgen/clad-tblgen" + cmake --build build-cppinterop -j "$JOBS" && cmake --build build-cppinterop --target install >/dev/null + echo "[cppjit] side module" + emcmake cmake -S cppjit -B build-cppjit -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH="$PREFIX" \ + -DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ON -DCppInterOp_DIR="$PREFIX/lib/cmake/CppInterOp" + cmake --build build-cppjit -j "$JOBS" + echo "[xeus-cpp] kernel (linked at -O1: binaryen runs in the wasm-opt stage)" + emcmake cmake -S xeus-cpp -B build-xeus-cpp -G Ninja -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_PREFIX_PATH="$PREFIX" -DCMAKE_INSTALL_PREFIX="$PREFIX" -DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ON \ + -DXEUS_CPP_EMSCRIPTEN_WASM_BUILD=ON -DXEUS_CPP_BUILD_TESTS=OFF "-DCMAKE_EXE_LINKER_FLAGS=-O1${LLVM_WASM_DIR:+ -L$LLVM_WASM_DIR/lib}" \ + -DXEUS_CPP_RESOURCE_DIR="$LLVM_ROOT/lib/clang/$CLANG_MAJOR" -DSYSROOT_PATH="$SYSROOT_PATH" \ + -DCPPJIT_SOURCE_DIR="$W/cppjit" -DCPPJIT_BUILD_DIR="$W/build-cppjit" \ + -DXEUS_CPP_CLAD_INCLUDE_DIR="$W/build-cppinterop/plugins/clad/include" + cmake --build build-xeus-cpp -j "$JOBS" && cmake --build build-xeus-cpp --target install >/dev/null + ls -la "$PREFIX"/bin/xcpp.* | awk '{printf " %7.1f MB %s\n",$5/1048576,$9}' +} + +wasm_opt() { # the same passes emcc runs at -Oz; needs about 12 GB of memory for this module + local opt=$EMSDK/upstream/bin/wasm-opt f=$PREFIX/bin/xcpp.wasm + "$opt" --strip-target-features --post-emscripten -Oz --low-memory-unused --zero-filled-memory \ + --pass-arg=directize-initial-contents-immutable --no-stack-ir "$f" -o "$f.opt" \ + --mvp-features --enable-threads --enable-bulk-memory --enable-bulk-memory-opt --enable-call-indirect-overlong \ + --enable-exception-handling --enable-multivalue --enable-mutable-globals --enable-nontrapping-float-to-int \ + --enable-reference-types --enable-sign-ext --enable-simd --enable-tail-call + mv "$f.opt" "$f"; ls -la "$f" | awk '{printf " %7.1f MB %s\n",$5/1048576,$9}' +} + +wheel() { # cppjit with CppInterOp built with Clad, against the native LLVM: the release's cppjit-*.whl + # cloned without a checkout: the source tree sits on a detached HEAD, which a plain clone would not check out + [ -d "$W/CppInterOp-native" ] || git clone -q --no-checkout "$W/CppInterOp" "$W/CppInterOp-native" + # the three follow-ups of CppInterOp #830: Clad's runtime headers found next to the installed library, and installed + (cd "$W/CppInterOp-native" && git checkout -q "$(git -C "$W/CppInterOp" rev-parse HEAD)" \ + && git $G am -3 "$OURS"/cppinterop-followup-*.patch \ + && grep -q "clad_runtime_include_dir\|install(DIRECTORY \${CMAKE_BINARY_DIR}/plugins/clad/include/clad" plugins/clad/CMakeLists.txt lib/CppInterOp/CMakeLists.txt CMakeLists.txt \ + || { echo "the Clad follow-ups did not apply"; exit 1; }) + "$NATIVE/bin/python" -m venv "$SP/wheel-venv" && "$SP/wheel-venv/bin/pip" install -q scikit-build-core ninja cmake + export PATH=$NATIVE/bin:$PATH CMAKE_PREFIX_PATH=$NATIVE CMAKE_BUILD_PARALLEL_LEVEL=$JOBS + export CMAKE_ARGS="-DLLVM_DIR=$NATIVE/lib/cmake/llvm -DClang_DIR=$NATIVE/lib/cmake/clang -DCMAKE_C_COMPILER=$NATIVE/bin/clang -DCMAKE_CXX_COMPILER=$NATIVE/bin/clang++ -DCPPINTEROP_SOURCE_DIR=$W/CppInterOp-native -DCPPJIT_ENABLE_CLAD=ON -DCPPJIT_CLAD_SOURCE_DIR=$W/clad" + (cd "$W/cppjit" && "$SP/wheel-venv/bin/pip" wheel --no-deps --no-build-isolation -w "$SP" .) + (cd "$SP" && ls cppjit-*.whl && sha256sum cppjit-*.whl) +} + +overlay() { # the files no conda package owns; the file is kernel-overlay-.tar.gz whether the tag carries the kernel- prefix or not + local tag=${2:?tag}; tag=${tag#kernel-}; cd "$PREFIX" + tar czf "$SP/kernel-overlay-$tag.tar.gz" bin/xcpp.js bin/xcpp.wasm bin/xcpp.data share/jupyter/kernels/xcpp23 + (cd "$SP" && sha256sum "kernel-overlay-$tag.tar.gz") +} + +case "$stage" in + envs) envs;; sources) sources;; build) build;; wasm-opt) wasm_opt;; overlay) overlay "$@";; wheel) wheel;; + all) envs; sources; build;; + *) echo "usage: $0 envs|sources|build|wasm-opt|overlay |wheel|all"; exit 2;; +esac diff --git a/tools/home2lite.py b/tools/home2lite.py new file mode 100644 index 0000000..e814f6b --- /dev/null +++ b/tools/home2lite.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python +"""Turn the home notebooks (Python kernel + cppjit wheel) into JupyterLite notebooks for the xcpp23 kernel that hosts +Python through cppjit: every Python cell becomes a %%python cell, a first pair of cells sets the working directory to the +mounted /cppjit (so kernel/ and data/ paths work unchanged), installs the lazy package loader (kernel/lazy.py: SciPy and +matplotlib download in the background and unpack on first import) and routes plt.show() through a C++ display helper +(matplotlib has no Jupyter backend inside this kernel: the figure is saved to /tmp and shown as a PNG by xcpp::display). +Usage: home2lite.py """ +import sys, json, os, copy, pathlib + +src, dst = pathlib.Path(sys.argv[1]), pathlib.Path(sys.argv[2]); dst.mkdir(parents=True, exist_ok=True) + +CPP_HELPER = r'''// Display helper: the Python cells save figures as PNG, this shows them. (C++ cell: the kernel is C++, Python runs inside it.) +#include +#include +#include "xcpp/xdisplay.hpp" +#include "nlohmann/json.hpp" +struct png_file { std::string bytes; explicit png_file(const std::string& path) { std::ifstream in(path, std::ios::binary); bytes.assign(std::istreambuf_iterator(in), {}); } }; +nlohmann::json mime_bundle_repr(const png_file& p) { + static const char* t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + std::string o; int v = 0, b = -6; + for (unsigned char c : p.bytes) { v = (v << 8) + c; b += 8; while (b >= 0) { o.push_back(t[(v >> b) & 63]); b -= 6; } } + if (b > -6) o.push_back(t[((v << 8) >> (b + 8)) & 63]); + while (o.size() % 4) o.push_back('='); + return {{"image/png", o}}; +} +void show_png(const std::string& path) { xcpp::display(png_file(path)); }''' + +PY_BOOT = '''%%python +# Browser setup: the kernel is C++ (xcpp23) and hosts this Python through cppjit; the notebook's files are mounted at /cppjit. +# SciPy and matplotlib are not in the kernel's start-up set: they download in the background from here on and unpack on +# their first import (kernel/lazy.py), so the kernel is ready sooner and nothing is fetched that a notebook never uses. +import os, sys, cppjit +os.chdir("/cppjit"); sys.path.insert(0, "/cppjit/kernel") +import lazy; lazy.install(show_png=cppjit.gbl.show_png) +print("ready: cppjit", cppjit.__version__, "in the browser, working directory", os.getcwd())''' + +def cell(kind, text): + c = {"cell_type": kind, "metadata": {}, "source": text.splitlines(keepends=True)} + if kind == "code": c["execution_count"] = None; c["outputs"] = [] + return c + +for nb_path in sorted(src.glob("*.ipynb")): + nb = json.load(open(nb_path)); out = copy.deepcopy(nb) + cells = [] + first_code_done = False + for c in nb["cells"]: + if c["cell_type"] == "code": + text = "".join(c["source"]) + if not first_code_done: + cells.append(cell("code", CPP_HELPER)); cells.append(cell("code", PY_BOOT)); first_code_done = True + if text.strip(): + cells.append(cell("code", "%%python\n" + text)) + else: + cells.append(copy.deepcopy(c)) + out["cells"] = cells + out["metadata"]["kernelspec"] = {"display_name": "C++23", "language": "cpp", "name": "xcpp23"} + out["metadata"]["language_info"] = {"name": "cpp", "codemirror_mode": "text/x-c++src", "file_extension": ".cpp", "mimetype": "text/x-c++src", "version": "23"} + json.dump(out, open(dst / nb_path.name, "w"), indent=1, ensure_ascii=False) + print(f"{nb_path.name}: {sum(1 for c in cells if c['cell_type']=='code')} code cells") diff --git a/tools/lite_run.py b/tools/lite_run.py new file mode 100644 index 0000000..fdce5ad --- /dev/null +++ b/tools/lite_run.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python +"""Run cells in a JupyterLite site's REPL app headlessly and dump what each output area shows. +The REPL takes repeated code= query parameters (one per cell) and executes them in order. +Usage: lite_run.py --site http://127.0.0.1:8941 --kernel xcpp23 --cells cells.json [--timeout 300] [--out dir] +cells.json: a JSON list of cell sources (strings). A %%python magic must start its own cell. +Prints each output area's text (and the byte size of any inline image) as JSON lines; exit 0 when the last cell produced output.""" +import argparse, json, sys, time, pathlib, urllib.parse +from playwright.sync_api import sync_playwright + +ap = argparse.ArgumentParser() +ap.add_argument("--site", required=True); ap.add_argument("--kernel", default="xcpp23"); ap.add_argument("--cells", required=True) +ap.add_argument("--timeout", type=int, default=300); ap.add_argument("--out", default=""); ap.add_argument("--sentinel", default="__LITE_DONE__"); ap.add_argument("--ledger", default="", help="write every response (url, status, body bytes) as JSON"); ap.add_argument("--console-all", action="store_true", help="keep every console message, not only errors") +a = ap.parse_args() +cells = json.load(open(a.cells)) +cells = cells + [f'#include \nstd::cout << "{a.sentinel}" << std::endl;'] # a last C++ cell marks the end +url = f"{a.site}/repl/index.html?" + urllib.parse.urlencode([("kernel", a.kernel), ("execute", "1"), ("toolbar", "0")] + [("code", c) for c in cells]) +t0 = time.time(); results = [] +with sync_playwright() as p: + browser = p.chromium.launch(); ctx = browser.new_context(); page = ctx.new_page() + console, net = [], [] + page.on("console", lambda m: console.append(m.text) if (a.console_all or m.type in ("error", "warning")) else None) + ctx.on("response", lambda r: net.append((r.status, r.url)) if (r.status >= 400 or ".so" in r.url or "mount_" in r.url) else None) + ctx.on("requestfailed", lambda r: net.append(("failed", r.url))) + ledger = [] + def _led(r): + try: ledger.append({"url": r.url, "status": r.status, "body": r.request.sizes().get("responseBodySize", -1), "type": r.headers.get("content-type", "")}) + except Exception as e: ledger.append({"url": r.url, "status": r.status, "body": -1, "err": str(e)[:60]}) + if a.ledger: ctx.on("response", _led) + page.goto(url, timeout=120_000, wait_until="domcontentloaded") + done = False + while time.time() - t0 < a.timeout: + time.sleep(2) + areas = page.query_selector_all(".jp-OutputArea-output") + texts = [el.inner_text() for el in areas] + if any(a.sentinel in t for t in texts): done = True; break + areas = page.query_selector_all(".jp-OutputArea-output") + for i, el in enumerate(areas): + img = el.query_selector("img"); src = img.get_attribute("src") if img else None + results.append({"i": i, "text": el.inner_text().strip()[:2000], "image_bytes": (len(src) * 3 // 4) if src else 0}) + if src and a.out: + import base64; pathlib.Path(a.out).mkdir(parents=True, exist_ok=True) + open(pathlib.Path(a.out) / f"out{i}.png", "wb").write(base64.b64decode(src.split(",", 1)[1])) + if a.out: + pathlib.Path(a.out).mkdir(parents=True, exist_ok=True); page.screenshot(path=str(pathlib.Path(a.out) / "page.png"), full_page=True) + browser.close() +if a.ledger: json.dump(ledger, open(a.ledger, "w"), indent=0) +for r in results: print(json.dumps(r)) +print(json.dumps({"done": done, "elapsed_s": round(time.time() - t0), "console_errors": console[:40], "net": net[:40]})) +sys.exit(0 if done else 1) diff --git a/tools/lite_wire.py b/tools/lite_wire.py new file mode 100644 index 0000000..e20085e --- /dev/null +++ b/tools/lite_wire.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python +"""Measure what a reader's browser downloads for one notebook of the JupyterLite site, end to end: open the notebook in +the Lab UI, Run All Cells, wait for the last expected output, record every response body (kernel worker included). +Serve the site with a gzip-capable server first (see lite/README-build.md; python -m http.server does not compress). +Usage: lite_wire.py --site http://127.0.0.1:8943 --notebook 4_higgs_open_data.ipynb --expect "q0 = 9.87" [--images 2] [--out ledger.json] +Prints the bytes received per component, and the time from page load to the expected output.""" +import argparse, json, time, urllib.parse, collections +from playwright.sync_api import sync_playwright + +ap = argparse.ArgumentParser(); ap.add_argument("--site", required=True); ap.add_argument("--notebook", required=True) +ap.add_argument("--expect", required=True, help="text that appears in the last cell's output"); ap.add_argument("--images", type=int, default=0, help="figures expected on the page") +ap.add_argument("--out", default=""); ap.add_argument("--timeout", type=int, default=600) +a = ap.parse_args(); led = [] +with sync_playwright() as p: + b = p.chromium.launch(); ctx = b.new_context(viewport={"width": 1280, "height": 900}); pg = ctx.new_page() + def rec(r): + try: led.append({"url": r.url, "status": r.status, "body": r.request.sizes().get("responseBodySize", -1), "t": time.time()}) + except Exception: pass + ctx.on("response", rec) + t0 = time.time() + pg.goto(f"{a.site}/lab/index.html?path={a.notebook}", timeout=120000, wait_until="domcontentloaded") + for _ in range(120): + time.sleep(2) + if pg.query_selector(".jp-Notebook") and pg.query_selector(".jp-KernelName, .jp-Toolbar-kernelName"): break + t_ui = time.time() - t0 + time.sleep(5); pg.keyboard.press("Escape") + # JupyterLab may ask "Save changes before closing?" for a tab it replaces when opening ?path=; keep the notebook open + for _ in range(10): + if not pg.query_selector(".jp-Dialog"): break + btn = pg.query_selector(".jp-Dialog button:has-text('Cancel')") or pg.query_selector(".jp-Dialog .jp-Dialog-button") + if btn: btn.click() + time.sleep(1) + pg.click("text=Run", timeout=30000); time.sleep(1); pg.click("text=Run All Cells", timeout=30000) + done = False + while time.time() - t0 < a.timeout: + time.sleep(2) + txt = pg.inner_text(".jp-Notebook") + if a.expect in txt and len(pg.query_selector_all(".jp-OutputArea-output img")) >= a.images: done = True; break + t_done = time.time() - t0 + if not done: # leave evidence of what the page showed + shot = (a.out or "wire") + ".png"; pg.screenshot(path=shot, full_page=False) + print("not done; dialogs:", [d.inner_text()[:200].replace("\n", " | ") for d in pg.query_selector_all(".jp-Dialog")], "screenshot:", shot) + b.close() +g = collections.defaultdict(lambda: [0, 0]); tot = 0; per = collections.Counter(); first_cell_bytes = 0 +for r in led: + u = urllib.parse.urlparse(r["url"]); path = u.path + if r["status"] != 200 or r["body"] <= 0: continue + per[path] += 1 + if "/lazy/" in path: k = "lazy packages (first import)" + elif "kernel_packages" in path: k = "Python packages at start" + elif path.endswith(("xcpp.wasm", "xcpp.data", "xcpp.js")): k = "C++ kernel" + elif path.endswith("libclangCppInterOp.so"): k = "CppInterOp module" + elif path.endswith(".so"): k = "shared libraries on demand" + else: k = "app shell, extensions, files" + g[k][0] += r["body"]; g[k][1] += 1; tot += r["body"] +print(f"{a.notebook}: UI up {t_ui:.0f} s, last output {t_done:.0f} s, done={done}") +for k, (bb, c) in sorted(g.items(), key=lambda x: -x[1][0]): print(f" {k:32s} {bb/1048576:6.1f} MB {c:4d} responses") +print(f" {'total':32s} {tot/1048576:6.1f} MB") +dups = [(pp.rsplit('/', 1)[-1], c) for pp, c in per.items() if c > 1 and not pp.endswith(('.json', '.html', '.ipynb'))] +if dups: print(" fetched more than once:", dups[:6]) +if a.out: json.dump({"notebook": a.notebook, "total_bytes": tot, "groups": {k: v[0] for k, v in g.items()}, "ui_s": t_ui, "done_s": t_done, "done": done}, open(a.out, "w"), indent=1) diff --git a/tools/setup-lite-env.sh b/tools/setup-lite-env.sh new file mode 100644 index 0000000..268ce25 --- /dev/null +++ b/tools/setup-lite-env.sh @@ -0,0 +1,87 @@ +#!/usr/bin/env bash +# Recreate, from the repository plus one saved kernel artifact, everything tools/build-lite-site.sh needs: +# +# SP= bash tools/setup-lite-env.sh +# +# Produces under $SP: +# bin/micromamba pinned release (MICROMAMBA_URL) +# site-venv/ host side: jupyter lite build + empack, pinned (lite/env/site-env.requirements.txt, +# constrained by lite/env/build-env.pip-freeze.txt, the 2026-09-20 build environment) +# mamba/envs/xeus-kernels/ the wasm32 environment of the kernel build, from the explicit lock +# (lite/env/xeus-kernels.explicit.txt), plus the kernel overlay: the xcpp23 kernel +# binaries and spec (KERNEL_ART/kernel-overlay-*.tar.gz, the part that takes an hour to +# rebuild: see lite/kernel/README.md) +# mamba/envs/xeus-slim/, xeus-lazy/ derived by deleting conda-meta entries (lite/env/*-remove.txt) and kernel specs +# +# Network: GitHub (micromamba), PyPI, prefix.dev (emscripten-forge-4x). No sudo. About 10 minutes. +set -euo pipefail +: "${SP:?set SP to an empty directory}" +REPO=${REPO:-$(cd "$(dirname "$0")/.." && pwd)} +KERNEL_ART=${KERNEL_ART:-$REPO/lite/kernel-artifacts} # kernel-overlay-*.tar.gz from the GitHub release +MICROMAMBA_URL=${MICROMAMBA_URL:-https://github.com/mamba-org/micromamba-releases/releases/download/2.9.0-0/micromamba-linux-64} +MICROMAMBA_SHA256=${MICROMAMBA_SHA256:-366cd9cd8be14df1ab8ed50352a82111082a36686b2d389fdb79a92c3fafb3e3} # linux-64, release 2.9.0-0 +PY=${PY:-python3} +mkdir -p "$SP/bin" "$SP/mamba" + +if [ ! -x "$SP/bin/micromamba" ]; then + echo "[setup] micromamba <- $MICROMAMBA_URL" + curl -sSL -o "$SP/bin/micromamba" "$MICROMAMBA_URL" + # verified against a digest committed here, not one fetched next to the binary + (cd "$SP/bin" && echo "$MICROMAMBA_SHA256 micromamba" | sha256sum -c -) && chmod +x "$SP/bin/micromamba" +fi +"$SP/bin/micromamba" --version + +if [ ! -x "$SP/site-venv/bin/jupyter" ]; then + echo "[setup] host environment (jupyter lite build, empack)" + "$PY" -m venv "$SP/site-venv" + "$SP/site-venv/bin/pip" install -q -c "$REPO/lite/env/build-env.pip-freeze.txt" -r "$REPO/lite/env/site-env.requirements.txt" +fi +"$SP/site-venv/bin/jupyter" lite --version | xargs echo " jupyterlite-core" + +export MAMBA_ROOT_PREFIX="$SP/mamba" +K="$SP/mamba/envs/xeus-kernels" +if [ ! -d "$K/conda-meta" ]; then + echo "[setup] wasm32 kernel environment from the explicit lock" + "$SP/bin/micromamba" create -y -q -p "$K" --platform emscripten-wasm32 -f "$REPO/lite/env/xeus-kernels.explicit.txt" +fi +echo " $(ls "$K/conda-meta"/*.json | wc -l) packages" + +OVERLAY=$(ls "$KERNEL_ART"/kernel-overlay-*.tar.gz 2>/dev/null | tail -1) +[ -n "$OVERLAY" ] || { echo "no kernel-overlay-*.tar.gz in $KERNEL_ART (download the kernel release assets there first)"; exit 2; } +# the kernel assets must match the digests committed in the repository (lite/kernel/SHA256SUMS), not ones shipped with them +(cd "$KERNEL_ART" && sha256sum -c --ignore-missing "$REPO/lite/kernel/SHA256SUMS") +if [ ! -f "$K/bin/xcpp.wasm" ]; then + echo "[setup] kernel overlay <- $OVERLAY" + tar xzf "$OVERLAY" -C "$K" +fi +ls -la "$K"/bin/xcpp.* | awk '{printf " %6.1f MB %s\n",$5/1048576,$9}' + +# The kernel spec in the overlay names the kernel binary by the absolute path of the machine that built it; jupyterlite-xeus +# finds xcpp.js/.wasm/.data next to argv[0], so point it at this prefix (and at each derived prefix below). +point_kernelspec() { # point_kernelspec + "$PY" - "$1" <<'PY' +import json, sys, pathlib +prefix = pathlib.Path(sys.argv[1]) +for ks in (prefix / "share/jupyter/kernels").glob("*/kernel.json"): + d = json.load(open(ks)); d["argv"][0] = str(prefix / "bin" / pathlib.Path(d["argv"][0]).name) + json.dump(d, open(ks, "w"), indent=2) +PY +} +point_kernelspec "$K" + +derive() { # derive ...: copy, then drop conda-meta entries and kernel specs + local src=$1 dst=$2; shift 2 + case "$dst" in */mamba/envs/*) ;; *) echo "refusing to remove $dst"; exit 2;; esac + rm -rf "$dst" && cp -a "$src" "$dst" + for list in "$@"; do + for p in $(grep -v '^#' "$list"); do rm -f "$dst"/conda-meta/"$p"-[0-9]*.json; done + done + for ks in $(grep -v '^#' "$REPO/lite/env/kernelspecs-remove.txt"); do rm -rf "$dst/share/jupyter/kernels/$ks"; done + rm -rf "$dst/share/jupyter/labextensions" + point_kernelspec "$dst" + echo " $(basename "$dst"): $(ls "$dst"/conda-meta/*.json | wc -l) packages, kernels: $(ls "$dst/share/jupyter/kernels")" +} +echo "[setup] derived environments" +derive "$K" "$SP/mamba/envs/xeus-slim" "$REPO/lite/env/slim-remove.txt" +derive "$K" "$SP/mamba/envs/xeus-lazy" "$REPO/lite/env/slim-remove.txt" "$REPO/lite/env/lazy-remove.txt" +echo "SETUP_DONE $SP" diff --git a/xeus-cpp/07_stl_modern_cpp.ipynb b/xeus-cpp/07_stl_modern_cpp.ipynb index 62c51b0..928d39e 100644 --- a/xeus-cpp/07_stl_modern_cpp.ipynb +++ b/xeus-cpp/07_stl_modern_cpp.ipynb @@ -206,23 +206,21 @@ ], "source": [ "// Lambda captures\n", - "[&]() {\n", - "int threshold = 5;\n", - "auto isAbove = [threshold](int x) { return x > threshold; }; // capture by value\n", - "auto addTo = [&threshold](int x) { return x + threshold; }; // capture by reference\n", - "\n", - "std::vector nums = {1, 3, 5, 7, 9, 2, 4, 6, 8};\n", - "std::vector above, shifted;\n", - "\n", - "std::copy_if(nums.begin(), nums.end(), back_inserter(above), isAbove);\n", - "std::transform(nums.begin(), nums.end(), back_inserter(shifted), addTo);\n", - "\n", - "std::cout << \"Above \" << threshold << \": \";\n", - "for (int x : above) std::cout << x << \" \";\n", - "std::cout << \"\\nShifted +\" << threshold << \": \";\n", - "for (int x : shifted) std::cout << x << \" \";\n", - "std::cout << std::endl;\n", - "}();" + "void lambda_captures() {\n", + " int threshold = 5;\n", + " auto isAbove = [threshold](int x) { return x > threshold; }; // capture by value\n", + " auto addTo = [&threshold](int x) { return x + threshold; }; // capture by reference\n", + " std::vector nums = {1, 3, 5, 7, 9, 2, 4, 6, 8};\n", + " std::vector above, shifted;\n", + " std::copy_if(nums.begin(), nums.end(), back_inserter(above), isAbove);\n", + " std::transform(nums.begin(), nums.end(), back_inserter(shifted), addTo);\n", + " std::cout << \"Above \" << threshold << \": \";\n", + " for (int x : above) std::cout << x << \" \";\n", + " std::cout << \"\\nShifted +\" << threshold << \": \";\n", + " for (int x : shifted) std::cout << x << \" \";\n", + " std::cout << std::endl;\n", + "}\n", + "lambda_captures();" ] }, { @@ -326,7 +324,7 @@ ], "source": [ "// std::variant\n", - "{\n", + "void variant_demo() {\n", " using Number = std::variant;\n", "\n", " std::vector my_numbers = {42, 3.14, std::string(\"forty-two\"), 100, 2.718};\n", @@ -347,7 +345,8 @@ " std::cout << \")\" << std::endl;\n", " }, n);\n", " }\n", - "}" + "}\n", + "variant_demo();" ] } ],