presubmit.yml

name: Presubmit

on: [push, pull_request]

jobs:
  format:
    name: Code formatting
    runs-on: ubuntu-latest
    defaults:
      run:
        shell: bash
    steps:
      - uses: actions/checkout@v3
        with:
          # repository: ${{ github.repository }} (default)
          fetch-depth: 0
      - name: Install clang-format
        run: sudo apt-get install clang-format
      - name: Check format
        run: $GITHUB_WORKSPACE/scripts/check-format.sh
          origin/`if [[ "${{ github.event_name }}" == "push" ]]; then echo "main"; else echo "${{ github.base_ref }}"; fi`
          --binary clang-format

  linux:
    runs-on: ubuntu-latest
    needs: format
    defaults:
      run:
        shell: bash
    strategy:
      matrix:
        CMAKE: [3.26.4]
        COMPILER:
          - C_NAME: gcc
            CXX_NAME: g++
            VER: 11
            EXCLUSIVE_C_FLAGS: -Wno-maybe-uninitialized
          # - C_NAME: gcc
          #   CXX_NAME: g++
          #   VER: 13
          #   EXCLUSIVE_C_FLAGS: -Wno-maybe-uninitialized
          # - C_NAME: clang
          #   CXX_NAME: clang++
          #   VER: 14
          #   EXCLUSIVE_C_FLAGS: ""
          # - C_NAME: clang
          #   CXX_NAME: clang++
          #   VER: 16
          #   EXCLUSIVE_C_FLAGS: ""
        DEPS: [os, vcpkg]
        BIN: [64]
        STD:
          - C: 11 # Utils C library uses C11 functions (e.g. timespec_get)
            CXX: 14 # Utils C++ library uses C14 types (e.g. integer_sequence)
          # - C: 17
          #   CXX: 17
        CONF:
          - GEN: Unix Makefiles
            CONFIG: Debug
          # - GEN: Unix Makefiles
          #   CONFIG: Release
          - GEN: Ninja Multi-Config
            CONFIG: Release
        IMAGE:
          - streamhpc/opencl-sdk-intelcpu:ubuntu-22.04-20230717
        include:
        - CMAKE: system
          COMPILER:
            C_NAME: gcc
            CXX_NAME: c++
            VER: 9
            EXCLUSIVE_C_FLAGS: ""
          DEPS: system
          BIN: 64
          STD:
            C: 11
            CXX: 14
          CONF:
            GEN: Unix Makefiles
            CONFIG: Debug
          IMAGE: streamhpc/opencl-sdk-intelcpu:ubuntu-20.04-20230717
        - CMAKE: system
          COMPILER:
            C_NAME: gcc
            CXX_NAME: c++
            VER: 9
            EXCLUSIVE_C_FLAGS: ""
          DEPS: system
          BIN: 64
          STD:
            C: 11
            CXX: 14
          CONF:
            GEN: Unix Makefiles
            CONFIG: Release
          IMAGE: streamhpc/opencl-sdk-intelcpu:ubuntu-20.04-20230717
        - CMAKE: system
          COMPILER:
            C_NAME: gcc
            CXX_NAME: c++
            VER: 9
            EXCLUSIVE_C_FLAGS: ""
          DEPS: vcpkg
          BIN: 32
          STD:
            C: 11
            CXX: 14
          CONF:
            GEN: Unix Makefiles
            CONFIG: Debug
          IMAGE: streamhpc/opencl-sdk-intelcpu:ubuntu-20.04-20230717
        - CMAKE: system
          COMPILER:
            C_NAME: gcc
            CXX_NAME: c++
            VER: 9
            EXCLUSIVE_C_FLAGS: ""
          DEPS: vcpkg
          BIN: 32
          STD:
            C: 11
            CXX: 14
          CONF:
            GEN: Unix Makefiles
            CONFIG: Release
          IMAGE: streamhpc/opencl-sdk-intelcpu:ubuntu-20.04-20230717
    container: ${{matrix.IMAGE}}
    env:
      CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake
      CPACK_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cpack
      CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest
      DEB_INSTALLATION_PATH: /usr
      CC: ${{matrix.COMPILER.C_NAME}}-${{matrix.COMPILER.VER}}
      CXX:  ${{matrix.COMPILER.CXX_NAME}}-${{matrix.COMPILER.VER}}
      # Excluding missing-field-initializers error because it comes from the Std dependency
      # Excluding maybe-uninitialized error because cannot workaround the compiler issuing this error
      # Not using -pedantic: error: ISO C forbids braced-groups within expressions
      CFLAGS: -Wall -Wextra -Werror -m${{matrix.BIN}} -Wno-missing-field-initializers ${{ matrix.COMPILER.EXCLUSIVE_C_FLAGS }}
      # Excluding missing-field-initializers error because it comes from the Std dependency
      CXXFLAGS: -Wall -Wextra -pedantic -Werror -m${{matrix.BIN}} -Wno-missing-field-initializers

    steps:
    - name: Set up vcpkg triplet
      if: matrix.DEPS == 'vcpkg'
      run: if [[ "${{ matrix.BIN }}" == "64" ]]; then
          echo "VCPKG_TRIPLET=x64-linux" >> $GITHUB_ENV;
        else
          echo "VCPKG_TRIPLET=x86-linux" >> $GITHUB_ENV;
        fi

    - name: Install system CMake
      if: matrix.CMAKE == 'system'
      run: apt-get update -qq && apt-get install -y cmake &&
        echo "CMAKE_EXE=cmake" >> "$GITHUB_ENV" &&
        echo "CTEST_EXE=ctest" >> "$GITHUB_ENV" &&
        echo "CPACK_EXE=cpack" >> "$GITHUB_ENV"

    - name: Cache dependencies (vcpkg)
      if: matrix.DEPS == 'vcpkg'
      id: vcpkg-install
      uses: actions/cache@v3
      with:
        path: /opt/Microsoft/vcpkg
        key: vcpkg-linux-${{matrix.BIN}}

    - name: Install dependencies (vcpkg)
      if: matrix.DEPS == 'vcpkg' && steps.vcpkg-install.outputs.cache-hit != 'true'
      run: |
        cd /opt/Microsoft/vcpkg
        git pull
        ./bootstrap-vcpkg.sh
        ./vcpkg install sfml:$VCPKG_TRIPLET tclap:$VCPKG_TRIPLET glm:$VCPKG_TRIPLET glew:$VCPKG_TRIPLET stb:$VCPKG_TRIPLET 

    - name: Checkout OpenCL-SDK
      uses: actions/checkout@v3
      with:
          fetch-depth: 0
          submodules: recursive

    - name: Configure, package & install OpenCL-Headers
      run: $CMAKE_EXE
          -G "${{matrix.CONF.GEN}}"
          `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi`
          -D BUILD_TESTING=OFF
          -D CPACK_PACKAGING_INSTALL_PREFIX=$DEB_INSTALLATION_PATH
          -S $GITHUB_WORKSPACE/external/OpenCL-Headers
          -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build &&
        $CPACK_EXE
          --config "$GITHUB_WORKSPACE/external/OpenCL-Headers/build/CPackConfig.cmake"
          -G DEB
          -C ${{matrix.CONF.CONFIG}}
          -B "$GITHUB_WORKSPACE/external/OpenCL-Headers/package-deb" &&
        dpkg -i $GITHUB_WORKSPACE/external/OpenCL-Headers/package-deb/*.deb

    - name: Configure, package & install OpenCL-ICD-Loader
      run: $CMAKE_EXE
          -G "${{matrix.CONF.GEN}}"
          `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi`
          -D BUILD_TESTING=OFF
          -D CPACK_PACKAGING_INSTALL_PREFIX=$DEB_INSTALLATION_PATH
          -S $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader
          -B $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build &&
          if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]];
          then
            $CMAKE_EXE --build $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build --parallel `nproc`;
          else
            $CMAKE_EXE --build $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build --config Debug --parallel `nproc`;
            $CMAKE_EXE --build $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build --config Release --parallel `nproc`;
          fi &&
        $CPACK_EXE
          --config "$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build/CPackConfig.cmake"
          -G DEB
          -C ${{matrix.CONF.CONFIG}}
          -B "$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/package-deb" &&
        dpkg -i $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/package-deb/*.deb

    - name: Configure, package & install OpenCL-CLHPP
      run: $CMAKE_EXE
          -G "${{matrix.CONF.GEN}}"
          `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi`
          -D BUILD_TESTING=OFF
          -D BUILD_EXAMPLES=OFF
          -D BUILD_DOCS=OFF
          -D CPACK_PACKAGING_INSTALL_PREFIX=$DEB_INSTALLATION_PATH
          -S $GITHUB_WORKSPACE/external/OpenCL-CLHPP
          -B $GITHUB_WORKSPACE/external/OpenCL-CLHPP/build &&
        $CPACK_EXE
          --config "$GITHUB_WORKSPACE/external/OpenCL-CLHPP/build/CPackConfig.cmake"
          -G DEB
          -C ${{matrix.CONF.CONFIG}}
          -B "$GITHUB_WORKSPACE/external/OpenCL-CLHPP/package-deb" &&
        dpkg -i $GITHUB_WORKSPACE/external/OpenCL-CLHPP/package-deb/*.deb

    - name: Configure
      run: $CMAKE_EXE
        -G "${{matrix.CONF.GEN}}"
        `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi`
        `if [[ "${{matrix.DEPS}}" == "vcpkg" ]]; then echo "-D CMAKE_TOOLCHAIN_FILE=/opt/Microsoft/vcpkg/scripts/buildsystems/vcpkg.cmake"; fi;`
        `if [[ "${{matrix.DEPS}}" == "vcpkg" ]]; then echo "-D VCPKG_TARGET_TRIPLET=$VCPKG_TRIPLET"; fi;`
        -D BUILD_DOCS=ON
        -D BUILD_TESTING=ON
        -D BUILD_EXAMPLES=ON
        -D OPENCL_SDK_BUILD_SAMPLES=ON
        -D OPENCL_ICD_LOADER_BUILD_TESTING=ON
        -D CMAKE_C_STANDARD=${{matrix.STD.C}}
        -D CMAKE_CXX_STANDARD=${{matrix.STD.CXX}}
        -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install
        -D CPACK_PACKAGING_INSTALL_PREFIX=$DEB_INSTALLATION_PATH
        -S $GITHUB_WORKSPACE
        -B $GITHUB_WORKSPACE/build

    - name: Build
      run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]];
        then
          $CMAKE_EXE --build $GITHUB_WORKSPACE/build --parallel `nproc`;
        else
          $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Debug;
          $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Release;
        fi;

    - name: Test
      working-directory: ${{runner.workspace}}/OpenCL-SDK/build
      run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]];
        then
          $CTEST_EXE --output-on-failure --parallel `nproc`;
        else
          $CTEST_EXE --output-on-failure -C Debug   --parallel `nproc`;
          $CTEST_EXE --output-on-failure -C Release --parallel `nproc`;
        fi;

    - name: Package DEB
      run: $CPACK_EXE
        --config "$GITHUB_WORKSPACE/build/CPackConfig.cmake"
        -G DEB
        -C ${{matrix.CONF.CONFIG}}
        -B "$GITHUB_WORKSPACE/package-deb"

    - name: Consume (DEB)
      run: dpkg -i $GITHUB_WORKSPACE/package-deb/*.deb &&
        $CMAKE_EXE
        -G "${{matrix.CONF.GEN}}"
        `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi`
        -D CMAKE_C_STANDARD=${{matrix.STD.C}}
        -D CMAKE_CXX_STANDARD=${{matrix.STD.CXX}}
        -S $GITHUB_WORKSPACE/test/cmake/pkgconfig/useutil
        -B $GITHUB_WORKSPACE/build_package &&
        if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]];
        then
          $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --parallel `nproc`;
        else
          $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config Debug;
          $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config Release;
        fi

    - name: Run consume test (DEB)
      if: matrix.BIN != 32
      working-directory: ${{runner.workspace}}/OpenCL-SDK/build_package
      run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]];
        then
          $CTEST_EXE -C ${{matrix.CONF.CONFIG}} --output-on-failure --parallel `nproc`;
        else
          $CTEST_EXE -C Debug --output-on-failure --parallel `nproc`;
          $CTEST_EXE -C Release --output-on-failure --parallel `nproc`;
        fi

    - name: Uninstall (DEB)
      # ToDo: khronos-opencl-loader*
      run: apt-get remove -y "ocl-icd*" opencl-c-headers opencl-clhpp-headers opencl-sdk

    - name: Test install
      run: $CMAKE_EXE
        --build $GITHUB_WORKSPACE/build
        --target install
        --config ${{matrix.CONF.CONFIG}}
        --parallel `nproc`

    - name: Consume (install)
      shell: bash
      run: $CMAKE_EXE
        -G "${{matrix.CONF.GEN}}"
        `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi`
        -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/install
        -D CMAKE_C_STANDARD=${{matrix.STD.C}}
        -D CMAKE_CXX_STANDARD=${{matrix.STD.CXX}}
        -S $GITHUB_WORKSPACE/test/cmake/pkgconfig/useutil
        -B $GITHUB_WORKSPACE/build_install &&
        if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]];
        then
          $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --parallel `nproc`;
        else
          $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --config Debug;
          $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --config Release;
        fi

    - name: Run consume test (install)
      if: matrix.BIN != 32
      working-directory: ${{runner.workspace}}/OpenCL-SDK/build_install
      run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]];
        then
          $CTEST_EXE -C ${{matrix.CONF.CONFIG}} --output-on-failure --parallel `nproc`;
        else
          $CTEST_EXE -C Debug --output-on-failure --parallel `nproc`;
          $CTEST_EXE -C Release --output-on-failure --parallel `nproc`;
        fi

  windows:
    if: false
    runs-on: windows-latest
    needs: format
    strategy:
      matrix:
        VER: [v141, v142, v143, clangcl]
        GEN: [Visual Studio 17 2022, Ninja Multi-Config]
        DEPS: [os, vcpkg]
        BIN: [x64]
        STD:
          - C: 11
            CXX: 14
          - C: 17
            CXX: 17
        exclude:
        - VER: clangcl
          GEN: Ninja Multi-Config
        include:
          - VER: v142
            GEN: Visual Studio 17 2022
            DEPS: vcpkg
            BIN: x86
            STD:
              C: 11
              CXX: 14
    env:
      NINJA_URL: https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip
      NINJA_ROOT: C:\Tools\Ninja
      VS_ROOT: 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise'
      UseMultiToolTask: true # Better parallel MSBuild execution
      EnforceProcessCountAcrossBuilds: 'true' # -=-
      MultiProcMaxCount: '3'                  # -=-
      WindowsSDKVersion: '10.0.22621.0'
      INTEL_OCL_URL: https://github.com/intel/llvm/releases/download/2023-WW27/win-oclcpuexp-2023.16.6.0.28_rel.zip
      INTEL_TBB_URL: https://github.com/oneapi-src/oneTBB/releases/download/v2021.10.0/oneapi-tbb-2021.10.0-win.zip
      IMAGE_INTEL_PREFIX: C:\Tools\Intel

    steps:
      - name: Cache Ninja install
        if: matrix.GEN == 'Ninja Multi-Config'
        id: ninja-install
        uses: actions/cache@v3
        with:
          path: |
            C:\Tools\Ninja
          key: ${{runner.os}}-ninja-${{env.NINJA_URL}}

      - name: Install Ninja
        if: matrix.GEN == 'Ninja Multi-Config' && steps.ninja-install.outputs.cache-hit != 'true'
        shell: pwsh
        run: |
          Invoke-WebRequest ${env:NINJA_URL} -OutFile ~\Downloads\ninja-win.zip
          Expand-Archive ~\Downloads\ninja-win.zip -DestinationPath ${env:NINJA_ROOT}\
          Remove-Item ~\Downloads\*

      - name: Install OpenCL runtime
        shell: pwsh
        run: |
          $INTEL_OCL_ARCHIVE_NAME = Split-Path ${env:INTEL_OCL_URL} -Leaf; `
          Invoke-WebRequest ${env:INTEL_OCL_URL} -OutFile ${env:TEMP}\$INTEL_OCL_ARCHIVE_NAME; `
          Expand-Archive ${env:TEMP}\$INTEL_OCL_ARCHIVE_NAME -DestinationPath ${env:IMAGE_INTEL_PREFIX}\oclcpuexp; `
          Remove-Item ${env:TEMP}\$INTEL_OCL_ARCHIVE_NAME; `
          $INTEL_TBB_ARCHIVE_NAME = Split-Path ${env:INTEL_TBB_URL} -Leaf; `
          Invoke-WebRequest ${env:INTEL_TBB_URL} -OutFile ${env:TEMP}\$INTEL_TBB_ARCHIVE_NAME; `
          Expand-Archive ${env:TEMP}\$INTEL_TBB_ARCHIVE_NAME -DestinationPath ${env:IMAGE_INTEL_PREFIX}; `
          Get-ChildItem ${env:IMAGE_INTEL_PREFIX}\oneapi-tbb* | Rename-Item  -NewName oneapi-tbb; `
          Remove-Item ${env:TEMP}\$INTEL_TBB_ARCHIVE_NAME; `
          New-Item -Type Directory ${env:IMAGE_INTEL_PREFIX}\oclcpuexp\tbb | Out-Null; `
          Get-ChildItem ${env:IMAGE_INTEL_PREFIX}\oneapi-tbb\redist\intel64\vc14\*.dll | ForEach-Object { New-Item -Type SymbolicLink -Path ${env:IMAGE_INTEL_PREFIX}\oclcpuexp\tbb -Name $_.Name -Value $_.FullName | Out-Null; }; `
          New-Item -Type Directory HKLM:\SOFTWARE\Khronos\OpenCL -Force | Out-Null; `
          New-Item -Type File HKLM:\SOFTWARE\Khronos\OpenCL\Vendors | Out-Null; `
          Set-ItemProperty -Path HKLM:\SOFTWARE\Khronos\OpenCL\Vendors -Name ${env:IMAGE_INTEL_PREFIX}\oclcpuexp\intelocl64.dll -Type DWord -Value 0;

      - name: Checkout OpenCL-SDK
        uses: actions/checkout@v3
        with:
            fetch-depth: 0
            submodules: recursive

      - name: Configure (MSBuild)
        if: matrix.GEN == 'Visual Studio 17 2022'
        shell: pwsh
        run: |
          if ('${{ matrix.DEPS }}' -eq 'vcpkg') {
            Get-ChildItem Env:\
            & ${env:VCPKG_INSTALLATION_ROOT}\vcpkg.exe --triplet=x64-windows install sfml tclap glm glew stb
            $TOOLCHAIN_ARG="-D CMAKE_TOOLCHAIN_FILE=${env:VCPKG_INSTALLATION_ROOT}\scripts\buildsystems\vcpkg.cmake"
          } else {
            $TOOLCHAIN_ARG=''
          }
          $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'}
          & cmake `
            $TOOLCHAIN_ARG `
            -G "${{matrix.GEN}}" `
            -A $BIN `
            -T ${{matrix.VER}} `
            -D BUILD_DOCS=ON `
            -D BUILD_TESTING=ON `
            -D OPENCL_SDK_BUILD_SAMPLES=ON `
            -D CMAKE_C_STANDARD=${{matrix.STD.C}} `
            -D CMAKE_CXX_STANDARD=${{matrix.STD.CXX}} `
            -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\install `
            -S ${env:GITHUB_WORKSPACE} `
            -B ${env:GITHUB_WORKSPACE}\build

      - name: Configure (Ninja Multi-Config)
        if: matrix.GEN == 'Ninja Multi-Config'
        shell: pwsh
        run: |
          if ('${{ matrix.DEPS }}' -eq 'vcpkg') {
            Get-ChildItem Env:\
            & ${env:VCPKG_INSTALLATION_ROOT}\vcpkg.exe --triplet=x64-windows install sfml tclap glm glew stb
            $TOOLCHAIN_ARG="-D CMAKE_TOOLCHAIN_FILE=${env:VCPKG_INSTALLATION_ROOT}\scripts\buildsystems\vcpkg.cmake"
          } else {
            $TOOLCHAIN_ARG=''
          }
          $VER = switch ('${{matrix.VER}}') { `
            'v141' {'14.1'} `
            'v142' {'14.2'} `
            'v143' {'14.3'} }
          Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
          Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER"
          & cmake `
            $TOOLCHAIN_ARG `
            -G "${{matrix.GEN}}" `
            -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" `
            -D BUILD_DOCS=ON `
            -D BUILD_TESTING=ON `
            -D OPENCL_SDK_BUILD_SAMPLES=ON `
            -D CMAKE_C_STANDARD=${{matrix.STD.C}} `
            -D CMAKE_CXX_STANDARD=${{matrix.STD.CXX}} `
            -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL `
            -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\install `
            -S ${env:GITHUB_WORKSPACE} `
            -B ${env:GITHUB_WORKSPACE}\build

      - name: Build (MSBuild)
        if: matrix.GEN == 'Visual Studio 17 2022'
        shell: pwsh
        run: |
          foreach ($Config in 'Release','Debug') { `
            & cmake `
              --build "${env:GITHUB_WORKSPACE}\build" `
              --config $Config `
              -- `
              /verbosity:minimal `
              /maxCpuCount `
              /noLogo
          }

      - name: Build (Ninja Multi-Config)
        if: matrix.GEN == 'Ninja Multi-Config'
        shell: pwsh
        run: |
          $VER = switch ('${{matrix.VER}}') { `
            'v141' {'14.1'} `
            'v142' {'14.2'} `
            'v143' {'14.3'} }
          Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
          Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER"
          foreach ($Config in 'Release','Debug') { `
            & cmake `
              --build "${env:GITHUB_WORKSPACE}\build" `
              --config $Config `
              -- `
              -j ${env:NUMBER_OF_PROCESSORS}
          }

      - name: Test
        working-directory: ${{runner.workspace}}/OpenCL-SDK/build
        shell: pwsh
        run: |
          foreach ($Config in 'Release','Debug') {
            & ctest `
              --build-config ${Config} `
              --output-on-failure `
              --parallel ${env:NUMBER_OF_PROCESSORS}
          }

      - name: Install
        shell: pwsh
        run: |
          & cmake `
            --install "${env:GITHUB_WORKSPACE}\build" `
            --prefix "${env:GITHUB_WORKSPACE}\install" `
            --config Release

      - name: "Consume (MSBuild SDK): Configure/Build/Test"
        shell: pwsh
        run: |
          $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'}
          & cmake `
            -G '${{matrix.GEN}}' `
            -A $BIN `
            -T ${{matrix.VER}} `
            -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL `
            -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\install" `
            -D DRIVER_STUB_PATH="${env:GITHUB_WORKSPACE}\build\Release\OpenCLDriverStub.dll" `
            -D CMAKE_C_STANDARD=${{matrix.STD.C}} `
            -D CMAKE_CXX_STANDARD=${{matrix.STD.CXX}} `
            -S "${env:GITHUB_WORKSPACE}\test\pkgconfig\useutil" `
            -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\useutil"
          foreach ($Config in 'Release','Debug') { `
            & cmake `
              --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\useutil" `
              --config ${Config} `
            & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\useutil `
            & ctest `
              --output-on-failure -C ${Config}
          }

      - name: "Consume (Ninja-Multi-Config SDK): Configure/Build/Test"
        shell: pwsh
        run: |
          $VER = switch ('${{matrix.VER}}') { `
            'v141' {'14.1'} `
            'v142' {'14.2'} `
            'v143' {'14.3'} }
          Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
          Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}"
          & cmake `
            -G '${{matrix.GEN}}' `
            -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" `
            -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL `
            -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\install" `
            -D DRIVER_STUB_PATH="${env:GITHUB_WORKSPACE}\build\Release\OpenCLDriverStub.dll" `
            -D CMAKE_C_STANDARD=${{matrix.STD.C}} `
            -D CMAKE_CXX_STANDARD=${{matrix.STD.CXX}} `
            -S "${env:GITHUB_WORKSPACE}\test\pkgconfig\useutil" `
            -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\useutil"
          foreach ($Config in 'Release','Debug') { `
            & cmake `
              --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\useutil" `
              --config ${Config} `
            & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\useutil `
            & ctest `
              --output-on-failure -C ${Config}
          }

  macos:
    if: false
    runs-on: macos-latest
    needs: format
    strategy:
      matrix:
        COMPILER:
          - C_NAME: /usr/bin/gcc
            CXX_NAME: /usr/bin/g++
            EXCLUSIVE_C_FLAGS: -Wno-conditional-uninitialized
          - C_NAME: /usr/local/bin/gcc-11
            CXX_NAME: /usr/local/bin/g++-11
            EXCLUSIVE_C_FLAGS: -Wno-maybe-uninitialized
          - C_NAME: /usr/local/bin/gcc-13
            CXX_NAME: /usr/local/bin/g++-13
            EXCLUSIVE_C_FLAGS: -Wno-maybe-uninitialized
        GEN:
        - Xcode
        - Ninja Multi-Config
        STD:
          - C: 11
            CXX: 14
          - C: 17
            CXX: 17
        exclude:
          - COMPILER:
              C_NAME: /usr/bin/gcc
              CXX_NAME: /usr/bin/g++
              EXCLUSIVE_C_FLAGS: -Wno-conditional-uninitialized
            GEN: Ninja Multi-Config
          - COMPILER:
              C_NAME: /usr/local/bin/gcc-11
              CXX_NAME: /usr/local/bin/g++-11
              EXCLUSIVE_C_FLAGS: -Wno-maybe-uninitialized
            GEN: Xcode
          - COMPILER:
              C_NAME: /usr/local/bin/gcc-13
              CXX_NAME: /usr/local/bin/g++-13
              EXCLUSIVE_C_FLAGS: -Wno-maybe-uninitialized
            GEN: Xcode
    env:
      CC: ${{matrix.COMPILER.C_NAME}}
      CCX: ${{matrix.COMPILER.CXX_NAME}}
      # Not using -pedantic: error: ISO C forbids braced-groups within expressions
      # The flags
      #  * -Wno-missing-field-initializers
      #  * matrix.COMPILER.EXCLUSIVE_C_FLAGS
      # have been added because of Std compilation errors
      CFLAGS: -Wall -Wextra -Werror -Wno-missing-field-initializers ${{ matrix.COMPILER.EXCLUSIVE_C_FLAGS }}
      # The flags
      #  * -Wno-deprecated-declarations
      #  * -Wno-missing-field-initializers
      # have been added because of Std compilation errors
      CXXFLAGS: -Wall -Wextra -pedantic -Wno-format -Werror -Wno-missing-field-initializers -Wno-deprecated-declarations

    steps:
      - name: Checkout OpenCL-SDK
        uses: actions/checkout@v3
        with:
            fetch-depth: 0
            submodules: recursive

      - name: Create Build Environment
        shell: bash
        run: |
          cmake -E make_directory $GITHUB_WORKSPACE/build &&
          cmake -E make_directory $GITHUB_WORKSPACE/install &&
          if [[ "${{matrix.GEN}}" == "Ninja Multi-Config" && ! `which ninja` ]]; then brew install ninja; fi &&
          # Install Ninja only if it's the selected generator and it's not available.
          cmake --version &&
          brew install tclap glm glew sfml mesa-glu

        # We need to provide an OpenCL driver for Intel CPU on mac
      - name: Install PoCL
        shell: bash
        run: |
          brew install pocl &&
          sudo ls /usr/local/etc/OpenCL/vendors

      - name: Configure
        shell: bash
        run: git clone https://github.com/Microsoft/vcpkg.git vcpkg &&
          ./vcpkg/bootstrap-vcpkg.sh &&
          ./vcpkg/vcpkg install stb &&
          TOOLCHAIN_ARG="-D CMAKE_TOOLCHAIN_FILE=./vcpkg/scripts/buildsystems/vcpkg.cmake" &&
          cmake
          $TOOLCHAIN_ARG
          -G "${{matrix.GEN}}"
          -D BUILD_DOCS=ON
          -D BUILD_TESTING=ON
          -D BUILD_EXAMPLES=ON
          -D OPENCL_SDK_BUILD_SAMPLES=ON
          -D CMAKE_C_STANDARD=${{matrix.STD.C}}
          -D CMAKE_CXX_STANDARD=${{matrix.STD.CXX}}
          -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install
          -S $GITHUB_WORKSPACE
          -B $GITHUB_WORKSPACE/build

      - name: Build
        shell: bash
        run: |
          cmake --build $GITHUB_WORKSPACE/build --config Debug --parallel `sysctl -n hw.logicalcpu`
          cmake --build $GITHUB_WORKSPACE/build --config Release --parallel `sysctl -n hw.logicalcpu`

      - name: Test
        working-directory: ${{runner.workspace}}/OpenCL-SDK/build
        shell: bash
        run: |
          OCL_ICD_VENDORS=/usr/local/etc/OpenCL/vendors ctest -C Debug --output-on-failure --parallel `sysctl -n hw.logicalcpu`
          OCL_ICD_VENDORS=/usr/local/etc/OpenCL/vendors ctest -C Release --output-on-failure --parallel `sysctl -n hw.logicalcpu`

      - name: Test install
        shell: bash
        run: |
          cmake --build $GITHUB_WORKSPACE/build --config Release --target install

      - name: Consume (install)
        shell: bash
        run: cmake
          -G "${{matrix.GEN}}"
          -D CMAKE_C_STANDARD=${{matrix.STD.C}}
          -D CMAKE_CXX_STANDARD=${{matrix.STD.CXX}}
          -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/install"
          -S $GITHUB_WORKSPACE/test/cmake/pkgconfig/useutil
          -B $GITHUB_WORKSPACE/build_install &&
          cmake --build $GITHUB_WORKSPACE/build_install --config Debug --parallel `sysctl -n hw.logicalcpu` `if [[ "${{matrix.GEN}}" == "Xcode" ]]; then echo "-- -quiet"; fi;` &&
          cmake --build $GITHUB_WORKSPACE/build_install --config Release --parallel `sysctl -n hw.logicalcpu` `if [[ "${{matrix.GEN}}" == "Xcode" ]]; then echo "-- -quiet"; fi;` &&
          OCL_ICD_VENDORS=/usr/local/etc/OpenCL/vendors ctest -C Debug --output-on-failure --parallel `sysctl -n hw.logicalcpu` &&
          OCL_ICD_VENDORS=/usr/local/etc/OpenCL/vendors ctest -C Release --output-on-failure --parallel `sysctl -n hw.logicalcpu`

  python:
    if: false
    name: Exercise Python examples on ${{matrix.os}}
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v3
      - name: Environment setup
        run: |
          MINIFORGE_INSTALL_DIR=.miniforge3
          MINIFORGE_INSTALL_SH="Miniforge3-$(uname)-$(uname -m).sh"
          curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/$MINIFORGE_INSTALL_SH"

          bash "$MINIFORGE_INSTALL_SH" -b -p "$MINIFORGE_INSTALL_DIR"
          PATH="$MINIFORGE_INSTALL_DIR/bin/:$PATH" conda update conda --yes --quiet
          PATH="$MINIFORGE_INSTALL_DIR/bin/:$PATH" conda update --all --yes --quiet
          PATH="$MINIFORGE_INSTALL_DIR/bin:$PATH" conda env create --file python/.test-conda-env.yml --name testing --quiet

      - name: Linter
        run: |

          source ".miniforge3/bin/activate" testing
          (cd python && flake8)

      - name: Run examples
        run: |

          source ".miniforge3/bin/activate" testing
          for i in python/*.py; do
            echo "-----------------------------------------------------------------------"
            echo "RUNNING $i"
            echo "-----------------------------------------------------------------------"
            time python $i
          done

  checkruby:
    if: false
    name: Check Ruby Samples ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest]
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0
          submodules: recursive
      - name: Install Ruby and POCL
        run: sudo apt update; sudo apt install pocl-opencl-icd
        if: ${{ matrix.os == 'ubuntu-latest' }}
      - name: Install OpenCL Ruby Bindings and RuboCop
        run: gem install --user-install opencl_ruby_ffi rubocop
      - name: Check Ruby Syntax
        run: |
          export PATH=`ruby -r rubygems -e 'puts Gem.user_dir'`/bin:$PATH
          rubocop
        working-directory: ruby
      - name: Run Ruby Samples
        run: rake test
        working-directory: ruby

  android:
    if: false
    runs-on: ubuntu-latest
    needs: format
    strategy:
      matrix:
        ABI:
        - arm64-v8a
        - x86_64
        API_LEVEL:
        - android-29
        - android-33
        CONFIG:
        - Debug
        - Release
    env:
      CFLAGS: -Wall -Wextra -pedantic -Werror -Wno-error=gnu-statement-expression
      CXXFLAGS: -Wall -Wextra -pedantic -Werror -Wno-error=missing-field-initializers
    steps:
    - name: Checkout OpenCL-SDK
      uses: actions/checkout@v3
      with:
          fetch-depth: 0
          submodules: recursive

    - name: Configure
      shell: bash
      run: cmake
        -G "Unix Makefiles"
        -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}}
        -D CMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake
        -D ANDROID_ABI=${{matrix.ABI}}
        -D ANDROID_PLATFORM=${{matrix.API_LEVEL}}
        -D OPENCL_SDK_BUILD_OPENGL_SAMPLES=OFF
        -S $GITHUB_WORKSPACE
        -B $GITHUB_WORKSPACE/build

    - name: Build
      shell: bash
      run: cmake --build $GITHUB_WORKSPACE/build --parallel `nproc`