Skip to content

Commit a07cb40

Browse files
SunrisepeakSunrisepeak
committed
ci: split windows/macos e2e into parallel workflows, fan out the linux job
Critical path was max(ci-windows 20.4m, ci-linux 18.2m) on a warm PR run. Both were single sequential jobs; everything below is wall-clock, not work. - .github/actions/bootstrap-mcpp: composite action for the cache lineage (mcpp sandbox + xlings + target/) and the xlings bootstrap, so the split jobs share ONE definition instead of a 40-line copy-pasted preamble each. Target cache is now keyed per job — the toolchain legs `clean` and rebuild, so a shared key had them clobbering each other's lineage. - .github/actions/setup-macos-llvm: same idea for the macOS-specific setup (xlings LLVM + sandbox wired to that exact package). - ci-linux.yml: one job -> four independent jobs (build+unit, cold gcc self-host, musl+llvm, xlings integration). No `needs:` — each pays one warm `mcpp build` (~2.5m), which is cheaper than serialising behind an artifact. Dropped the duplicate `mcpp test` in the gcc leg: same suite, same toolchain, same driver binary as build-test, differing only in incremental state. ~18m -> ~7-8m. - ci-windows.yml: e2e moved out (9.7m of 20.4m); remainder split into build+test+package and toolchains+regressions. Integration keeps its original position before the llvm rebuild that invalidates $MCPP_SELF. ~20m -> ~8m. - ci-windows-e2e.yml, ci-macos-e2e.yml: new, mirroring ci-linux-e2e.yml. macOS is not sharded — 3.5m is under this workflow's setup+build floor. - ci-macos.yml: e2e step removed, setup replaced by the composite; the clang probe/module validation steps stay here. - run_all.sh: E2E_SHARD="<index>/<total>" runs a round-robin slice. Round robin rather than contiguous ranges because per-test durations are wildly uneven (the existing timing report exists for exactly that reason). The slice is computed on the full file list before capability filtering, so a test's shard does not move with host capabilities. Linux and Windows e2e run 2 shards; 147 tests split 74/73. Expected critical path: ~20.4m -> ~8m.
1 parent 9cd0cfe commit a07cb40

9 files changed

Lines changed: 568 additions & 376 deletions

File tree

‎.github/actions/bootstrap-mcpp/action.yml‎

Lines changed: 113 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,113 @@
1+
name: bootstrap-mcpp
2+
description: >
3+
Restore the shared CI cache lineage (mcpp sandbox + xlings + target/) and
4+
bootstrap a released mcpp via xlings. Exports MCPP and XLINGS_BIN.
5+
6+
Extracted so the split CI jobs (build / toolchain legs / e2e shards /
7+
integration) share ONE definition instead of copy-pasting a 40-line
8+
preamble per job. Every job that uses it lands on the same cache keys,
9+
which is what makes splitting cheap: each job restores a warm sandbox
10+
and only pays one incremental `mcpp build`.
11+
12+
inputs:
13+
xlings-version:
14+
description: xlings release to bootstrap from
15+
required: false
16+
default: '0.4.30'
17+
cache-target:
18+
description: also restore/save target/ (build artifacts + BMIs)
19+
required: false
20+
default: 'true'
21+
22+
runs:
23+
using: composite
24+
steps:
25+
# NOTE: the "-ci-" segment keeps this lineage disjoint from release.yml's
26+
# "-release-" caches. A bare "mcpp-sandbox-<os>-" restore prefix used to
27+
# match the release sandbox too, silently swapping in a differently
28+
# populated registry (issue #120).
29+
- name: Cache mcpp sandbox
30+
uses: actions/cache@v4
31+
with:
32+
path: ~/.mcpp
33+
key: mcpp-sandbox-${{ runner.os }}-ci-${{ hashFiles('mcpp.toml', '.xlings.json') }}
34+
restore-keys: |
35+
mcpp-sandbox-${{ runner.os }}-ci-
36+
37+
- name: Cache xlings
38+
uses: actions/cache@v4
39+
with:
40+
path: ~/.xlings
41+
key: xlings-${{ runner.os }}-v2-${{ hashFiles('.xlings.json') }}
42+
restore-keys: |
43+
xlings-${{ runner.os }}-v2-
44+
45+
- name: Bootstrap mcpp via xlings (unix)
46+
if: runner.os != 'Windows'
47+
shell: bash
48+
env:
49+
XLINGS_NON_INTERACTIVE: '1'
50+
XLINGS_VERSION: ${{ inputs.xlings-version }}
51+
run: |
52+
# Always install the pinned version — the cache may hold an older
53+
# xlings whose sysroot/packages are incompatible.
54+
case "$(uname -s)" in
55+
Darwin) tarball="xlings-${XLINGS_VERSION}-macosx-arm64.tar.gz" ;;
56+
*) tarball="xlings-${XLINGS_VERSION}-linux-x86_64.tar.gz" ;;
57+
esac
58+
WORK=$(mktemp -d)
59+
curl -fsSL -o "${WORK}/${tarball}" \
60+
"https://github.com/d2learn/xlings/releases/download/v${XLINGS_VERSION}/${tarball}"
61+
tar -xzf "${WORK}/${tarball}" -C "${WORK}"
62+
"${WORK}/${tarball%.tar.gz}/subos/default/bin/xlings" self install
63+
export PATH="$HOME/.xlings/subos/default/bin:$PATH"
64+
echo "$HOME/.xlings/subos/default/bin" >> "$GITHUB_PATH"
65+
xlings --version
66+
# xim:mcpp — `xlings install` is idempotent, so cache hits skip the
67+
# download.
68+
xlings install mcpp -y
69+
MCPP="$HOME/.xlings/subos/default/bin/mcpp"
70+
test -x "$MCPP"
71+
"$MCPP" --version
72+
echo "MCPP=$MCPP" >> "$GITHUB_ENV"
73+
echo "XLINGS_BIN=$HOME/.xlings/subos/default/bin/xlings" >> "$GITHUB_ENV"
74+
75+
- name: Bootstrap mcpp via xlings (windows)
76+
if: runner.os == 'Windows'
77+
shell: bash
78+
env:
79+
XLINGS_NON_INTERACTIVE: '1'
80+
XLINGS_VERSION: ${{ inputs.xlings-version }}
81+
run: |
82+
WORK=$(mktemp -d)
83+
zipfile="xlings-${XLINGS_VERSION}-windows-x86_64.zip"
84+
curl -fsSL -o "${WORK}/${zipfile}" \
85+
"https://github.com/d2learn/xlings/releases/download/v${XLINGS_VERSION}/${zipfile}"
86+
cd "${WORK}"
87+
unzip -q "${zipfile}"
88+
"$WORK/xlings-${XLINGS_VERSION}-windows-x86_64/subos/default/bin/xlings.exe" self install
89+
export PATH="$USERPROFILE/.xlings/subos/default/bin:$PATH"
90+
echo "$USERPROFILE/.xlings/subos/default/bin" >> "$GITHUB_PATH"
91+
xlings.exe --version
92+
xlings.exe install mcpp -y
93+
MCPP=$(find "$USERPROFILE/.xlings" -name "mcpp.exe" -path "*/bin/*" 2>/dev/null | head -1)
94+
if [ -z "$MCPP" ]; then
95+
MCPP=$(find "$USERPROFILE/.xlings" -name "mcpp" -path "*/bin/*" 2>/dev/null | head -1)
96+
fi
97+
test -n "$MCPP" || { echo "FAIL: mcpp not found after xlings install"; exit 1; }
98+
"$MCPP" --version
99+
echo "MCPP=$MCPP" >> "$GITHUB_ENV"
100+
echo "XLINGS_BIN=$(cygpath -w "$USERPROFILE/.xlings/subos/default/bin/xlings.exe")" >> "$GITHUB_ENV"
101+
102+
# Precise key on src/ + manifest so a no-source-change run lands on a full
103+
# hit; layered restore-keys let partial hits keep BMI/dyndep state for a
104+
# proper incremental build.
105+
- name: Cache target/ (build artifacts + BMIs)
106+
if: inputs.cache-target == 'true'
107+
uses: actions/cache@v4
108+
with:
109+
path: target
110+
key: mcpp-target-${{ runner.os }}-${{ github.job }}-${{ hashFiles('src/**', 'tests/**', 'mcpp.toml', 'mcpp.lock') }}
111+
restore-keys: |
112+
mcpp-target-${{ runner.os }}-${{ github.job }}-
113+
mcpp-target-${{ runner.os }}-

‎.github/actions/setup-macos-llvm/action.yml‎

Lines changed: 108 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,108 @@
1+
name: setup-macos-llvm
2+
description: >
3+
macOS ARM64 setup shared by ci-macos.yml and ci-macos-e2e.yml: xlings +
4+
the xlings-managed LLVM + a dev mcpp sandbox wired to that exact LLVM.
5+
Exports LLVM_ROOT, CXX, MCPP_LLVM_VER, MCPP, XLINGS_BIN.
6+
7+
Kept separate from bootstrap-mcpp: macOS does not reuse the ~/.mcpp cache
8+
lineage — it builds its sandbox from the freshly resolved LLVM package on
9+
every run, which is exactly the property the macOS job exists to prove.
10+
11+
inputs:
12+
xlings-version:
13+
description: xlings release to bootstrap from
14+
required: false
15+
default: '0.4.30'
16+
17+
runs:
18+
using: composite
19+
steps:
20+
- name: Cache xlings
21+
uses: actions/cache@v4
22+
with:
23+
path: ~/.xlings
24+
key: xlings-macos15-arm64-v3-${{ hashFiles('.xlings.json') }}
25+
restore-keys: |
26+
xlings-macos15-arm64-v3-
27+
28+
- name: Bootstrap xlings
29+
shell: bash
30+
env:
31+
XLINGS_NON_INTERACTIVE: '1'
32+
XLINGS_VERSION: ${{ inputs.xlings-version }}
33+
run: |
34+
WORK=$(mktemp -d)
35+
tarball="xlings-${XLINGS_VERSION}-macosx-arm64.tar.gz"
36+
curl -fsSL -o "${WORK}/${tarball}" \
37+
"https://github.com/d2learn/xlings/releases/download/v${XLINGS_VERSION}/${tarball}"
38+
tar -xzf "${WORK}/${tarball}" -C "${WORK}"
39+
XLINGS_DIR="${WORK}/xlings-${XLINGS_VERSION}-macosx-arm64"
40+
"$XLINGS_DIR/subos/default/bin/xlings" self install
41+
export PATH="$HOME/.xlings/subos/default/bin:$PATH"
42+
xlings --version
43+
echo "PATH=$HOME/.xlings/subos/default/bin:$PATH" >> "$GITHUB_ENV"
44+
45+
- name: Install LLVM via xlings
46+
shell: bash
47+
run: |
48+
# latest-first: test binaries now link the toolchain's own libc++
49+
# (A1 root fix in flags.cppm), so new llvm releases are
50+
# self-consistent — the macOS job is the proof for each new default.
51+
xlings install llvm -y || xlings install llvm@20.1.7 -y
52+
LLVM_ROOT=$(find "$HOME/.xlings" -path "*/xpkgs/xim-x-llvm/*/bin/clang++" | head -1 | xargs dirname | xargs dirname)
53+
ls "$LLVM_ROOT/bin/clang++"
54+
"$LLVM_ROOT/bin/clang++" --version
55+
echo "LLVM_ROOT=$LLVM_ROOT" >> "$GITHUB_ENV"
56+
echo "CXX=$LLVM_ROOT/bin/clang++" >> "$GITHUB_ENV"
57+
58+
- name: Bootstrap mcpp via xlings
59+
shell: bash
60+
run: |
61+
xlings install mcpp -y
62+
MCPP="$HOME/.xlings/subos/default/bin/mcpp"
63+
test -x "$MCPP"
64+
"$MCPP" --version
65+
echo "MCPP=$MCPP" >> "$GITHUB_ENV"
66+
echo "XLINGS_BIN=$HOME/.xlings/subos/default/bin/xlings" >> "$GITHUB_ENV"
67+
68+
- name: Configure dev mcpp sandbox to reuse xlings LLVM
69+
shell: bash
70+
run: |
71+
# Use EXACTLY the LLVM the install step resolved (env LLVM_ROOT) — a
72+
# version-glob pick chose a stale cached 20.1.7 next to the freshly
73+
# installed 22.1.8 and silently tested the wrong toolchain.
74+
LLVM_PKG="$LLVM_ROOT"
75+
test -d "$LLVM_PKG"
76+
LLVM_VER=$(basename "$LLVM_PKG")
77+
echo "MCPP_LLVM_VER=$LLVM_VER" >> "$GITHUB_ENV"
78+
MCPP_LLVM_LINK="$HOME/.mcpp/registry/data/xpkgs/xim-x-llvm/$LLVM_VER"
79+
printf '1\n' > "$LLVM_PKG/.mcpp_ok"
80+
81+
mkdir -p "$HOME/.mcpp/registry/data/xpkgs/xim-x-llvm"
82+
rm -rf "$MCPP_LLVM_LINK"
83+
ln -s "$LLVM_PKG" "$MCPP_LLVM_LINK"
84+
85+
mkdir -p "$HOME/.mcpp"
86+
cat > "$HOME/.mcpp/config.toml" <<EOF
87+
# mcpp global config for CI. Dev binaries under target/.../bin/mcpp
88+
# fall back to ~/.mcpp; keep its registry isolated while reusing
89+
# the LLVM package already installed by \`xlings install llvm\`.
90+
[xlings]
91+
binary = "$HOME/.xlings/subos/default/bin/xlings"
92+
93+
[index]
94+
default = "mcpplibs"
95+
96+
[index.repos."mcpplibs"]
97+
url = "https://github.com/mcpp-community/mcpp-index.git"
98+
99+
[cache]
100+
search_ttl_seconds = 3600
101+
102+
[build]
103+
default_jobs = 0
104+
default_backend = "ninja"
105+
EOF
106+
107+
cat "$HOME/.mcpp/config.toml"
108+
ls "$MCPP_LLVM_LINK/bin/clang++"

‎.github/workflows/ci-linux-e2e.yml‎

Lines changed: 19 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,14 @@
11
name: ci-linux-e2e
22

3-
# The e2e suite (tests/e2e/run_all.sh, ~18 min) split out of ci-linux.yml so it
4-
# runs in PARALLEL with the build/unit/toolchain-matrix job instead of tacked on
5-
# after it. Both workflows share the same cache lineage (mcpp sandbox + xlings +
6-
# target/), so this job restores a warm build and the only added wall-clock vs.
7-
# the inline version is one extra warm `mcpp build`. Net per-PR critical path
8-
# drops from "build + … + e2e" to max(build+matrix, build+e2e).
3+
# The e2e suite (tests/e2e/run_all.sh) split out of ci-linux.yml so it runs in
4+
# PARALLEL with the build/unit/toolchain jobs instead of tacked on after them,
5+
# and SHARDED across two runners on top of that. Both workflows share the same
6+
# cache lineage (mcpp sandbox + xlings + target/), so each shard restores a warm
7+
# build and the only added wall-clock vs. the inline version is one extra warm
8+
# `mcpp build` per runner.
99
#
10-
# Paired workflows: ci-linux.yml (build + unit + toolchain matrix + integration),
11-
# ci-macos.yml, ci-windows.yml.
10+
# Paired workflows: ci-linux.yml (build + unit + toolchain legs + integration),
11+
# ci-macos.yml / ci-macos-e2e.yml, ci-windows.yml / ci-windows-e2e.yml.
1212

1313
on:
1414
push:
@@ -23,10 +23,18 @@ concurrency:
2323

2424
jobs:
2525
e2e:
26-
name: e2e suite (linux x86_64, self-host)
26+
name: e2e ${{ matrix.shard }}/2 (linux x86_64, self-host)
2727
runs-on: ubuntu-24.04
2828
timeout-minutes: 45
29+
strategy:
30+
fail-fast: false
31+
matrix:
32+
shard: [1, 2]
2933
env:
34+
# Round-robin slice of tests/e2e (see run_all.sh). Two shards halve the
35+
# suite's wall-clock; the split is computed on the full file list, so a
36+
# test's shard does not move when host capabilities differ.
37+
E2E_SHARD: ${{ matrix.shard }}/2
3038
MCPP_HOME: /home/runner/.mcpp
3139
# NOTE: do NOT force MCPP_VERBOSE here. The e2e suite includes tests that
3240
# assert mcpp's DEFAULT (quiet) output — e.g. 48_build_error_output and
@@ -37,51 +45,8 @@ jobs:
3745
- uses: actions/checkout@v4
3846

3947
# Same cache lineage as ci-linux.yml so this job lands on a warm
40-
# toolchain/sandbox instead of re-installing it. Both workflows read
41-
# (and may save) the same keys; actions/cache tolerates concurrent
42-
# "already exists" saves.
43-
- name: Cache mcpp sandbox
44-
uses: actions/cache@v4
45-
with:
46-
path: ~/.mcpp
47-
key: mcpp-sandbox-${{ runner.os }}-ci-${{ hashFiles('mcpp.toml', '.xlings.json') }}
48-
restore-keys: |
49-
mcpp-sandbox-${{ runner.os }}-ci-
50-
51-
- name: Cache xlings
52-
uses: actions/cache@v4
53-
with:
54-
path: ~/.xlings
55-
key: xlings-${{ runner.os }}-v2-${{ hashFiles('.xlings.json') }}
56-
restore-keys: |
57-
xlings-${{ runner.os }}-v2-
58-
59-
- name: Bootstrap mcpp via xlings
60-
env:
61-
XLINGS_NON_INTERACTIVE: '1'
62-
XLINGS_VERSION: '0.4.30'
63-
run: |
64-
tarball="xlings-${XLINGS_VERSION}-linux-x86_64.tar.gz"
65-
curl -fsSL -o "/tmp/${tarball}" \
66-
"https://github.com/d2learn/xlings/releases/download/v${XLINGS_VERSION}/${tarball}"
67-
tar -xzf "/tmp/${tarball}" -C /tmp
68-
"/tmp/xlings-${XLINGS_VERSION}-linux-x86_64/subos/default/bin/xlings" self install
69-
export PATH="$HOME/.xlings/subos/default/bin:$PATH"
70-
xlings --version
71-
xlings install mcpp -y
72-
MCPP="$HOME/.xlings/subos/default/bin/mcpp"
73-
test -x "$MCPP"
74-
"$MCPP" --version
75-
echo "MCPP=$MCPP" >> "$GITHUB_ENV"
76-
echo "XLINGS_BIN=$HOME/.xlings/subos/default/bin/xlings" >> "$GITHUB_ENV"
77-
78-
- name: Cache target/ (build artifacts + BMIs)
79-
uses: actions/cache@v4
80-
with:
81-
path: target
82-
key: mcpp-target-${{ runner.os }}-${{ hashFiles('src/**', 'tests/**', 'mcpp.toml', 'mcpp.lock') }}
83-
restore-keys: |
84-
mcpp-target-${{ runner.os }}-
48+
# toolchain/sandbox instead of re-installing it.
49+
- uses: ./.github/actions/bootstrap-mcpp
8550

8651
- name: Configure mirror + Build mcpp from source (self-host)
8752
run: |

0 commit comments

Comments
 (0)