Initial implementation of lazy JLLs for LinearAlgebra

This alters CompilerSupportLibraries_jll, OpenBLAS_jll and
libblastrampoline_jll to use `LazyLibrary` objects and thereby be loaded
only upon first `dlopen()` or `ccall()` to the individual library
objects.  Note that this is one of the more complicated cases, as
`libblastrampoline` must have OpenBLAS_jll added as a dynamic dependency
(as it does not actually have it listed in its shared object headers)
and also has some on-load callbacks that must be invoked.

Long-term, I would like to replace the bespoke JLLs here with actual JLL
source code, and vendor a version of `LazyJLLWrappers` in-tree to do the
actual code generation even for Base.  That is left as future work.

This must be paired with the appropriate `LinearAlgebra.jl` changes [0].

[0] JuliaLang/LinearAlgebra.jl#1235

Author: staticfloat

stdlib/CompilerSupportLibraries_jll/src/CompilerSupportLibraries_jll.jl

@@ -5,80 +5,108 @@
 baremodule CompilerSupportLibraries_jll
 using Base, Libdl, Base.BinaryPlatforms
 
-const PATH_list = String[]
-const LIBPATH_list = String[]
-
-export libgfortran, libstdcxx, libgomp
+export libgfortran, libstdcxx, libgomp, libatomic, libgcc_s
 
 # These get calculated in __init__()
-const PATH = Ref("")
 const LIBPATH = Ref("")
+const LIBPATH_list = String[]
 artifact_dir::String = ""
-libgcc_s_handle::Ptr{Cvoid} = C_NULL
 libgcc_s_path::String = ""
-libgfortran_handle::Ptr{Cvoid} = C_NULL
 libgfortran_path::String = ""
-libstdcxx_handle::Ptr{Cvoid} = C_NULL
 libstdcxx_path::String = ""
-libgomp_handle::Ptr{Cvoid} = C_NULL
 libgomp_path::String = ""
 
 if Sys.iswindows()
+    const _libatomic_path = BundledLazyLibraryPath("bin\\libatomic-1.dll")
+    const _libquadmath_path = BundledLazyLibraryPath("bin\\libquadmath-0.dll")
     if arch(HostPlatform()) == "x86_64"
-        const libgcc_s = "libgcc_s_seh-1.dll"
+        const _libgcc_s_path = BundledLazyLibraryPath("bin\\libgcc_s_seh-1.dll")
     else
-        const libgcc_s = "libgcc_s_sjlj-1.dll"
+        const _libgcc_s_path = BundledLazyLibraryPath("bin\\libgcc_s_sjlj-1.dll")
     end
-    const libgfortran = string("libgfortran-", libgfortran_version(HostPlatform()).major, ".dll")
-    const libstdcxx = "libstdc++-6.dll"
-    const libgomp = "libgomp-1.dll"
-    const libssp = "libssp-0.dll"
+    const _libgfortran_path = BundledLazyLibraryPath(string("bin\\libgfortran-", libgfortran_version(HostPlatform()).major, ".dll"))
+    const _libstdcxx_path = BundledLazyLibraryPath("bin\\libstdc++-6.dll")
+    const _libgomp_path = BundledLazyLibraryPath("bin\\libgomp-1.dll")
+    const _libssp_path = BundledLazyLibraryPath("bin\\libssp-0.dll")
 elseif Sys.isapple()
+    const _libatomic_path = BundledLazyLibraryPath("lib/libatomic.1.dylib")
+    const _libquadmath_path = BundledLazyLibraryPath("lib/libquadmath.0.dylib")
     if arch(HostPlatform()) == "aarch64" || libgfortran_version(HostPlatform()) == v"5"
-        const libgcc_s = "@rpath/libgcc_s.1.1.dylib"
+        const _libgcc_s_path = BundledLazyLibraryPath("lib/libgcc_s.1.1.dylib")
     else
-        const libgcc_s = "@rpath/libgcc_s.1.dylib"
+        const _libgcc_s_path = BundledLazyLibraryPath("lib/libgcc_s.1.dylib")
     end
-    const libgfortran = string("@rpath/", "libgfortran.", libgfortran_version(HostPlatform()).major, ".dylib")
-    const libstdcxx = "@rpath/libstdc++.6.dylib"
-    const libgomp = "@rpath/libgomp.1.dylib"
-    const libssp = "@rpath/libssp.0.dylib"
+    const _libgfortran_path = BundledLazyLibraryPath(string("lib/libgfortran.", libgfortran_version(HostPlatform()).major, ".dylib"))
+    const _libstdcxx_path = BundledLazyLibraryPath("lib/libstdc++.6.dylib")
+    const _libgomp_path = BundledLazyLibraryPath("lib/libgomp.1.dylib")
+    const _libssp_path = BundledLazyLibraryPath("lib/libssp.0.dylib")
 else
-    const libgcc_s = "libgcc_s.so.1"
-    const libgfortran = string("libgfortran.so.", libgfortran_version(HostPlatform()).major)
-    const libstdcxx = "libstdc++.so.6"
-    const libgomp = "libgomp.so.1"
+    if !Sys.isfreebsd()    
+        const _libatomic_path = BundledLazyLibraryPath("lib/libatomic.so.1")
+    end
+    const _libgcc_s_path = BundledLazyLibraryPath("lib/libgcc_s.so.1")
+    const _libgfortran_path = BundledLazyLibraryPath(string("lib/libgfortran.so.", libgfortran_version(HostPlatform()).major))
+    const _libstdcxx_path = BundledLazyLibraryPath("lib/libstdc++.so.6")
+    const _libgomp_path = BundledLazyLibraryPath("lib/libgomp.so.1")
     if libc(HostPlatform()) != "musl"
-        const libssp = "libssp.so.0"
+        const _libssp_path = BundledLazyLibraryPath("lib/libssp.so.0")
+    end
+    if arch(HostPlatform()) ∈ ("x86_64", "i686")
+        const _libquadmath_path = BundledLazyLibraryPath("lib/libquadmath.so.0")
     end
 end
 
+if @isdefined(_libatomic_path)
+    const libatomic = LazyLibrary(_libatomic_path)
+end
+const libgcc_s = LazyLibrary(_libgcc_s_path)
+libgfortran_deps = [libgcc_s]
+if @isdefined _libquadmath_path
+    const libquadmath = LazyLibrary(_libquadmath_path)
+    push!(libgfortran_deps, libquadmath)
+end
+const libgfortran = LazyLibrary(_libgfortran_path, dependencies=libgfortran_deps)
+const libstdcxx = LazyLibrary(_libstdcxx_path, dependencies=[libgcc_s])
+const libgomp = LazyLibrary(_libgomp_path)
+if @isdefined _libssp_path
+    const libssp = LazyLibrary(_libssp_path)
+end
+
+# Conform to LazyJLLWrappers API
+function eager_mode()
+    if @isdefined(libatomic)
+        dlopen(libatomic)
+    end
+    dlopen(libgcc_s)
+    dlopen(libgomp)
+    if @isdefined libquadmath
+        dlopen(libquadmath)
+    end
+    if @isdefined libssp
+        dlopen(libssp)
+    end
+    dlopen(libgfortran)
+    dlopen(libstdcxx)
+end
+is_available() = true
+
 function __init__()
-    global libgcc_s_handle = dlopen(libgcc_s)
-    global libgcc_s_path = dlpath(libgcc_s_handle)
-    global libgfortran_handle = dlopen(libgfortran)
-    global libgfortran_path = dlpath(libgfortran_handle)
-    global libstdcxx_handle = dlopen(libstdcxx)
-    global libstdcxx_path = dlpath(libstdcxx_handle)
-    global libgomp_handle = dlopen(libgomp)
-    global libgomp_path = dlpath(libgomp_handle)
-    @static if libc(HostPlatform()) != "musl"
-        dlopen(libssp; throw_error = false)
+    if @isdefined _libatomic_path
+        global libatomic_path = string(_libatomic_path)
     end
+    global libgcc_s_path = string(_libgcc_s_path)
+    global libgomp_path = string(_libgomp_path)
+    if @isdefined _libquadmath_path
+        global libquadmath_path = string(_libquadmath_path)
+    end
+    if @isdefined _libssp_path
+        global libssp_path = string(_libssp_path)
+    end
+    global libgfortran_path = string(_libgfortran_path)
+    global libstdcxx_path = string(_libstdcxx_path)
     global artifact_dir = dirname(Sys.BINDIR)
     LIBPATH[] = dirname(libgcc_s_path)
     push!(LIBPATH_list, LIBPATH[])
 end
 
-# JLLWrappers API compatibility shims.  Note that not all of these will really make sense.
-# For instance, `find_artifact_dir()` won't actually be the artifact directory, because
-# there isn't one.  It instead returns the overall Julia prefix.
-is_available() = true
-find_artifact_dir() = artifact_dir
-dev_jll() = error("stdlib JLLs cannot be dev'ed")
-best_wrapper = nothing
-get_libgfortran_path() = libgfortran_path
-get_libstdcxx_path() = libstdcxx_path
-get_libgomp_path() = libgomp_path
-
 end  # module CompilerSupportLibraries_jll

stdlib/OpenBLAS_jll/src/OpenBLAS_jll.jl

@@ -3,27 +3,17 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/OpenBLAS_jll.jl
 baremodule OpenBLAS_jll
 using Base, Libdl, Base.BinaryPlatforms
-
-# We are explicitly NOT loading this at runtime, as it contains `libgomp`
-# which conflicts with `libiomp5`, breaking things like MKL.  In the future,
-# we hope to transition to a JLL interface that provides a more granular
-# interface than eagerly dlopen'ing all libraries provided in the JLL
-# which will eliminate issues like this, where we avoid loading a JLL
-# because we don't want to load a library that we don't even use yet.
-# using CompilerSupportLibraries_jll
-# Because of this however, we have to manually load the libraries we
-# _do_ care about, namely libgfortran
+using CompilerSupportLibraries_jll
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
 
 export libopenblas
 
 # These get calculated in __init__()
-const PATH = Ref("")
 const LIBPATH = Ref("")
+const LIBPATH_list = String[]
 artifact_dir::String = ""
-libopenblas_handle::Ptr{Cvoid} = C_NULL
 libopenblas_path::String = ""
 
 if Base.USE_BLAS64
@@ -33,19 +23,25 @@ else
 end
 
 if Sys.iswindows()
-    const libopenblas = "libopenblas$(libsuffix).dll"
-    const _libgfortran = string("libgfortran-", libgfortran_version(HostPlatform()).major, ".dll")
+    const _libopenblas_path = BundledLazyLibraryPath(string("bin\\libopenblas", libsuffix, ".dll"))
 elseif Sys.isapple()
-    const libopenblas = "@rpath/libopenblas$(libsuffix).dylib"
-    const _libgfortran = string("@rpath/", "libgfortran.", libgfortran_version(HostPlatform()).major, ".dylib")
+    const _libopenblas_path = BundledLazyLibraryPath(string("lib/libopenblas", libsuffix, ".dylib"))
 else
-    const libopenblas = "libopenblas$(libsuffix).so"
-    const _libgfortran = string("libgfortran.so.", libgfortran_version(HostPlatform()).major)
+    const _libopenblas_path = BundledLazyLibraryPath(string("lib/libopenblas", libsuffix, ".so"))
+end
+const libopenblas = LazyLibrary(_libopenblas_path, dependencies=[libgfortran])
+
+# Conform to LazyJLLWrappers API
+function eager_mode()
+    CompilerSupportLibraries_jll.eager_mode()
+    dlopen(libopenblas_path)
 end
+is_available() = true
 
 function __init__()
+    global libopenblas_path = string(_libopenblas_path)
     # make sure OpenBLAS does not set CPU affinity (#1070, #9639)
-    if !haskey(ENV, "OPENBLAS_MAIN_FREE")
+    if !(haskey(ENV, "OPENBLAS_MAIN_FREE"))
         ENV["OPENBLAS_MAIN_FREE"] = "1"
     end
 
@@ -54,32 +50,16 @@ function __init__()
     # threads it thinks it needs to use.
     # X-ref: https://github.com/xianyi/OpenBLAS/blob/c43ec53bdd00d9423fc609d7b7ecb35e7bf41b85/README.md#setting-the-number-of-threads-using-environment-variables
     # X-ref: https://github.com/JuliaLang/julia/issues/45434
-    if !haskey(ENV, "OPENBLAS_NUM_THREADS") &&
-       !haskey(ENV, "GOTO_NUM_THREADS") &&
-       !haskey(ENV, "OMP_NUM_THREADS")
+    if !(haskey(ENV, "OPENBLAS_NUM_THREADS")) && (!(haskey(ENV, "GOTO_NUM_THREADS")) && !(haskey(ENV, "OMP_NUM_THREADS")))
         # We set this to `1` here, and then LinearAlgebra will update
         # to the true value in its `__init__()` function.
         ENV["OPENBLAS_DEFAULT_NUM_THREADS"] = "1"
     end
 
-    # As mentioned above, we are sneaking this in here so that we don't have to
-    # depend on CSL_jll and load _all_ of its libraries.
-    dlopen(_libgfortran)
-
-    global libopenblas_handle = dlopen(libopenblas)
-    global libopenblas_path = dlpath(libopenblas_handle)
+    global libopenblas_path = string(_libopenblas_path)
     global artifact_dir = dirname(Sys.BINDIR)
     LIBPATH[] = dirname(libopenblas_path)
     push!(LIBPATH_list, LIBPATH[])
 end
 
-# JLLWrappers API compatibility shims.  Note that not all of these will really make sense.
-# For instance, `find_artifact_dir()` won't actually be the artifact directory, because
-# there isn't one.  It instead returns the overall Julia prefix.
-is_available() = true
-find_artifact_dir() = artifact_dir
-dev_jll() = error("stdlib JLLs cannot be dev'ed")
-best_wrapper = nothing
-get_libopenblas_path() = libopenblas_path
-
 end  # module OpenBLAS_jll

stdlib/OpenBLAS_jll/test/runtests.jl

@@ -13,5 +13,5 @@ else
 end
 
 @testset "OpenBLAS_jll" begin
-    @test dlsym(OpenBLAS_jll.libopenblas_handle, @blasfunc(openblas_set_num_threads); throw_error=false) !== nothing
+    @test dlsym(OpenBLAS_jll.libopenblas, @blasfunc(openblas_set_num_threads); throw_error=false) !== nothing
 end

stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl

@@ -81,6 +81,8 @@ else
 end
 
 function __init__()
+    libblastrampoline_jll.eager_mode()
+
     # BSD-3-Clause
     global libamd_handle = dlopen(libamd)
     global libamd_path = dlpath(libamd_handle)

stdlib/libblastrampoline_jll/src/libblastrampoline_jll.jl

@@ -5,42 +5,55 @@
 baremodule libblastrampoline_jll
 using Base, Libdl
 
-const PATH_list = String[]
-const LIBPATH_list = String[]
-
 export libblastrampoline
 
 # These get calculated in __init__()
-const PATH = Ref("")
 const LIBPATH = Ref("")
+const LIBPATH_list = String[]
 artifact_dir::String = ""
-libblastrampoline_handle::Ptr{Cvoid} = C_NULL
 libblastrampoline_path::String = ""
 
+
+# Because LBT needs to have a weak-dependence on OpenBLAS (or any other BLAS)
+# we must manually construct a list of which modules and libraries we're going
+# to be using with it, as well as the on load callbacks they may or may not need.
+const on_load_callbacks::Vector{Function} = Function[]
+const eager_mode_modules::Vector{Module} = Module[]
+function libblastrampoline_on_load_callback()
+    for callback = on_load_callbacks
+        callback()
+    end
+end
+
+function add_dependency!(mod::Module, lib::LazyLibrary, on_load_callback::Function = () -> nothing)
+    Libdl.add_dependency!(libblastrampoline, lib)
+    push!(eager_mode_modules, mod)
+    push!(on_load_callbacks, on_load_callback)
+end
+
 # NOTE: keep in sync with `Base.libblas_name` and `Base.liblapack_name`.
-const libblastrampoline = if Sys.iswindows()
-    "libblastrampoline-5.dll"
+const _libblastrampoline_path = if Sys.iswindows()
+    BundledLazyLibraryPath("bin\\libblastrampoline-5.dll")
 elseif Sys.isapple()
-    "@rpath/libblastrampoline.5.dylib"
+    BundledLazyLibraryPath("lib/libblastrampoline.5.dylib")
 else
-    "libblastrampoline.so.5"
+    BundledLazyLibraryPath("lib/libblastrampoline.so.5")
+end
+const libblastrampoline = LazyLibrary(_libblastrampoline_path, dependencies=[],
+                                      on_load_callback=libblastrampoline_on_load_callback)
+
+function eager_mode()
+    for mod in eager_mode_modules
+        mod.eager_mode()
+    end
+    dlopen(libblastrampoline)
 end
+is_available() = true
 
 function __init__()
-    global libblastrampoline_handle = dlopen(libblastrampoline)
-    global libblastrampoline_path = dlpath(libblastrampoline_handle)
+    global libblastrampoline_path = string(_libblastrampoline_path)
     global artifact_dir = dirname(Sys.BINDIR)
     LIBPATH[] = dirname(libblastrampoline_path)
     push!(LIBPATH_list, LIBPATH[])
 end
-
-# JLLWrappers API compatibility shims.  Note that not all of these will really make sense.
-# For instance, `find_artifact_dir()` won't actually be the artifact directory, because
-# there isn't one.  It instead returns the overall Julia prefix.
-is_available() = true
-find_artifact_dir() = artifact_dir
-dev_jll() = error("stdlib JLLs cannot be dev'ed")
-best_wrapper = nothing
-get_libblastrampoline_path() = libblastrampoline_path
-
 end  # module libblastrampoline_jll

stdlib/libblastrampoline_jll/test/runtests.jl

@@ -3,5 +3,5 @@
 using Test, Libdl, libblastrampoline_jll
 
 @testset "libblastrampoline_jll" begin
-    @test isa(Libdl.dlsym(libblastrampoline_jll.libblastrampoline_handle, :dgemm_64_), Ptr{Nothing})
+    @test isa(Libdl.dlsym(libblastrampoline_jll.libblastrampoline, :dgemm_64_), Ptr{Nothing})
 end