M1 (#185)

* Improve M1 support

* apple silicon params

* No `strict=true` for `makedocs`

* Bump version

* Tilesearch updates

* update params

Author: chriselrod

Project.toml

@@ -1,7 +1,7 @@
 name = "Octavian"
 uuid = "6fd5a793-0b7e-452c-907f-f8bfe9c57db4"
 authors = ["Chris Elrod", "Dilum Aluthge", "Mason Protter", "contributors"]
-version = "0.3.26"
+version = "0.3.27"
 
 [deps]
 CPUSummary = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9"

benchmark/tilesearch.jl

@@ -14,18 +14,19 @@ function matmul_pack_ab!(
   K = size(B, 1)
   zc, za, zb = Octavian.zstridedpointer.((C, A, B))
   nspawn = VectorizationBase.num_cores()
-  threads, torelease = Octavian.PolyesterWeave.__request_threads(
-    (nspawn - 1) % UInt32,
-    Octavian.PolyesterWeave.worker_pointer(),
-    nothing
-  )
+  nthreads = min(Int(nspawn), Threads.nthreads())
+  # threads, torelease = Octavian.PolyesterWeave.__request_threads(
+  #   (nspawn - 1) % UInt32,
+  #   Octavian.PolyesterWeave.worker_pointer(),
+  #   nothing
+  # )
   t = Inf
   GC.@preserve C A B begin
     for _ ∈ 1:2
       t = min(
         t,
         @elapsed(
-          Octavian.matmul_pack_A_and_B!(
+          Octavian.__matmul!(
             zc,
             za,
             zb,
@@ -34,7 +35,7 @@ function matmul_pack_ab!(
             M,
             K,
             N,
-            threads,
+            nthreads,
             F64(W₁),
             F64(W₂),
             F64(R₁),
@@ -44,7 +45,7 @@ function matmul_pack_ab!(
       )
     end
   end
-  Octavian.PolyesterWeave.free_threads!(torelease)
+  # Octavian.PolyesterWeave.free_threads!(torelease)
   return t
 end
 
@@ -134,24 +135,28 @@ function matrix_range(S, ::Type{T} = Float64) where {T}
 end
 
 T = Float32
-min_size = round(
-  Int,
-  sqrt(
-    (0.65 / 4) *
-    Octavian.num_cores() *
-    Octavian.VectorizationBase.cache_size(Val(3)) / sizeof(T)
-  )
+min_size = min(
+  round(
+    Int,
+    sqrt(
+      (0.65 / 4) * Octavian.num_cores() * Octavian.second_cache_size() /
+      sizeof(T)
+    )
+  ),
+  2000
 )
-max_size = round(
-  Int,
-  sqrt(
-    (32 / 4) *
-    Octavian.num_cores() *
-    Octavian.VectorizationBase.cache_size(Val(3)) / sizeof(T)
-  )
+max_size = min(
+  round(
+    Int,
+    sqrt(
+      (32 / 4) * Octavian.num_cores() * Octavian.second_cache_size() /
+      sizeof(T)
+    )
+  ),
+  10_000
 )
 
-SR = size_range(max_size, min_size, 400);
+SR = size_range(max_size, min_size, 40);
 const CsConst, AsConst, BsConst = matrix_range(SR, T);
 
 # using Hyperopt
@@ -213,7 +218,7 @@ init = Float64[
   Octavian.R₁Default(),
   Octavian.R₂Default()
 ]
-lower = 0.75 .* init;
+lower = 0.25 .* init;
 # upper = [1.25init[1], 1.25init[2], 0.75*init[3] + 0.25, 0.75*init[4] + 0.25];
 upper = [0.9, 1.25init[2], 0.999, 0.999];
 # init = [0.001, 0.9754033943603924, 0.5711159869399494, 0.7547361860432168];
@@ -222,5 +227,5 @@ opt = Optim.optimize(
   matmul_objective,
   init,
   ParticleSwarm(; lower = lower, upper = upper),
-  Optim.Options(; iterations = 10^6, time_limit = 14 * hours)
+  Optim.Options(; iterations = 10^6, time_limit = 8 * hours)
 );

docs/make.jl

@@ -16,7 +16,7 @@ makedocs(;
     "Getting Started" => "getting-started.md",
     "Public API" => "public-api.md",
     "Internals (Private)" => "internals.md"
-  ],
+  ]
 )
 
 deploydocs(; repo = "github.com/JuliaLinearAlgebra/Octavian.jl")

src/funcptrs.jl

@@ -1,8 +1,8 @@
 
-struct LoopMulFunc{P,TC,TA,TB,Α,Β,Md,Kd,Nd} <: Function end
-function (::LoopMulFunc{P,TC,TA,TB,Α,Β,Md,Kd,Nd})(
+struct LoopMulFunc{P,TC,TA,TB,Α,Β,Md,Kd,Nd,W₁,W₂,R₁,R₂} <: Function end
+function (::LoopMulFunc{P,TC,TA,TB,Α,Β,Md,Kd,Nd,W₁,W₂,R₁,R₂})(
   p::Ptr{UInt}
-) where {P,TC,TA,TB,Α,Β,Md,Kd,Nd}
+) where {P,TC,TA,TB,Α,Β,Md,Kd,Nd,W₁,W₂,R₁,R₂}
   offset, C = load(p, TC, 2 * sizeof(UInt))
   offset, A = load(p, TA, offset)
   offset, B = load(p, TB, offset)
@@ -11,11 +11,25 @@ function (::LoopMulFunc{P,TC,TA,TB,Α,Β,Md,Kd,Nd})(
   offset, M = load(p, Md, offset)
   offset, K = load(p, Kd, offset)
   offset, N = load(p, Nd, offset)
-  _call_loopmul!(C, A, B, α, β, M, K, N, Val{P}())
+  _call_loopmul!(
+    C,
+    A,
+    B,
+    α,
+    β,
+    M,
+    K,
+    N,
+    Val{P}(),
+    static(W₁),
+    static(W₂),
+    static(R₁),
+    static(R₂)
+  )
   _atomic_store!(p, SPIN)
   nothing
 end
-@inline _call_loopmul!(C, A, B, α, β, M, K, N, ::Val{false}) =
+@inline _call_loopmul!(C, A, B, α, β, M, K, N, ::Val{false}, W₁, W₂, R₁, R₂) =
   loopmul!(C, A, B, α, β, M, K, N)
 @inline function _call_loopmul!(
   C::StridedPointer{T},
@@ -26,31 +40,20 @@ end
   M,
   K,
   N,
-  ::Val{true}
+  ::Val{true},
+  W₁,
+  W₂,
+  R₁,
+  R₂
 ) where {T}
-  if M * K < ceil(Int, Float64(first_cache_size(Val(T)) * R₂Default()))
+  if M * K < ceil(Int, Float64(first_cache_size(Val(T)) * R₂))
     packaloopmul!(C, A, B, α, β, M, K, N)
     return
   else
-    matmul_st_only_pack_A!(
-      C,
-      A,
-      B,
-      α,
-      β,
-      M,
-      K,
-      N,
-      W₁Default(),
-      W₂Default(),
-      R₁Default(),
-      R₂Default()
-    )
+    matmul_st_only_pack_A!(C, A, B, α, β, M, K, N, W₁, W₂, R₁, R₂)
     return
   end
 end
-call_loopmul!(C, A, B, α, β, M, K, N, ::Val{P}) where {P} =
-  _call_loopmul!(C, A, B, α, β, M, K, N, Val{P}())
 
 struct SyncMulFunc{TC,TA,TB,Α,Β,Md,Kd,Nd,BCP,ID,TT,W₁,W₂,R₁,R₂} <: Function end
 function (::SyncMulFunc{TC,TA,TB,Α,Β,Md,Kd,Nd,BCP,ID,TT,W₁,W₂,R₁,R₂})(
@@ -108,11 +111,15 @@ end
   M::Md,
   K::Kd,
   N::Nd,
-  ::Val{P}
-) where {P,TC,TA,TB,Α,Β,Md,Kd,Nd}
+  ::Val{P},
+  ::StaticFloat64{W₁},
+  ::StaticFloat64{W₂},
+  ::StaticFloat64{R₁},
+  ::StaticFloat64{R₂}
+) where {P,TC,TA,TB,Α,Β,Md,Kd,Nd,W₁,W₂,R₁,R₂}
   offset = store!(
     p,
-    cfuncpointer(LoopMulFunc{P,TC,TA,TB,Α,Β,Md,Kd,Nd}()),
+    cfuncpointer(LoopMulFunc{P,TC,TA,TB,Α,Β,Md,Kd,Nd,W₁,W₂,R₁,R₂}()),
     sizeof(UInt)
   )
   offset = store!(p, C, offset)
@@ -136,9 +143,13 @@ end
   K,
   N,
   tid::UInt32,
-  ::Val{P}
+  ::Val{P},
+  W₁,
+  W₂,
+  R₁,
+  R₂
 ) where {P}
-  launch(setup_matmul!, tid, C, A, B, α, β, M, K, N, Val{P}())
+  launch(setup_matmul!, tid, C, A, B, α, β, M, K, N, Val{P}(), W₁, W₂, R₁, R₂)
 end
 
 struct SyncMulLauncher{W₁,W₂,R₁,R₂} end

src/global_constants.jl

@@ -18,45 +18,46 @@ MᵣW_mul_factor(::True) = StaticInt{4}()
 MᵣW_mul_factor(::False) = StaticInt{9}()
 MᵣW_mul_factor() = MᵣW_mul_factor(has_feature(Val(:x86_64_avx512f)))
 
-
-if Sys.ARCH === :aarch64 && (Sys.isapple() || occursin("apple", Sys.CPU_NAME::String))
-  W₁Default() = StaticFloat64{0.23015506935919203}()
-W₂Default() = StaticFloat64{0.16967706087713014}()
-R₁Default() = StaticFloat64{0.9982516031563079}()
-R₂Default() = StaticFloat64{0.5167030291302886}()
+if Sys.ARCH === :aarch64 &&
+   (Sys.isapple() || occursin("apple", Sys.CPU_NAME::String))
+  W₁Default() = StaticFloat64{0.1464967933382345}()
+  W₂Default() = StaticFloat64{0.07243228432052636}()
+  R₁Default() = StaticFloat64{0.5024723443788641}()
+  R₂Default() = StaticFloat64{0.9018940596921994}()
 else
-W₁Default(::True) = StaticFloat64{0.0007423708195588264}()
-W₂Default(::True) = StaticFloat64{0.7757548987718677}()
-R₁Default(::True) = StaticFloat64{0.7936663315339363}()
-R₂Default(::True) = StaticFloat64{0.7144577794375783}()
-
-W₁Default_arch(::Val{:znver1}) = StaticFloat64{0.053918949422353986}()
-W₂Default_arch(::Val{:znver1}) = StaticFloat64{0.3013238122374886}()
-R₁Default_arch(::Val{:znver1}) = StaticFloat64{0.6077103834481342}()
-R₂Default_arch(::Val{:znver1}) = StaticFloat64{0.8775382433240162}()
-
-W₁Default_arch(::Union{Val{:znver2},Val{:znver3}}) = StaticFloat64{0.1}()
-W₂Default_arch(::Union{Val{:znver2},Val{:znver3}}) =
-  StaticFloat64{0.993489411720157}()
-R₁Default_arch(::Union{Val{:znver2},Val{:znver3}}) =
-  StaticFloat64{0.6052218809954467}()
-R₂Default_arch(::Union{Val{:znver2},Val{:znver3}}) =
-  StaticFloat64{0.7594052633561165}()
-
-W₁Default_arch(_) = StaticFloat64{0.05846951331683783}()
-W₂Default_arch(_) = StaticFloat64{0.16070447575367697}()
-R₁Default_arch(_) = StaticFloat64{0.5370318382263098}()
-R₂Default_arch(_) = StaticFloat64{0.5584398748982029}()
-
-W₁Default(::False) = W₁Default_arch(VectorizationBase.cpu_name())
-W₂Default(::False) = W₂Default_arch(VectorizationBase.cpu_name())
-R₁Default(::False) = R₁Default_arch(VectorizationBase.cpu_name())
-R₂Default(::False) = R₂Default_arch(VectorizationBase.cpu_name())
-
-W₁Default() = W₁Default(has_feature(Val(:x86_64_avx512f)))
-W₂Default() = W₂Default(has_feature(Val(:x86_64_avx512f)))
-R₁Default() = R₁Default(has_feature(Val(:x86_64_avx512f)))
-R₂Default() = R₂Default(has_feature(Val(:x86_64_avx512f)))
+  W₁Default(::True) = StaticFloat64{0.0007423708195588264}()
+  W₂Default(::True) = StaticFloat64{0.7757548987718677}()
+  R₁Default(::True) = StaticFloat64{0.7936663315339363}()
+  R₂Default(::True) = StaticFloat64{0.7144577794375783}()
+
+  W₁Default_arch(::Val{:znver1}) = StaticFloat64{0.053918949422353986}()
+  W₂Default_arch(::Val{:znver1}) = StaticFloat64{0.3013238122374886}()
+  R₁Default_arch(::Val{:znver1}) = StaticFloat64{0.6077103834481342}()
+  R₂Default_arch(::Val{:znver1}) = StaticFloat64{0.8775382433240162}()
+
+  W₁Default_arch(::Union{Val{:znver2},Val{:znver3}}) = StaticFloat64{0.1}()
+  W₂Default_arch(::Union{Val{:znver2},Val{:znver3}}) =
+    StaticFloat64{0.993489411720157}()
+  R₁Default_arch(::Union{Val{:znver2},Val{:znver3}}) =
+    StaticFloat64{0.6052218809954467}()
+  R₂Default_arch(::Union{Val{:znver2},Val{:znver3}}) =
+    StaticFloat64{0.7594052633561165}()
+
+  W₁Default_arch(_) = StaticFloat64{0.05846951331683783}()
+  W₂Default_arch(_) = StaticFloat64{0.16070447575367697}()
+  R₁Default_arch(_) = StaticFloat64{0.5370318382263098}()
+  R₂Default_arch(_) = StaticFloat64{0.5584398748982029}()
+
+  W₁Default(::False) = W₁Default_arch(VectorizationBase.cpu_name())
+  W₂Default(::False) = W₂Default_arch(VectorizationBase.cpu_name())
+  R₁Default(::False) = R₁Default_arch(VectorizationBase.cpu_name())
+  R₂Default(::False) = R₂Default_arch(VectorizationBase.cpu_name())
+
+  W₁Default() = W₁Default(has_feature(Val(:x86_64_avx512f)))
+  W₂Default() = W₂Default(has_feature(Val(:x86_64_avx512f)))
+  R₁Default() = R₁Default(has_feature(Val(:x86_64_avx512f)))
+  R₂Default() = R₂Default(has_feature(Val(:x86_64_avx512f)))
+
 end
 
 # @static if Sys.ARCH === :x86_64 || Sys.ARCH === :i686
@@ -77,7 +78,8 @@ first_cache_size() = _first_cache_size(cache_size(first_cache()))
 
 _second_cache_size(scs::StaticInt, ::True) = scs - cache_size(first_cache())
 _second_cache_size(scs::StaticInt, ::False) = scs
-@static if (Sys.isapple() || occursin("apple", Sys.CPU_NAME::String)) && Sys.ARCH === :aarch64
+@static if (Sys.isapple() || occursin("apple", Sys.CPU_NAME::String)) &&
+           Sys.ARCH === :aarch64
   _second_cache_size(::StaticInt{0}, ::False) = StaticInt(100663296)
 else
   _second_cache_size(::StaticInt{0}, ::False) = StaticInt(3145728)