Merge branch 'master' into libSparse

Author: ViralBShah

.github/dependabot.yml

@@ -4,4 +4,4 @@ updates:
   - package-ecosystem: "github-actions"
     directory: "/" # Location of package manifests
     schedule:
-      interval: "weekly"
+      interval: "monthly"

.github/workflows/CI.yml

@@ -14,48 +14,31 @@ jobs:
       matrix:
         version:
           - '1'
+          - 'lts'
         os:
           - ubuntu-latest
           - windows-latest
           - macOS-13 # intel
-          - macOS-14 # arm
         arch:
           - x64
-          - aarch64
-        exclude:
-          - os: ubuntu-latest
+        include:
+          - os: macOS-latest
             arch: aarch64
-          - os: windows-latest
+            version: 'lts'
+          - os: macOS-latest
             arch: aarch64
-          - os: macOS-13
-            arch: x86
-          - os: macOS-13
-            arch: aarch64
-          - os: macOS-14
-            arch: x86
-          - os: macOS-14
-            arch: x64
+            version: '1'
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}
-      - uses: actions/cache@v4
-        env:
-          cache-name: cache-artifacts
-        with:
-          path: ~/.julia/artifacts
-          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
-          restore-keys: |
-            ${{ runner.os }}-test-${{ env.cache-name }}-
-            ${{ runner.os }}-test-
-            ${{ runner.os }}-
+      - uses: julia-actions/cache@v2
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
-      - uses: codecov/codecov-action@v4
+      - uses: codecov/codecov-action@v5
         with:
-          file: lcov.info
+          files: lcov.info
           token: ${{ secrets.CODECOV_TOKEN }}
-

.github/workflows/TagBot.yml

@@ -6,20 +6,7 @@ on:
   workflow_dispatch:
     inputs:
       lookback:
-        default: 3
-permissions:
-  actions: read
-  checks: read
-  contents: write
-  deployments: read
-  issues: read
-  discussions: read
-  packages: read
-  pages: read
-  pull-requests: read
-  repository-projects: read
-  security-events: read
-  statuses: read
+        default: "3"
 jobs:
   TagBot:
     if: github.event_name == 'workflow_dispatch' || github.actor == 'JuliaTagBot'
@@ -28,6 +15,4 @@ jobs:
       - uses: JuliaRegistries/TagBot@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          # Edit the following line to reflect the actual name of the GitHub Secret containing your private key
           ssh: ${{ secrets.DOCUMENTER_KEY }}
-          # ssh: ${{ secrets.NAME_OF_MY_SSH_PRIVATE_KEY_SECRET }}

Project.toml

@@ -1,6 +1,6 @@
 name = "AppleAccelerate"
 uuid = "13e28ba4-7ad8-5781-acae-3021b1ed3924"
-version = "0.4.1"
+version = "0.4.4"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

README.md

@@ -4,7 +4,7 @@ This provides a Julia interface to some of the
 [macOS Accelerate framework](https://developer.apple.com/documentation/accelerate). At
 the moment, this package provides:
 1. Access to Accelerate BLAS and LAPACK using the [libblastrampoline](https://github.com/JuliaLinearAlgebra/libblastrampoline) framework,
-2. An interface to the [array-oriented functions](https://developer.apple.com/library/mac/documentation/Performance/Conceptual/vecLib/index.html#//apple_ref/doc/uid/TP30000414-357225),
+2. An interface to the [array-oriented functions](https://developer.apple.com/documentation/accelerate/veclib),
 which provide a vectorised form for many common mathematical functions
 
 The performance is significantly better than using standard libm functions in some cases, though there does appear to be some reduced accuracy.
@@ -36,9 +36,33 @@ Some additional functions that are also available:
 * `fdiv(x,y)`: divide (`x ./ y` in Base)
 * `sincos(x)`: returns `(sin(x), cos(x))`
 
-## Setting the number of threads
+## BLAS Multi-threading
+
+Accelerate BLAS is multi-threaded by default. Starting with macOS 15 (Sequoia), `get_num_threads()` and `set_num_threads()` are available. The Accelerate API only allows the user to choose single-threaded operation or multi-threaded operation. Thus, `set_num_threads(1)` will give single-threaded operation, and any number greater than 1 will give multi-threaded operation. `get_num_threads()` will return `1` for single-threaded operation and `Sys.CPU_THREADS` for multi-threaded operation. The following example is on Apple M2 Max, where `Sys.CPU_THREADS` is `8`.
+
+```julia
+julia> using AppleAccelerate
+
+julia> AppleAccelerate.get_num_threads()  # Default is multi-threaded. Return value is `Sys.CPU_THREADS`
+8
+
+julia> AppleAccelerate.set_num_threads(1) # Set single-threaded operation
+
+julia> AppleAccelerate.get_num_threads()
+1
+
+julia> AppleAccelerate.set_num_threads(4) # Set multi-threaded operation, with input value > 1.
+
+julia> AppleAccelerate.get_num_threads()  # Return value is `Sys.CPU_THREADS` for multi-threaded operation
+8
+```
+
+On older versions of macOS (< 15), the number of threads can be changed with the `VECLIB_MAXIMUM_THREADS` environment variable before starting Julia:
+
+```julia
+VECLIB_MAXIMUM_THREADS=1 julia
+```
 
-Accelerate is multithreaded by default. You can set an upper limit on the number of threads through the `VECLIB_MAXIMUM_THREADS` environment variable; for example, for single-threaded execution, start Julia as `VECLIB_MAXIMUM_THREADS=1 julia`. Accelerate does not support the `BLAS.set_num_threads(nthreads)` and `BLAS.get_num_threads()` API used by other BLAS backends (`set_num_threads` is a no-op and `get_num_threads` returns a hardcoded default).
 
 ## Example
 

src/AppleAccelerate.jl

@@ -1,11 +1,14 @@
 module AppleAccelerate
-
 using LinearAlgebra, Libdl
-#using LAPACK_jll, LAPACK32_jll # Needed if use_external_lapack == true
 
-# For now, only use BLAS from Accelerate (that is to say, vecLib)
-global const libacc = "/System/Library/Frameworks/Accelerate.framework/Accelerate"
-global const libacc_info_plist = "/System/Library/Frameworks/Accelerate.framework/Versions/Current/Resources/Info.plist"
+const libacc = "/System/Library/Frameworks/Accelerate.framework/Accelerate"
+const libacc_info_plist = "/System/Library/Frameworks/Accelerate.framework/Versions/Current/Resources/Info.plist"
+
+# VecLib Threading API: /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/Frameworks/vecLib.framework/Headers/thread_api.h
+@enum Threading::Cuint begin
+    BLAS_THREADING_MULTI_THREADED
+    BLAS_THREADING_SINGLE_THREADED
+end
 
 function forward_accelerate(interface::Symbol;
                             new_lapack::Bool = interface == :ilp64,
@@ -27,12 +30,16 @@ function forward_accelerate(interface::Symbol;
 end
 
 """
-    load_accelerate(;clear = true, verbose = false)
+    load_accelerate(; clear = false, verbose = false, load_ilp64 = true)
 
-Load Accelerate, replacing the current LBT forwarding tables if `clear` is `true`.
-Attempts to load the ILP64 symbols if `load_ilp64` is `true`, and errors out if unable.
+Load Accelerate, replacing the current LBT forwarding tables if `clear` is `true`. `clear`
+is `false` by default to allow for OpenBLAS to act as a fallback for operations missing
+from Accelerate, such as `gemmt`. Attempts to load the ILP64 symbols if `load_ilp64` is
+`true`, and errors out if unable.
 """
-function load_accelerate(;clear::Bool = true, verbose::Bool = false, load_ilp64::Bool = true, use_external_lapack::Bool = true)
+function load_accelerate(; clear::Bool = false,
+                           verbose::Bool = false,
+                           load_ilp64::Bool = true)
     # Silently exit on non-Accelerate-capable platforms
     @static if !Sys.isapple()
         return
@@ -44,25 +51,17 @@ function load_accelerate(;clear::Bool = true, verbose::Bool = false, load_ilp64:
 
     # Check to see if we can load ILP64 symbols
     if load_ilp64 && dlsym_e(libacc_hdl, "dgemm\$NEWLAPACK\$ILP64") == C_NULL
-        error("Unable to load ILP64 interface from '$(libacc)'; You are running macOS version $(get_macos_version()), you need v13.4+")
+        @error "Unable to load ILP64 interface from '$(libacc)'; You are running macOS version $(get_macos_version()), you need v13.4+"
     end
 
     # First, load :lp64 symbols, optionally clearing the current LBT forwarding tables
     forward_accelerate(:lp64; new_lapack=true, clear, verbose)
     if load_ilp64
         forward_accelerate(:ilp64; new_lapack=true, verbose)
     end
-
-    # Next, load an external LAPACK, if requested
-    if use_external_lapack
-        if load_ilp64
-            BLAS.lbt_forward(LAPACK_jll.liblapack_path; suffix_hint="64_", verbose)
-        end
-        BLAS.lbt_forward(LAPACK32_jll.liblapack32_path; verbose)
-    end
 end
 
-function get_macos_version()
+function get_macos_version(normalize=true)
     @static if !Sys.isapple()
         return nothing
     end
@@ -78,17 +77,64 @@ function get_macos_version()
         return nothing
     end
 
-    return VersionNumber(only(m.captures))
+    ver = VersionNumber(only(m.captures))
+    if normalize && ver.major == 16
+        return VersionNumber(26, ver.minor, ver.patch)
+    end
+    return ver
+end
+
+function set_num_threads(n::LinearAlgebra.BlasInt)
+    @static if Sys.isapple()
+        if get_macos_version() < v"15"
+            @warn "The threading API is only available in macOS 15 and later"
+            return -1
+        end
+    else
+        return -1
+    end
+
+    retval::Cint = -1
+    if n == 1
+        retval = ccall((:BLASSetThreading, libacc), Cint, (Cint,), BLAS_THREADING_SINGLE_THREADED)
+    elseif n > 1
+        retval = ccall((:BLASSetThreading, libacc), Cint, (Cint,), BLAS_THREADING_MULTI_THREADED)
+    end
+    @assert retval == 0 "AppleAccelerate: Call to BlasSetThreading failed"
+    return nothing
+end
+
+function get_num_threads()::LinearAlgebra.BlasInt
+    @static if Sys.isapple()
+        if get_macos_version() < v"15"
+            @warn "The threading API is only available in macOS 15 and later"
+            return -1
+        end
+    else
+        return -1
+    end
+
+    retval::Threading = ccall((:BLASGetThreading, libacc), Threading, ())
+    if retval == BLAS_THREADING_SINGLE_THREADED
+        return LinearAlgebra.BlasInt(1)
+    elseif retval == BLAS_THREADING_MULTI_THREADED
+        return ccall((:APPLE_NTHREADS, libacc), LinearAlgebra.BlasInt, ())
+    else
+        @error "AppleAccelerate: Call to BlasGetThreading failed"
+    end
 end
 
 function __init__()
     Sys.isapple() || return
     ver = get_macos_version()
     # Default to loading the ILP64 interface on macOS 13.3+
     # dsptrf has a bug in the initial release of the $NEWLAPACK symbols in 13.3.
-    # Thus use macOS 13.4 for ILP64 and a correct LAPACK
-    ver < v"13.4" && return
-    load_accelerate(; load_ilp64=true, use_external_lapack=false)
+    # Thus use macOS 13.4 for ILP64, a correct LAPACK, and threading APIs
+    if ver < v"13.4"
+        @info AppleAccelerate.jl needs macOS 13.4 or later
+        return
+    end
+    load_accelerate(; clear = false, load_ilp64=true)
 end
 
 if Sys.isapple()

src/Util.jl

@@ -7,8 +7,8 @@ tupletypelength(a)=length(a.parameters)
 
 const OPS = Dict{Symbol,Tuple{Symbol, Symbol, Symbol}}(:+ => (:vadd, :vsadd, :vsadd),
 :- => (:vsub, :vssub, :svsub),
-:* => (:vadd, :vsmul, :vsmul),
-:/ => (:vadd, :vsdiv, :vsdiv),)
+:* => (:vmul, :vsmul, :vsmul),
+:/ => (:vdiv, :vsdiv, :vsdiv),)
 
 macro replaceBase(fs...)
     b = Expr(:block)

test/runtests.jl

@@ -338,8 +338,8 @@ end
 =#
 end
 
-if AppleAccelerate.get_macos_version() < v"13.3"
-    @info("AppleAccelerate.jl needs macOS >= 13.3 for BLAS forwarding. Not testing forwarding capabilities.")
+if AppleAccelerate.get_macos_version() < v"13.4"
+    @info("AppleAccelerate.jl needs macOS >= 13.4 for BLAS forwarding. Not testing forwarding capabilities.")
     exit(0)
 end
 
@@ -386,24 +386,27 @@ end
     @test BLAS.dot(a, a) ≈ 14f0
 end
 
-# Run all the LinearAlgebra stdlib tests, but with Accelerate.  We still
-# use `Base.runtests()` to get multithreaded, distributed execution
-# to cut down on CI times, and also to restart workers that trip over
-# the testing RSS limit.  In order for distributed workers to use Accelerate,
-# we'll modify the test source code so that it imports Accelerate:
-
-@testset "Full LinearAlgebra test suite" begin; mktempdir() do dir
-    cp(joinpath(Sys.BINDIR, Base.DATAROOTDIR, "julia", "test"), dir; force=true, follow_symlinks=true)
-
-    # Prepend `using AppleAccelerate` to `testdefs.jl`, so that all test workers load Acclerate
-    testdefs_path = joinpath(dir, "testdefs.jl")
-    chmod(testdefs_path, 0o644)
-    testdefs_content = String(read(testdefs_path))
-    open(testdefs_path, write=true) do io
-        println(io, accelerate_header)
-        println(io, testdefs_content)
+@testset "BLAS threading tests" begin
+    if AppleAccelerate.get_macos_version() >= v"15"
+        AppleAccelerate.set_num_threads(1)
+        @test AppleAccelerate.get_num_threads() == 1
+        AppleAccelerate.set_num_threads(4)
+        @test AppleAccelerate.get_num_threads() == Sys.CPU_THREADS
+    else
+        @test AppleAccelerate.get_num_threads() == -1
     end
+end
+
+linalg_stdlib_test_path = joinpath(dirname(pathof(LinearAlgebra)), "..", "test")
+
+# TODO: Re-enable after fixing https://github.com/JuliaLinearAlgebra/AppleAccelerate.jl/issues/87
+# Don't run blas.jl tests since the "strided interface blas" tests are currently failing
+#=
+@testset verbose=true "LinearAlgebra.jl BLAS tests" begin
+    joinpath(linalg_stdlib_test_path, "blas.jl") |> include
+end
+=#
 
-    run(`$(Base.julia_cmd()) --project=$(Base.active_project()) $(dir)/runtests.jl LinearAlgebra/blas LinearAlgebra/lapack`)
-end;
+@testset verbose=true "LinearAlgebra.jl LAPACK tests" begin
+    joinpath(linalg_stdlib_test_path, "lapack.jl") |> include
 end