mdir 0.2.1__tar.gz

mdir-0.2.1/.dockerignore

@@ -0,0 +1,18 @@
+# The build context of packaging/Dockerfile is the source tree only: no
+# repository metadata, build trees, archives, or local notes, so that they
+# neither enlarge the context nor invalidate the layer of MDIR's sources.
+.git
+.github
+.claude
+.codex
+build
+build-*
+**/__pycache__
+*.zip
+*.tar.gz
+*.sif
+docs/diagrams
+docs/paper/out
+notes
+AGENTS.md
+LEADER.md

mdir-0.2.1/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: true

mdir-0.2.1/.github/ISSUE_TEMPLATE/defect.md

@@ -0,0 +1,26 @@
+---
+name: Defect
+about: A run that fails, crashes, or gives results that look wrong
+labels: defect
+---
+
+## What happened
+
+<!-- The command, what you expected, and what happened instead. Paste the
+     message of the error, or the lines of the log that look wrong. -->
+
+## Report
+
+<!-- Run the following and attach report.tar.gz. It holds the version, the
+     devices, the inputs (with hashes; those over 16 MiB are not copied),
+     and the program at each stage. See docs/debugging.md.
+
+       mdir bug-report run.toml -o report --run
+       tar czf report.tar.gz report
+
+     If the run takes long, leave out --run and paste the log instead. -->
+
+## Anything else
+
+<!-- Whether it happens on the CPU and the GPU, with double and mixed
+     precision, with MDRT_WAIT=1, or under compute-sanitizer. -->

mdir-0.2.1/.github/workflows/ci-image.yml

@@ -0,0 +1,85 @@
+name: ci-image
+
+# The image of the CPU tier of CI (#611): HDF5, LLVM/MLIR 23.1.2, and the
+# tools of the tests, pushed to ghcr.io/vv137/mdir-ci with the tag
+# `llvm-23.1.2-<hash>`, a hash of packaging/Dockerfile and of the two build
+# scripts, which ci.yml computes the same way. LLVM is built by
+# scripts/build-llvm.sh in up to three parts that share a compile cache
+# (ci-llvm-part.yml), since one hosted job cannot build it in six hours;
+# the image is then the stage `ci-prebuilt` of packaging/Dockerfile over
+# that install (the stage `ci` builds the same image in one go where a
+# machine can). It pushes, so it runs only when the maintainer starts it
+# (workflow_dispatch; the maintainer, 2026-10-26), and builds nothing when
+# the tag is present already.
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  tag:
+    runs-on: ubuntu-latest
+    outputs:
+      image: ${{ steps.tag.outputs.image }}
+      present: ${{ steps.present.outputs.yes }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: tag
+        run: |
+          hash=$(cat packaging/Dockerfile scripts/build-llvm.sh scripts/build-hdf5.sh | sha256sum | cut -c1-16)
+          echo "image=ghcr.io/vv137/mdir-ci:llvm-23.1.2-$hash" >> "$GITHUB_OUTPUT"
+      - id: present
+        run: |
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u "${{ github.actor }}" --password-stdin
+          if docker manifest inspect "${{ steps.tag.outputs.image }}" > /dev/null 2>&1; then
+            echo "yes=true" >> "$GITHUB_OUTPUT"
+          fi
+
+  part1:
+    needs: tag
+    uses: ./.github/workflows/ci-llvm-part.yml
+    with:
+      part: 1
+      skip: ${{ needs.tag.outputs.present == 'true' }}
+  part2:
+    needs: [tag, part1]
+    uses: ./.github/workflows/ci-llvm-part.yml
+    with:
+      part: 2
+      skip: ${{ needs.tag.outputs.present == 'true' || needs.part1.outputs.done == 'true' }}
+  part3:
+    needs: [tag, part1, part2]
+    uses: ./.github/workflows/ci-llvm-part.yml
+    with:
+      part: 3
+      skip: ${{ needs.tag.outputs.present == 'true' || needs.part1.outputs.done == 'true' || needs.part2.outputs.done == 'true' }}
+
+  image:
+    needs: [tag, part1, part2, part3]
+    if: ${{ always() && needs.tag.outputs.present != 'true' && (needs.part1.outputs.done == 'true' || needs.part2.outputs.done == 'true' || needs.part3.outputs.done == 'true') }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          name: llvm-install
+      - name: The install of LLVM in the context
+        run: mkdir ci-llvm && tar -C ci-llvm -xzf llvm-install.tar.gz && rm llvm-install.tar.gz && du -sh ci-llvm
+      - uses: docker/setup-buildx-action@v3
+      - name: Login
+        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u "${{ github.actor }}" --password-stdin
+      - uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: packaging/Dockerfile
+          target: ci-prebuilt
+          push: true
+          tags: ${{ needs.tag.outputs.image }}
+      - name: Size
+        run: |
+          docker pull -q "${{ needs.tag.outputs.image }}"
+          docker image inspect "${{ needs.tag.outputs.image }}" --format '{{.Size}}' |
+            awk '{printf "image size: %.2f GB\n", $1 / 1e9}' | tee -a "$GITHUB_STEP_SUMMARY"

mdir-0.2.1/.github/workflows/ci-llvm-part.yml

@@ -0,0 +1,81 @@
+name: ci-llvm-part
+
+# One part of the build of LLVM/MLIR 23.1.2 for the image of CI (#611),
+# called by ci-image.yml. A hosted job has 4 cores and six hours, which the
+# whole build exceeds, so each part builds for at most 320 minutes with
+# scripts/build-llvm.sh and keeps its compile cache (ccache) in the Actions
+# cache; the next part takes it and goes on. The part that finishes uploads
+# the install tree.
+on:
+  workflow_call:
+    inputs:
+      part:
+        type: number
+        required: true
+      skip:
+        type: boolean
+        default: false
+    outputs:
+      done:
+        value: ${{ jobs.build.outputs.done }}
+
+jobs:
+  build:
+    if: ${{ !inputs.skip }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 355
+    outputs:
+      done: ${{ steps.build.outputs.done }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Disk
+        run: |
+          sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/ghc /opt/hostedtoolcache/CodeQL
+          df -h /
+      - name: Tools
+        run: sudo apt-get update -q && sudo apt-get install -y -q ninja-build ccache lld
+      - name: Key
+        id: key
+        run: echo "hash=$(cat packaging/Dockerfile scripts/build-llvm.sh scripts/build-hdf5.sh | sha256sum | cut -c1-16)" >> "$GITHUB_OUTPUT"
+      - uses: actions/cache/restore@v4
+        with:
+          path: ~/.ccache
+          key: llvm-ccache-${{ steps.key.outputs.hash }}-${{ github.run_id }}-${{ inputs.part }}
+          restore-keys: llvm-ccache-${{ steps.key.outputs.hash }}-
+      - name: Build
+        id: build
+        env:
+          CCACHE_DIR: ~/.ccache
+          CCACHE_MAXSIZE: 6G
+          CCACHE_COMPRESS: "true"
+        run: |
+          export CCACHE_DIR=$HOME/.ccache
+          ccache -z
+          start=$(date +%s)
+          status=0
+          LLVM_ROOT=$HOME/llvm LLVM_PREFIX=$HOME/llvm-install LLVM_VERSION=23.1.2 \
+            LLVM_TARGETS="X86;NVPTX" JOBS=4 LINK_JOBS=2 \
+            LLVM_EXTRA_CMAKE_ARGS="-DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DLLVM_USE_LINKER=lld" \
+            timeout 320m scripts/build-llvm.sh || status=$?
+          echo "part ${{ inputs.part }}: status $status after $(( $(date +%s) - start )) s" | tee -a "$GITHUB_STEP_SUMMARY"
+          ccache -s | tee -a "$GITHUB_STEP_SUMMARY"
+          df -h / | tee -a "$GITHUB_STEP_SUMMARY"
+          if [ "$status" -eq 0 ]; then
+            echo "done=true" >> "$GITHUB_OUTPUT"
+          elif [ "$status" -ne 124 ]; then
+            exit "$status"
+          fi
+      - uses: actions/cache/save@v4
+        if: always()
+        with:
+          path: ~/.ccache
+          key: llvm-ccache-${{ steps.key.outputs.hash }}-${{ github.run_id }}-${{ inputs.part }}
+      - name: Install tree
+        if: steps.build.outputs.done == 'true'
+        run: tar -C "$HOME/llvm-install" -czf llvm-install.tar.gz .
+      - uses: actions/upload-artifact@v4
+        if: steps.build.outputs.done == 'true'
+        with:
+          name: llvm-install
+          path: llvm-install.tar.gz
+          retention-days: 3

mdir-0.2.1/.github/workflows/ci.yml

@@ -0,0 +1,134 @@
+name: ci
+
+# The CPU tier of CI (#611; docs/workflow.md, Continuous integration), in two
+# tiers:
+#
+# 1. checks, on every push to a pull request and to main: the links, the
+#    decision numbers and their table, the changelog fragments, the list of
+#    the expected unsupported tests, and the release path. No build;
+#    seconds.
+# 2. build, on a pull request that is ready for review (not on a draft) and
+#    on main: MDIR built in the image of ci-image.yml, with Python, and its
+#    CPU tests (lit, no GPU: the GPU tests are unsupported). The compile
+#    cache (ccache) is kept in the Actions cache between runs. It does not
+#    block a merge yet; the GPU suite, the sanitizer tier, and the Amber
+#    suite still run on the cluster at the train.
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+  push:
+    branches: [main]
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  checks:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Links
+        run: python3 scripts/check-markdown-links.py
+      - name: Decision numbers and their table
+        run: scripts/decision-number.sh check --pending
+      - name: Changelog fragments
+        run: python3 scripts/release/changelog.py fragments
+      - name: The list of the expected unsupported tests
+        run: python3 test/mdir_lit.py
+      - name: The release path
+        run: scripts/release/check-path.sh
+
+  build:
+    if: github.event_name == 'push' || github.event.pull_request.draft == false
+    needs: checks
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    continue-on-error: true
+    # The CPU tests in four shards (the maintainer, 2026-10-26), each a job of
+    # its own that builds MDIR from the shared compile cache and runs every
+    # fourth test in the lexical order of their names (D344), so
+    # that the four together hold every test once. Shard 1 also builds the
+    # Python package from its sdist, and alone saves the cache.
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [1, 2, 3, 4]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Image
+        id: image
+        run: |
+          hash=$(cat packaging/Dockerfile scripts/build-llvm.sh scripts/build-hdf5.sh | sha256sum | cut -c1-16)
+          echo "name=ghcr.io/vv137/mdir-ci:llvm-23.1.2-$hash" >> "$GITHUB_OUTPUT"
+      # Restored and saved apart, so that the cache is kept also when a test
+      # fails (the build is what it holds).
+      - name: Compile cache
+        uses: actions/cache/restore@v4
+        with:
+          path: .ccache
+          key: ccache-shards-${{ steps.image.outputs.name }}-${{ github.sha }}
+          restore-keys: ccache-shards-${{ steps.image.outputs.name }}-
+      - name: Build and CPU tests, shard ${{ matrix.shard }} of 4
+        env:
+          SHARD: ${{ matrix.shard }}
+        run: |
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u "${{ github.actor }}" --password-stdin
+          docker pull -q "${{ steps.image.outputs.name }}" || {
+            echo "::error::no image ${{ steps.image.outputs.name }}; the maintainer builds it (docs/workflow.md)"; exit 1; }
+          # As the runner's user, not root: root writes into a directory of
+          # mode 555 (checkpoint-write-failure.test), and git refuses a
+          # repository that another user owns (the commit of the manifest,
+          # script-paths.test).
+          docker run --rm --user "$(id -u):$(id -g)" -e HOME=/tmp -e SHARD \
+            -v "$PWD":/src -w /src -e CCACHE_DIR=/src/.ccache \
+            -e CCACHE_MAXSIZE=2G "${{ steps.image.outputs.name }}" bash -euo pipefail -c '
+            start=$(date +%s)
+            ccache -z
+            cmake -G Ninja -S . -B /tmp/build -DCMAKE_BUILD_TYPE=Release \
+              -DLLVM_DIR=/opt/llvm/23.1.2/lib/cmake/llvm \
+              -DMLIR_DIR=/opt/llvm/23.1.2/lib/cmake/mlir \
+              -DLLVM_EXTERNAL_LIT=$(command -v lit) \
+              -DHDF5_ROOT=/opt/hdf5/1.14.6 -DMDIR_ENABLE_CUDA=OFF \
+              -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+              "-DCMAKE_EXE_LINKER_FLAGS=-fuse-ld=lld" \
+              "-DCMAKE_SHARED_LINKER_FLAGS=-fuse-ld=lld" \
+              "-DCMAKE_MODULE_LINKER_FLAGS=-fuse-ld=lld" \
+              -DMDIR_ENABLE_PYTHON=ON \
+              -Dpybind11_DIR=$(python3 -m pybind11 --cmakedir) \
+              -DPython_EXECUTABLE=$(command -v python3)
+            ninja -C /tmp/build
+            built=$(date +%s)
+            hits=$(ccache -s | sed -n "s/^ *Hits: *\([0-9]*\) *\/ *\([0-9]*\).*/\1 of \2/p" | head -1)
+            echo "shard $SHARD: build $((built - start)) s (ccache hits: ${hits:-none})" > /src/.ci-times
+            # The GPU, PyTorch, OpenMM, and h5py are not here: their tests
+            # are unsupported, which the list of #608 does not describe.
+            status=0
+            lit -j 4 -sv -Dexpected_unsupported=off --order=lexical \
+              --num-shards=4 --run-shard="$SHARD" /tmp/build/test || status=$?
+            end=$(date +%s)
+            echo "shard $SHARD: tests $((end - built)) s, lit status $status" >> /src/.ci-times
+            # The Python package from its sdist, built and installed as a
+            # user does (#624), in shard 1, where the script exists.
+            if [ "$SHARD" = 1 ] && [ -x scripts/check-sdist.sh ]; then
+              HDF5_LIBRARY_DIR=/opt/hdf5/1.14.6/lib scripts/check-sdist.sh /tmp/sdist \
+                cmake.define.LLVM_DIR=/opt/llvm/23.1.2/lib/cmake/llvm \
+                cmake.define.MLIR_DIR=/opt/llvm/23.1.2/lib/cmake/mlir \
+                cmake.define.HDF5_ROOT=/opt/hdf5/1.14.6 \
+                cmake.define.MDIR_ENABLE_CUDA=OFF \
+                cmake.define.CMAKE_C_COMPILER_LAUNCHER=ccache \
+                cmake.define.CMAKE_CXX_COMPILER_LAUNCHER=ccache || status=1
+              echo "shard $SHARD: sdist $(($(date +%s) - end)) s" >> /src/.ci-times
+            fi
+            exit $status
+          '
+      - name: Times
+        if: always()
+        run: cat .ci-times 2>/dev/null | tee -a "$GITHUB_STEP_SUMMARY" || true
+      - name: Save the compile cache
+        if: always() && matrix.shard == 1
+        uses: actions/cache/save@v4
+        with:
+          path: .ccache
+          key: ccache-shards-${{ steps.image.outputs.name }}-${{ github.sha }}

mdir-0.2.1/.github/workflows/decisions.yml

@@ -0,0 +1,22 @@
+name: decisions
+
+# On main, the table of docs/decisions.md is that of docs/decisions/, a
+# decision without its number yet has its file there, and every changelog
+# fragment is well formed (#602). Branches write labels, D[<label>], and
+# the merger numbers them after the merge (docs/workflow.md), so a push of
+# a merge carries labels until the commit that numbers them; a tag runs the
+# strict check (release-check.yml).
+on:
+  push:
+    branches: [main]
+  # A change of this workflow runs it on its pull request.
+  pull_request:
+    paths: ['.github/workflows/decisions.yml']
+
+jobs:
+  numbers:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: scripts/decision-number.sh check --pending
+      - run: python3 scripts/release/changelog.py fragments

mdir-0.2.1/.github/workflows/release-check.yml

@@ -0,0 +1,22 @@
+name: release-check
+
+# A tag vX.Y.Z must name the version that CMakeLists.txt states, have a dated
+# section in CHANGELOG.md, and leave no decision without its number. The
+# build and the suite run on the maintainer's machine before the tag
+# (scripts/release/publish.sh); there is no GPU here.
+on:
+  push:
+    tags: ['v*']
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Version, changelog, decisions
+        run: |
+          version=${GITHUB_REF_NAME#v}
+          grep -q "project(mdir VERSION $version " CMakeLists.txt
+          python3 scripts/release/changelog.py check "$version"
+          test -f "docs/release-notes/$GITHUB_REF_NAME.md"
+          scripts/decision-number.sh check

mdir-0.2.1/.github/workflows/release-path.yml

@@ -0,0 +1,24 @@
+name: release-path
+
+# The release path on a copy of the tree, on every push to main (#609;
+# docs/workflow.md, Releases): the edits of prepare.sh with the next
+# version, the move of the changelog with its count, the notes of the
+# GitHub Release, their links, and the version pinned in tests or code.
+# No build and no GPU.
+on:
+  push:
+    branches: [main]
+  pull_request:
+    paths:
+      - 'scripts/release/**'
+      - 'CHANGELOG.md'
+      - 'changelog.d/**'
+      - 'CMakeLists.txt'
+      - '.github/workflows/release-path.yml'
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: scripts/release/check-path.sh

mdir-0.2.1/.gitignore

@@ -0,0 +1,9 @@
+/build/
+/build-*/
+__pycache__/
+argon.dcd
+/references/
+.claude
+.codex
+.env
+.env.*