`fastCholesky` is slower than `cholesky` with `StaticArrays`

[btmit]

Edit: I just found StaticArraysCoreExt which appears to try and cover this case. I'm not sure why this is so much slower. The StaticArraysCoreExt method also doesn't appear to check for near symmetry.

Edit: The reason fastcholesky(::Hermitian) is so much slower is because it always appears to dispatch to the PositiveFactorizations version of cholesky() even if this is unnecessary.

It seems like fastCholesky should fall through to the existing cholesky(::Hermitian{T,<:SMatrix}) implementation if the matrix is nearly symmetric.

There also appears to be some sort of dispatch bug with fastcholesky(::Hermitian{T,<:SMatrix)}).

using StaticArrays, BenchmarkTools, LinearAlgebra, FastCholesky

randPosDefs(n) = AbstractMatrix(Cholesky(LowerTriangular(rand(SMatrix{n,n}))))

function testCholesky(n)

    s = randPosDefs(n)
    m = Matrix(s)

    println("n = $n")
    print("cholesky(::Matrix)                     ") 
    @btime cholesky($m)
    print("fastcholesky(:Matrix)                  ") 
    @btime fastcholesky($m)
    print("cholesky(::SMatrix)                    ") 
    @btime cholesky($s)
    print("cholesky(::Hermitian{T,<:SMatrix)}     ") 
    @btime cholesky(Hermitian($s))
    print("fastcholesky(::SMatrix)                ") 
    @btime fastcholesky($s)
    print("fastcholesky(::Hermitian{T,<:SMatrix)})") 
    @btime fastcholesky(Hermitian($s))

    return nothing
end

n = 9
testCholesky(n)

# n = 9
# cholesky(::Matrix)                       659.377 ns (2 allocations: 720 bytes)
# fastcholesky(:Matrix)                    480.077 ns (2 allocations: 720 bytes)
# cholesky(::SMatrix)                      209.058 ns (0 allocations: 0 bytes)
# cholesky(::Hermitian{T,<:SMatrix)}       139.052 ns (0 allocations: 0 bytes)
# fastcholesky(::SMatrix)                  216.766 ns (0 allocations: 0 bytes)
# fastcholesky(::Hermitian{T,<:SMatrix)})  1.411 μs (6 allocations: 880 bytes)

n = 3
testCholesky(n)

# n = 3
# cholesky(::Matrix)                       237.731 ns (2 allocations: 144 bytes)
# fastcholesky(:Matrix)                    118.273 ns (2 allocations: 144 bytes)
# cholesky(::SMatrix)                      13.557 ns (0 allocations: 0 bytes)
# cholesky(::Hermitian{T,<:SMatrix)}       11.824 ns (0 allocations: 0 bytes)
# fastcholesky(::SMatrix)                  23.928 ns (0 allocations: 0 bytes)
# fastcholesky(::Hermitian{T,<:SMatrix)})  325.323 ns (6 allocations: 288 bytes)

[btmit]

The differene between cholesky(::SMatrix) and fastcholesky(::SMatrix) appears to just be the extra call to issuccess. It would be nice to be able to see the resulting speedup from tagging the input as Hermitian however.

[bvdmitri]

Thanks for checking this...this library was written quite a while ago and it was indeed faster back then, the things have changed though. Maybe we have a misleading name, I would maybe rename the library to a StableCholesky.jl since indeed we do more checks for near symmetricity and retry with PositiveFactorization.jl if we fail with a naive method.