main.yml

name: snmalloc CI

# Controls when the workflow will run
on:
  # Triggers the workflow on push or pull request events but only for the master branch
  push:
    branches: [ main ]
  pull_request:
    branches: [ main, snmalloc1 ]

  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

jobs:
  ubuntu:
    strategy:
      matrix:
        # Build each combination of OS and release/debug variants
        os: [ "ubuntu-latest", "ubuntu-20.04" ]
        build-type: [ "Release", "Debug" ]
        # Extra cmake flags.  GitHub Actions matrix overloads `include` to mean
        # 'add extra things to a job' and 'add jobs'.  You can add extra things
        # to a job by specifying things that exist in a job created from the
        # matrix definition and adding things.  You can specify extra jobs by
        # specifying properties that don't match existing jobs.  We use
        # `cmake-flags` to add cmake flags to all jobs matching a pattern and
        # `extra-cmake-flags` to specify a new job with custom CMake flags.
        #
        # Note that adding new jobs does not *refine* existing matrix entries,
        # but rather adds new tuples wholesale.  That is, specifying "os" alone
        # will result in a tuple without set "build-type" rather than one for
        # each existing "build-type" value!
        extra-cmake-flags: [ "" ]
        # Modify the complete matrix
        include:
          - os: "ubuntu-20.04"
            variant: "C++17"
            build-type: "Debug"
            extra-cmake-flags: "-DSNMALLOC_USE_CXX17=ON"
          # Add the self-host build, using the bounds-checked memcpy in
          # maximally paranoid mode (checking loads and stores)
          - os: "ubuntu-latest"
            build-type: Debug
            self-host: true
            extra-cmake-flags: "-DSNMALLOC_MEMCPY_BOUNDS=ON -DSNMALLOC_CHECK_LOADS=ON"
          # Extra build to check using pthread library for destructing local state.
          - os: "ubuntu-latest"
            variant: "with pthread destructors"
            build-type: Debug
            self-host: true
            extra-cmake-flags: "-DSNMALLOC_USE_PTHREAD_DESTRUCTORS=On"
          # Extra build to check using individual mitigations works.
          - os: "ubuntu-latest"
            variant: "individual mitigations"
            build-type: Release
            self-host: true
            extra-cmake-flags: "-DSNMALLOC_BENCHMARK_INDIVIDUAL_MITIGATIONS=On -DSNMALLOC_BUILD_TESTING=Off"
          # Check that we can build specifically with libstdc++
          - os: "ubuntu-latest"
            variant: "libstdc++ (Build only)"
            build-type: Release
            extra-cmake-flags: "-DCMAKE_CXX_COMPILER=clang++ -DCMAKE_CXX_FLAGS=-stdlib=libstdc++"
            build-only: yes
          # Replay some of the above tests with clang-10 specifically
          - os: "ubuntu-20.04"
            variant: "clang-10 (with pthread destructors)."
            build-type: Debug
            self-host: true
            extra-cmake-flags: "-DSNMALLOC_USE_PTHREAD_DESTRUCTORS=On -DCMAKE_CXX_COMPILER=clang++-10 -DCMAKE_C_COMPILER=clang-10"
          - os: "ubuntu-20.04"
            variant: "Traced Build"
            build-type: Release
            extra-cmake-flags: "-DSNMALLOC_TRACING=On"
            build-only: yes
          - os: "ubuntu-20.04"
            variant: "clang-10 libstdc++ (Build only)"
            build-type: Release
            extra-cmake-flags: "-DCMAKE_CXX_COMPILER=clang++-10 -DCMAKE_C_COMPILER=clang-10 -DCMAKE_CXX_FLAGS=-stdlib=libstdc++"
            build-only: yes
      # Don't abort runners if a single one fails
      fail-fast: false
    runs-on: ${{ matrix.os }}
    name: ${{ matrix.os }} ${{ matrix.build-type }} ${{ matrix.variant }}
    steps:
    - uses: actions/checkout@v4
    - name: Install build dependencies
      run: "sudo apt install ninja-build"
    - name: Configure CMake
      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.build-type}} -G Ninja ${{ matrix.cmake-flags }} ${{ matrix.extra-cmake-flags }}
      # Build with a nice ninja status line
    - name: Build
      working-directory: ${{github.workspace}}/build
      run: NINJA_STATUS="%p [%f:%s/%t] %o/s, %es" ninja
    - name: Test file size of binaries is sane
      working-directory: ${{github.workspace}}/build
      run: "ls -l libsnmallocshim.* ; [ $(ls -l libsnmallocshim.* | awk '{ print $5}') -lt 10000000 ]"
      # If the tests are enabled for this job, run them
    - name: Test
      if: ${{ matrix.build-only != 'yes' }}
      working-directory: ${{github.workspace}}/build
      run: ctest --output-on-failure -j 4 -C ${{ matrix.build-type }} --timeout 400
    - name: Selfhost
      if: ${{ matrix.self-host }}
      working-directory: ${{github.workspace}}/build
      run: |
        mkdir libs
        cp libsnmallocshim*.so libs
        for lib in `ls libs`; do echo; echo Testing $lib; ninja clean; LD_PRELOAD=libs/$lib ninja libsnmallocshim.so; done

  # If this looks remarkably familiar, that's because it is.  Sigh.
  macos:
    strategy:
      matrix:
        os: [ "macos-13", "macos-14", "macos-15" ]
        build-type: [ "Release", "Debug" ]
        extra-cmake-flags: [ "", "-DSNMALLOC_USE_CXX17=ON" ]
      fail-fast: false
    runs-on: ${{ matrix.os }}
    name: ${{ matrix.os }} ${{ matrix.build-type }} ${{ matrix.extra-cmake-flags }}
    steps:
    - uses: actions/checkout@v4
    - name: Install build dependencies
            # The homebrew packages are broken at the moment and error out
            # after trying to install Python as a dependency of ninja because
            # 2to3 exists.  As a quick hack, delete it first.  This should be
            # removed once the homebrew install is fixed.
      run: "rm -f /usr/local/bin/2to3 ; brew update && brew install ninja"
    - name: Pick the latest XCode in runner
      uses: maxim-lobanov/setup-xcode@v1
      with:
        xcode-version: latest-stable
    - name: Configure CMake
      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.build-type}} -G Ninja ${{ matrix.cmake-flags }} ${{ matrix.extra-cmake-flags }}
      # Build with a nice ninja status line
    - name: Build
      working-directory: ${{github.workspace}}/build
      run: NINJA_STATUS="%p [%f:%s/%t] %o/s, %es" ninja
    - name: Test file size of binaries is sane
      working-directory: ${{github.workspace}}/build
      run: "ls -l libsnmallocshim.* ; [ $(ls -l libsnmallocshim.* | awk '{ print $5}') -lt 10000000 ]"
      # If the tests are enabled for this job, run them
    - name: Test
      if: ${{ matrix.build-only != 'yes' }}
      working-directory: ${{github.workspace}}/build
      run: ctest --output-on-failure -j 4 -C ${{ matrix.build-type }} --timeout 400
    - name: Selfhost
      if: ${{ matrix.self-host }}
      working-directory: ${{github.workspace}}/build
      run: |
        mkdir libs
        cp libsnmallocshim*.so libs
        for lib in `ls libs`; do echo; echo Testing $lib; ninja clean; LD_PRELOAD=libs/$lib ninja libsnmallocshim.so; done


  # GitHub doesn't natively support *BSD, but we can run them in VMs on Mac /
  # Linux runners
  freebsd:
    strategy:
      matrix:
        # Build each combination of OS, version, and release/debug variants
        # FreeBSD and OpenBSD run on xhyve, netbsd needs qemu
        os:
          - version: '13.2'
            dependencies: pkg ins -y cmake ninja
        build-type: [ Release, Debug ]
      # Don't abort runners if a single one fails
      fail-fast: false
    # Kill these jobs if they take too long.
    timeout-minutes: 25
    runs-on: ubuntu-22.04
    name: FreeBSD-${{ matrix.os.version}} ${{ matrix.build-type }}
    steps:
    - uses: actions/checkout@v4
    - uses: vmactions/freebsd-vm@v1
      with:
        release: ${{ matrix.os.version}}
        usesh: true
        mem: 8192
        copyback: false
        prepare: |
          ${{ matrix.os.dependencies }}
        run: |
          set -e
          cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.build-type}} -G Ninja 
          cd ${{github.workspace}}/build
          NINJA_STATUS="%p [%f:%s/%t] %o/s, %es" ninja
          ctest -j 4 --output-on-failure -E '(perf-.*)|(.*-malloc$)' --timeout 400

  netbsd:
    strategy:
      matrix:
        os:
          - version: '9.2'
            dependencies: |
              /usr/sbin/pkg_add cmake ninja-build gcc10
        build-type: [ Release ]
      # Don't abort runners if a single one fails
      fail-fast: false
    # Kill these jobs if they take too long.
    timeout-minutes: 25
    runs-on: ubuntu-22.04
    name: NetBSD-${{ matrix.os.version}} ${{ matrix.build-type }}
    steps:
    - uses: actions/checkout@v4
    - uses: vmactions/netbsd-vm@v1
      with:
        release: ${{ matrix.os.version}}
        usesh: true
        mem: 8192
        copyback: false
        prepare: |
          ${{ matrix.os.dependencies }}
        run: |
          set -e
          cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.build-type}} -G Ninja -DCMAKE_CXX_COMPILER=/usr/pkg/gcc10/bin/g++ -DCMAKE_C_COMPILER=/usr/pkg/gcc10/bin/gcc
          cd ${{github.workspace}}/build
          NINJA_STATUS="%p [%f:%s/%t] %o/s, %es" ninja
          ctest -j 4 --output-on-failure -E '(perf-.*)|(.*-malloc$)' --timeout 400

  ## Without overcommit, or explicit commit the current implementation cannot be made to work on openbsd.
  ## We could add a layered pagemap for openbsd, that would address the requirements. 
  # openbsd:
  #   strategy:
  #     matrix:
  #       # Build each combination of OS, version, and release/debug variants
  #       os:
  #         - version: '7.2'
  #           dependencies: pkg_add -I cmake ninja
  #       build-type: [ Release, Debug ]
  #     # Don't abort runners if a single one fails
  #     fail-fast: false
  #   # Kill these jobs if they take too long.
  #   timeout-minutes: 25
  #   runs-on: macos-latest
  #   name: OpenBSD-${{ matrix.os.version}} ${{ matrix.build-type }}
  #   steps:
  #   - uses: actions/checkout@v4
  #   - uses: vmactions/openbsd-vm@v0
  #     with:
  #       release: ${{ matrix.os.version}}
  #       usesh: true
  #       mem: 8192
  #       copyback: false
  #       prepare: |
  #         ${{ matrix.os.dependencies }}
  #       run: |
  #         set -e
  #         cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.build-type}} -G Ninja
  #         cd ${{github.workspace}}/build
  #         NINJA_STATUS="%p [%f:%s/%t] %o/s, %es" ninja
  #         ctest -j 4 --output-on-failure -E '(perf-.*)|(.*-malloc$)' --timeout 400

  sanitizer:
    strategy:
      matrix:
        # Build just release variant as Debug is too slow.
        build-type: [ Release ]
        os: ["ubuntu-latest", "ubuntu-20.04"]
        include:
          - os: "ubuntu-latest"
            variant: "libc++ (TSan + UBSan)"
            dependencies: "sudo apt install ninja-build libc++-dev"
            extra-cmake-flags: "-DCMAKE_CXX_COMPILER=clang++ -DCMAKE_CXX_FLAGS=-stdlib=\"libc++ -g\" -DSNMALLOC_SANITIZER=undefined,thread"
          # Also test specifically with clang-10 (on ubuntu-20.04)
          - os: "ubuntu-20.04"
            variant: "clang-10 libc++ (TSan + UBSan)"
            dependencies: "sudo apt install ninja-build libc++-dev"
            extra-cmake-flags: "-DCMAKE_CXX_COMPILER=clang++-10 -DCMAKE_CXX_FLAGS=-stdlib=\"libc++ -g\" -DSNMALLOC_SANITIZER=undefined,thread"
      # Don't abort runners if a single one fails
      fail-fast: false
    runs-on: ${{ matrix.os }}
    name: ${{ matrix.os }} ${{ matrix.build-type }} ${{ matrix.variant }}
    steps:
    - uses: actions/checkout@v4
    - name: Install build dependencies
      run: ${{ matrix.dependencies }}
    - name: Configure CMake
      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.build-type}} -G Ninja ${{ matrix.cmake-flags }} ${{ matrix.extra-cmake-flags }}
      # Build with a nice ninja status line
    - name: Build
      working-directory: ${{github.workspace}}/build
      run: NINJA_STATUS="%p [%f:%s/%t] %o/s, %es" ninja
    - name: Test
      working-directory: ${{github.workspace}}/build
      run: ctest --output-on-failure -j 4 -C ${{ matrix.build-type }} --timeout 400 -E "memcpy|external_pointer" --repeat-until-fail 2

  qemu-crossbuild:
    strategy:
      matrix:
        build-type: [ Release, Debug ]
        arch:
          - name: armhf
            system-processor: arm
            triple: arm-linux-gnueabihf
            rtld: ld-linux-armhf.so.3
            ld-flavour: lld
            host-os: ubuntu-latest
          - name: arm64
            system-processor: aarch64
            triple: aarch64-linux-gnu
            rtld: ld-linux-aarch64.so.1
            ld-flavour: lld
            host-os: ubuntu-latest
          - name: ppc64el
            system-processor: powerpc64le
            triple: powerpc64le-linux-gnu
            rtld: ld64.so.2
            ld-flavour: lld
            # See https://github.com/microsoft/snmalloc/issues/576
            host-os: ubuntu-20.04
          - name: riscv64
            system-processor: riscv64
            triple: riscv64-linux-gnu
            rtld: ld-linux-riscv64-lp64d.so.1
            extra-packages: binutils-riscv64-linux-gnu
            ld-flavour: bfd
            ld: /usr/bin/riscv64-linux-gnu-ld.bfd
            host-os: ubuntu-latest
      # Don't abort runners if a single one fails
      fail-fast: false
    runs-on: ${{matrix.arch.host-os}}
    name: ${{matrix.build-type}} cross-build for ${{ matrix.arch.triple }}
    steps:
    - uses: actions/checkout@v4
    - name: "Install cross-compile toolchain and QEMU (ubuntu-20.04)"
      # Install the dependencies and clang 13.  Earlier versions of clang don't
      # find the multilib things for this week's Ubuntu filesystem layout.
      if: matrix.arch.host-os == 'ubuntu-20.04'
      run: |
        wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
        sudo add-apt-repository "deb http://apt.llvm.org/focal/     llvm-toolchain-focal-13  main"
        sudo apt update
        sudo apt install libstdc++-9-dev-${{ matrix.arch.name }}-cross qemu-user ninja-build clang-13 lld-13
        sudo apt install ${{matrix.arch.extra-packages}}
    - name: "Install cross-compile toolchain and QEMU (ubuntu-latest)"
      if: matrix.arch.host-os == 'ubuntu-latest'
      run: |
        sudo apt update
        sudo apt install libstdc++-12-dev-${{ matrix.arch.name }}-cross qemu-user ninja-build
        sudo apt install ${{matrix.arch.extra-packages}}
    - name: Reconfigure for PowerPC64LE
      if: startsWith(matrix.arch.triple, 'powerpc64le')
      # The default PowerPC qemu configuration uses the wrong page size.
      # Wrap it in a script that fixes this.
      run: |
        sudo update-binfmts --disable qemu-ppc64le
        sudo sh -c 'echo ":qemu-ppc64le:M:0:\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x15\x00:\xff\xff\xff\xff\xff\xff\xff\xfc\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\x00:`pwd`/ppc64.sh:" > /proc/sys/fs/binfmt_misc/register'
        echo '#!/bin/sh' > ppc64.sh
        echo '/usr/bin/qemu-ppc64le -p 65536 $@' >> ppc64.sh
        chmod +x ppc64.sh
    - name: Configure
      env:
        SNMALLOC_CI_CLANG_VERSION: ${{ (matrix.arch.host-os == 'ubuntu-latest') && 16 || 13 }}
        RTLD_NAME: ${{ matrix.arch.rtld }}
        ARCH: ${{ matrix.arch.system-processor }}
        TRIPLE: ${{ matrix.arch.triple}}
      run: >
        cmake
        -B ${{github.workspace}}/build
        -DCMAKE_BUILD_TYPE=${{matrix.build-type}}
        -G Ninja
        -DSNMALLOC_CI_BUILD=ON
        -DSNMALLOC_QEMU_WORKAROUND=ON
        -DSNMALLOC_STATIC_LIBRARY=OFF
        -DCMAKE_TOOLCHAIN_FILE=ci/Toolchain.cmake
        -DSNMALLOC_LINKER=${{matrix.arch.ld}}
        -DSNMALLOC_LINKER_FLAVOUR=${{matrix.arch.ld-flavour}}
    - name: Build
      working-directory: ${{github.workspace}}/build
      run: NINJA_STATUS="%p [%f:%s/%t] %o/s, %es" ninja
    # For debugging: verify that we've actually cross-compiled.
    - name: Run `file` for inspection
      working-directory: ${{github.workspace}}/build
      run: file func*
    # Run the tests, skipping the -malloc and perf- tests (perf doesn't make
    # sense in an emulator and the pass-through malloc is slightly flaky in
    # QEMU)
    - name: Test
      working-directory: ${{github.workspace}}/build
      run: ctest -j 2 --output-on-failure -E '(perf-.*)|(.*-malloc$)' --timeout 400
      timeout-minutes: 30

  windows:
    strategy:
      matrix:
        # Build each combination of OS and release/debug variants
        os: [ windows-2019 ]
        build-type: [ Release, Debug ]
        arch: [ Win32, x64 ]
        toolchain: [ "", "-T ClangCL" ]
        extra-cmake-flags: [ "" ]
        # Add an extra check for the Windows 8 compatible PAL
        include:
          - os: windows-2019
            build-type: Release
            arch: x64
            toolchain: ""
            extra-cmake-flags: -DWIN8COMPAT=TRUE
            variant: Windows 8 compatible
          - os: windows-2022
            build-type: Release
            arch: Win32
            toolchain: ""
          - os: windows-2022
            build-type: Debug
            arch: Win32
            toolchain: ""
          - os: windows-2022
            build-type: Release
            arch: x64
            toolchain: ""
          - os: windows-2022
            build-type: Debug
            arch: x64
            toolchain: ""
          - os: windows-2022
            build-type: Release
            arch: ARM64
            toolchain: ""
            build-only: yes
          - os: windows-2022
            build-type: Debug
            arch: ARM64
            toolchain: ""
            build-only: yes
          - os: windows-2022
            build-type: Release
            arch: ARM64EC
            toolchain: ""
            extra-cmake-flags: -DCMAKE_SYSTEM_VERSION="10.0.22621.0"
            build-only: yes
          - os: windows-2022
            build-type: Debug
            arch: ARM64EC
            toolchain: ""
            extra-cmake-flags: -DCMAKE_SYSTEM_VERSION="10.0.22621.0"
            build-only: yes
        
      # Don't abort runners if a single one fails
      fail-fast: false
    runs-on: ${{ matrix.os }}
    name: ${{ matrix.os }} ${{ matrix.arch }} ${{ matrix.build-type }} ${{ matrix.toolchain }} ${{ matrix.variant }}
    steps:
    - uses: actions/checkout@v4
    - name: Configure CMake
      run: |
        cmake -B ${{github.workspace}}/build -A ${{ matrix.arch }} ${{ matrix.toolchain }} ${{ matrix.extra-cmake-flags }} -DSNMALLOC_CI_BUILD=On -DSNMALLOC_RUST_SUPPORT=On
      # Build with whatever version of msbuild was configured, for a single build configuration.
    - name: Build
      run: cmake --build ${{github.workspace}}/build -- /m /p:Configuration=${{ matrix.build-type }}
      # Run the tests.
    - name: Test
      if: ${{ matrix.build-only != 'yes' }}
      working-directory: ${{ github.workspace }}/build
      run: ctest -j 2 --interactive-debug-mode 0 --output-on-failure -C ${{ matrix.build-type }} --timeout 400
      timeout-minutes: 20


  # Job to run clang-format and report errors
  format:
    runs-on: ubuntu-22.04
    # We don't need to do the build for this job, but we need to configure it to get the clang-format target
    steps:
    - uses: actions/checkout@v4
    - name: Install clang-tidy and clang-format
      run: |
        sudo apt update
        sudo apt install clang-tidy-15 clang-format-15
    - name: Configure CMake
      run: cmake -B ${{github.workspace}}/build -DSNMALLOC_USE_CXX17=ON
    # Run the clang-format check and error if it generates a diff
    - name: Run clang-format
      working-directory: ${{github.workspace}}/build
      run: |
        set -eo pipefail
        make clangformat
        git diff --exit-code
    - name: Run clang-tidy
      run: |
        clang-tidy-15  src/snmalloc/override/malloc.cc  -header-filter="`pwd`/*" -warnings-as-errors='*' -export-fixes=tidy.fail -- -std=c++17 -mcx16 -DSNMALLOC_USE_WAIT_ON_ADDRESS=1 -DSNMALLOC_PLATFORM_HAS_GETENTROPY=0 -Isrc
        if [ -f tidy.fail ] ; then
          cat tidy.fail
          exit 1
        fi

  fuzzing:
    runs-on: ubuntu-24.04
    steps:
    - uses: actions/checkout@v4
    - name: Configure CMake
      run: cmake -B ${{github.workspace}}/build -DSNMALLOC_ENABLE_FUZZING=ON -DFUZZTEST_FUZZING_MODE=ON -DCMAKE_CXX_COMPILER=clang++
    - name: Build
      run: cmake --build ${{github.workspace}}/build --target snmalloc-fuzzer
    - name: Test
      run: ${{github.workspace}}/build/fuzzing/snmalloc-fuzzer

  self-vendored:
    name: Self Vendored STL Functionality
    strategy:
      fail-fast: false
      matrix:
        include:
        - os: windows-2022
          cxx: clang-cl
          cc: clang-cl
        - os: ubuntu-24.04
          cxx: clang++-18
          cc: clang-18
        - os: ubuntu-24.04
          cxx: g++-14
          cc: gcc-14
        - os: macos-latest
          cxx: clang++
          cc: clang 
    runs-on: ${{ matrix.os }}
    steps:
    - uses: actions/checkout@v4
    - name: Prepare Windows
      if: runner.os == 'Windows'
      run: |
        choco install ninja
    - name: Prepare macOS
      if: runner.os == 'macOS'
      run: |
        brew install ninja
    - name: Prepare Ubuntu
      if: runner.os == 'Linux'
      run: |
        sudo apt-get install -y ninja-build
    - name: Configure CMake
      run: >
        cmake 
        -B ${{github.workspace}}/build 
        -DSNMALLOC_USE_SELF_VENDORED_STL=ON
        -GNinja
        -DCMAKE_BUILD_TYPE=RelWithDebInfo
        -DCMAKE_CXX_COMPILER=${{ matrix.cxx }}
        -DCMAKE_C_COMPILER=${{ matrix.cc }}
    - name: Build
      run: cmake --build ${{github.workspace}}/build --parallel
    - name: Test
      run: |
        cd ${{github.workspace}}/build
        ctest --parallel
      
  all-checks:
    # Currently FreeBSD and NetBSD CI are not working, so we do not require them to pass.
    # Add fuzzing back when the memove issue is fixed.
    needs: [ubuntu, macos, freebsd, netbsd, sanitizer, qemu-crossbuild, windows, format]
    runs-on: ubuntu-latest
    steps:
    - name: Dummy step
      run: true