[pull] main from llvm:main

.ci/generate_test_report_lib.py

@@ -355,10 +355,15 @@ def generate_report_from_files(title, return_code, build_log_files):
 
 
 def compute_platform_title() -> str:
-    logo = ":window:" if platform.system() == "Windows" else ":penguin:"
+    logo = {
+        "Windows": ":window:",
+        "Linux": ":penguin:",
+        "Darwin": ":green_apple:",
+    }.get(platform.system())
+
     # On Linux the machine value is x86_64 on Windows it is AMD64.
     if platform.machine() == "x86_64" or platform.machine() == "AMD64":
         arch = "x64"
     else:
         arch = platform.machine()
-    return f"{logo} {platform.system()} {arch} Test Results"
+    return f"{logo + ' ' if logo is not None else ''}{platform.system()} {arch} Test Results"

.github/workflows/libc-fullbuild-tests.yml

@@ -88,13 +88,20 @@ jobs:
             cpp_compiler: clang++-23
             target: armv7em-none-eabi
             testing: SKIP
-          - name: baremetal-armv8m
+          - name: baremetal-armv8m-softfp
             os: ubuntu-24.04
             build_type: MinSizeRel
             c_compiler: clang-23
             cpp_compiler: clang++-23
             target: armv8m.main-none-eabi
             testing: SKIP
+          - name: baremetal-armv8m-hard
+            os: ubuntu-24.04
+            build_type: MinSizeRel
+            c_compiler: clang-23
+            cpp_compiler: clang++-23
+            target: armv8m.main-none-eabihf
+            testing: SKIP
           - name: baremetal-armv8.1m
             os: ubuntu-24.04
             build_type: MinSizeRel

.github/workflows/libcxx-benchmark-commit.yml

@@ -3,7 +3,9 @@
 # it requires several inputs that allow customizing its behavior.
 
 name: "[libc++] Run benchmark suite against commit"
-run-name: "[libc++] Run benchmark suite against ${{ inputs.commit }} on ${{ inputs.lnt-machine }}"
+
+# Keep in sync with libcxx/utils/ci/lnt/dispatch-benchmarks
+run-name: "[libc++] Run benchmark suite against ${{ inputs.commit }} on ${{ inputs.lnt-machine }}${{ !inputs.submit-lnt && ' (dry run)' || '' }}"
 
 permissions:
   contents: read
@@ -18,15 +20,15 @@ on:
       lnt-machine:
         description: 'The LNT machine to run the benchmarks on'
         required: true
-        type: choice
-        options:
-          - macos-26.5-arm64
-          - linux-x86_64
-      benchmark-suite-version:
-        description: 'The version of the benchmark suite to use (a LLVM monorepo SHA)'
+        type: string
+      benchmark-suite-override:
+        description: |
+          Override the version of the benchmark suite to use (a LLVM monorepo SHA). By default, the version pinned
+          for this machine in machines.json is used. This override can be used to dry-run benchmarks with arbitrary
+          commits of the benchmark suite, but only the version pinned in machines.json can be used when actually
+          submitting to LNT.
         required: false
         type: string
-        default: 0eefb2682bf8c04954c46e91916b5164d8424702
       filter:
         description: 'An optional filter to determine which benchmarks to run'
         required: false
@@ -49,37 +51,50 @@ jobs:
     outputs:
       matrix: ${{ steps.select.outputs.matrix }}
     steps:
+      - name: Checkout the machine definitions
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        with:
+          persist-credentials: false
+          # Disabling cone mode allows checking out exactly the single file we need.
+          sparse-checkout: libcxx/utils/ci/lnt/machines.json
+          sparse-checkout-cone-mode: false
+
       - name: Select the configuration to benchmark on
         id: select
         uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         env:
           LNT_MACHINE: ${{ inputs.lnt-machine }}
+          BENCHMARK_SUITE_OVERRIDE: ${{ inputs.benchmark-suite-override }}
+          SUBMIT_LNT: ${{ inputs.submit-lnt }}
         with:
           script: |
-            const MACHINES = [
-              {
-                'lnt-machine': 'macos-26.5-arm64',
-                runner: ['self-hosted', 'macOS', 'ARM64', '26', '26.5'],
-                cxx: 'clang++',
-                'running-on': 'macos',
-                'xcode-version': '26.5',
-              },
-              {
-                'lnt-machine': 'linux-x86_64',
-                runner: 'llvm-premerge-libcxx-runners',
-                cxx: 'clang++-22',
-                'running-on': 'linux',
-              },
-            ];
+            const config = JSON.parse(require('fs').readFileSync('libcxx/utils/ci/lnt/machines.json', 'utf8'));
 
             const requested = process.env.LNT_MACHINE;
-            const selected = MACHINES.filter(m => m['lnt-machine'] === requested);
+            const selected = config.filter(cfg => cfg['lnt-machine'] === requested);
             if (selected.length === 0) {
-              const known = MACHINES.map(m => m['lnt-machine']).join(', ');
+              const known = config.map(cfg => cfg['lnt-machine']).join(', ');
               core.setFailed(`Unknown LNT machine '${requested}' (known machines: ${known})`);
               return;
             }
 
+            // Honor benchmark suite version override and make sure we don't submit if an incorrect
+            // override is provided.
+            const version_override = (process.env.BENCHMARK_SUITE_OVERRIDE || '').trim().toLowerCase();
+            for (const cfg of selected) {
+              const pinned = cfg['benchmark-suite-version'];
+              if (process.env.SUBMIT_LNT === 'true' && version_override && version_override !== pinned) {
+                core.setFailed(`Refusing to submit results for ${cfg['lnt-machine']}, since the benchmark suite was `
+                                + `overridden to version ${version_override}, which is different from the version `
+                                + `pinned in machines.json (${pinned}).`);
+                return;
+              }
+
+              if (version_override) {
+                cfg['benchmark-suite-version'] = version_override;
+              }
+            }
+
             core.setOutput('matrix', JSON.stringify(selected));
 
   run-benchmarks:
@@ -134,7 +149,7 @@ jobs:
       - name: Run the benchmarks
         env:
           COMMIT: ${{ inputs.commit }}
-          BENCHMARK_SUITE_VERSION: ${{ inputs.benchmark-suite-version }}
+          BENCHMARK_SUITE_VERSION: ${{ matrix.benchmark-suite-version }}
           FILTER: ${{ inputs.filter }}
           LNT_MACHINE: ${{ matrix.lnt-machine }}
         run: |

.github/workflows/libcxx-benchmark-cron.yml

@@ -0,0 +1,137 @@
+# This file defines a workflow that periodically requests benchmark runs for the commits
+# that should have historical performance data but don't yet.
+#
+# The workflow keeps no state: on every invocation, the commits that should be benchmarked
+# are recomputed from Git and the ones that have been benchmarked are recomputed from LNT
+# and from the Github Actions API. It then dispatches libcxx-benchmark-commit.yml for the
+# difference, within a budget. This makes the system converge towards having data for all
+# the desired commits, without necessarily ever reaching that state (as new commits land).
+#
+# The actual configuration driving this job is in libcxx/utils/ci/lnt/machines.json.
+
+name: "[libc++] Request historical benchmark data"
+
+permissions:
+  contents: read
+
+on:
+  schedule:
+    # Trigger every hour, off the hour boundary to avoid popular times.
+    - cron: '37 * * * *'
+  workflow_dispatch:
+    inputs:
+      dry-run:
+        description: 'Report what would be requested, but request nothing'
+        required: false
+        type: boolean
+        default: false
+      allow-missing-machine:
+        description: 'Plan for machines that have no data in LNT yet. Needed to seed a new machine.'
+        required: false
+        type: boolean
+        default: false
+
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: false
+
+jobs:
+  # Turn the machine definitions stored in libcxx/utils/ci/lnt/machines.json into actual
+  # dispatch jobs.
+  select-machines:
+    if: github.repository_owner == 'llvm'
+    runs-on: ubuntu-24.04
+    outputs:
+      matrix: ${{ steps.select.outputs.matrix }}
+    steps:
+      - name: Checkout the machine definitions
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        with:
+          persist-credentials: false
+          # Disabling cone mode allows checking out exactly the single file we need.
+          sparse-checkout: libcxx/utils/ci/lnt/machines.json
+          sparse-checkout-cone-mode: false
+
+      - name: Select the machines to request runs for
+        id: select
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          script: |
+            const config = JSON.parse(require('fs').readFileSync('libcxx/utils/ci/lnt/machines.json', 'utf8'));
+            core.setOutput('matrix', JSON.stringify(config.map(cfg => ({
+              machine: cfg['lnt-machine'],
+              ...cfg.coverage,
+            }))));
+
+  request-runs:
+    permissions:
+      contents: read
+      actions: write # to dispatch libcxx-benchmark-commit.yml
+    needs:
+      - select-machines
+    strategy:
+      matrix:
+        include: ${{ fromJSON(needs.select-machines.outputs.matrix) }}
+      fail-fast: false
+    name: "Request ${{ matrix.machine }}"
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
+    env:
+      MACHINE: ${{ matrix.machine }}
+      SINCE: ${{ matrix.since }}
+      EVERY: ${{ matrix.every }}
+      SAMPLES: ${{ matrix.samples }}
+      MAX_IN_FLIGHT: ${{ matrix.max-in-flight }}
+      LNT_URL: ${{ matrix.lnt-url }}
+
+      ALLOW_MISSING_MACHINE: ${{ inputs.allow-missing-machine || 'false' }}
+      DRY_RUN: ${{ inputs.dry-run || 'false' }}
+    steps:
+      - name: Checkout the LLVM monorepo
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        with:
+          persist-credentials: false
+          # Selecting anchor commits requires full Git history, but not the blob content.
+          fetch-depth: 0
+          filter: blob:none
+
+      - name: Install Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: '3.14'
+          cache: pip
+          cache-dependency-path: libcxx/utils/requirements.txt
+
+      - name: Install dependencies
+        run: pip install -r libcxx/utils/requirements.txt
+
+      - name: Determine which commits should have benchmark data
+        run: |
+          libcxx/utils/ci/lnt/select-anchor-commits --since "${SINCE}" --every "${EVERY}" --output anchors.txt
+          # Anchor commits go from oldest to newest. Reverse them to prioritize newer commits first.
+          tac anchors.txt > tmp.txt
+          mv tmp.txt anchors.txt
+
+      - name: Determine which of them are missing from LNT
+        run: |
+          allow_missing=()
+          if [ "${ALLOW_MISSING_MACHINE}" = "true" ]; then
+            allow_missing=(--allow-missing-machine)
+          fi
+
+          libcxx/utils/ci/lnt/plan-benchmarks --commit-list anchors.txt --lnt-url "${LNT_URL}" --test-suite libcxx  \
+                                              --machine "${MACHINE}" --samples "${SAMPLES}" "${allow_missing[@]}"   \
+                                              --output plan.jsonl
+
+      - name: Request the missing runs
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: |
+          dry_run=()
+          if [ "${DRY_RUN}" = "true" ]; then
+            dry_run=(--dry-run)
+          fi
+
+          libcxx/utils/ci/lnt/dispatch-benchmarks --work-items plan.jsonl --lnt-url "${LNT_URL}"  \
+                                                  --max-in-flight "${MAX_IN_FLIGHT}"              \
+                                                  --output dispatched.jsonl "${dry_run[@]}"

.github/workflows/libcxx-pr-benchmark.yml

@@ -48,6 +48,14 @@ jobs:
     permissions:
       pull-requests: write
     steps:
+      - name: Checkout the LNT configurations
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        with:
+          persist-credentials: false
+          # Disabling cone mode allows checking out exactly the single file we need.
+          sparse-checkout: libcxx/utils/ci/lnt/machines.json
+          sparse-checkout-cone-mode: false
+
       - name: Extract information from the PR
         id: vars
         uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
@@ -63,6 +71,10 @@ jobs:
             const match = context.payload.comment.body.match(/\/libcxx-bot benchmark (.+)/);
             core.setOutput('benchmarks', match ? match[1] : '');
 
+            // Benchmark on the same configurations that we track performance on.
+            const config = JSON.parse(require('fs').readFileSync('libcxx/utils/ci/lnt/machines.json', 'utf8'));
+            core.setOutput('matrix', JSON.stringify(config.map(({coverage, ...machine}) => machine)));
+
       - name: Update comment with link to the run
         uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
@@ -84,20 +96,12 @@ jobs:
       pr_base: ${{ steps.vars.outputs.pr_base }}
       pr_head: ${{ steps.vars.outputs.pr_head }}
       benchmarks: ${{ steps.vars.outputs.benchmarks }}
+      matrix: ${{ steps.vars.outputs.matrix }}
 
   run-benchmarks:
     strategy:
       matrix:
-        include:
-          - platform: macOS 26.5 arm64
-            runner: ["self-hosted", "macOS", "ARM64", "26", "26.5"]
-            cxx: clang++
-            running-on: macos
-            xcode-version: '26.5'
-          - platform: Linux x86_64
-            runner: llvm-premerge-libcxx-runners
-            cxx: clang++-22
-            running-on: linux
+        include: ${{ fromJSON(needs.extract-info.outputs.matrix) }}
       fail-fast: false
     permissions:
       pull-requests: write
@@ -107,7 +111,7 @@ jobs:
     env:
       BENCHMARKS: ${{ needs.extract-info.outputs.benchmarks }}
       COMPILER: ${{ matrix.cxx }}
-      PLATFORM: ${{ matrix.platform }}
+      LNT_MACHINE: ${{ matrix.lnt-machine }}
       PR_HEAD: ${{ needs.extract-info.outputs.pr_head }}
       PR_BASE: ${{ needs.extract-info.outputs.pr_base }}
     steps:
@@ -158,21 +162,14 @@ jobs:
       - name: Run baseline and candidate interleaved
         run: |
           source .venv/bin/activate
-          # Run 3 times so we can pick the median, and interleave to mitigate the impact of environmental noise
-          ./libcxx/utils/test-at-commit --libcxx-installation install/baseline -B benchmarks/baseline --compiler "${COMPILER}" -- -sv -j1 --param optimization=speed "$BENCHMARKS"
-          ./libcxx/utils/consolidate-benchmarks benchmarks/baseline | tee baseline.lnt
-          ./libcxx/utils/test-at-commit --libcxx-installation install/candidate -B benchmarks/candidate --compiler "${COMPILER}" -- -sv -j1 --param optimization=speed "$BENCHMARKS"
-          ./libcxx/utils/consolidate-benchmarks benchmarks/candidate | tee candidate.lnt
-
-          ./libcxx/utils/test-at-commit --libcxx-installation install/baseline -B benchmarks/baseline --compiler "${COMPILER}" -- -sv -j1 --param optimization=speed "$BENCHMARKS"
-          ./libcxx/utils/consolidate-benchmarks benchmarks/baseline | tee -a baseline.lnt
-          ./libcxx/utils/test-at-commit --libcxx-installation install/candidate -B benchmarks/candidate --compiler "${COMPILER}" -- -sv -j1 --param optimization=speed "$BENCHMARKS"
-          ./libcxx/utils/consolidate-benchmarks benchmarks/candidate | tee -a candidate.lnt
-
-          ./libcxx/utils/test-at-commit --libcxx-installation install/baseline -B benchmarks/baseline --compiler "${COMPILER}" -- -sv -j1 --param optimization=speed "$BENCHMARKS"
-          ./libcxx/utils/consolidate-benchmarks benchmarks/baseline | tee -a baseline.lnt
-          ./libcxx/utils/test-at-commit --libcxx-installation install/candidate -B benchmarks/candidate --compiler "${COMPILER}" -- -sv -j1 --param optimization=speed "$BENCHMARKS"
-          ./libcxx/utils/consolidate-benchmarks benchmarks/candidate | tee -a candidate.lnt
+          # Run 5 times so we can pick the median, and interleave baseline and candidate to mitigate the impact of
+          # environmental noise
+          for _ in $(seq 1 5); do
+            ./libcxx/utils/test-at-commit --libcxx-installation install/baseline -B benchmarks/baseline --compiler "${COMPILER}" -- -sv -j1 --param optimization=speed "$BENCHMARKS"
+            ./libcxx/utils/consolidate-benchmarks benchmarks/baseline | tee -a baseline.lnt
+            ./libcxx/utils/test-at-commit --libcxx-installation install/candidate -B benchmarks/candidate --compiler "${COMPILER}" -- -sv -j1 --param optimization=speed "$BENCHMARKS"
+            ./libcxx/utils/consolidate-benchmarks benchmarks/candidate | tee -a candidate.lnt
+          done
 
       - name: Compare baseline and candidate runs
         run: |
@@ -193,7 +190,7 @@ jobs:
             const details = [
               '<details>',
               '<summary>',
-              `Benchmark results for ${process.env.PLATFORM}:`,
+              `Benchmark results for ${process.env.LNT_MACHINE}:`,
               '</summary>',
               '',
               '```',
@@ -220,7 +217,7 @@ jobs:
               comment_id: context.payload.comment.id,
             });
             const run_url = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;
-            const note = `> _:x: Benchmarks for ${process.env.PLATFORM} failed. See ${run_url} for details._`;
+            const note = `> _:x: Benchmarks for ${process.env.LNT_MACHINE} failed. See ${run_url} for details._`;
             await github.rest.issues.updateComment({
               owner: context.repo.owner,
               repo: context.repo.repo,