Showcase example of using LazyLibrary in shipped JLLs

This converts the following JLLs to LazyLibrary APIs:

* LibCURL_jll
* LibSSH2_jll
* MbedTLS_jll
* OpenBLAS_jll
* libblastrampoline_jll
* nghttp2_jll

It also introduces a new precompilation statement for a basic matrix
multiplciation to ensure that TTFMM (time to first matmul) remains
excellent.

Author: staticfloat

contrib/generate_precompile.jl

@@ -88,6 +88,7 @@ f(x) = x03
 f(1,2)
 [][1]
 cd("complet_path\t\t$CTRL_C
+randn(10, 10) * randn(10, 10)
 """
 
 precompile_script = """

pkgimage.mk

@@ -81,11 +81,11 @@ $(eval $(call pkgimg_builder,GMP_jll,Artifacts Libdl))
 $(eval $(call pkgimg_builder,LLVMLibUnwind_jll,Artifacts Libdl))
 $(eval $(call pkgimg_builder,LibUV_jll,Artifacts Libdl))
 $(eval $(call pkgimg_builder,LibUnwind_jll,Artifacts Libdl))
-$(eval $(call pkgimg_builder,MbedTLS_jll,Artifacts Libdl))
-$(eval $(call pkgimg_builder,nghttp2_jll,Artifacts Libdl))
+$(eval $(call sysimg_builder,MbedTLS_jll,Artifacts Libdl))
+$(eval $(call sysimg_builder,nghttp2_jll,Artifacts Libdl))
 $(eval $(call pkgimg_builder,OpenLibm_jll,Artifacts Libdl))
 $(eval $(call pkgimg_builder,PCRE2_jll,Artifacts Libdl))
-$(eval $(call pkgimg_builder,Zlib_jll,Artifacts Libdl))
+$(eval $(call sysimg_builder,Zlib_jll,Artifacts Libdl))
 $(eval $(call pkgimg_builder,dSFMT_jll,Artifacts Libdl))
 $(eval $(call pkgimg_builder,libLLVM_jll,Artifacts Libdl))
 $(eval $(call sysimg_builder,libblastrampoline_jll,Artifacts Libdl))
@@ -98,7 +98,7 @@ $(eval $(call pkgimg_builder,DelimitedFiles,Mmap))
 
 # 2-depth packages
 $(eval $(call pkgimg_builder,LLD_jll,Zlib_jll libLLVM_jll Artifacts Libdl))
-$(eval $(call pkgimg_builder,LibSSH2_jll,Artifacts Libdl MbedTLS_jll))
+$(eval $(call sysimg_builder,LibSSH2_jll,Artifacts Libdl MbedTLS_jll))
 $(eval $(call pkgimg_builder,MPFR_jll,Artifacts Libdl GMP_jll))
 $(eval $(call sysimg_builder,LinearAlgebra,Libdl libblastrampoline_jll OpenBLAS_jll))
 $(eval $(call sysimg_builder,Dates,Printf))
@@ -110,7 +110,7 @@ $(eval $(call sysimg_builder,UUIDs,Random SHA))
 
  # 3-depth packages
  # LibGit2_jll
-$(eval $(call pkgimg_builder,LibCURL_jll,LibSSH2_jll nghttp2_jll MbedTLS_jll Zlib_jll Artifacts Libdl))
+$(eval $(call sysimg_builder,LibCURL_jll,LibSSH2_jll nghttp2_jll MbedTLS_jll Zlib_jll Artifacts Libdl))
 $(eval $(call sysimg_builder,REPL,InteractiveUtils Markdown Sockets Unicode))
 $(eval $(call pkgimg_builder,SharedArrays,Distributed Mmap Random Serialization))
 $(eval $(call sysimg_builder,TOML,Dates))

stdlib/LibCURL_jll/src/LibCURL_jll.jl

@@ -3,44 +3,21 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/LibCURL_jll.jl
 
 baremodule LibCURL_jll
-using Base, Libdl, nghttp2_jll
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
-
-const PATH_list = String[]
-const LIBPATH_list = String[]
-
+using Base, Libdl, nghttp2_jll, LibSSH2_jll
 export libcurl
 
-# These get calculated in __init__()
-const PATH = Ref("")
-const LIBPATH = Ref("")
-artifact_dir::String = ""
-libcurl_handle::Ptr{Cvoid} = C_NULL
-libcurl_path::String = ""
-
 if Sys.iswindows()
-    const libcurl = "libcurl-4.dll"
+    const libcurl_name = "bin/libcurl-4.dll"
 elseif Sys.isapple()
-    const libcurl = "@rpath/libcurl.4.dylib"
+    const libcurl_name = "lib/libcurl.4.dylib"
 else
-    const libcurl = "libcurl.so.4"
-end
-
-function __init__()
-    global libcurl_handle = dlopen(libcurl)
-    global libcurl_path = dlpath(libcurl_handle)
-    global artifact_dir = dirname(Sys.BINDIR)
-    LIBPATH[] = dirname(libcurl_path)
-    push!(LIBPATH_list, LIBPATH[])
+    const libcurl_name = "lib/libcurl.so.4"
 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_libcurl_path() = libcurl_path
+const libcurl_path = BundledLazyLibraryPath(libcurl_name)
+const libcurl = LazyLibrary(libcurl_path; dependencies=[libssh2, libnghttp2],
+                            on_load_callback = () -> begin
+                                @assert ccall(dlsym(libcurl, :curl_global_init), UInt32, (Clong,), 0x03) == 0
+                            end) # eventually add libz
 
 end  # module LibCURL_jll

stdlib/LibSSH2_jll/src/LibSSH2_jll.jl

@@ -4,44 +4,17 @@
 
 baremodule LibSSH2_jll
 using Base, Libdl, MbedTLS_jll
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
-
-const PATH_list = String[]
-const LIBPATH_list = String[]
-
 export libssh2
 
-# These get calculated in __init__()
-const PATH = Ref("")
-const LIBPATH = Ref("")
-artifact_dir::String = ""
-libssh2_handle::Ptr{Cvoid} = C_NULL
-libssh2_path::String = ""
-
 if Sys.iswindows()
-    const libssh2 = "libssh2.dll"
+    const libssh2_name = "bin/libssh2.dll"
 elseif Sys.isapple()
-    const libssh2 = "@rpath/libssh2.1.dylib"
+    const libssh2_name = "lib/libssh2.1.dylib"
 else
-    const libssh2 = "libssh2.so.1"
+    const libssh2_name = "lib/libssh2.so.1"
 end
 
-function __init__()
-    global libssh2_handle = dlopen(libssh2)
-    global libssh2_path = dlpath(libssh2_handle)
-    global artifact_dir = dirname(Sys.BINDIR)
-    LIBPATH[] = dirname(libssh2_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_libssh2_path() = libssh2_path
+const libssh2_path = BundledLazyLibraryPath(libssh2_name)
+const libssh2 = LazyLibrary(libssh2_path; dependencies=[libmbedx509, libmbedcrypto, libmbedtls])
 
 end  # module LibSSH2_jll

stdlib/LinearAlgebra/src/LinearAlgebra.jl

@@ -676,24 +676,29 @@ function versioninfo(io::IO=stdout)
     return nothing
 end
 
-function __init__()
-    try
-        BLAS.lbt_forward(OpenBLAS_jll.libopenblas_path; clear=true)
-        BLAS.check()
-    catch ex
-        Base.showerror_nostdio(ex, "WARNING: Error during initialization of module LinearAlgebra")
-    end
+
+function lbt_onload_callback()
+    # We don't use `BLAS.lbt_forward()` here because we explicitly don't
+    # want to take a lock on the config cache.
+    ccall(Libdl.dlsym(libblastrampoline, :lbt_forward), Int32, (Cstring, Int32, Int32, Cstring),
+           OpenBLAS_jll.libopenblas_path, 1, 0, C_NULL)
+
     # register a hook to disable BLAS threading
     Base.at_disable_library_threading(() -> BLAS.set_num_threads(1))
 
     # https://github.com/xianyi/OpenBLAS/blob/c43ec53bdd00d9423fc609d7b7ecb35e7bf41b85/README.md#setting-the-number-of-threads-using-environment-variables
     if !haskey(ENV, "OPENBLAS_NUM_THREADS") && !haskey(ENV, "GOTO_NUM_THREADS") && !haskey(ENV, "OMP_NUM_THREADS")
         @static if Sys.isapple() && Base.BinaryPlatforms.arch(Base.BinaryPlatforms.HostPlatform()) == "aarch64"
-            BLAS.set_num_threads(max(1, Sys.CPU_THREADS))
+            nthreads = max(1, Sys.CPU_THREADS)
         else
-            BLAS.set_num_threads(max(1, Sys.CPU_THREADS ÷ 2))
+            nthreads = max(1, Sys.CPU_THREADS ÷ 2)
         end
+        ccall(Libdl.dlsym(libblastrampoline, :lbt_set_num_threads), Cvoid, (Int32,), nthreads)
     end
 end
 
+# Force `libblastrampoline` to forward to `libopenblas` once it's loaded
+Libdl.add_dependency!(libblastrampoline, libopenblas)
+push!(libblastrampoline_jll.on_load_callbacks, lbt_onload_callback)
+
 end # module LinearAlgebra

stdlib/MbedTLS_jll/src/MbedTLS_jll.jl

@@ -4,59 +4,29 @@
 
 baremodule MbedTLS_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
-
-const PATH_list = String[]
-const LIBPATH_list = String[]
-
 export libmbedcrypto, libmbedtls, libmbedx509
 
-# These get calculated in __init__()
-const PATH = Ref("")
-const LIBPATH = Ref("")
-artifact_dir::String = ""
-libmbedcrypto_handle::Ptr{Cvoid} = C_NULL
-libmbedcrypto_path::String = ""
-libmbedtls_handle::Ptr{Cvoid} = C_NULL
-libmbedtls_path::String = ""
-libmbedx509_handle::Ptr{Cvoid} = C_NULL
-libmbedx509_path::String = ""
-
 if Sys.iswindows()
-    const libmbedcrypto = "libmbedcrypto.dll"
-    const libmbedtls = "libmbedtls.dll"
-    const libmbedx509 = "libmbedx509.dll"
+    const libmbedcrypto_name = "bin/libmbedcrypto.dll"
+    const libmbedx509_name = "bin/libmbedx509.dll"
+    const libmbedtls_name = "bin/libmbedtls.dll"
 elseif Sys.isapple()
-    const libmbedcrypto = "@rpath/libmbedcrypto.7.dylib"
-    const libmbedtls = "@rpath/libmbedtls.14.dylib"
-    const libmbedx509 = "@rpath/libmbedx509.1.dylib"
+    const libmbedcrypto_name = "lib/libmbedcrypto.7.dylib"
+    const libmbedx509_name = "lib/libmbedx509.1.dylib"
+    const libmbedtls_name = "lib/libmbedtls.14.dylib"
 else
-    const libmbedcrypto = "libmbedcrypto.so.7"
-    const libmbedtls = "libmbedtls.so.14"
-    const libmbedx509 = "libmbedx509.so.1"
+    const libmbedcrypto_name = "lib/libmbedcrypto.so.7"
+    const libmbedx509_name = "lib/libmbedx509.so.1"
+    const libmbedtls_name = "lib/libmbedtls.so.14"
 end
 
-function __init__()
-    global libmbedcrypto_handle = dlopen(libmbedcrypto)
-    global libmbedcrypto_path = dlpath(libmbedcrypto_handle)
-    global libmbedtls_handle = dlopen(libmbedtls)
-    global libmbedtls_path = dlpath(libmbedtls_handle)
-    global libmbedx509_handle = dlopen(libmbedx509)
-    global libmbedx509_path = dlpath(libmbedx509_handle)
-    global artifact_dir = dirname(Sys.BINDIR)
-    LIBPATH[] = dirname(libmbedtls_path)
-    push!(LIBPATH_list, LIBPATH[])
-end
+const libmbedcrypto_path = BundledLazyLibraryPath(libmbedcrypto_name)
+const libmbedtls_path = BundledLazyLibraryPath(libmbedtls_name)
+const libmbedx509_path = BundledLazyLibraryPath(libmbedx509_name)
 
-# 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_libmbedcrypto_path() =libmbedcrypto_path
-get_libmbedtls_path() = libmbedtls_path
-get_libmbedx509_path() = libmbedx509_path
+const libmbedcrypto = LazyLibrary(libmbedcrypto_path)
+const libmbedx509 = LazyLibrary(libmbedx509_path; dependencies=[libmbedcrypto])
+libmbedtls_stack = Any[]
+const libmbedtls = LazyLibrary(libmbedtls_path; dependencies=[libmbedcrypto, libmbedx509], on_load_callback = () -> push!(libmbedtls_stack, stacktrace()))
 
 end  # module MbedTLS_jll

stdlib/OpenBLAS_jll/src/OpenBLAS_jll.jl

@@ -3,47 +3,31 @@
 ## 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
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
-
-const PATH_list = String[]
-const LIBPATH_list = String[]
-
 export libopenblas
 
-# These get calculated in __init__()
-const PATH = Ref("")
-const LIBPATH = Ref("")
-artifact_dir::String = ""
-libopenblas_handle::Ptr{Cvoid} = C_NULL
-libopenblas_path::String = ""
-
 if Base.USE_BLAS64
     const libsuffix = "64_"
 else
     const libsuffix = ""
 end
 
 if Sys.iswindows()
-    const libopenblas = "libopenblas$(libsuffix).dll"
-    const _libgfortran = string("libgfortran-", libgfortran_version(HostPlatform()).major, ".dll")
+    const libopenblas_name = "bin/libopenblas$(libsuffix).dll"
+    const libgfortran_name = string("libgfortran-", libgfortran_version(HostPlatform()).major, ".dll")
 elseif Sys.isapple()
-    const libopenblas = "@rpath/libopenblas$(libsuffix).dylib"
-    const _libgfortran = string("@rpath/", "libgfortran.", libgfortran_version(HostPlatform()).major, ".dylib")
+    const libopenblas_name = "lib/libopenblas$(libsuffix).dylib"
+    const libgfortran_name = string("lib/libgfortran.", libgfortran_version(HostPlatform()).major, ".dylib")
 else
-    const libopenblas = "libopenblas$(libsuffix).so"
-    const _libgfortran = string("libgfortran.so.", libgfortran_version(HostPlatform()).major)
+    const libopenblas_name = "lib/libopenblas$(libsuffix).so"
+    const libgfortran_name = string("lib/libgfortran.so.", libgfortran_version(HostPlatform()).major)
 end
 
+const libgfortran_path = BundledLazyLibraryPath(libgfortran_name)
+const libgfortran = LazyLibrary(libgfortran_path)
+
+const libopenblas_path = BundledLazyLibraryPath(libopenblas_name)
+const libopenblas = LazyLibrary(libopenblas_path; dependencies=[libgfortran])
+
 function __init__()
     # make sure OpenBLAS does not set CPU affinity (#1070, #9639)
     if !haskey(ENV, "OPENBLAS_MAIN_FREE")
@@ -62,25 +46,6 @@ function __init__()
         # 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 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