Monte Carlo time stepping action #19043

Workflow file for this run

	# Distributed under the MIT License.
	# See LICENSE.txt for details.

	# Continuous integration tests that pull requests are required to pass. This
	# workflow can also be dispatched manually to tag and release versions.
	name: Tests

	# Set any defaults for the runs below.
	# - use bash as the default shell since this is almost certainly what
	# is always expected. We use regular expressions in a few places
	# that rely on bash.
	defaults:
	run:
	shell: bash

	# Note that by default the jobs only run on the base repository, testing pull
	# requests and merge commits. Enable GitHub Actions in your fork's repository
	# settings to also run the tests on every push to one of your branches.
	on:
	# We run all jobs when pull requests are opened, commits are pushed, or pull
	# requests are re-opened after being closed.
	# The jobs triggered by this event run on the base repository of the pull
	# request, so they have access to its caches.
	pull_request:
	# We run those jobs that require no information about a pull request (e.g.
	# unit tests) also on `push` events. This setup tests merge commits into
	# `develop` and also builds up caches on `develop` that can be re-used by PRs.
	# It also runs the jobs on forks if they have GitHub Actions enabled.
	push:
	branches-ignore:
	- gh-pages
	# Allow running the workflow manually to run tests and optionally release a
	# version on success (see the dev guide on "Automatic versioning")
	workflow_dispatch:
	inputs:
	release_version:
	description: >
	Enter a version name YYYY.MM.DD[.TWEAK] to create a release on success
	required: false
	default: ''
	timezone:
	description: >
	Timezone used for validating the version name. The release must be
	approved by the end of the day in the specified timezone. See
	/usr/share/zoneinfo for a list of possible values.
	required: false
	default: 'America/Los_Angeles'
	clear_ccache:
	description: >
	Enter 'yes' without quotes to clear ccache before running
	required: false
	default: ''
	container:
	description: >
	Container to use for builds
	required: false
	default: 'sxscollaboration/spectre:dev'
	# Allow running this workflow as a job in another workflow. This is used to
	# test a new Docker container before publishing it.
	workflow_call:
	inputs:
	container:
	description: >
	Container to use for builds
	required: false
	type: string
	default: 'sxscollaboration/spectre:dev'

	# Cancel all other queued or in-progress runs of this workflow when it is
	# scheduled, so repeated pushes to a branch or a PR don't block CI. Repeated
	# pushes to 'develop' and 'release' are not canceled, so every merge commit is
	# tested.
	concurrency:
	group: ${{ github.ref }}
	cancel-in-progress: ${{ github.ref != 'refs/heads/develop'
	&& github.ref != 'refs/heads/release' }}

	jobs:
	# Make sure no commits are prefixed with `fixup` or similar keywords. See
	# `tools/CheckCommits.sh` for details.
	check_commits:
	name: Commits
	# Only run on pull requests since we don't check _all_ commits, but only
	# those that came after the PR's base ref.
	if: github.event_name == 'pull_request'
	runs-on: ubuntu-latest
	steps:
	- name: Checkout repository
	uses: actions/checkout@v4
	with:
	fetch-depth: 0
	- name: Check commits
	# `CheckCommits.sh` tests against the local `develop` branch, so that's
	# where we fetch the pull-request's base-branch to. Typically, it is
	# the upstream `sxs-collaboration/spectre/develop` branch.
	run: >
	cd $GITHUB_WORKSPACE

	git remote add upstream
	https://github.com/${{ github.repository }}.git

	git remote -v

	git fetch upstream ${{ github.base_ref }}:develop

	./tools/CheckCommits.sh

	# - Run simple textual checks over files in the repository, e.g. checking for
	# a license, line length limits etc. See `tools/CheckFiles.sh` for details.
	# - Run format checker for python to make sure the code is formatted correctly
	# - Check the metadata are consistent
	check_files_and_formatting:
	name: Files and formatting
	runs-on: ubuntu-latest
	container:
	image: ${{ inputs.container \|\| 'sxscollaboration/spectre:dev' }}
	steps:
	- name: Checkout repository
	uses: actions/checkout@v4
	with:
	fetch-depth: 0
	# Work around https://github.com/actions/checkout/issues/760
	- name: Trust checkout
	run: \|
	git config --global --add safe.directory $GITHUB_WORKSPACE
	# The action above checks out the `github.ref` by default, which points to
	# the merge commit with the target branch for pull-request events. For
	# this job we check out the pull-request HEAD instead. It makes
	# git-related issues easier to debug because the state matches the local
	# repository. It also prevents releases that happened since the
	# pull-request branch was last rebased from disrupting tests that involve
	# the latest release tag.
	- name: Checkout pull-request HEAD
	if: github.event_name == 'pull_request'
	run: \|
	git checkout ${{ github.event.pull_request.head.sha }}
	# Some tests involve release tags, which may not have been pushed to
	# forks. Fetching them here.
	- name: Fetch upstream tags on forks
	if: github.repository != 'sxs-collaboration/spectre'
	run: \|
	git fetch --tags https://github.com/sxs-collaboration/spectre
	- name: Install Python dependencies
	run: \|
	pip3 install -r .github/scripts/requirements-release.txt
	pip3 install -r support/Python/dev_requirements.txt
	- name: Test tools
	run: \|
	python3 -m unittest discover -p 'Test_CompileReleaseNotes.py' \
	tests.tools -v
	- name: Check Python formatting
	run: \|
	cd $GITHUB_WORKSPACE
	echo "Using 'black' to check Python formatting..."
	black --check .
	echo "Using 'isort' to check Python formatting..."
	isort --check-only .
	- name: Test script
	run: \|
	cd $GITHUB_WORKSPACE
	./tools/CheckFiles.sh --test
	- name: Check files
	run: \|
	cd $GITHUB_WORKSPACE
	./tools/CheckFiles.sh
	- name: Check metadata
	run: \|
	python3 tools/CheckMetadata.py
	- name: Check the metadata is consistent with the releases
	# No need to check this on forks. They would need to set a Zenodo token
	# for this test. Also disable on PRs because they don't have access to
	# the repo's secrets.
	if: >
	github.repository == 'sxs-collaboration/spectre'
	&& github.event_name != 'pull_request'
	run: \|
	python3 .github/scripts/Release.py prepare -vv --check-only \
	--zenodo-token ${{ secrets.ZENODO_READONLY_TOKEN }} \
	--github-token ${{ secrets.GITHUB_TOKEN }}
	python3 .github/scripts/Release.py publish -vv --check-only \
	--zenodo-token ${{ secrets.ZENODO_READONLY_TOKEN }} \
	--github-token ${{ secrets.GITHUB_TOKEN }} \
	--auto-publish
	- name: Check release notes
	run: \|
	python3 tools/CompileReleaseNotes.py -vv -o release_notes.md \
	--github-token ${{ secrets.GITHUB_TOKEN }}
	- name: Upload release notes
	uses: actions/upload-artifact@v4
	with:
	name: release-notes
	path: release_notes.md
	# GitHub doesn't display artifacts until the workflow has completed, so we
	# print the release notes here to be able to review them before approving
	# a release
	- name: Print release notes
	run: \|
	cat release_notes.md

	# Lint with clang-tidy. We check only code that changed relative to the
	# nearest common ancestor commit with `sxs-collaboration/spectre/develop`.
	clang_tidy:
	name: Clang-tidy
	if: >
	(github.event_name == 'pull_request'
	&& github.repository == 'sxs-collaboration/spectre'
	&& github.base_ref == 'develop')
	\|\| github.ref != 'refs/heads/develop'
	runs-on: ubuntu-latest
	container:
	image: ${{ inputs.container \|\| 'sxscollaboration/spectre:dev' }}
	strategy:
	matrix:
	build_type: [Debug, Release]
	steps:
	- name: Checkout repository
	uses: actions/checkout@v4
	with:
	fetch-depth: 0
	# Work around https://github.com/actions/checkout/issues/760
	- name: Trust checkout
	run: \|
	git config --global --add safe.directory $GITHUB_WORKSPACE
	# Some cpp20 features aren't supported until clang-tidy-16. See:
	# https://stackoverflow.com/questions/46114214/lambda-implicit-capture-fails-with-variable-declared-from-structured-binding#comment135007519_46115028
	# The clang-tidy-diff tool doesn't report exit codes until version
	# 18.1.0, so we grab the version that does:
	# https://github.com/llvm/llvm-project/commit/4294bca5e4f6e6e8cfdbd9fbe8751c5e5415fd47
	- name: Install clang-tidy-16
	run: \|
	apt-get update -y
	apt-get remove -y clang-tidy clang-tidy-14
	apt-get install -y clang-tidy-16
	ln -s /usr/bin/clang-tidy-16 /usr/bin/clang-tidy
	wget https://raw.githubusercontent.com/llvm/llvm-project/4294bca5e4f6e6e8cfdbd9fbe8751c5e5415fd47/clang-tools-extra/clang-tidy/tool/clang-tidy-diff.py
	chmod +x clang-tidy-diff.py
	mv clang-tidy-diff.py /usr/bin/clang-tidy-diff.py
	ln -s /usr/bin/clang-tidy-diff.py /usr/bin/clang-tidy-diff
	- name: Configure annotations
	# Has to be accessible outside the container, see issue:
	# https://github.com/actions/toolkit/issues/305
	run: \|
	cp .github/problem_matchers/ClangTidy.json "$HOME/"
	echo "::add-matcher::$HOME/ClangTidy.json"
	- name: Fetch sxs-collaboration/spectre/develop
	run: >
	cd $GITHUB_WORKSPACE

	git remote add upstream
	https://github.com/sxs-collaboration/spectre.git

	git remote -v

	git fetch upstream develop
	- name: Configure with cmake
	run: >
	mkdir build && cd build

	cmake
	-D CMAKE_C_COMPILER=clang-14
	-D CMAKE_CXX_COMPILER=clang++-14
	-D CMAKE_Fortran_COMPILER=gfortran
	-D CHARM_ROOT=${CHARM_ROOT}
	-D CMAKE_BUILD_TYPE=${{ matrix.build_type }}
	-D OVERRIDE_ARCH=x86-64
	-D USE_CCACHE=OFF
	-D USE_PCH=OFF
	-D DEBUG_SYMBOLS=OFF
	-D BUILD_PYTHON_BINDINGS=ON
	$GITHUB_WORKSPACE

	make -j4 module_All
	- name: Check clang-tidy
	run: >
	UPSTREAM_HASH=$(git merge-base HEAD upstream/develop)

	echo "Running clang-tidy relative to: $UPSTREAM_HASH\n"

	git diff -U0 $UPSTREAM_HASH \|
	clang-tidy-diff -path build -p1 -use-color \
	-extra-arg=-I/usr/include/hdf5/serial


	# Build the documentation and check for problems, then upload as a workflow
	# artifact and deploy to gh-pages.
	doc_check:
	name: Documentation
	needs: check_files_and_formatting
	runs-on: ubuntu-latest
	container:
	image: ${{ inputs.container \|\| 'sxscollaboration/spectre:dev' }}
	env:
	CCACHE_DIR: /work/ccache
	CCACHE_READONLY: 1
	CCACHE_COMPILERCHECK: content
	CCACHE_BASEDIR: $GITHUB_WORKSPACE
	steps:
	- name: Checkout repository
	uses: actions/checkout@v4
	# Work around https://github.com/actions/checkout/issues/760
	- name: Trust checkout
	run: \|
	git config --global --add safe.directory $GITHUB_WORKSPACE
	# These can be installed directly in the Docker container instead
	- name: Install Python dependencies
	run: \|
	python3 -m pip install -r support/Python/dev_requirements.txt
	- name: Download release notes
	uses: actions/download-artifact@v4
	id: release-notes
	with:
	name: release-notes
	path: /work
	- name: Append release notes to changelog
	# The sed command escapes @ symbols at beginning of words (GitHub
	# usernames) so they aren't interpreted as Doxygen commands
	run: \|
	echo "" >> docs/Changelog.md
	cat /work/release_notes.md \| sed 's/$\B\@$/\\\1/g' \
	>> docs/Changelog.md
	- name: Restore ccache
	uses: actions/cache/restore@v4
	id: restore-ccache
	env:
	CACHE_KEY_PREFIX: ccache-gcc-11-Debug-pch-ON
	with:
	path: /work/ccache
	key: "${{ env.CACHE_KEY_PREFIX }}-${{ github.run_id }}"
	restore-keys: \|
	${{ env.CACHE_KEY_PREFIX }}-
	# - Make sure to use the same build configuration as the unit tests from
	# which we restore the ccache.
	# - Set `BUILD_TESTING=OFF` to test a CMake configuration with tests
	# turned off.
	- name: Configure with cmake
	run: >
	mkdir build && cd build

	cmake
	-D CMAKE_C_COMPILER=gcc-11
	-D CMAKE_CXX_COMPILER=g++-11
	-D CMAKE_Fortran_COMPILER=gfortran-11
	-D CMAKE_CXX_FLAGS="-Werror"
	-D OVERRIDE_ARCH=x86-64
	-D CHARM_ROOT=${CHARM_ROOT}
	-D CMAKE_BUILD_TYPE=Debug
	-D DEBUG_SYMBOLS=OFF
	-D USE_PCH=ON
	-D USE_XSIMD=ON
	-D USE_CCACHE=ON
	-D ENABLE_OPENMP=ON
	-D BUILD_PYTHON_BINDINGS=ON
	-D BUILD_SHARED_LIBS=ON
	-D MEMORY_ALLOCATOR=SYSTEM
	-D BUILD_DOCS=ON
	-D BUILD_TESTING=OFF
	$GITHUB_WORKSPACE
	- name: Check documentation
	working-directory: build
	run: \|
	make doc-check
	# Re-build with coverage information on pushes to develop for deployment
	# to gh-pages.
	- name: Build documentation with coverage
	if: github.event_name == 'push' && github.ref == 'refs/heads/develop'
	working-directory: build
	run: \|
	make doc-coverage
	- name: Build Python docs
	working-directory: build
	run: \|
	make py-docs
	# Upload as an artifact to make available to deployment and to PRs
	- name: Prepare for upload
	working-directory: build
	run: \|
	tar -cf docs-html.tar --directory docs/html .
	- name: Upload documentation
	uses: actions/upload-artifact@v4
	with:
	name: docs-html
	path: build/docs-html.tar

	# Deploy to gh-pages on pushes to develop
	# See docs: https://github.com/actions/deploy-pages
	docs-deploy:
	name: Deploy documentation
	if: github.event_name == 'push' && github.ref == 'refs/heads/develop'
	needs: doc_check
	runs-on: ubuntu-latest
	permissions:
	pages: write
	id-token: write
	environment:
	name: github-pages
	url: ${{ steps.deploy.outputs.page_url }}
	steps:
	- uses: actions/deploy-pages@v4
	id: deploy
	with:
	artifact_name: docs-html

	# Build all test executables and run unit tests on a variety of compiler
	# configurations.
	unit_tests:
	name: Unit tests
	runs-on: ubuntu-latest
	strategy:
	fail-fast: false
	matrix:
	# We have a sparse clang test configuration to reduce the amount of
	# GitHub cache space we use. GCC being the production compiler on
	# supercomputers means we need to thoroughly test it.
	compiler:
	- gcc-9
	- gcc-10
	- gcc-11
	build_type: [Debug, Release]
	include:
	# Generate code coverage report for a single build
	# Note: currently disabled because it exceeds the available disk space
	# - compiler: gcc-9
	# build_type: Debug
	# COVERAGE: ON
	# TEST_TIMEOUT_FACTOR: 3
	# This configuration seems to run consistently slower than newer gcc
	# or clang builds, so we increase the test timeout a bit
	- compiler: gcc-10
	build_type: Debug
	TEST_TIMEOUT_FACTOR: 2
	# Test 3D rendering with ParaView
	# Note: currently disabled because of some unknown upstream issue
	# test_3d_rendering: ON
	# Need Python version consistent with ParaView
	PYTHON_VERSION: "3.9"
	# Don't modify the gcc-11 Debug build so its cache can be reused for
	# the documentation build
	# - compiler: gcc-11
	# build_type: Debug
	# Test with Python 3.8 so that we retain backwards compatibility. We
	# keep track of Python versions on supercomputers in this issue:
	# https://github.com/sxs-collaboration/spectre/issues/442
	- compiler: gcc-11
	build_type: Release
	PYTHON_VERSION: "3.8"
	# Disable building executable for this build for now because it
	# exceeds the available memory. See issue:
	# https://github.com/sxs-collaboration/spectre/issues/5472
	test_executables: OFF
	# Test building with static libraries. Do so with clang in release
	# mode because these builds use up little disk space compared to GCC
	# builds or clang Debug builds
	- compiler: clang-13
	build_type: Release
	BUILD_SHARED_LIBS: OFF
	use_xsimd: OFF
	MEMORY_ALLOCATOR: JEMALLOC
	# Add a test without PCH to the build matrix, which only builds core
	# libraries. Building all the tests without the PCH takes very long
	# and the most we would catch is a missing include of something that's
	# in the PCH.
	# Use this test also to build and test all input files with "normal"
	# or higher priority. The other configurations only test input files
	# with "high" priority to reduce the total build time.
	- compiler: clang-13
	build_type: Debug
	use_pch: OFF
	unit_tests: OFF
	input_file_tests_min_priority: "normal"
	# Test with ASAN
	- compiler: clang-14
	build_type: Debug
	# When building with ASAN we also need python bindings to be
	# disabled because otherwise we get link errors. See issue:
	# https://github.com/sxs-collaboration/spectre/issues/1890
	# So we are also using this build to test building without Python
	# bindings enabled.
	ASAN: ON
	BUILD_PYTHON_BINDINGS: OFF
	MEMORY_ALLOCATOR: JEMALLOC
	TEST_TIMEOUT_FACTOR: 2
	- compiler: clang-14
	build_type: Release
	# Test compatibility with oldest supported CMake version
	CMAKE_VERSION: "3.18.2"
	# Use an MPI version of Charm
	CHARM_ROOT: /work/charm_7_0_0/mpi-linux-x86_64-smp-clang
	# MPI running tests is a bit slower than multicore
	TEST_TIMEOUT_FACTOR: 3
	# If MPI should be tested
	USE_MPI: ON
	# Test `install` target with clang in Release mode because it uses
	# little disk space
	install: ON

	container:
	image: ${{ inputs.container \|\| 'sxscollaboration/spectre:dev' }}
	env:
	# We run unit tests with the following compiler flags:
	# - `-Werror`: Treat warnings as error.
	# - `-march=x86-64`: Make sure we are building on a consistent
	# architecture so caching works. This is necessary because GitHub
	# may run the job on different hardware.
	CXXFLAGS: "-Werror"
	# We make sure to use a fixed absolute path for the ccache directory
	CCACHE_DIR: /work/ccache
	# Use a separate temp directory to conserve cache space on GitHub
	CCACHE_TEMPDIR: /work/ccache-tmp
	# Control the max cache size. We evict unused entries in a step below to
	# make sure that each build only uses what it need of this max size.
	CCACHE_MAXSIZE: "2G"
	# Control the compression level. The ccache docs recommend at most level
	# 5 to avoid slowing down compilation.
	CCACHE_COMPRESS: 1
	CCACHE_COMPRESSLEVEL: 5
	# We hash the content of the compiler rather than the location and mtime
	# to make sure the cache works across the different machines
	CCACHE_COMPILERCHECK: content
	# Rewrite absolute paths starting with this base dir to relative paths
	# before hashing. This is needed to reuse the cache for the formaline
	# test below, which builds in a different directory.
	CCACHE_BASEDIR: $GITHUB_WORKSPACE
	# These vars are to allow running charm with MPI as root inside the
	# container which arises from using the "--privileged" flag just below.
	OMPI_ALLOW_RUN_AS_ROOT: 1
	OMPI_ALLOW_RUN_AS_ROOT_CONFIRM: 1
	# The number of cores to run on. This is given at:
	# https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners/about-github-hosted-runners#standard-github-hosted-runners-for-public-repositories
	NUMBER_OF_CORES: 4
	# See https://lists.cs.illinois.edu/lists/arc/charm/2018-10/msg00011.html
	# for why we need this
	options: --privileged
	steps:
	- name: Record start time
	id: start
	run: \|
	echo "time=$(date +%s)" >> "$GITHUB_OUTPUT"
	- name: Checkout repository
	uses: actions/checkout@v4
	# Work around https://github.com/actions/checkout/issues/760
	- name: Trust checkout
	run: \|
	git config --global --add safe.directory $GITHUB_WORKSPACE
	- uses: ./.github/actions/parse-compiler
	with:
	compiler: ${{ matrix.compiler }}
	# Install the selected compiler. We don't bundle all of them in the
	# container because they take up a lot of space.
	- name: Install compiler
	run: \|
	apt-get update -y
	if [[ $COMPILER_ID = gcc ]]; then
	apt-get install -y $CC $CXX $FC
	else
	apt-get install -y $CC $FC
	fi
	# Install specific CMake version if requested
	- name: Install CMake version
	if: matrix.CMAKE_VERSION
	working-directory: /work
	run: \|
	CMAKE_VERSION=${{ matrix.CMAKE_VERSION }}
	wget -O cmake-install.sh "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-x86_64.sh"
	sh cmake-install.sh --prefix=/usr --skip-license
	rm cmake-install.sh
	- name: Install Python version
	if: matrix.PYTHON_VERSION
	uses: actions/setup-python@v5
	with:
	python-version: ${{ matrix.PYTHON_VERSION }}
	- name: Install Python dependencies
	if: matrix.PYTHON_VERSION
	run: \|
	python3 -m pip install -r support/Python/requirements.txt \
	-r support/Python/dev_requirements.txt
	python3 -m pip list -v
	- name: Install ParaView
	if: matrix.test_3d_rendering == 'ON'
	working-directory: /work
	# Can't just `apt-get install python3-paraview` because we need the
	# headless build of ParaView. So we download a binary from paraview.org
	# (which is built for a specific Python version unfortunately).
	run: \|
	apt-get install -y libglvnd-dev # Needed to find 'libglapi.so'
	wget -O paraview.tar.gz --no-check-certificate "https://www.paraview.org/paraview-downloads/download.php?submit=Download&version=v5.10&type=binary&os=Linux&downloadFile=ParaView-5.10.1-osmesa-MPI-Linux-Python3.9-x86_64.tar.gz"
	tar -xzf paraview.tar.gz
	rm paraview.tar.gz
	mv ParaView-* /opt/paraview
	echo "/opt/paraview/bin" >> $GITHUB_PATH
	# Make 'paraview' Python package available
	PYTHONPATH=/opt/paraview/lib/python3.9/site-packages:$PYTHONPATH
	# Give system-installed Python packages priority over ParaView's
	PYTHONPATH=$pythonLocation/lib/python3.9/site-packages:$PYTHONPATH
	echo "PYTHONPATH=$PYTHONPATH" >> $GITHUB_ENV
	- name: Install MPI and Charm++
	if: matrix.USE_MPI == 'ON'
	working-directory: /work
	run: \|
	apt-get install -y libopenmpi-dev
	cd /work/charm_7_0_0 && ./build charm++ mpi-linux-x86_64-smp clang \
	-j ${NUMBER_OF_CORES} -g0 -O1 --build-shared --with-production

	# Assign a unique cache key for every run.
	# - We will save the cache using this unique key, but only on the develop
	# branch. This way we regularly update the cache without filling up the
	# storage space with caches from other branches.
	# - To restore the most recent cache we provide a partially-matched
	# "restore key".
	- name: Restore ccache
	uses: actions/cache/restore@v4
	id: restore-ccache
	env:
	CACHE_KEY_PREFIX: "ccache-${{ matrix.compiler }}-\
	${{ matrix.build_type }}-pch-${{ matrix.use_pch \|\| 'ON' }}"
	with:
	path: /work/ccache
	key: "${{ env.CACHE_KEY_PREFIX }}-${{ github.run_id }}"
	restore-keys: \|
	${{ env.CACHE_KEY_PREFIX }}-
	- name: Configure ccache
	# Print the ccache configuration and reset statistics
	run: \|
	ccache -pz
	- name: Clear ccache
	# Clear ccache if requested
	if: >
	github.event_name == 'workflow_dispatch'
	&& github.event.inputs.clear_ccache == 'yes'
	run: \|
	ccache -C
	- name: Configure build with cmake
	# Notes on the build configuration:
	# - We don't need debug symbols during CI, so we turn them off to reduce
	# memory usage.
	run: >
	mkdir build && cd build

	BUILD_PYTHON_BINDINGS=${{ matrix.BUILD_PYTHON_BINDINGS }}
	BUILD_SHARED_LIBS=${{ matrix.BUILD_SHARED_LIBS }}
	MATRIX_CHARM_ROOT=${{ matrix.CHARM_ROOT }}
	ASAN=${{ matrix.ASAN }}
	MEMORY_ALLOCATOR=${{ matrix.MEMORY_ALLOCATOR }}
	UBSAN_UNDEFINED=${{ matrix.UBSAN_UNDEFINED }}
	UBSAN_INTEGER=${{ matrix.UBSAN_INTEGER }}
	USE_PCH=${{ matrix.use_pch }}
	USE_XSIMD=${{ matrix.use_xsimd }}
	COVERAGE=${{ matrix.COVERAGE }}
	TEST_TIMEOUT_FACTOR=${{ matrix.TEST_TIMEOUT_FACTOR }}
	INPUT_FILE_MIN_PRIO=${{ matrix.input_file_tests_min_priority }}

	cmake --version

	cmake
	-D CMAKE_C_COMPILER=${CC}
	-D CMAKE_CXX_COMPILER=${CXX}
	-D CMAKE_Fortran_COMPILER=${FC}
	-D CMAKE_CXX_FLAGS="${CXXFLAGS} ${{ matrix.EXTRA_CXX_FLAGS }}"
	-D OVERRIDE_ARCH=x86-64
	-D CHARM_ROOT=${MATRIX_CHARM_ROOT:-$CHARM_ROOT}
	-D CMAKE_BUILD_TYPE=${{ matrix.build_type }}
	-D DEBUG_SYMBOLS=OFF
	-D BACKTRACE_LIB=/usr/local/lib/libbacktrace.a
	-D BACKTRACE_HEADER_DIR=/usr/local/include
	-D UNIT_TESTS_IN_TEST_EXECUTABLES=OFF
	-D SPECTRE_INPUT_FILE_TEST_MIN_PRIORITY=${INPUT_FILE_MIN_PRIO:-'high'}
	-D STRIP_SYMBOLS=ON
	-D STUB_EXECUTABLE_OBJECT_FILES=ON
	-D STUB_LIBRARY_OBJECT_FILES=ON
	-D USE_PCH=${USE_PCH:-'ON'}
	-D USE_XSIMD=${USE_XSIMD:-'ON'}
	-D USE_CCACHE=ON
	-D ENABLE_OPENMP=ON
	-D COVERAGE=${COVERAGE:-'OFF'}
	-D BUILD_PYTHON_BINDINGS=${BUILD_PYTHON_BINDINGS:-'ON'}
	-D BUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-'ON'}
	-D ASAN=${ASAN:-'OFF'}
	-D UBSAN_UNDEFINED=${UBSAN_UNDEFINED:-'OFF'}
	-D UBSAN_INTEGER=${UBSAN_INTEGER:-'OFF'}
	-D MEMORY_ALLOCATOR=${MEMORY_ALLOCATOR:-'SYSTEM'}
	-D SPECTRE_UNIT_TEST_TIMEOUT_FACTOR=${TEST_TIMEOUT_FACTOR:-'1'}
	-D SPECTRE_INPUT_FILE_TEST_TIMEOUT_FACTOR=${TEST_TIMEOUT_FACTOR:-'1'}
	-D SPECTRE_PYTHON_TEST_TIMEOUT_FACTOR=${TEST_TIMEOUT_FACTOR:-'1'}
	-D CMAKE_INSTALL_PREFIX=/work/spectre_install
	-D BUILD_DOCS=OFF
	--warn-uninitialized
	$GITHUB_WORKSPACE 2>&1 \| tee CMakeOutput.txt 2>&1
	- name: Check for CMake warnings
	working-directory: build
	run: \|
	! grep -A 6 "CMake Warning" ./CMakeOutput.txt
	- name: Build unit tests
	if: matrix.unit_tests != 'OFF'
	working-directory: build
	run: \|
	make -j${NUMBER_OF_CORES} unit-tests
	- name: Run unit tests
	if: matrix.unit_tests != 'OFF' && matrix.COVERAGE != 'ON'
	working-directory: build
	run: \|
	# We get occasional random timeouts, repeat tests to see if
	# it is a random timeout or systematic.
	#
	# We run ctest -L unit before build test-executables to make
	# sure that all the unit tests are actually built by the
	# unit-tests target.
	ctest -j${NUMBER_OF_CORES} -L unit \
	--output-on-failure --repeat after-timeout:3
	- name: Run unit tests with coverage reporting
	if: matrix.COVERAGE == 'ON'
	working-directory: build
	run: \|
	make unit-test-coverage
	rm -r docs/html/unit-test-coverage
	- name: Upload coverage report to codecov.io
	if: matrix.COVERAGE == 'ON'
	uses: codecov/codecov-action@v4
	with:
	files: build/tmp/coverage.info
	token: ${{ secrets.CODECOV_TOKEN }}
	# Display the job as failed if upload fails (defaults to false for
	# some reason)
	fail_ci_if_error: true
	# We currently don't require codecov in our guidelines, so don't fail
	# the CI build if codecov fails to upload
	continue-on-error: true
	# Build the executables in a single thread to reduce memory usage
	# sufficiently so they compile on the GitHub-hosted runners
	- name: Build executables
	if: matrix.COVERAGE != 'ON' && matrix.test_executables != 'OFF'
	working-directory: build
	run: \|
	make test-executables
	- name: Build Benchmark executable
	if: matrix.build_type == 'Release'
	working-directory: build
	run: \|
	make -j${NUMBER_OF_CORES} Benchmark
	# Delete unused cache entries before uploading the cache
	- name: Clean up ccache
	if: github.ref == 'refs/heads/develop'
	run: \|
	now=$(date +%s)
	job_duration=$((now - ${{ steps.start.outputs.time }}))
	ccache --evict-older-than "${job_duration}s"
	# Save the cache after everything has been built. Also save on failure or
	# on cancellation (`always()`) because a partial cache is better than no
	# cache.
	- name: Save ccache
	if: always() && github.ref == 'refs/heads/develop'
	uses: actions/cache/save@v4
	with:
	path: /work/ccache
	key: ${{ steps.restore-ccache.outputs.cache-primary-key }}
	- name: Print size of build directory
	working-directory: build
	run: \|
	ls \| xargs du -sh
	du -sh .
	- name: Diagnose ccache
	run: \|
	ccache -s
	- name: Run non-unit tests
	if: matrix.COVERAGE != 'ON' && matrix.test_executables != 'OFF'
	working-directory: build
	run: \|
	# We get occasional random timeouts, repeat tests to see if
	# it is a random timeout or systematic
	#
	# Only use 2 cores because these tests run more slowly.
	ctest -j2 -LE unit --output-on-failure \
	--repeat after-timeout:3
	- name: Install
	if: matrix.install == 'ON'
	working-directory: build
	# Make sure the `install` target runs without error. We could add some
	# basic smoke tests here to make sure the installation worked.
	run: \|
	make install
	- name: Print size of install directory
	if: matrix.install == 'ON'
	working-directory: /work/spectre_install
	# Remove files post-install to reduce disk space for later on.
	run: \|
	ls \| xargs du -sh
	du -sh .
	rm -r ./*
	- name: Test formaline tar can be built
	# - We only run the formaline tests in debug mode to reduce total build
	# time in CI.
	# - We do run for all compilers, though, because formaline injects data
	# at the linking stage, which means we are somewhat tied to the
	# compiler version.
	# - We make sure to use the same compiler flags as the full build above
	# so ccache is able to speed up the build.
	if: matrix.build_type == 'Debug'
	working-directory: build
	run: >
	make EvolveBurgers -j${NUMBER_OF_CORES}

	if [ ! -f ./bin/EvolveBurgers ]; then
	echo "Could not find the executable EvolveBurgers";
	echo "which we use for testing formaline";
	exit 1
	fi

	# We disable ASAN's leak sanitizer because Charm++ has false
	# positives that would cause the build to fail. We disable
	# leak sanitizer for the ctest runs inside CMake anyway.

	ASAN_OPTIONS=detect_leaks=0 ./bin/EvolveBurgers
	--dump-source-tree-as spectre_src --dump-only

	mkdir spectre_src;
	mv spectre_src.tar.gz spectre_src;
	cd spectre_src;
	tar xf spectre_src.tar.gz;
	mkdir build-formaline;
	cd build-formaline

	BUILD_PYTHON_BINDINGS=${{ matrix.BUILD_PYTHON_BINDINGS }}
	MATRIX_CHARM_ROOT=${{ matrix.CHARM_ROOT }}
	MEMORY_ALLOCATOR=${{ matrix.MEMORY_ALLOCATOR }};
	USE_PCH=${{ matrix.use_pch }};
	USE_XSIMD=${{ matrix.use_xsimd }}

	cmake
	-D CMAKE_C_COMPILER=${CC}
	-D CMAKE_CXX_COMPILER=${CXX}
	-D CMAKE_Fortran_COMPILER=${FC}
	-D CMAKE_CXX_FLAGS="${CXXFLAGS} ${{ matrix.EXTRA_CXX_FLAGS }}"
	-D OVERRIDE_ARCH=x86-64
	-D BUILD_SHARED_LIBS=ON
	-D CHARM_ROOT=${MATRIX_CHARM_ROOT:-$CHARM_ROOT}
	-D CMAKE_BUILD_TYPE=${{ matrix.build_type }}
	-D DEBUG_SYMBOLS=OFF
	-D UNIT_TESTS_IN_TEST_EXECUTABLES=OFF
	-D STRIP_SYMBOLS=ON
	-D STUB_EXECUTABLE_OBJECT_FILES=ON
	-D STUB_LIBRARY_OBJECT_FILES=ON
	-D USE_PCH=${USE_PCH:-'ON'}
	-D USE_XSIMD=${USE_XSIMD:-'ON'}
	-D USE_CCACHE=ON
	-D BUILD_PYTHON_BINDINGS=${BUILD_PYTHON_BINDINGS:-'ON'}
	-D MEMORY_ALLOCATOR=${MEMORY_ALLOCATOR:-'SYSTEM'}
	-D BUILD_DOCS=OFF
	..

	make EvolveBurgers -j${NUMBER_OF_CORES}

	# Run on multiple cores to run both the "parse" and "execute" tests
	# simultaneously.

	ctest -j${NUMBER_OF_CORES} -R InputFiles.Burgers.Step.yaml
	--output-on-failure

	cd .. && rm -r build-formaline
	- name: Test bundled exporter
	if: matrix.ASAN != 'ON'
	working-directory: build
	run: \|
	make -j${NUMBER_OF_CORES} BundledExporter
	mkdir build-test-exporter && cd build-test-exporter
	cmake -D SPECTRE_ROOT=$GITHUB_WORKSPACE/build \
	$GITHUB_WORKSPACE/tests/Unit/IO/Exporter/BundledExporter
	make -j${NUMBER_OF_CORES}
	./TestSpectreExporter \
	$GITHUB_WORKSPACE/tests/Unit/Visualization/Python/VolTestData0.h5 \
	element_data 0 Psi 0 0 0 -0.07059806932542323
	cd .. && rm -r build-test-exporter
	- name: Diagnose ccache
	run: \|
	ccache -s

	# Build all test executables and run unit tests on macOS
	unit_tests_macos:
	name: Unit tests on macOS
	strategy:
	fail-fast: false
	matrix:
	include:
	# The number of cores is given at:
	# https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners/about-github-hosted-runners#supported-runners-and-hardware-resources
	- arch: x86
	macos-version: 13 # Intel
	NUM_CORES: 4
	- arch: arm64
	macos-version: 14 # Apple Silicon
	NUM_CORES: 3
	runs-on: macos-${{ matrix.macos-version }}
	env:
	# We install some low-level dependencies with Homebrew. They get picked up
	# by `spack external find`.
	SPECTRE_BREW_DEPS: >- # Line breaks are spaces, no trailing newline
	autoconf automake boost catch2 ccache cmake gsl hdf5 openblas yaml-cpp
	# We install these packages with Spack and cache them. The full specs are
	# listed below. This list is only needed to create the cache.
	SPECTRE_SPACK_DEPS: blaze charmpp libxsmm
	CCACHE_DIR: $HOME/ccache
	CCACHE_TEMPDIR: $HOME/ccache-tmp
	CCACHE_MAXSIZE: "2G"
	CCACHE_COMPRESS: 1
	CCACHE_COMPRESSLEVEL: 5
	CCACHE_COMPILERCHECK: content
	SPACK_SKIP_MODULES: true
	SPACK_COLOR: always
	NUM_CORES: ${{ matrix.NUM_CORES }}
	steps:
	- name: Record start time
	id: start
	run: \|
	echo "time=$(date +%s)" >> "$GITHUB_OUTPUT"
	- name: Checkout repository
	uses: actions/checkout@v4
	- uses: actions/setup-python@v5
	with:
	python-version: '3.12'
	- name: Install Homebrew dependencies
	run: \|
	brew install $SPECTRE_BREW_DEPS
	# We install the remaining dependencies with Spack and cache them.
	# See the `unit_tests` job above for details on the cache configuration.
	- name: Restore dependency cache
	uses: actions/cache/restore@v4
	id: restore-dependencies
	env:
	CACHE_KEY_PREFIX: "dependencies-macos-${{ matrix.macos-version }}"
	with:
	path: ~/dependencies
	key: "${{ env.CACHE_KEY_PREFIX }}-${{ github.run_id }}"
	restore-keys: \|
	${{ env.CACHE_KEY_PREFIX }}-
	- name: Install Spack
	# Pin a specific version of Spack to avoid breaking CI builds when
	# Spack changes.
	run: \|
	cd $HOME
	git clone -c feature.manyFiles=true \
	https://github.com/spack/spack.git
	cd spack
	git checkout 7d1de58378fa210b7db887964fcc17187a504ad8
	- name: Configure Spack
	# - To avoid re-building packages that are already installed by Homebrew
	# we let Spack find them.
	# - Add the dependency cache as binary mirror.
	run: \|
	source $HOME/spack/share/spack/setup-env.sh
	spack debug report
	spack compiler find && spack compiler list
	spack external find
	spack config get packages
	spack mirror add dependencies file://$HOME/dependencies/spack
	# Install the remaining dependencies from source with Spack. We install
	# them in an environment that we can activate later. After building the
	# dependencies from source we cache them as compressed tarballs.
	- name: Install Spack dependencies
	run: \|
	source $HOME/spack/share/spack/setup-env.sh
	spack env create spectre
	spack env activate spectre
	spack add blaze@3.8.2 ~blas ~lapack smp=none
	spack add charmpp@7.0.0 +shared backend=multicore build-target=charm++
	# Use main branch until spack has 2.0 release
	spack add libxsmm@main
	spack concretize --reuse
	spack install --no-check-signature
	spack find -v
	- name: Update dependency cache
	if: github.ref == 'refs/heads/develop'
	run: \|
	source $HOME/spack/share/spack/setup-env.sh
	# Clear existing buildcache so we don't accumulate old versions of
	# packages in the cache
	rm -rf $HOME/dependencies
	spack buildcache create -ufa -m dependencies $SPECTRE_SPACK_DEPS
	# Allow the buildcache creation to fail without failing the job, since
	# it sometimes runs out of memory
	continue-on-error: true
	- name: Save dependency cache
	if: github.ref == 'refs/heads/develop'
	uses: actions/cache/save@v4
	with:
	path: ~/dependencies
	key: ${{ steps.restore-dependencies.outputs.cache-primary-key }}
	# Install remaining pure Python dependencies with pip because the Spack
	# package index can be incomplete (it can't mirror all of pip)
	- name: Install Python dependencies
	run: \|
	source $HOME/spack/share/spack/setup-env.sh
	spack env activate spectre
	pip install -r support/Python/requirements.txt
	# Replace the ccache directory that building the dependencies may have
	# generated with the cached ccache directory.
	- name: Clear ccache from dependencies
	run: \|
	ccache --clear
	rm -rf $CCACHE_DIR
	mkdir -p $CCACHE_DIR
	- name: Restore ccache
	uses: actions/cache/restore@v4
	id: restore-ccache
	env:
	CACHE_KEY_PREFIX: "ccache-macos-${{ matrix.macos-version }}"
	with:
	path: ~/ccache
	key: "${{ env.CACHE_KEY_PREFIX }}-${{ github.run_id }}"
	restore-keys: \|
	${{ env.CACHE_KEY_PREFIX }}-
	- name: Configure ccache
	run: \|
	ccache -pz
	- name: Clear ccache
	# Clear ccache if requested
	if: >
	github.event_name == 'workflow_dispatch'
	&& github.event.inputs.clear_ccache == 'yes'
	run: \|
	ccache -C
	# Configure, build and run tests. See the `unit_tests` job above for
	# details.
	# - We increase the timeout for tests because the GitHub-hosted macOS VMs
	# appear to be quite slow.
	- name: Configure build with cmake
	run: \|
	source $HOME/spack/share/spack/setup-env.sh
	spack env activate spectre
	mkdir build && cd build
	cmake \
	-D CMAKE_C_COMPILER=clang \
	-D CMAKE_CXX_COMPILER=clang++ \
	-D CMAKE_Fortran_COMPILER=gfortran-14 \
	-D CMAKE_CXX_FLAGS="-Werror" \
	-D BUILD_SHARED_LIBS=ON \
	-D BUILD_PYTHON_BINDINGS=ON \
	-D MEMORY_ALLOCATOR=SYSTEM \
	-D CHARM_ROOT=$(spack location --install-dir charmpp) \
	-D BLAS_ROOT=$(brew --prefix openblas) \
	-D LAPACK_ROOT=$(brew --prefix openblas) \
	-D CMAKE_BUILD_TYPE=Debug \
	-D DEBUG_SYMBOLS=OFF \
	-D UNIT_TESTS_IN_TEST_EXECUTABLES=OFF \
	-D STUB_EXECUTABLE_OBJECT_FILES=ON \
	-D STUB_LIBRARY_OBJECT_FILES=ON \
	-D USE_PCH=ON \
	-D USE_CCACHE=ON \
	-D SPECTRE_TEST_TIMEOUT_FACTOR=10 \
	-D CMAKE_INSTALL_PREFIX=../install \
	-D BUILD_DOCS=OFF \
	-D USE_XSIMD=OFF \
	$GITHUB_WORKSPACE
	- name: Build unit tests
	working-directory: build
	run: \|
	make -j${NUM_CORES} unit-tests
	- name: Build executables
	working-directory: build
	run: \|
	make test-executables
	- name: Clean up ccache
	if: github.ref == 'refs/heads/develop'
	run: \|
	now=$(date +%s)
	job_duration=$((now - ${{ steps.start.outputs.time }}))
	ccache --evict-older-than "${job_duration}s"
	- name: Save ccache
	if: always() && github.ref == 'refs/heads/develop'
	uses: actions/cache/save@v4
	with:
	path: ~/ccache
	key: ${{ steps.restore-ccache.outputs.cache-primary-key }}
	- name: Print size of build directory
	working-directory: build
	run: \|
	ls \| xargs du -sh
	du -sh .
	- name: Diagnose ccache
	run: \|
	ccache -s
	- name: Run unit tests
	working-directory: build
	run: \|
	ctest -j${NUM_CORES} --repeat after-timeout:3 --output-on-failure
	- name: Install
	working-directory: build
	run: \|
	make install
	- name: Print size of install directory
	working-directory: install
	run: \|
	ls \| xargs du -sh
	du -sh .
	rm -r ./*

	# Release a new version on manual events when requested and the tests pass.
	# Only enable this on the `sxs-collaboration/spectre` repository (not on
	# forks).
	release_version:
	name: Release version
	# Running in a protected environment that provides the necessary secrets
	environment: release
	runs-on: ubuntu-latest
	if: >
	github.repository == 'sxs-collaboration/spectre'
	&& github.ref == 'refs/heads/develop'
	&& github.event_name == 'workflow_dispatch'
	&& github.event.inputs.release_version != ''
	needs:
	- check_files_and_formatting
	- doc_check
	- unit_tests
	env:
	TZ: ${{ github.event.inputs.timezone }}
	steps:
	- uses: actions/checkout@v4
	with:
	fetch-depth: 0
	# Using a personal access token with admin privileges here so this
	# action can push to protected branches. Note that this also means
	# that the pushes can trigger additional workflows (GitHub only
	# prevents pushes with the default GITHUB_TOKEN from triggering
	# additional workflows).
	#
	# Note: sxs-bot has the personal access token configured.
	#
	# GitHub has 2 forms of personal access tokens.
	# For Fine-Grained Access:
	# "Only selected repositories"
	# - Contents: Access: Read and write
	# - Deployments: Access: Read and write
	#
	# For Tokens (classic):
	# repo: (off)
	# public_repo: on
	# Everything else is off.
	token: ${{ secrets.GH_TOKEN_RELEASE }}
	- uses: actions/setup-python@v5
	with:
	python-version: '3.8'
	- name: Install Python dependencies
	run: \|
	pip3 install -r .github/scripts/requirements-release.txt
	# We use the current date as tag name, unless a tag name was specified
	# as input to the `workflow_dispatch` event
	- name: Determine release version
	id: get_version
	run: \|
	INPUT_RELEASE_VERSION=${{ github.event.inputs.release_version }}
	RELEASE_VERSION=${INPUT_RELEASE_VERSION:-$(date +'%Y.%m.%d')}
	echo "Release version is: ${RELEASE_VERSION}"
	echo "RELEASE_VERSION=$RELEASE_VERSION" >> $GITHUB_ENV
	- name: Validate release version
	run: \|
	VERSION_PATTERN="^([0-9]{4})\.([0-9]{2})\.([0-9]{2})(\.[0-9]+)?$"
	if [[ $RELEASE_VERSION =~ $VERSION_PATTERN ]]; then
	if [ $(date +'%Y') != ${BASH_REMATCH[1]} ] \|\|
	[ $(date +'%m') != ${BASH_REMATCH[2]} ] \|\|
	[ $(date +'%d') != ${BASH_REMATCH[3]} ]; then
	TODAY=$(date +'%Y.%m.%d')
	echo "'$RELEASE_VERSION' doesn't match current date '$TODAY'"
	exit 1
	fi
	else
	echo "'$RELEASE_VERSION' doesn't match '$VERSION_PATTERN'"
	exit 1
	fi
	if [ $(git tag -l "v$RELEASE_VERSION") ]; then
	echo "Tag 'v$RELEASE_VERSION' already exists"
	exit 1
	fi
	if [ $(git rev-parse HEAD) == $(git rev-parse origin/release) ]; then
	echo "Nothing changed since last release $(git describe release)."
	exit 1
	fi
	- name: Reserve Zenodo DOI and prepare repository
	run: \|
	python3 .github/scripts/Release.py prepare -vv \
	--version $RELEASE_VERSION \
	--zenodo-token ${{ secrets.ZENODO_READWRITE_TOKEN }} \
	--github-token ${{ secrets.GITHUB_TOKEN }}
	git diff
	- name: Download release notes
	uses: actions/download-artifact@v4
	id: release-notes
	with:
	name: release-notes
	path: ~/release-notes
	# Push a commit tagged with the new version to `develop` and `release`.
	# The push will trigger the workflow again because we're using a personal
	# access token. The triggered workflow will build and deploy the
	# documentation so we don't need to do that here.
	- name: Commit and push
	run: \|
	git config user.name sxs-bot
	git config user.email sxs-bot@black-holes.org
	git commit -a -m "Prepare release $RELEASE_VERSION"
	git show HEAD
	git status
	git tag -a v$RELEASE_VERSION -m "Release $RELEASE_VERSION" HEAD
	git push origin HEAD:develop
	git push origin HEAD:release
	git push origin v$RELEASE_VERSION
	- name: Create release on GitHub
	uses: softprops/action-gh-release@v2
	with:
	token: ${{ secrets.GH_TOKEN_RELEASE }}
	tag_name: v${{ env.RELEASE_VERSION }}
	name: Release ${{ env.RELEASE_VERSION }}
	body_path: >-
	${{ steps.release-notes.outputs.download-path }}/release_notes.md
	# Publish the Zenodo record. Once published, the record can't be deleted
	# anymore and editing is limited.
	- name: Publish to Zenodo
	run: \|
	python3 .github/scripts/Release.py publish -vv \
	--zenodo-token ${{ secrets.ZENODO_PUBLISH_TOKEN }} \
	--github-token ${{ secrets.GITHUB_TOKEN }} \
	--auto-publish

	arch_datastructures_tests:
	name: Archs
	runs-on: ubuntu-latest
	strategy:
	fail-fast: false
	matrix:
	compiler:
	- gcc-9
	- gcc-10
	- clang-13
	- clang-14
	include:
	- sde_arch: ("-nhm;nehalem" "-snb;sandybridge" "-hsw;haswell"
	"-skl;skylake")
	compiler: gcc-9
	- sde_arch: ("-nhm;nehalem" "-snb;sandybridge" "-hsw;haswell"
	"-skl;skylake" "-icx;icelake-server")
	compiler: gcc-10
	- sde_arch: ("-nhm;nehalem" "-snb;sandybridge" "-hsw;haswell"
	"-skl;skylake" "-icx;icelake-server")
	compiler: clang-13
	- sde_arch: ("-nhm;nehalem" "-snb;sandybridge" "-hsw;haswell"
	"-skl;skylake" "-icx;icelake-server" "-tgl;tigerlake")
	compiler: clang-14
	container:
	image: ${{ inputs.container \|\| 'sxscollaboration/spectre:dev' }}
	env:
	# See the unit test job for the reasons for these configuration choices
	CXXFLAGS: "-Werror"
	steps:
	- name: Checkout repository
	uses: actions/checkout@v4
	# Work around https://github.com/actions/checkout/issues/760
	- name: Trust checkout
	run: \|
	git config --global --add safe.directory $GITHUB_WORKSPACE
	- uses: ./.github/actions/parse-compiler
	with:
	compiler: ${{ matrix.compiler }}
	- name: Install compiler
	run: \|
	apt-get update -y
	if [[ $COMPILER_ID = gcc ]]; then
	apt-get install -y $CC $CXX $FC
	else
	apt-get install -y $CC $FC
	fi
	- name: Install Intel SDE
	working-directory: /work
	run: \|
	wget -O sde-external.tar.xz https://downloadmirror.intel.com/813591/sde-external-9.33.0-2024-01-07-lin.tar.xz
	tar -xJf sde-external.tar.xz
	mv sde-external-* sde
	rm sde-*
	- name: Configure, build, and run tests
	working-directory: /work
	# Notes on the build configuration:
	# - We don't need debug symbols during CI, so we turn them off to reduce
	# memory usage.
	run: >
	ARCH_PARAM_LIST=${{ matrix.sde_arch }}

	for ARCH_PARAM in ${ARCH_PARAM_LIST[@]}; do
	OVERRIDE_ARCH=`echo ${ARCH_PARAM} \| cut -d";" -f2`
	SDE_FLAG=`echo ${ARCH_PARAM} \| cut -d";" -f1`
	echo "CMake arch flag: $OVERRIDE_ARCH"
	echo "Intel SDE arch flag: $SDE_FLAG"
	cd /work
	BUILD_DIR=build$OVERRIDE_ARCH
	mkdir $BUILD_DIR && cd $BUILD_DIR

	cmake\
	-D CMAKE_C_COMPILER=${CC}\
	-D CMAKE_CXX_COMPILER=${CXX}\
	-D CMAKE_Fortran_COMPILER=${FC}\
	-D CMAKE_CXX_FLAGS="${CXXFLAGS}"\
	-D OVERRIDE_ARCH=${OVERRIDE_ARCH}\
	-D CHARM_ROOT=${CHARM_ROOT}\
	-D CMAKE_BUILD_TYPE=Debug\
	-D DEBUG_SYMBOLS=OFF\
	-D STRIP_SYMBOLS=ON\
	-D STUB_EXECUTABLE_OBJECT_FILES=ON\
	-D STUB_LIBRARY_OBJECT_FILES=ON\
	-D USE_PCH=ON\
	-D USE_CCACHE=ON\
	-D BUILD_DOCS=OFF\
	$GITHUB_WORKSPACE

	make -j4 TestArchitectureVectorization

	/work/sde/sde ${SDE_FLAG}\
	-- ./bin/TestArchitectureVectorization [Unit]
	done

	shell: bash

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Monte Carlo time stepping action #19043

Workflow file

Monte Carlo time stepping action #19043

Jobs

Run details

Workflow file for this run