Merge branch 'main' into reuse-input-sparsity-pattern

Author: sott0n

.github/CODEOWNERS

@@ -15,7 +15,6 @@
 /libcxx/ @llvm/reviewers-libcxx
 /libcxxabi/ @llvm/reviewers-libcxxabi
 /libunwind/ @llvm/reviewers-libunwind
-/runtimes/ @llvm/reviewers-libcxx
 
 /llvm/lib/Analysis/BasicAliasAnalysis.cpp @nikic
 /llvm/lib/Analysis/HashRecognize.cpp @artagnon @pfusik

.github/new-prs-labeler.yml

@@ -961,6 +961,7 @@ backend:SPIR-V:
       - llvm/test/CodeGen/SPIRV/**
       - llvm/test/Frontend/HLSL/**
       - llvm/docs/SPIRVUsage.rst
+      - llvm/tools/spirv-tools/**
 
 mlgo:
   - changed-files:

.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/libc-overlay-tests.yml

@@ -12,7 +12,7 @@ jobs:
   native:
     if: github.repository_owner == 'llvm'
     name: ${{ matrix.os }} - ${{ matrix.compiler.c_compiler }}
-    timeout-minutes: 30
+    timeout-minutes: 60
     runs-on: ${{ matrix.os }}
     container: ${{ matrix.container || null }}
     strategy:

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

@@ -3,6 +3,8 @@
 # it requires several inputs that allow customizing its behavior.
 
 name: "[libc++] Run benchmark suite against commit"
+
+# Keep in sync with libcxx/utils/ci/lnt/dispatch-benchmarks
 run-name: "[libc++] Run benchmark suite against ${{ inputs.commit }} on ${{ inputs.lnt-machine }}"
 
 permissions:
@@ -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:
@@ -125,13 +140,20 @@ jobs:
           "${COMPILER}" --version
           python3 --version
 
+      - name: Setup virtual environment
+        run: |
+          python3 -m venv .venv
+          source .venv/bin/activate
+          pip install -r libcxx/utils/requirements.txt
+
       - 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: |
+          source .venv/bin/activate
           filter_arg=()
           if [ -n "${FILTER}" ]; then
             filter_arg=(--filter "${FILTER}")
@@ -152,6 +174,7 @@ jobs:
           COMMIT: ${{ inputs.commit }}
           LNT_URL: ${{ inputs.lnt-url }}
         run: |
+          source .venv/bin/activate
           libcxx/utils/ci/lnt/submit-benchmarks             \
             --lnt-url "${LNT_URL}"                          \
             --test-suite libcxx                             \

.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[@]}"