parallel_test_matlab.yml

name: Parallel test, MATLAB

on:
  # Trigger the workflow on push or pull request
  #push:
  #pull_request:  # DANGEROUS! MUST be disabled for self-hosted runners!
  # Trigger the workflow by cron. The default time zone of GitHub Actions is UTC.
  schedule:
    - cron: '0 14 2-31/2 * *'
  # Trigger the workflow manually
  workflow_dispatch:
    inputs:
      git-ref:
        description: Git Ref (Optional)
        required: false
      random-seed:
        description: Random Seed (Optional)
        required: false
      dimension:
        description: Dimension (Optional)
        required: false
      np:
        description: Number of Parallel Calls (Optional)
        required: false

# Show the git ref in the workflow name if it is invoked manually.
run-name: ${{ github.event_name == 'workflow_dispatch' && format('Manual run {0} , seed {1}, dimension {2}, {3} parallel calls', inputs.git-ref, inputs.random-seed, inputs.dimension, inputs.np) || '' }}

jobs:
  test:
    name: Parallel test of PRIMA
    runs-on: ${{ matrix.os }}
    continue-on-error: true
    strategy:
      fail-fast: false

      # The matrix is the same as that of stress_test_matlab.yml, except for test
      matrix:
        os: [ubuntu-latest, macos-15-intel, windows-latest]
        matlab: [R2023a, latest]
        solver: [uobyqa, newuoa, bobyqa, lincoa, cobyla]
        use_system_libgcc: [true]  # Whether to use the system libgcc or the one shipped with MATLAB.


    steps:

      - name: Set http.postBuffer and core.compression
        # This is a workaround for random "early EOF" of checkout.
        # See https://github.com/actions/checkout/issues/748, https://github.com/actions/checkout/issues/1379
        if: startsWith(matrix.os, 'windows')
        run: git config --global http.postBuffer 1048576000 && git config --global core.compression 0

      - name: Run `sudo apt update -y`
        if: startsWith(matrix.os, 'ubuntu')
        run: sudo apt update -y  # Otherwise, free-disk-space or other actions relying on `apt` may fail

      - name: Free disk space
        uses: jlumbroso/free-disk-space@main
        if: startsWith(matrix.os, 'ubuntu')
        with:
          # all of these default to true, but feel free to set to "false" if necessary for your workflow
          android: true
          dotnet: true
          haskell: true
          large-packages: true
          docker-images: true
          swap-storage: false  # Important, or the runner may be shut down due to memory starvation.

      - name: Clone Repository (Latest)
        uses: actions/checkout@v6.0.1
        if: github.event.inputs.git-ref == ''
        with:
          submodules: recursive
        #   ssh-key: ${{ secrets.SSH_PRIVATE_KEY_ACT }} # This forces checkout to use SSH, not HTTPS
        # As of 231227, checkout with ssh fails frequently on Windows runners.
      - name: Clone Repository (Custom Ref)
        uses: actions/checkout@v6.0.1
        if: github.event.inputs.git-ref != ''
        with:
          ref: ${{ github.event.inputs.git-ref }}
          submodules: recursive
        #   ssh-key: ${{ secrets.SSH_PRIVATE_KEY_ACT }} # This forces checkout to use SSH, not HTTPS
        # As of 231227, checkout with ssh fails frequently on Windows runners.

      - name: Miscellaneous setup
        run: bash .github/scripts/misc_setup

      - name: Set up gfortran on Linux
        if: startsWith(matrix.os, 'ubuntu')
        uses: fortran-lang/setup-fortran@main
        with:
          compiler: gcc
          version: latest
      - name: Check gfortran version on Linux
        if: startsWith(matrix.os, 'ubuntu')
        run: which gcc && gcc --version && which gfortran && gfortran --version

      - name: Decide the version of oneAPI to use on macOS and Windows
        shell: bash
        if: ${{ startsWith(matrix.os, 'macos') || startsWith(matrix.os, 'windows') }}
        run: |
          # Initialize ONEAPI_VERSION to "latest", causing the installer script to install the latest oneAPI.
          ONEAPI_VERSION="latest"
          # On Windows. the latest oneAPI supported by MATLAB R2023a/b and R2024a/b is 2023 and 2024,
          # respectively. Thus we set ONEAPI_VERSION to the following. If matrix.matlab is "latest",
          # then ONEAPI_VERSION will be "latest".
          if [[ "${{ matrix.os }}" == windows* ]]; then
              ONEAPI_VERSION=$(echo "${{ matrix.matlab }}" | sed -e 's/R\([0-9]*\)\([ab]\)/\1/')
          fi
          echo "ONEAPI_VERSION=$ONEAPI_VERSION" >> $GITHUB_ENV
          echo "ONEAPI_VERSION:" $ONEAPI_VERSION

      - name: Install Intel oneAPI on macOS
        if: startsWith(matrix.os, 'macos')
        run: bash .github/scripts/install_oneapi_macos.sh $ONEAPI_VERSION

      - name: Install Intel oneAPI on Windows
        if: startsWith(matrix.os, 'windows')
        run: cmd.exe "/K" '".github\scripts\install_oneapi_windows.bat %ONEAPI_VERSION%"'

      - name: Set up MATLAB with optimization toolbox
        uses: matlab-actions/setup-matlab@v2.6.1
        with:
          release: ${{ matrix.matlab }}
          cache: true
          products: Optimization_Toolbox Parallel_Computing_Toolbox

      - name: Link system libgcc to MATLAB if needed
        if: startsWith(matrix.os, 'ubuntu')
        shell: bash
        run: |
          matlab_root=$(realpath $(dirname $(which matlab))/../)
          echo "MATLAB root is ${matlab_root}"

          matlab_libgcc="${matlab_root}/sys/os/glnxa64/libgcc_s.so.1"
          echo "MATLAB libgcc is:"
          ls -alh ${matlab_libgcc} || exit 42
          echo "gcc strings in MATLAB libgcc are:"
          strings ${matlab_libgcc} | grep -iE "^GCC_"
          echo "latest gcc version string in MATLAB libgcc is:"
          readelf -V ${matlab_libgcc} | grep -oiE 'GCC_([0-9]+)(.[0-9]+){0,2}' | sort -V | tail -1

          system_libgcc="/usr/lib/x86_64-linux-gnu/libgcc_s.so.1"
          echo "System libgcc is:"
          ls -alh ${system_libgcc} || exit 42
          echo "gcc strings in system libgcc are:"
          strings ${system_libgcc} | grep -iE "^GCC_"
          echo "latest gcc version string in system libgcc is:"
          readelf -V ${system_libgcc} | grep -oiE 'GCC_([0-9]+)(.[0-9]+){0,2}' | sort -V | tail -1

          if [[ "${{ matrix.use_system_libgcc }}" == "true" ]] ; then
              ln -sf ${system_libgcc} ${matlab_libgcc} || exit 42
              echo "Linked ${system_libgcc} to ${matlab_libgcc}."
          else
              echo "Keep ${matlab_libgcc} untouched."
          fi
          echo "After the operation, MATLAB libgcc is:"
          ls -alh ${matlab_libgcc} || exit 42
          echo "gcc strings in MATLAB libgcc are:"
          strings ${matlab_libgcc} | grep -iE "^GCC_"
          echo "latest gcc version string in MATLAB libgcc is:"
          readelf -V ${matlab_libgcc} | grep -oiE 'GCC_([0-9]+)(.[0-9]+){0,2}' | sort -V | tail -1

      - name: Revise getMexLibgcc and compiled.m to print necessary information
        shell: bash
        run: |
          cd matlab/setup_tools || exit 42
          $SEDI 's|\(.*lddOut.*\);|\1|' getMexLibgcc.m
          $SEDI 's|\(.*Path.*\);|\1|' getMexLibgcc.m
          $SEDI 's|\(.*String.*\);|\1|' getMexLibgcc.m
          $SEDI 's|\(.*Version.*\);|\1|' getMexLibgcc.m
          cat getMexLibgcc.m
          $SEDI 's|\(common_mex_options\s*=\s*.*$\)$|\1\ncommon_mex_options{:}|' compile.m
          $SEDI 's|\(.*\s*=\s*getMexLibgcc().gccVersion.*\)|\1\ngetMexLibgcc() |' compile.m
          $SEDI 's|\(.*_version\s*=\s*.*\);|\1 |' compile.m
          $SEDI 's|\(compiler_options\s*=\s*.*\);|\1 |' compile.m
          $SEDI "s|\(if\s*~support_internal_procedures\)|verLessThan('matlab', '25.1'), verLessThan('matlab', '25.2'), compiler_manufacturer,  compiler_options, support_internal_procedures\n\1|" compile.m
          cat compile.m


      - name: Conduct the test
        uses: matlab-actions/run-command@v2.4.0
        with:
          command: |
            ver;
            root_dir = pwd();
            cd(fullfile(root_dir, 'matlab/tests'));
            options = struct();
            if ~isempty('${{ inputs.random-seed }}')
                options.seed = str2num('${{ inputs.random-seed }}');
            end
            if ~isempty('${{ inputs.dimension }}')
                options.n = str2num('${{ inputs.dimension }}');
            end
            if ~isempty('${{ inputs.np }}')
                options.np = str2num('${{ inputs.np }}');
            end
            options

            % Conduct the test multiple times. Some errors may not occur during the first test.
            try
              parallel('${{ matrix.solver }}', options);
              options.compile = false;
              parallel('${{ matrix.solver }}', options);
              parallel('${{ matrix.solver }}', options);
            catch exception
              % Copy the crash dump files to root_dir if exceptions occur.
              copy_crash_dump_files(root_dir, true)
              dir(root_dir)
              rethrow(exception);
            end


      - name: Store artifacts
        uses: actions/upload-artifact@v6
        if: always()  # Always run even if the workflow is canceled manually or due to overtime.
        with:
          name: ${{ matrix.solver }}
          path: |
            matlab_crash_dump*



  # The following job check whether the tests were successful or cancelled due to timeout.
  # N.B.: Remember to specify `continue-on-error: true` for the job of the tests.
  check_success_timeout:
    runs-on: ubuntu-latest
    if: ${{ !cancelled() }}
    needs: test
    steps:
      - name: Clone the GitHub actions scripts
        uses: actions/checkout@v6.0.1
        with:
          repository: equipez/github_actions_scripts
          ssh-key: ${{ secrets.SSH_PRIVATE_KEY_ACT }} # This forces checkout to use SSH, not HTTPS
          path: scripts

      - name: Check whether the tests were successful or cancelled due to timeout
        run: bash scripts/check_success_timeout ${{ secrets.GITHUB_TOKEN }} ${{ github.repository }} ${{ github.run_id }}