Tests.yaml

# 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: ''

# 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@v2
        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: sxscollaboration/spectrebuildenv:latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2
        with:
          fetch-depth: 0
      # 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
      - name: Test tools
        run: |
          python3 -m unittest discover -p 'Test_*' tests.tools -v
      - name: Check Python formatting
        run: |
          cd $GITHUB_WORKSPACE
          ./tools/CheckPythonFormatting.sh
      - 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@v2
        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: sxscollaboration/spectrebuildenv:latest
    strategy:
      matrix:
        build_type: [Debug, Release]
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2
        with:
          fetch-depth: 0
      - 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
        working-directory: /work
        # Notes on the build configuration:
        # - Set `BUILD_TESTING=OFF` to test a CMake configuration with tests
        #   turned off.
        run: >
          mkdir build && cd build

          cmake
          -D CMAKE_C_COMPILER=clang
          -D CMAKE_CXX_COMPILER=clang++
          -D CMAKE_Fortran_COMPILER=gfortran-8
          -D CHARM_ROOT=/work/charm_6_10_2/multicore-linux-x86_64-clang
          -D CMAKE_BUILD_TYPE=${{ matrix.build_type }}
          -D OVERRIDE_ARCH=x86-64
          -D USE_CCACHE=OFF
          -D DEBUG_SYMBOLS=OFF
          -D BUILD_PYTHON_BINDINGS=ON
          -D BUILD_TESTING=OFF
          $GITHUB_WORKSPACE
      - name: Check clang-tidy
        working-directory: /work/build
        run: >
          UPSTREAM_HASH=$(
            cd $GITHUB_WORKSPACE && git merge-base HEAD upstream/develop)

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

          make clang-tidy-hash HASH=$UPSTREAM_HASH NUM_THREADS=2

  # Build the documentation and check for problems, then upload as a workflow
  # artifact and deploy to gh-pages.
  doc_check:
    name: Documentation
    runs-on: ubuntu-latest
    container:
      image: sxscollaboration/spectrebuildenv:latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2
      - name: Configure with cmake
        working-directory: /work
        run: >
          mkdir build && cd build

          cmake
          -D CMAKE_C_COMPILER=clang
          -D CMAKE_CXX_COMPILER=clang++
          -D CMAKE_Fortran_COMPILER=gfortran-8
          -D CHARM_ROOT=/work/charm_6_10_2/multicore-linux-x86_64-clang
          -D CMAKE_BUILD_TYPE=Debug
          -D DEBUG_SYMBOLS=OFF
          -D BUILD_PYTHON_BINDINGS=ON
          $GITHUB_WORKSPACE
      - name: Check documentation
        working-directory: /work/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: /work/build
        run: |
          make doc-coverage
      # Upload as an artifact to make available to PRs
      - name: Prepare for upload
        working-directory: /work/build
        run: |
          zip -qr docs-html.zip docs/html
      - name: Upload documentation
        uses: actions/upload-artifact@v2
        with:
          name: docs-html
          path: /work/build/docs-html.zip
      # Deploy to gh-pages on pushes to develop
      - name: Deploy to gh-pages
        if: github.event_name == 'push' && github.ref == 'refs/heads/develop'
        uses: peaceiris/actions-gh-pages@v3
        with:
          publish_dir: /work/build/docs/html
          cname: spectre-code.org
          publish_branch: gh-pages
          github_token: ${{ secrets.GITHUB_TOKEN }}
          force_orphan: true

  # 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:
        compiler:
          - gcc-7
          - gcc-8
          - gcc-9
          - gcc-10
          - clang-8
          - clang-9
          - clang-10
          - clang-11
        build_type: [Debug, Release]
        use_pch: [ON]
        include:
          # Configure ccache sizes. The cache becomes ineffective if it can't
          # hold at least one full build. The sizes for the build configurations
          # are determined empirically by running the workflow with no cache
          # size limit. Note that the cache is automatically cleaned up to
          # remain below 80% of the size configured here. Configurations further
          # down in the `include` list can override these default settings.
          - build_type: Debug
            ccache_max_size: 900M
          - build_type: Release
            ccache_max_size: 400M
          # Generate code coverage report for a single build
          - compiler: gcc-10
            build_type: Debug
            COVERAGE: ON
            TEST_TIMEOUT_FACTOR: 3
            ccache_max_size: 2.3G
          # Test with ASAN
          - compiler: clang-8
            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
            ccache_max_size: 1.3G
          # Test with Python 2 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-8
            build_type: Debug
            PYTHON_EXECUTABLE: /usr/bin/python2
          # 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-9
            build_type: Release
            BUILD_SHARED_LIBS: 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.
          - compiler: clang-9
            build_type: Debug
            use_pch: OFF
            ccache_max_size: 400M

    container:
      image: sxscollaboration/spectrebuildenv:latest
      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
        # Control the cache size
        CCACHE_MAXSIZE: ${{ matrix.ccache_max_size }}
        CCACHE_COMPRESS: 1
        CCACHE_COMPRESSLEVEL: 6
        # 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
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2
      # Assign a unique cache key for every run. Restoring the cache for this
      # exact key will always fail, ensuring that the cache gets updated when
      # the run succeeds. The partially-matched 'restore-keys' ensure that the
      # cache from previous runs gets used even though it has a different
      # suffix. By including the branch name in the key we make sure to only use
      # caches from the 'develop' branch. Caches on other branches are cleared
      # in a later step to avoid filling up the storage space (see below).
      - name: Determine unique cache key
        run: |
          CACHE_KEY_SUFFIX=$(date +%s)
          echo "CACHE_KEY_SUFFIX=$CACHE_KEY_SUFFIX" >> $GITHUB_ENV
      - name: Restore ccache
        uses: actions/cache@v2
        env:
          CACHE_KEY_PREFIX: "ccache-${{ matrix.compiler }}-\
${{ matrix.build_type }}-pch-${{ matrix.use_pch }}"
        with:
          path: /work/ccache
          key: "${{ env.CACHE_KEY_PREFIX }}-${{ github.ref }}-\
${{ env.CACHE_KEY_SUFFIX }}"
          restore-keys: |
            ${{ env.CACHE_KEY_PREFIX }}-refs/heads/develop-
      - name: Configure ccache
        # Print the ccache configuration and reset statistics
        run: |
          ccache -pz
      - name: Configure build with cmake
        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: >
          mkdir build && cd build

          if [[ ${{ matrix.compiler }} =~ (gcc|clang)-([0-9\.]+) ]]; then
            CC=${BASH_REMATCH[1]}-${BASH_REMATCH[2]};
            CHARM_CC=${BASH_REMATCH[1]};
            if [[ ${BASH_REMATCH[1]} = gcc ]]; then
              CXX=g++-${BASH_REMATCH[2]};
              FC=gfortran-${BASH_REMATCH[2]};
            else
              CXX=clang++-${BASH_REMATCH[2]};
              FC=gfortran-8;
            fi
          fi

          BUILD_PYTHON_BINDINGS=${{ matrix.BUILD_PYTHON_BINDINGS }}
          BUILD_SHARED_LIBS=${{ matrix.BUILD_SHARED_LIBS }}
          PYTHON_EXECUTABLE=${{ matrix.PYTHON_EXECUTABLE }}
          ASAN=${{ matrix.ASAN }}
          MEMORY_ALLOCATOR=${{ matrix.MEMORY_ALLOCATOR }}
          UBSAN_UNDEFINED=${{ matrix.UBSAN_UNDEFINED }}
          UBSAN_INTEGER=${{ matrix.UBSAN_INTEGER }}
          USE_PCH=${{ matrix.use_pch }}
          COVERAGE=${{ matrix.COVERAGE }}
          TEST_TIMEOUT_FACTOR=${{ matrix.TEST_TIMEOUT_FACTOR }}

          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=/work/charm_6_10_2/multicore-linux-x86_64-${CHARM_CC}
          -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}
          -D USE_CCACHE=ON
          -D COVERAGE=${COVERAGE:-'OFF'}
          -D BUILD_PYTHON_BINDINGS=${BUILD_PYTHON_BINDINGS:-'ON'}
          -D Python_EXECUTABLE=${PYTHON_EXECUTABLE:-'/usr/bin/python3'}
          -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'}
          --warn-uninitialized
          $GITHUB_WORKSPACE 2>&1 | tee CMakeOutput.txt 2>&1
      - name: Check for CMake warnings
        working-directory: /work/build
        run: |
          ! grep -A 6 "CMake Warning" ./CMakeOutput.txt
      - name: Build unit tests
        if: matrix.use_pch == 'ON'
        working-directory: /work/build
        run: |
          make -j2 unit-tests
      - name: Run unit tests
        if: matrix.use_pch == 'ON' && matrix.COVERAGE != 'ON'
        working-directory: /work/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 -j2 -L unit --output-on-failure --repeat after-timeout:3
      - name: Run unit tests with coverage reporting
        if: matrix.COVERAGE == 'ON'
        working-directory: /work/build
        run: |
          make unit-test-coverage
      - name: Upload coverage report to codecov.io
        if: matrix.COVERAGE == 'ON'
        uses: codecov/codecov-action@v2
        with:
          file: /work/build/tmp/coverage.info
      - name: Upload coverage report to coveralls.io
        if: matrix.COVERAGE == 'ON'
        uses: coverallsapp/github-action@master
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          path-to-lcov: /work/build/tmp/coverage.info
        # We don't actively use coveralls currently, so it's ok when the upload
        # fails (they had some outages)
        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
        working-directory: /work/build
        run: |
          make test-executables
      - name: Build Benchmark executable
        if: matrix.build_type == 'Release'
        working-directory: /work/build
        run: |
          make -j2 Benchmark
      - name: Print size of build directory
        working-directory: /work/build
        run: |
          ls | xargs du -sh
          du -sh .
      - name: Diagnose ccache
        run: |
          ccache -s
      - name: Run non-unit tests
        working-directory: /work/build
        run: |
          # We get occasional random timeouts, repeat tests to see if
          # it is a random timeout or systematic
          ctest -j2 -LE unit --output-on-failure --repeat after-timeout:3
      - name: Test formaline tar can be built
        if: matrix.build_type == 'Debug'
        working-directory: /work/build
        run: >
          # 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.

          make EvolveBurgersStep -j2

          if [ ! -f ./bin/EvolveBurgersStep ]; then
            echo "Could not find the executable EvolveBurgersStep";
            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/EvolveBurgersStep
          --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;
          cd build

          if [[ ${{ matrix.compiler }} =~ (gcc|clang)-([0-9\.]+) ]]; then
            CC=${BASH_REMATCH[1]}-${BASH_REMATCH[2]};
            CHARM_CC=${BASH_REMATCH[1]};
            if [[ ${BASH_REMATCH[1]} = gcc ]]; then
              CXX=g++-${BASH_REMATCH[2]};
              FC=gfortran-${BASH_REMATCH[2]};
            else
              CXX=clang++-${BASH_REMATCH[2]};
              FC=gfortran-8;
            fi
          fi

          MEMORY_ALLOCATOR=${{ matrix.MEMORY_ALLOCATOR }};
          USE_PCH=${{ matrix.use_pch }};

          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=/work/charm_6_10_2/multicore-linux-x86_64-${CHARM_CC}
          -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}
          -D USE_CCACHE=OFF
          -D BUILD_PYTHON_BINDINGS=OFF
          -D MEMORY_ALLOCATOR=${MEMORY_ALLOCATOR:-'SYSTEM'}
          ..

          make EvolveBurgersStep -j2

          ctest -j2 -R InputFiles.Burgers.Step.yaml
      - name: Diagnose ccache
        run: |
          ccache -s
      # Retain the cache only on the 'develop' branch. We discard caches on
      # other branches so they don't fill up the available storage space. This
      # means that all jobs share the caches from 'develop'.
      - name: Clear ccache
        if: github.ref != 'refs/heads/develop'
        run: |
          rm -rf $CCACHE_DIR

  # 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
    steps:
      - uses: actions/checkout@v2
        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).
          token: ${{ secrets.GH_TOKEN_RELEASE }}
      - uses: actions/setup-python@v2
        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@v2
        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: actions/create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GH_TOKEN_RELEASE }}
        with:
          tag_name: v${{ env.RELEASE_VERSION }}
          release_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-7
          - gcc-10
          - clang-8
          - clang-11
        include:
          - sde_arch: ("-nhm;nehalem" "-snb;sandybridge" "-hsw;haswell"
              "-skl;skylake")
            compiler: gcc-7
          - 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-8
          - sde_arch: ("-nhm;nehalem" "-snb;sandybridge" "-hsw;haswell"
              "-skl;skylake" "-icx;icelake-server" "-tgl;tigerlake")
            compiler: clang-11
    container:
      image: sxscollaboration/spectrebuildenv:latest
      env:
        # See the unit test job for the reasons for these configuration choices
        CXXFLAGS: "-Werror"
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2
      - 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
            if [[ ${{ matrix.compiler }} =~ (gcc|clang)-([0-9\.]+) ]]; then
              CC=${BASH_REMATCH[1]}-${BASH_REMATCH[2]};
              CHARM_CC=${BASH_REMATCH[1]};
              if [[ ${BASH_REMATCH[1]} = gcc ]]; then
                CXX=g++-${BASH_REMATCH[2]};
                FC=gfortran-${BASH_REMATCH[2]};
              else
                CXX=clang++-${BASH_REMATCH[2]};
                FC=gfortran-8;
              fi
            fi

            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=/work/charm_6_10_2/multicore-linux-x86_64-${CHARM_CC}\
            -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\
            $GITHUB_WORKSPACE

            make -j2 TestArchitectureVectorization

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

        shell: bash