Add findBLAS support to CMakeLists.txt

.github/workflows/CI.yml

@@ -59,23 +59,25 @@ jobs:
       with:
         compiler: ${{ matrix.toolchain.compiler }}
         version: ${{ matrix.toolchain.version }}
-
+
+    # Build and test with built-in BLAS and LAPACK
     - name: Configure with CMake
       if: ${{ contains(matrix.build, 'cmake') }}
       run: >-
         cmake -Wdev -G Ninja
         -DCMAKE_BUILD_TYPE=Release
         -DCMAKE_MAXIMUM_RANK:String=4
         -DCMAKE_INSTALL_PREFIX=$PWD/_dist
+        -DFIND_BLAS:STRING=FALSE
         -S . -B ${{ env.BUILD_DIR }}
 
     - name: Build and compile
       if: ${{ contains(matrix.build, 'cmake') }}
       run: cmake --build ${{ env.BUILD_DIR }} --parallel
 
     - name: catch build fail
-      run: cmake --build ${{ env.BUILD_DIR }} --verbose --parallel 1
       if: ${{ failure() && contains(matrix.build, 'cmake') }}
+      run: cmake --build ${{ env.BUILD_DIR }} --verbose --parallel 1
 
     - name: test
       if: ${{ contains(matrix.build, 'cmake') }}
@@ -89,3 +91,71 @@ jobs:
     - name: Install project
       if: ${{ contains(matrix.build, 'cmake') }}
       run: cmake --install ${{ env.BUILD_DIR }}
+
+  Build-with-MKL:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        toolchain:
+          - {compiler: intel, version: '2024.1'}
+        build: [cmake]
+    env:
+      BUILD_DIR: ${{ matrix.build == 'cmake' && 'build' || '.' }}
+      APT_PACKAGES: >-
+        intel-oneapi-mkl
+        intel-oneapi-mkl-devel
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python 3.x
+      uses: actions/setup-python@v5 # Use pip to install latest CMake, & FORD/Jin2For, etc.
+      with:
+        python-version: 3.x
+
+    - name: Install fypp
+      run: pip install --upgrade fypp ninja
+
+    - name: Setup Fortran compiler
+      uses: fortran-lang/[email protected]
+      id: setup-fortran
+      with:
+        compiler: ${{ matrix.toolchain.compiler }}
+        version: ${{ matrix.toolchain.version }}
+
+    - name: Install Intel oneAPI MKL
+      run: |
+        sudo apt-get install ${APT_PACKAGES}
+        source /opt/intel/oneapi/mkl/latest/env/vars.sh
+        printenv >> $GITHUB_ENV
+
+    # Build and test with external BLAS and LAPACK (MKL on Ubuntu with Intel compilers)
+    - name: Configure with CMake and MKL
+      run: >-
+        cmake -Wdev -G Ninja
+        -DCMAKE_BUILD_TYPE=Release
+        -DCMAKE_MAXIMUM_RANK:String=4
+        -DCMAKE_INSTALL_PREFIX=$PWD/_dist
+        -DFIND_BLAS:STRING=TRUE
+        -DBLAS_LIBRARIES="/opt/intel/oneapi/mkl/latest/lib/intel64/libmkl_rt.so"
+        -DLAPACK_LIBRARIES="/opt/intel/oneapi/mkl/latest/lib/intel64/libmkl_rt.so"
+        -S . -B build_mkl
+
+    - name: Build and compile with MKL
+      run: cmake --build build_mkl --parallel
+
+    - name: catch build fail with MKL
+      if: failure()
+      run: cmake --build build_mkl --verbose --parallel 1
+
+    - name: test with MKL
+      run: >-
+        ctest
+        --test-dir build_mkl
+        --parallel
+        --output-on-failure
+        --no-tests=error
+
+    - name: Install project with MKL
+      run: cmake --install build_mkl

.github/workflows/ci_windows.yml

@@ -56,7 +56,8 @@ jobs:
 
     - name: Install fypp
       run: pip install fypp
-
+
+    # Build and test with built-in BLAS and LAPACK
     - run: >-
         PATH=$PATH:/mingw64/bin/ cmake
         -Wdev
@@ -65,6 +66,7 @@ jobs:
         -DCMAKE_Fortran_FLAGS_DEBUG="-Wall -Wextra -Wimplicit-interface -fPIC -g -fcheck=all -fbacktrace"
         -DCMAKE_MAXIMUM_RANK:String=4
         -DCMAKE_INSTALL_PREFIX=$PWD/_dist
+        -DFIND_BLAS:STRING=FALSE
       env:
         FC: gfortran
         CC: gcc
@@ -88,3 +90,86 @@ jobs:
 
     - name: Install project
       run: PATH=$PATH:/mingw64/bin/ cmake --install build
+
+  msys2-build-with-OpenBLAS:
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include: [
+          { msystem: MINGW64, arch: x86_64 }
+        ]
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Setup MinGW native environment
+      uses: msys2/setup-msys2@v2
+      with:
+        msystem: ${{ matrix.msystem }}
+        update: false
+        install: >-
+          git
+          mingw-w64-${{ matrix.arch }}-gcc
+          mingw-w64-${{ matrix.arch }}-gcc-fortran
+          mingw-w64-${{ matrix.arch }}-python
+          mingw-w64-${{ matrix.arch }}-python-pip
+          mingw-w64-${{ matrix.arch }}-python-setuptools
+          mingw-w64-${{ matrix.arch }}-cmake
+          mingw-w64-${{ matrix.arch }}-ninja
+          mingw-w64-${{ matrix.arch }}-openblas
+
+    - name: Setup msys POSIX environment
+      uses: msys2/setup-msys2@v2
+      if: contains(matrix.msystem, 'MSYS')
+      with:
+        msystem: MSYS
+        update: false
+        install: >-
+          git
+          mingw-w64-x86_64-gcc
+          mingw-w64-x86_64-gcc-fortran
+          python
+          python-pip
+          cmake
+          ninja
+
+    - name: Install fypp
+      run: pip install fypp
+
+    # Build and test with external BLAS and LAPACK (OpenBLAS on MINGW64)
+    - name: Configure with CMake and OpenBLAS
+      run: >-
+        PATH=$PATH:/mingw64/bin/ cmake
+        -Wdev
+        -B build_openblas
+        -DCMAKE_BUILD_TYPE=Debug
+        -DCMAKE_Fortran_FLAGS_DEBUG="-Wall -Wextra -Wimplicit-interface -fPIC -g -fcheck=all -fbacktrace"
+        -DCMAKE_MAXIMUM_RANK:String=4
+        -DCMAKE_INSTALL_PREFIX=$PWD/_dist
+        -DFIND_BLAS:STRING=TRUE
+      env:
+        FC: gfortran
+        CC: gcc
+        CXX: g++
+
+    - name: CMake build with OpenBLAS
+      run: PATH=$PATH:/mingw64/bin/ cmake --build build_openblas --parallel
+
+    - name: catch build fail
+      if: failure()
+      run: PATH=$PATH:/mingw64/bin/ cmake --build build_openblas --verbose --parallel 1
+
+    - name: CTest with OpenBLAS
+      run: PATH=$PATH:/mingw64/bin/ ctest --test-dir build_openblas --output-on-failure --parallel -V -LE quadruple_precision
+
+    - uses: actions/upload-artifact@v1
+      if: failure()
+      with:
+        name: WindowsCMakeTestlog_openblas
+        path: build_openblas/Testing/Temporary/LastTest.log
+
+    - name: Install project with OpenBLAS
+      run: PATH=$PATH:/mingw64/bin/ cmake --install build_openblas

CMakeLists.txt

@@ -42,6 +42,20 @@ if(NOT DEFINED CMAKE_MAXIMUM_RANK)
   set(CMAKE_MAXIMUM_RANK 4 CACHE STRING "Maximum array rank for generated procedures")
 endif()
 
+option(FIND_BLAS "Find external BLAS and LAPACK" ON)
+
+# --- find BLAS and LAPACK
+if(FIND_BLAS)
+  find_package(BLAS)
+  if(BLAS_FOUND)
+    add_compile_definitions(STDLIB_EXTERNAL_BLAS)
+  endif()
+  find_package(LAPACK)
+  if(LAPACK_FOUND)
+    add_compile_definitions(STDLIB_EXTERNAL_LAPACK)
+  endif()
+endif()
+
 # --- find preprocessor
 find_program(FYPP fypp)
 if(NOT FYPP)

README.md

@@ -135,6 +135,7 @@ Important options are
 - `-DBUILD_TESTING` set to `off` in case you want to disable the stdlib tests (default: `on`).
 - `-DCMAKE_VERBOSE_MAKEFILE` is by default set to `Off`, but if set to `On` will show commands used to compile the code.
 - `-DCMAKE_BUILD_TYPE` is by default set to `RelWithDebInfo`, which uses compiler flags suitable for code development (but with only `-O2` optimization). Beware the compiler flags set this way will override any compiler flags specified via `FFLAGS`. To prevent this, use `-DCMAKE_BUILD_TYPE=NoConfig` in conjunction with `FFLAGS`.
+- `-DFIND_BLAS` set to `off` in case you want to disable finding the extlib BLAS/LAPACK dependency (default: `on`).
 
 For example, to configure a build using the Ninja backend while specifying compiler optimization via `FFLAGS`, generating procedures up to rank 7, installing to your home directory, using the `NoConfig` compiler flags, and printing the compiler commands, use
 

src/CMakeLists.txt

@@ -120,6 +120,14 @@ set(SRC
 
 add_library(${PROJECT_NAME} ${SRC})
 
+# Link to BLAS and LAPACK
+if(BLAS_FOUND)
+  target_link_libraries(${PROJECT_NAME} BLAS::BLAS)
+endif()
+if(LAPACK_FOUND)
+  target_link_libraries(${PROJECT_NAME} LAPACK::LAPACK)
+endif()
+
 set_target_properties(
   ${PROJECT_NAME}
   PROPERTIES

test/CMakeLists.txt

@@ -10,6 +10,15 @@ macro(ADDTEST name)
              WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 endmacro(ADDTEST)
 
+macro(ADDTESTPP name)
+    add_executable(test_${name} test_${name}.F90)
+    target_link_libraries(test_${name} "${PROJECT_NAME}" "test-drive::test-drive")
+    add_test(NAME ${name}
+             COMMAND $<TARGET_FILE:test_${name}> ${CMAKE_CURRENT_BINARY_DIR}
+             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+endmacro(ADDTESTPP)
+
+
 add_subdirectory(array)
 add_subdirectory(ascii)
 add_subdirectory(bitsets)
@@ -30,4 +39,4 @@ add_subdirectory(system)
 add_subdirectory(quadrature)
 add_subdirectory(math)
 add_subdirectory(stringlist)
-add_subdirectory(terminal)
+add_subdirectory(terminal)

test/linalg/CMakeLists.txt

@@ -1,15 +1,22 @@
 set(
   fppFiles
   "test_linalg.fypp"
-  "test_blas_lapack.fypp"
   "test_linalg_eigenvalues.fypp"
   "test_linalg_solve.fypp"
   "test_linalg_lstsq.fypp"
   "test_linalg_determinant.fypp"
   "test_linalg_svd.fypp"
   "test_linalg_matrix_property_checks.fypp"
 )
+
+# Preprocessed files to contain preprocessor directives -> .F90
+set(
+  cppFiles
+  "test_blas_lapack.fypp"
+)
+
 fypp_f90("${fyppFlags}" "${fppFiles}" outFiles)
+fypp_f90pp("${fyppFlags}" "${cppFiles}" outPreprocFiles)
 
 ADDTEST(linalg)
 ADDTEST(linalg_determinant)
@@ -18,4 +25,4 @@ ADDTEST(linalg_matrix_property_checks)
 ADDTEST(linalg_solve)
 ADDTEST(linalg_lstsq)
 ADDTEST(linalg_svd)
-ADDTEST(blas_lapack)
+ADDTESTPP(blas_lapack)

test/linalg/test_blas_lapack.fypp

@@ -30,7 +30,9 @@ contains
             new_unittest("test_gemv${t1[0]}$${k1}$", test_gemv${t1[0]}$${k1}$), &
             new_unittest("test_getri${t1[0]}$${k1}$", test_getri${t1[0]}$${k1}$), &
   #:endfor
-            new_unittest("test_idamax", test_idamax) &
+            new_unittest("test_idamax", test_idamax), &
+            new_unittest("test_external_blas",external_blas_test), &
+            new_unittest("test_external_lapack",external_lapack_test) &
             ]
 
     end subroutine collect_blas_lapack
@@ -117,6 +119,75 @@ contains
 
     end subroutine test_idamax
 
+    !> Test availability of the external BLAS interface
+    subroutine external_blas_test(error)
+        !> Error handling
+        type(error_type), allocatable, intent(out) :: error
+
+#ifdef STDLIB_EXTERNAL_BLAS           
+        interface 
+            subroutine saxpy(n,sa,sx,incx,sy,incy)
+                 import sp,ilp 
+                 implicit none(type,external) 
+                 real(sp), intent(in) :: sa,sx(*)
+                 integer(ilp), intent(in) :: incx,incy,n
+                 real(sp), intent(inout) :: sy(*)
+            end subroutine saxpy        
+        end interface
+
+        integer(ilp), parameter :: n = 5, inc=1
+        real(sp) :: a,x(n),y(n)
+
+        x = 1.0_sp
+        y = 2.0_sp
+        a = 3.0_sp
+
+        call saxpy(n,a,x,inc,y,inc)
+        call check(error, all(abs(y-5.0_sp)<sqrt(epsilon(0.0_sp))), "saxpy: check result")
+        if (allocated(error)) return
+
+#else
+        call skip_test(error, "Not using an external BLAS")
+#endif        
+
+    end subroutine external_blas_test        
+
+    !> Test availability of the external BLAS interface
+    subroutine external_lapack_test(error)
+        !> Error handling
+        type(error_type), allocatable, intent(out) :: error
+
+#ifdef STDLIB_EXTERNAL_LAPACK       
+        interface 
+           subroutine dgetrf( m, n, a, lda, ipiv, info )
+                import dp,ilp
+                implicit none(type,external) 
+                integer(ilp), intent(out) :: info,ipiv(*)
+                integer(ilp), intent(in) :: lda,m,n
+                real(dp), intent(inout) :: a(lda,*)
+           end subroutine dgetrf       
+        end interface
+
+        integer(ilp), parameter :: n = 3
+        real(dp) :: A(n,n)
+        integer(ilp) :: ipiv(n),info
+
+
+        A = eye(n)        
+        info = 123
+
+        ! Factorize matrix 
+        call dgetrf(n,n,A,n,ipiv,info)
+
+        call check(error, info==0, "dgetrf: check result")
+        if (allocated(error)) return
+
+#else
+        call skip_test(error, "Not using an external LAPACK")
+#endif        
+
+    end subroutine external_lapack_test                  
+
 end module test_blas_lapack