Don't use cuda just because cuda is loaded

[hexaeder]

#733 introduced cuda offloading based on

LinearSolve.jl/src/LinearSolve.jl

Line 437 in 940ea1d

usecuda() = Base.get_extension(@__MODULE__, :LinearSolveCUDAExt) !== nothing

That is problematic, because it es possible to have CUDA in your env while cuda is not usable. I think is allways necessary to check `CUDA.functional() for that.

I recently started getting errors in CI because i have CUDA in my test env (filtering my testes based of CUDA.fuctional).

[hexaeder]

Not fixed unfortunately. Can you reopen this issue?

[hexaeder]

Hm i don't quite understand the codebase. But the problem seems to be the call in

LinearSolve.jl/src/default.jl

Lines 483 to 486 in f1bdc47

	init_cacheval($(algchoice_to_alg(alg)), A, b, u, Pl, Pr, maxiters, abstol,
	reltol,
	verbose,
	assump)

in @generated function init_cacheval(alg::DefaultLinearSolver,...) which will init the cache on all (?) default choices, which then tries to construct a CuVector

LinearSolve.jl/ext/LinearSolveCUDAExt.jl

Line 59 in f1bdc47

ipiv = CuVector{Int32}(undef, 0)

(which fails if CUDA not functional)

[ChrisRackauckas]

The sumtype formulation can be a bit odd, but it's making it so the same type and initialization is done for all possible choices, so that it's type-stable with respect to the choice criteria which is not known at compile time. One of the things that's done though is a fallback so that initializations are the right type but are effectively free. For example, KLU has a dispatch for initialization on non-sparse matrices to just return nothing. And for algorithms that can be called, they return 0x0 LU factorizations of the right type. This makes it so the type for a given A and b is always type-stable, regardless of which default solver is chosen.

[ChrisRackauckas]

The issue that you're running into is that https://github.com/SciML/LinearSolve.jl/blob/main/ext/LinearSolveCUDAExt.jl#L59 this initialization is called on your system because it's building the 0x0 LU, since it's possible for that algorithm to be called. If the extension isn't loaded, that initialization is just nothing, so it's type-stable in the world where without the extension it's always nothing and in the world where the extension is loaded it's always a CUDA LU type.

But you want to both load the extension but also not have CUDA available? In that case, it will always need to make the CUDA LU, and that will fail.

If usecuda() is known at compile time, you could do:

@static if usecoda()
    function LinearSolve.init_cacheval(alg::CudaOffloadLUFactorization, A::AbstractArray, b, u, Pl, Pr,
        maxiters::Int, abstol, reltol, verbose::Bool,
        assumptions::OperatorAssumptions)
    T = eltype(A)
    noUnitT = typeof(zero(T))
    luT = LinearAlgebra.lutype(noUnitT)
    ipiv = CuVector{Int32}(undef, 0)
    info = zero(LinearAlgebra.BlasInt)
    return LU{luT}(CuMatrix{Float64}(undef, 0, 0), ipiv, info)
end
else
function LinearSolve.init_cacheval(alg::CudaOffloadLUFactorization, A::AbstractArray, b, u, Pl, Pr,
        maxiters::Int, abstol, reltol, verbose::Bool,
        assumptions::OperatorAssumptions)
        nothing
end

so that way you get the nothing case?