Use Fortran setup in workflows to access multiple compilers.

.github/workflows/test_suite_macos.yml

@@ -0,0 +1,138 @@
+# Workflow to run the FTorch test suite on Macos platforms
+name: TestSuiteMacOS
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on pushes to the "main" branch, i.e., PR merges
+  push:
+    branches: [ "main" ]
+
+  # Triggers the workflow on pushes to open pull requests with code changes
+  pull_request:
+    paths:
+      - '.github/workflows/test_suite_macos.yml'
+      - '**.c'
+      - '**.cpp'
+      - '**.fypp'
+      - '**.f90'
+      - '**.F90'
+      - '**.pf'
+      - '**.py'
+      - '**.sh'
+      - '**CMakeLists.txt'
+      - '**requirements.txt'
+      - '**data/*'
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Cancel jobs running if new commits are pushed
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+# Workflow run - one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "test-suite-macos"
+  test-suite-macos:
+    # The type of runner that the job will run on
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Newest possible gcc on macos-latest (arm64)
+          - os: macos-latest
+            toolchain: {compiler: gcc, version: 13}
+          # Oldest possible gcc on macos-latest (arm64)
+          - os: macos-latest
+            toolchain: {compiler: gcc, version: 11}
+          # Newest possible gcc on macos (x86)
+          - os: macos-15
+            toolchain: {compiler: gcc, version: 13}
+          - os: macos-13
+            toolchain: {compiler: gcc, version: 13}
+          # Newest possible intel-classic on macos
+          - os: macos-15
+            toolchain: {compiler: intel-classic, version: '2021.10'}
+          - os: macos-14
+            toolchain: {compiler: intel-classic, version: '2021.10'}
+          - os: macos-13
+            toolchain: {compiler: intel-classic, version: '2021.10'}
+          # Newest possible lfortran on macos
+          - os: macos-15
+            toolchain: {compiler: lfortran, version: '0.33.0'}
+          - os: macos-14
+            toolchain: {compiler: lfortran, version: '0.33.0'}
+          - os: macos-13
+            toolchain: {compiler: lfortran, version: '0.33.0'}
+    defaults:
+      run:
+        shell: bash -el {0}
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - name: Checkout code
+        with:
+          persist-credentials: false
+        uses: actions/checkout@v4
+
+      - name: setup-fortran
+        uses: fortran-lang/setup-fortran@v1
+        with:
+          compiler: ${{ matrix.toolchain.compiler }}
+          version: ${{ matrix.toolchain.version }}
+
+      - name: check-compilers-env
+        run: ${FC}
+        env: 
+          FC: ${{ steps.setup-fortran.outputs.fc }}
+
+      # Conda following instructions at https://github.com/conda-incubator/setup-miniconda
+      - name: Setup Conda environment
+        uses: conda-incubator/setup-miniconda@v3
+        continue-on-error: true
+        with:
+          environment-file: conda/environment_mac.yaml
+          activate-environment: ftorch-mac
+          miniforge-version: latest
+      - name: Check arm64
+        run: |
+          python -c "import platform; assert platform.machine() == 'arm64', platform.machine()"
+
+      - name: Check conda
+        run: |
+          conda info
+          conda list
+
+      - name: Install pFUnit
+        run: |
+          # TODO: Avoid version pinning (needed because version appears in install path)
+          git clone -b v4.10.0 https://github.com/Goddard-Fortran-Ecosystem/pFUnit.git
+          mkdir pFUnit/build
+          cd pFUnit/build
+          cmake .. -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX
+          make -j 4 install
+
+      - name: Build FTorch
+        run: |
+          VN=$(python -c "import sys; print('.'.join(sys.version.split('.')[:2]))")
+          export BUILD_DIR=$(pwd)/build
+          mkdir ${BUILD_DIR}
+          cd ${BUILD_DIR}
+          python -c 'import torch;print(torch.utils.cmake_prefix_path)'
+          cmake .. \
+            -DCMAKE_PREFIX_PATH="${CONDA_PREFIX};$(python -c 'import torch;print(torch.utils.cmake_prefix_path)')" \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_Fortran_COMPILER=${FC} \
+            -DCMAKE_C_COMPILER=${CC} \
+            -DCMAKE_CXX_COMPILER=${CXX} \
+            -DCMAKE_INSTALL_PREFIX=${CONDA_PREFIX} \
+            -DCMAKE_BUILD_TESTS=TRUE
+          cmake --build .
+          cmake --install .
+
+      - name: Integration tests
+        run: |
+          ./run_integration_tests.sh -V

.github/workflows/test_suite_ubuntu.yml

@@ -40,7 +40,21 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        std: ["f2008", "f2018"]
+        toolchain:
+          - {compiler: gcc, version: 13}
+          - {compiler: gcc, version: 12}
+          - {compiler: gcc, version: 11}
+          - {compiler: gcc, version: 10}
+          - {compiler: gcc, version: 9}
+          - {compiler: intel, version: '2024.1'}
+          - {compiler: intel-classic, version: '2021.10'}
+          - {compiler: lfortran, version: '0.33.0'}
+          - {compiler: nvidia-hpc, version: '23.11'}
+        std: ["f2008"]
+        include:
+          # Run 2018 Fortran standards on latest gcc only
+          - toolchain: {compiler: gcc, version: 13}
+            std: "f2018"
 
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
@@ -50,10 +64,21 @@ jobs:
           persist-credentials: false
         uses: actions/checkout@v4
 
+      - name: setup-fortran
+        uses: fortran-lang/setup-fortran@v1
+        with:
+          compiler: ${{ matrix.toolchain.compiler }}
+          version: ${{ matrix.toolchain.version }}
+
+      - name: check-compilers-env
+        run: ${FC}
+        env:
+          FC: ${{ steps.setup-fortran.outputs.fc }}
+
       - name: Install Python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.x'
+          python-version: '3.11'
 
       - name: Install PyTorch
         run: |
@@ -92,6 +117,9 @@ jobs:
           cmake .. \
             -DPython_EXECUTABLE="$(which python)" \
             -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_Fortran_COMPILER=${FC} \
+            -DCMAKE_C_COMPILER=${CC} \
+            -DCMAKE_CXX_COMPILER=${CXX} \
             -DCMAKE_INSTALL_PREFIX=${BUILD_DIR} \
             -DCMAKE_BUILD_TESTS=TRUE \
             -DCMAKE_PREFIX_PATH="${PFUNIT_DIR};${Torch_DIR}" \

README.md

@@ -115,9 +115,12 @@ Note that LibTorch is not supported for the GNU Fortran compiler with MinGW.
 
 #### Apple Silicon Support
 
-At the time of writing, LibTorch is only officially available for x86 architectures
-(according to https://pytorch.org/). However, the version of PyTorch provided by
-`pip install torch` uses an ARM binary for LibTorch which works on Apple Silicon.
+At the time of writing [there are issues](https://github.com/pytorch/pytorch/issues/143571)
+building FTorch on apple silicon when linking to downloaded `LibTorch` binaries or
+pip-installed PyTorch.
+FTorch can successfully be built, including utilising the MPS backend, from inside a
+conda environment using the environment files and instructions in
+[`conda/`](https://github.com/Cambridge-ICCS/FTorch/tree/main/conda).
 
 #### Conda Support
 

conda/README.md

@@ -74,6 +74,32 @@ cmake --build . --target install
 Note: There is the option of using `--parallel` to speed this up as described in
 the main documentation.
 
+### Mac and MPS
+
+At the time of writing [there are issues](https://github.com/pytorch/pytorch/issues/143571)
+building FTorch when linking to downloaded `LibTorch` binaries or pip-installed PyTorch.
+FTorch can successfully be built, including utilising the MPS backend, from inside a
+conda environment using the environment files provided here.
+
+From a conda base environment run:
+```sh
+conda env create -f environment_mac.yaml
+```
+from this directory to create the environment and install dependencies.
+We install PyTorch using `pip` from within the conda environment which should include
+the MPS backend.
+
+FTorch can then be build with a CMake command similar to the following:
+```sh
+cmake \
+    -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX \
+    -DCMAKE_PREFIX_PATH=$(python -c 'import torch;print(torch.utils.cmake_prefix_path)') \
+    -DCMAKE_BUILD_TYPE=Release \
+    ..
+cmake --build . --target install
+```
+Note: There is the option of using `--parallel` to speed this up as described in
+the main documentation.
 
 ### Other Backends
 

conda/environment_mac.yaml

@@ -0,0 +1,13 @@
+name: ftorch-mac
+channels:
+  - conda-forge
+  - nodefaults
+dependencies:
+  - fortran-compiler
+  - cxx-compiler
+  - cmake >=3.15
+  - openmpi >=5.0.6  # For pFUnit
+  - pip
+  - pip:  # We install PyTorch using pip as recommended by PyTorch
+    - torch
+    - torchvision