Run extensive tests in CI when relevant files change

Add a CI job with a dynamically calculated matrix that runs extensive
jobs on changed files. This makes use of the new
`function-definitions.json` file to determine which changed files
require full tests for a routine to run.

Author: tgross35

.github/workflows/main.yml

@@ -186,13 +186,71 @@ jobs:
         rustup component add rustfmt
     - run: cargo fmt -- --check
 
+  calculate_matrix:
+    name: Calculate job matrix
+    runs-on: ubuntu-24.04
+    outputs:
+      matrix: ${{ steps.script.outputs.matrix }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 100
+      - name: Fetch pull request ref
+        run: git fetch origin "$GITHUB_REF:$GITHUB_REF"
+      - run: python3 ci/calculate-exhaustive-matrix.py >> "$GITHUB_OUTPUT"
+        id: script
+
+  extensive:
+    name: Extensive tests for ${{ matrix.ty }}
+    needs:
+      - test
+      - calculate_matrix
+    runs-on: ubuntu-24.04
+    timeout-minutes: 80
+    strategy:
+      matrix:
+        ty: [f16, f32, f64, f128]
+        # Use the output from `calculate_matrix` to add more `skip` and `changed`
+        include: ${{ fromJSON(needs.calculate_matrix.outputs.matrix).matrix }}
+    env:
+      CHANGED: ${{ matrix.changed }}
+    steps:
+      - uses: actions/checkout@v4
+        if: ${{ !matrix.skip }}
+
+      - name: Install Rust
+        if: ${{ !matrix.skip }}
+        run: |
+          rustup update nightly --no-self-update
+          rustup default nightly
+
+      - uses: Swatinem/rust-cache@v2
+        if: ${{ !matrix.skip }}
+
+      - name: Download musl source
+        if: ${{ !matrix.skip }}
+        run: ./ci/download-musl.sh
+
+      - name: Run extensive tests
+        if: ${{ !matrix.skip }}
+        run: |
+          LIBM_EXTENSIVE_TESTS="$CHANGED" cargo t \
+            --features test-multiprecision,build-musl,unstable \
+            --release -- extensive
+
+      - name: Print test logs if available
+        if: ${{ !matrix.skip }}
+        run: if [ -f "target/test-log.txt" ]; then cat target/test-log.txt; fi
+        shell: bash
+
   success:
     needs:
       - test
       - builtins
       - benchmarks
       - msrv
       - rustfmt
+      - extensive
     runs-on: ubuntu-24.04
     # GitHub branch protection is exceedingly silly and treats "jobs skipped because a dependency
     # failed" as success. So we have to do some contortions to ensure the job fails if any of its

ci/calculate-exhaustive-matrix.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""Calculate which exhaustive tests should be run as part of CI.
+
+This dynamically prepares a list of TODO
+"""
+
+import subprocess as sp
+import sys
+import json
+from dataclasses import dataclass
+from os import getenv
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).parent.parent
+GIT = ["git", "-C", REPO_ROOT]
+
+IGNORE_FILES = [
+    "src/math/support/",
+    "src/libm_helper.rs",
+    "src/math/arch/intrinsics.rs",
+]
+"""Don't run exhaustive tests if these files change, even if they contaiin a function
+definition."""
+
+
+@dataclass
+class Context:
+    gh_ref: str | None
+    changed: list[Path]
+    defs: dict[str, dict[str, list[str] | str]]
+    """A list of all available functions by name."""
+
+    def __init__(self) -> None:
+        self.gh_ref = getenv("GITHUB_REF")
+        self.changed = []
+        self._init_change_list()
+
+        with open(REPO_ROOT.joinpath("etc/function-definitions.json")) as f:
+            defs = json.load(f)
+
+        defs.pop("__comment", None)
+        self.defs = defs
+
+    def _init_change_list(self):
+        """Create a list of files that have been changed. This uses GITHUB_REF if
+        available, otherwise a diff between `HEAD` and `master`."""
+
+        # For pull requests, GitHub creates a ref `refs/pull/1234/merge` (1234 being
+        # the PR number), and sets this as `GITHUB_REF`.
+        ref = self.gh_ref
+        if ref is not None:
+            eprint(f"using ref `{ref}`")
+            if "merge" not in ref:
+                # If the ref is not for `merge` then we are not in PR CI
+                eprint("No diff available for ref")
+                return
+
+            # The ref is for a dummy merge commit. We can extract the merge base by
+            # inspecting all parents (`^@`).
+            merge_sha = sp.check_output(
+                GIT + ["show-ref", "--hash", ref], text=True
+            ).strip()
+            merge_log = sp.check_output(GIT + ["log", "-1", merge_sha], text=True)
+            eprint(f"Merge:\n{merge_log}\n")
+
+            parents = (
+                sp.check_output(GIT + ["rev-parse", f"{merge_sha}^@"], text=True)
+                .strip()
+                .splitlines()
+            )
+            assert len(parents) == 2, f"expected two-parent merge but got:\n{parents}"
+            base = parents[0]
+            incoming = parents[1]
+        else:
+            # When running locally, allow providing a rev via `MERGE_BASE`. Otherwise
+            # assume `HEAD -> MASTER`
+            base = getenv("MERGE_BASE")
+            if base is None:
+                base = sp.check_output(
+                    GIT + ["merge-base", "HEAD", "master"], text=True
+                )
+            incoming = "HEAD"
+
+        base = base.strip()
+        incoming = incoming.strip()
+
+        eprint(f"base: {base}, incoming: {incoming}")
+        textlist = sp.check_output(
+            GIT + ["diff", base, incoming, "--name-only"], text=True
+        )
+        self.changed = [Path(p) for p in textlist.splitlines()]
+
+    def changed_routines(self) -> dict[str, list[str]]:
+        """Create a list of routines for which one or more files have been updated,
+        separated by type.
+        """
+        routines = set()
+        for name, meta in self.defs.items():
+            def_list = meta["sources"]
+            add = False
+            for fname in def_list:
+                # Skip if the file was not changed
+                if Path(fname) not in self.changed:
+                    continue
+
+                # Don't update if changes to the file should be ignored
+                if any(fname.startswith(pfx) for pfx in IGNORE_FILES):
+                    continue
+
+                add = True
+
+            if add:
+                routines.add(name)
+
+        ret = {}
+        for r in sorted(routines):
+            ret.setdefault(self.defs[r]["type"], []).append(r)
+
+        return ret
+
+    def make_workflow_output(self) -> str:
+        changed = self.changed_routines()
+        ret = []
+        for ty in ["f16", "f32", "f64", "f128"]:
+            ty_changed = changed.get(ty, [])
+            item = {
+                "ty": ty,
+                "changed": ",".join(ty_changed),
+                "skip": len(ty_changed) == 0,
+            }
+            ret.append(item)
+        output = json.dumps({"matrix": ret}, separators=(",", ":"))
+        eprint(f"output: {output}")
+        return output
+
+
+def eprint(*args, **kwargs):
+    """Print to stderr."""
+    print(*args, file=sys.stderr, **kwargs)
+
+
+def main():
+    ctx = Context()
+    output = ctx.make_workflow_output()
+    print(f"matrix={output}")
+
+
+if __name__ == "__main__":
+    main()