Merge pull request DrTimothyAldenDavis#904 from DrTimothyAldenDavis/dev2

SuiteSparse 7.9.0

Author: DrTimothyAldenDavis

.github/workflows/build-arch-emu.yaml

@@ -35,14 +35,12 @@ jobs:
       matrix:
         # For available CPU architectures, see:
         # https://github.com/marketplace/actions/setup-alpine-linux-environment
-        arch: [x86, aarch64, armv7, ppc64le, s390x, riscv64]
+        arch: [x86, armv7, ppc64le, s390x, riscv64]
         include:
           - arch: x86
             ccache-max: 64M
             extra-build-libs: ":GraphBLAS:LAGraph"
             extra-check-libs: ":GraphBLAS:LAGraph"
-          - arch: aarch64
-            ccache-max: 28M
           - arch: armv7
             ccache-max: 25M
           - arch: ppc64le

.github/workflows/build.yaml

@@ -23,71 +23,58 @@ jobs:
   ubuntu:
     # For available GitHub-hosted runners, see:
     # https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
 
-    name: ubuntu (${{ matrix.compiler }} ${{ matrix.cuda }} CUDA ${{ matrix.openmp }} OpenMP, ${{ matrix.link }})
+    name: ${{ matrix.os }} (${{ matrix.compiler }} ${{ matrix.cuda }} CUDA ${{ matrix.openmp }} OpenMP, ${{ matrix.link }})
 
     strategy:
       # Allow other runners in the matrix to continue if some fail
       fail-fast: false
 
       matrix:
-        compiler: [gcc, clang]
-        cuda: [with, without]
+        os: [ubuntu-latest]
+        compiler: [gcc]
+        cuda: [with]
         openmp: [with]
         link: [both]
         include:
-          - compiler: gcc
-            compiler-pkgs: "g++ gcc"
-            cc: "gcc"
-            cxx: "g++"
-          - compiler: clang
-            compiler-pkgs: "clang libomp-dev"
-            cc: "clang"
-            cxx: "clang++"
-          # Clang seems to generally require less cache size (smaller object files?).
-          - compiler: gcc
-            ccache-max: 600M
-          - compiler: clang
-            ccache-max: 500M
-          - cuda: with
-            cuda-pkgs: "nvidia-cuda-dev nvidia-cuda-toolkit"
-            cuda-cmake-flags:
-              -DSUITESPARSE_USE_CUDA=ON
-              -DSUITESPARSE_USE_STRICT=ON
-              -DCUDAToolkit_INCLUDE_DIRS="/usr/include"
-              -DCMAKE_CUDA_COMPILER_LAUNCHER="ccache"
-          - compiler: gcc
-            compiler-pkgs: "g++ gcc"
-            cc: "gcc"
-            cxx: "g++"
-            ccache-max: 600M
+          - os: ubuntu-latest
+            compiler: gcc
+            cuda: with
+            openmp: with
+            link: both
+          - os: ubuntu-latest
+            compiler: gcc
+            cuda: without
+            openmp: with
+            link: both
+          - os: ubuntu-latest
+            compiler: gcc
             cuda: without
             openmp: without
-            openmp-cmake-flags: "-DSUITESPARSE_USE_OPENMP=OFF"
-          - compiler: gcc
-            compiler-pkgs: "g++ gcc"
-            cc: "gcc"
-            cxx: "g++"
-            ccache-max: 600M
+            link: both
+          - os: ubuntu-latest
+            compiler: clang
+            cuda: with
+            openmp: with
+            link: both
+          - os: ubuntu-latest
+            compiler: gcc
             cuda: with
-            cuda-pkgs: "nvidia-cuda-dev nvidia-cuda-toolkit"
-            cuda-cmake-flags:
-              -DSUITESPARSE_USE_CUDA=ON
-              -DSUITESPARSE_USE_STRICT=ON
-              -DCUDAToolkit_INCLUDE_DIRS="/usr/include"
-              -DCMAKE_CUDA_COMPILER_LAUNCHER="ccache"
             openmp: with
             link: static
             # "Fake" a cross-compilation to exercise that build system path
-            link-cmake-flags:
-              -DBUILD_SHARED_LIBS=OFF
-              -DBUILD_STATIC_LIBS=ON
+            extra-cmake-flags:
               -DCMAKE_SYSTEM_NAME="Linux"
+          - os: ubuntu-24.04-arm
+            compiler: gcc
+            cuda: without
+            openmp: with
+            link: both
 
     env:
-      CC: ${{ matrix.cc }}
-      CXX: ${{ matrix.cxx }}
+      CC: ${{ matrix.compiler == 'gcc' && 'gcc' || 'clang' }}
+      CXX: ${{ matrix.compiler == 'gcc' && 'g++' || 'clang++' }}
 
     steps:
       - name: get CPU information
@@ -97,21 +84,22 @@ jobs:
         uses: actions/checkout@v4
 
       - name: install dependencies
-        env:
-          COMPILER_PKGS: ${{ matrix.compiler-pkgs }}
-          CUDA_PKGS: ${{ matrix.cuda-pkgs }}
         run: |
           sudo apt -qq update
-          sudo apt install -y ${COMPILER_PKGS} autoconf automake ccache cmake \
+          sudo apt install -y \
+            ${{ matrix.compiler == 'gcc' && 'g++ gcc' || 'clang' }} \
+            ${{ matrix.compiler == 'clang' &&  matrix.openmp == 'with' && 'libomp-dev' || '' }} \
+            autoconf automake ccache cmake \
             dvipng gfortran libgmp-dev liblapack-dev libmpfr-dev valgrind \
-            libopenblas-dev ${CUDA_PKGS}
+            libopenblas-dev \
+            ${{ matrix.cuda == 'with' && 'nvidia-cuda-dev nvidia-cuda-toolkit' || '' }}
 
       - name: prepare ccache
         # create key with human readable timestamp
         # used in action/cache/restore and action/cache/save steps
         id: ccache-prepare
         run: |
-          echo "key=ccache:ubuntu:${{ matrix.compiler }}:${{ matrix.cuda }}:${{ matrix.openmp }}:${{ matrix.link }}:${{ github.ref }}:$(date +"%Y-%m-%d_%H-%M-%S"):${{ github.sha }}" >> $GITHUB_OUTPUT
+          echo "key=ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.cuda }}:${{ matrix.openmp }}:${{ matrix.link }}:${{ github.ref }}:$(date +"%Y-%m-%d_%H-%M-%S"):${{ github.sha }}" >> $GITHUB_OUTPUT
 
       - name: restore ccache
         # setup the GitHub cache used to maintain the ccache from one job to the next
@@ -121,8 +109,8 @@ jobs:
           key: ${{ steps.ccache-prepare.outputs.key }}
           # Prefer caches from the same branch. Fall back to caches from the dev branch.
           restore-keys: |
-            ccache:ubuntu:${{ matrix.compiler }}:${{ matrix.cuda }}:${{ matrix.openmp }}:${{ matrix.link }}:${{ github.ref }}
-            ccache:ubuntu:${{ matrix.compiler }}:${{ matrix.cuda }}:${{ matrix.openmp }}:${{ matrix.link }}:
+            ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.cuda }}:${{ matrix.openmp }}:${{ matrix.link }}:${{ github.ref }}
+            ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.cuda }}:${{ matrix.openmp }}:${{ matrix.link }}:
 
       - name: create empty libraries
         # This is to work around a bug in nvlink.
@@ -135,16 +123,17 @@ jobs:
           ar rcsv librt.a empty.o
           ar rcsv libpthread.a empty.o
           # overwrite system libraries with "valid" empty libraries
-          sudo mv ./libdl.a /usr/lib/x86_64-linux-gnu/libdl.a
-          sudo mv ./librt.a /usr/lib/x86_64-linux-gnu/librt.a
-          sudo mv ./libpthread.a /usr/lib/x86_64-linux-gnu/libpthread.a
+          sudo mv ./libdl.a /usr/lib/$(dpkg-architecture -qDEB_HOST_MULTIARCH)/libdl.a
+          sudo mv ./librt.a /usr/lib/$(dpkg-architecture -qDEB_HOST_MULTIARCH)/librt.a
+          sudo mv ./libpthread.a /usr/lib/$(dpkg-architecture -qDEB_HOST_MULTIARCH)/libpthread.a
 
       - name: configure ccache
         env:
           CCACHE_MAX: ${{ matrix.ccache-max }}
         run: |
           test -d ~/.ccache || mkdir ~/.ccache
-          echo "max_size = $CCACHE_MAX" >> ~/.ccache/ccache.conf
+          # Clang seems to generally require less cache size (smaller object files?).
+          echo "max_size = ${{ matrix.compiler == 'gcc' && '600M' || '500M' }}" >> ~/.ccache/ccache.conf
           echo "compression = true" >> ~/.ccache/ccache.conf
           ccache -s
           echo "/usr/lib/ccache" >> $GITHUB_PATH
@@ -156,21 +145,29 @@ jobs:
             printf "   \033[0;32m==>\033[0m Building library \033[0;32m${lib}\033[0m\n"
             echo "::group::Configure $lib"
             cd ${GITHUB_WORKSPACE}/${lib}/build
-            cmake -DCMAKE_BUILD_TYPE="Release" \
+            cmake -DCMAKE_BUILD_TYPE='Release' \
                   -DCMAKE_INSTALL_PREFIX="${GITHUB_WORKSPACE}" \
                   -DCMAKE_C_COMPILER_LAUNCHER="ccache" \
                   -DCMAKE_CXX_COMPILER_LAUNCHER="ccache" \
                   -DCMAKE_Fortran_COMPILER_LAUNCHER="ccache" \
                   -DBLA_VENDOR="OpenBLAS" \
                   -DSUITESPARSE_DEMOS=OFF \
                   -DBUILD_TESTING=OFF \
-                  ${{ matrix.cuda-cmake-flags }} \
-                  ${{ matrix.openmp-cmake-flags }} \
-                  ${{ matrix.link-cmake-flags }} \
+                  ${{ matrix.cuda == 'with'
+                    && '-DSUITESPARSE_USE_CUDA=ON \
+                        -DSUITESPARSE_USE_STRICT=ON \
+                        -DCUDAToolkit_INCLUDE_DIRS="/usr/include" \
+                        -DCMAKE_CUDA_COMPILER_LAUNCHER="ccache"'
+                    || '-DSUITESPARSE_USE_CUDA=OFF' }} \
+                  -DSUITESPARSE_USE_OPENMP=${{ matrix.openmp == 'without' && 'OFF' || 'ON' }} \
+                  ${{ matrix.link == 'static'
+                    && '-DBUILD_SHARED_LIBS=OFF -DBUILD_STATIC_LIBS=ON'
+                    || '' }} \
+                  ${{ matrix.extra-cmake-flags }} \
                   ..
             echo "::endgroup::"
             echo "::group::Build $lib"
-            cmake --build . --config Release
+            cmake --build .
             echo "::endgroup::"
           done
 
@@ -214,8 +211,15 @@ jobs:
           cmake \
             -DCMAKE_PREFIX_PATH="${GITHUB_WORKSPACE}/lib/cmake" \
             -DBLA_VENDOR="OpenBLAS" \
-            ${{ matrix.cuda-cmake-flags }} \
-            ${{ matrix.link-cmake-flags }} \
+            ${{ matrix.cuda == 'with'
+              && '-DSUITESPARSE_USE_CUDA=ON \
+                  -DSUITESPARSE_USE_STRICT=ON \
+                  -DCUDAToolkit_INCLUDE_DIRS="/usr/include" \
+                  -DCMAKE_CUDA_COMPILER_LAUNCHER="ccache"'
+              || '' }} \
+            ${{ matrix.link == 'static'
+              && '-DBUILD_SHARED_LIBS=OFF -DBUILD_STATIC_LIBS=ON'
+              || '' }} \
             ..
           echo "::endgroup::"
           printf "::group::\033[0;32m==>\033[0m Building example\n"