Initial implementation of lazy JLLs for LinearAlgebra (#57719)

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.

[0] JuliaLang/LinearAlgebra.jl#1235

Author: staticfloat

base/Base.jl

@@ -213,9 +213,6 @@ using .PermutedDimsArrays
 include("sort.jl")
 using .Sort
 
-# BinaryPlatforms, used by Artifacts.  Needs `Sort`.
-include("binaryplatforms.jl")
-
 # Fast math
 include("fastmath.jl")
 using .FastMath
@@ -269,6 +266,9 @@ include("linking.jl")
 include("staticdata.jl")
 include("loading.jl")
 
+# BinaryPlatforms, used by Artifacts.  Needs `Sort`.
+include("binaryplatforms.jl")
+
 # misc useful functions & macros
 include("timing.jl")
 include("client.jl")

base/binaryplatforms.jl

@@ -841,20 +841,48 @@ function parse_dl_name_version(path::AbstractString, os::AbstractString)
     return parse_dl_name_version(string(path)::String, string(os)::String)
 end
 
+function get_csl_member(member::Symbol)
+    # If CompilerSupportLibraries_jll is an stdlib, we can just grab things from it
+    csl_pkgids = filter(pkgid -> pkgid.name == "CompilerSupportLibraries_jll", keys(Base.loaded_modules))
+    if !isempty(csl_pkgids)
+        CSL_mod = Base.loaded_modules[first(csl_pkgids)]
+
+        # This can fail during bootstrap, so we skip in that case.
+        if isdefined(CSL_mod, member)
+            return getproperty(CSL_mod, member)
+        end
+    end
+
+    return nothing
+end
+
 """
     detect_libgfortran_version()
 
 Inspects the current Julia process to determine the libgfortran version this Julia is
-linked against (if any).
+linked against (if any).  Returns `nothing` if no libgfortran version dependence is
+detected.
 """
 function detect_libgfortran_version()
-    libgfortran_paths = filter!(x -> occursin("libgfortran", x), Libdl.dllist())
-    if isempty(libgfortran_paths)
+    function get_libgfortran_path()
+        # If CompilerSupportLibraries_jll is an stdlib, we can just directly ask for
+        # the path here, without checking `dllist()`:
+        libgfortran_path = get_csl_member(:libgfortran_path)
+        if libgfortran_path !== nothing
+            return libgfortran_path::String
+        end
+
+        # Otherwise, look for it having already been loaded by something
+        libgfortran_paths = filter!(x -> occursin("libgfortran", x), Libdl.dllist())
+        if !isempty(libgfortran_paths)
+            return first(libgfortran_paths)::String
+        end
+
         # One day, I hope to not be linking against libgfortran in base Julia
         return nothing
     end
-    libgfortran_path = first(libgfortran_paths)
 
+    libgfortran_path = get_libgfortran_path()
     name, version = parse_dl_name_version(libgfortran_path, os())
     if version === nothing
         # Even though we complain about this, we allow it to continue in the hopes that
@@ -878,24 +906,37 @@ it is linked against (if any).  `max_minor_version` is the latest version in the
 3.4 series of GLIBCXX where the search is performed.
 """
 function detect_libstdcxx_version(max_minor_version::Int=30)
-    libstdcxx_paths = filter!(x -> occursin("libstdc++", x), Libdl.dllist())
-    if isempty(libstdcxx_paths)
-        # This can happen if we were built by clang, so we don't link against
-        # libstdc++ at all.
+    function get_libstdcxx_handle()
+        # If CompilerSupportLibraries_jll is an stdlib, we can just directly open it
+        libstdcxx = get_csl_member(:libstdcxx)
+        if libstdcxx !== nothing
+            return nothing
+        end
+
+        # Otherwise, look for it having already been loaded by something
+        libstdcxx_paths = filter!(x -> occursin("libstdc++", x), Libdl.dllist())
+        if !isempty(libstdcxx_paths)
+            return Libdl.dlopen(first(libstdcxx_paths), Libdl.RTLD_NOLOAD)::Ptr{Cvoid}
+        end
+
+        # One day, I hope to not be linking against libgfortran in base Julia
         return nothing
     end
 
     # Brute-force our way through GLIBCXX_* symbols to discover which version we're linked against
-    hdl = Libdl.dlopen(first(libstdcxx_paths))::Ptr{Cvoid}
-    # Try all GLIBCXX versions down to GCC v4.8:
-    # https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html
-    for minor_version in max_minor_version:-1:18
-        if Libdl.dlsym(hdl, "GLIBCXX_3.4.$(minor_version)"; throw_error=false) !== nothing
-            Libdl.dlclose(hdl)
-            return VersionNumber("3.4.$(minor_version)")
+    libstdcxx = get_libstdcxx_handle()
+
+    if libstdcxx !== nothing
+        # Try all GLIBCXX versions down to GCC v4.8:
+        # https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html
+        for minor_version in max_minor_version:-1:18
+            if Libdl.dlsym(libstdcxx, "GLIBCXX_3.4.$(minor_version)"; throw_error=false) !== nothing
+                Libdl.dlclose(libstdcxx)
+                return VersionNumber("3.4.$(minor_version)")
+            end
         end
     end
-    Libdl.dlclose(hdl)
+    Libdl.dlclose(libstdcxx)
     return nothing
 end
 

base/libdl.jl

@@ -333,14 +333,17 @@ struct LazyLibraryPath
     pieces::Tuple{Vararg{Any}}
     LazyLibraryPath(pieces...) = new(pieces)
 end
-Base.string(llp::LazyLibraryPath) = joinpath(String[string(p) for p in llp.pieces])
+@inline Base.string(llp::LazyLibraryPath) = joinpath(String[string(p) for p in llp.pieces])
 Base.cconvert(::Type{Cstring}, llp::LazyLibraryPath) = Base.cconvert(Cstring, string(llp))
 # Define `print` so that we can wrap this in a `LazyString`
 Base.print(io::IO, llp::LazyLibraryPath) = print(io, string(llp))
 
-# Helper to get `Sys.BINDIR` at runtime
-struct SysBindirGetter; end
-Base.string(::SysBindirGetter) = dirname(Sys.BINDIR)
+# Helper to get `$(private_shlibdir)` at runtime
+struct PrivateShlibdirGetter; end
+const private_shlibdir = Base.OncePerProcess{String}() do
+    dirname(dlpath("libjulia-internal"))
+end
+Base.string(::PrivateShlibdirGetter) = private_shlibdir()
 
 """
     BundledLazyLibraryPath
@@ -349,10 +352,10 @@ Helper type for lazily constructed library paths that are stored within the
 bundled Julia distribution, primarily for use by Base modules.
 
 ```
-libfoo = LazyLibrary(BundledLazyLibraryPath("lib/libfoo.so.1.2.3"))
+libfoo = LazyLibrary(BundledLazyLibraryPath("libfoo.so.1.2.3"))
 ```
 """
-BundledLazyLibraryPath(subpath) = LazyLibraryPath(SysBindirGetter(), subpath)
+BundledLazyLibraryPath(subpath) = LazyLibraryPath(PrivateShlibdirGetter(), subpath)
 
 
 """

deps/checksums/LinearAlgebra-1ce842652c07b33289046236b09bc59bad43dbeb.tar.gz/md5

@@ -0,0 +1 @@
+33933c31906af2086702d38b9d8eb90b

deps/checksums/LinearAlgebra-1ce842652c07b33289046236b09bc59bad43dbeb.tar.gz/sha512

@@ -0,0 +1 @@
+3783b8c3a46c4db5cf750a99c6753e1bf377b2d979a85df8e26c81f41cb3c75a41c28a487fce332e19ba8287c2531d440b248a6f5aedc93e8fa6673d60456c33

deps/checksums/LinearAlgebra-f781708fffbd7e74ff17686c334ddd4f22d75a2c.tar.gz/md5

@@ -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("libatomic-1.dll")
+    const _libquadmath_path = BundledLazyLibraryPath("libquadmath-0.dll")
     if arch(HostPlatform()) == "x86_64"
-        const libgcc_s = "libgcc_s_seh-1.dll"
+        const _libgcc_s_path = BundledLazyLibraryPath("libgcc_s_seh-1.dll")
     else
-        const libgcc_s = "libgcc_s_sjlj-1.dll"
+        const _libgcc_s_path = BundledLazyLibraryPath("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("libgfortran-", libgfortran_version(HostPlatform()).major, ".dll"))
+    const _libstdcxx_path = BundledLazyLibraryPath("libstdc++-6.dll")
+    const _libgomp_path = BundledLazyLibraryPath("libgomp-1.dll")
+    const _libssp_path = BundledLazyLibraryPath("libssp-0.dll")
 elseif Sys.isapple()
+    const _libatomic_path = BundledLazyLibraryPath("libatomic.1.dylib")
+    const _libquadmath_path = BundledLazyLibraryPath("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("libgcc_s.1.1.dylib")
     else
-        const libgcc_s = "@rpath/libgcc_s.1.dylib"
+        const _libgcc_s_path = BundledLazyLibraryPath("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("libgfortran.", libgfortran_version(HostPlatform()).major, ".dylib"))
+    const _libstdcxx_path = BundledLazyLibraryPath("libstdc++.6.dylib")
+    const _libgomp_path = BundledLazyLibraryPath("libgomp.1.dylib")
+    const _libssp_path = BundledLazyLibraryPath("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("libatomic.so.1")
+    end
+    const _libgcc_s_path = BundledLazyLibraryPath("libgcc_s.so.1")
+    const _libgfortran_path = BundledLazyLibraryPath(string("libgfortran.so.", libgfortran_version(HostPlatform()).major))
+    const _libstdcxx_path = BundledLazyLibraryPath("libstdc++.so.6")
+    const _libgomp_path = BundledLazyLibraryPath("libgomp.so.1")
     if libc(HostPlatform()) != "musl"
-        const libssp = "libssp.so.0"
+        const _libssp_path = BundledLazyLibraryPath("libssp.so.0")
+    end
+    if arch(HostPlatform()) ∈ ("x86_64", "i686")
+        const _libquadmath_path = BundledLazyLibraryPath("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

deps/checksums/LinearAlgebra-f781708fffbd7e74ff17686c334ddd4f22d75a2c.tar.gz/sha512

@@ -1,4 +1,4 @@
 LINEARALGEBRA_BRANCH = master
-LINEARALGEBRA_SHA1 = f781708fffbd7e74ff17686c334ddd4f22d75a2c
+LINEARALGEBRA_SHA1 = 1ce842652c07b33289046236b09bc59bad43dbeb
 LINEARALGEBRA_GIT_URL := https://github.com/JuliaLang/LinearAlgebra.jl.git
 LINEARALGEBRA_TAR_URL = https://api.github.com/repos/JuliaLang/LinearAlgebra.jl/tarball/$1