Make FFTW relocatable for PackageCompiler

Because we need to know the FFTW vendor pretty early (at precompile
time to generate code, and at runtime) we need to load the path during
build (which bakes it into the precompile image), however we need to
update that path on next load within `__init__()` in case we're a part
of PackageCompiler and we need to be able to move things around without
requiring a recompile.  So we change all accesses of `libfftw3{,f}` to
be through a `Ref{String}()`, then update that ref within `__init__()`.

In the future, accesses of `FFTW_jll.libfftw3` will be through a
function, rather than a direct variable access, and we'll be able to get
these things for free, but that's still a ways down the line.

Author: staticfloat

src/FFTW.jl

@@ -23,9 +23,17 @@ function __init__()
         Base.depwarn("JULIA_FFTW_PROVIDER is deprecated; use FFTW.set_provider!() instead", :JULIA_FFTW_PROVIDER)
     end
 
-    # Hook FFTW threads up to our partr runtime
+    # Hook FFTW threads up to our partr runtime, and re-assign the
+    # libfftw3{,f} refs at runtime, since we may have relocated and
+    # changed the path to the library since the last time we precompiled.
     @static if fftw_provider == "fftw"
         fftw_init_threads()
+        libfftw3[] = FFTW_jll.libfftw3_path
+        libfftw3f[] = FFTW_jll.libfftw3f_path
+    end
+    @static if fftw_provider == "mkl"
+        libfftw3[] = MKL_jll.libmkl_rt_path
+        libfftw3f[] = MKL_jll.libmkl_rt_path
     end
 end
 

src/fft.jl

@@ -56,7 +56,7 @@ function plan_r2r end
 ## FFT: Implement fft by calling fftw.
 
 const version = VersionNumber(split(unsafe_string(cglobal(
-    (:fftw_version,libfftw3), UInt8)), ['-', ' '])[2])
+    (:fftw_version,libfftw3[]), UInt8)), ['-', ' '])[2])
 
 ## Direction of FFT
 
@@ -141,39 +141,39 @@ alignment_of(A::FakeArray) = Int32(0)
 @exclusive function export_wisdom(fname::AbstractString)
     f = ccall(:fopen, Ptr{Cvoid}, (Cstring,Cstring), fname, :w)
     systemerror("could not open wisdom file $fname for writing", f == C_NULL)
-    ccall((:fftw_export_wisdom_to_file,libfftw3), Cvoid, (Ptr{Cvoid},), f)
+    ccall((:fftw_export_wisdom_to_file,libfftw3[]), Cvoid, (Ptr{Cvoid},), f)
     ccall(:fputs, Int32, (Ptr{UInt8},Ptr{Cvoid}), " "^256, f) # no NUL, hence no Cstring
-    ccall((:fftwf_export_wisdom_to_file,libfftw3f), Cvoid, (Ptr{Cvoid},), f)
+    ccall((:fftwf_export_wisdom_to_file,libfftw3f[]), Cvoid, (Ptr{Cvoid},), f)
     ccall(:fclose, Cvoid, (Ptr{Cvoid},), f)
 end
 
 @exclusive function import_wisdom(fname::AbstractString)
     f = ccall(:fopen, Ptr{Cvoid}, (Cstring,Cstring), fname, :r)
     systemerror("could not open wisdom file $fname for reading", f == C_NULL)
-    if ccall((:fftw_import_wisdom_from_file,libfftw3),Int32,(Ptr{Cvoid},),f)==0||
-       ccall((:fftwf_import_wisdom_from_file,libfftw3f),Int32,(Ptr{Cvoid},),f)==0
+    if ccall((:fftw_import_wisdom_from_file,libfftw3[]),Int32,(Ptr{Cvoid},),f)==0||
+       ccall((:fftwf_import_wisdom_from_file,libfftw3f[]),Int32,(Ptr{Cvoid},),f)==0
         error("failed to import wisdom from $fname")
     end
     ccall(:fclose, Cvoid, (Ptr{Cvoid},), f)
 end
 
 @exclusive function import_system_wisdom()
-    if ccall((:fftw_import_system_wisdom,libfftw3), Int32, ()) == 0 ||
-       ccall((:fftwf_import_system_wisdom,libfftw3f), Int32, ()) == 0
+    if ccall((:fftw_import_system_wisdom,libfftw3[]), Int32, ()) == 0 ||
+       ccall((:fftwf_import_system_wisdom,libfftw3f[]), Int32, ()) == 0
         error("failed to import system wisdom")
     end
 end
 
 @exclusive function forget_wisdom()
-    ccall((:fftw_forget_wisdom,libfftw3), Cvoid, ())
-    ccall((:fftwf_forget_wisdom,libfftw3f), Cvoid, ())
+    ccall((:fftw_forget_wisdom,libfftw3[]), Cvoid, ())
+    ccall((:fftwf_forget_wisdom,libfftw3f[]), Cvoid, ())
 end
 
 # Threads
 
 @exclusive function set_num_threads(nthreads::Integer)
-    ccall((:fftw_plan_with_nthreads,libfftw3), Cvoid, (Int32,), nthreads)
-    ccall((:fftwf_plan_with_nthreads,libfftw3f), Cvoid, (Int32,), nthreads)
+    ccall((:fftw_plan_with_nthreads,libfftw3[]), Cvoid, (Int32,), nthreads)
+    ccall((:fftwf_plan_with_nthreads,libfftw3f[]), Cvoid, (Int32,), nthreads)
 end
 
 # pointer type for fftw_plan (opaque pointer)
@@ -187,9 +187,9 @@ const NO_TIMELIMIT = -1.0 # from fftw3.h
 
 # only call these when fftwlock is held:
 unsafe_set_timelimit(precision::fftwTypeDouble,seconds) =
-    ccall((:fftw_set_timelimit,libfftw3), Cvoid, (Float64,), seconds)
+    ccall((:fftw_set_timelimit,libfftw3[]), Cvoid, (Float64,), seconds)
 unsafe_set_timelimit(precision::fftwTypeSingle,seconds) =
-    ccall((:fftwf_set_timelimit,libfftw3f), Cvoid, (Float64,), seconds)
+    ccall((:fftwf_set_timelimit,libfftw3f[]), Cvoid, (Float64,), seconds)
 @exclusive set_timelimit(precision, seconds) = unsafe_set_timelimit(precision, seconds)
 
 # Array alignment mod 16:
@@ -210,9 +210,9 @@ unsafe_set_timelimit(precision::fftwTypeSingle,seconds) =
         convert(Int32, convert(Int64, pointer(A)) % 16)
 else
     alignment_of(A::StridedArray{T}) where {T<:fftwDouble} =
-        ccall((:fftw_alignment_of, libfftw3), Int32, (Ptr{T},), A)
+        ccall((:fftw_alignment_of, libfftw3[]), Int32, (Ptr{T},), A)
     alignment_of(A::StridedArray{T}) where {T<:fftwSingle} =
-        ccall((:fftwf_alignment_of, libfftw3f), Int32, (Ptr{T},), A)
+        ccall((:fftwf_alignment_of, libfftw3f[]), Int32, (Ptr{T},), A)
 end
 
 # FFTWPlan (low-level)
@@ -268,9 +268,9 @@ unsafe_convert(::Type{PlanPtr}, p::FFTWPlan) = p.plan
 
 # these functions should only be called while the fftwlock is held
 unsafe_destroy_plan(plan::FFTWPlan{<:fftwDouble}) =
-    ccall((:fftw_destroy_plan,libfftw3), Cvoid, (PlanPtr,), plan)
+    ccall((:fftw_destroy_plan,libfftw3[]), Cvoid, (PlanPtr,), plan)
 unsafe_destroy_plan(plan::FFTWPlan{<:fftwSingle}) =
-    ccall((:fftwf_destroy_plan,libfftw3f), Cvoid, (PlanPtr,), plan)
+    ccall((:fftwf_destroy_plan,libfftw3f[]), Cvoid, (PlanPtr,), plan)
 
 const deferred_destroy_lock = ReentrantLock() # lock protecting the deferred_destroy_plans list
 const deferred_destroy_plans = FFTWPlan[]
@@ -331,19 +331,19 @@ end
 #################################################################################################
 
 cost(plan::FFTWPlan{<:fftwDouble}) =
-    ccall((:fftw_cost,libfftw3), Float64, (PlanPtr,), plan)
+    ccall((:fftw_cost,libfftw3[]), Float64, (PlanPtr,), plan)
 cost(plan::FFTWPlan{<:fftwSingle}) =
-    ccall((:fftwf_cost,libfftw3f), Float64, (PlanPtr,), plan)
+    ccall((:fftwf_cost,libfftw3f[]), Float64, (PlanPtr,), plan)
 
 @exclusive function arithmetic_ops(plan::FFTWPlan{<:fftwDouble})
     add, mul, fma = Ref(0.0), Ref(0.0), Ref(0.0)
-    ccall((:fftw_flops,libfftw3), Cvoid,
+    ccall((:fftw_flops,libfftw3[]), Cvoid,
           (PlanPtr,Ref{Float64},Ref{Float64},Ref{Float64}), plan, add, mul, fma)
     return (round(Int64, add[]), round(Int64, mul[]), round(Int64, fma[]))
 end
 @exclusive function arithmetic_ops(plan::FFTWPlan{<:fftwSingle})
     add, mul, fma = Ref(0.0), Ref(0.0), Ref(0.0)
-    ccall((:fftwf_flops,libfftw3f), Cvoid,
+    ccall((:fftwf_flops,libfftw3f[]), Cvoid,
           (PlanPtr,Ref{Float64},Ref{Float64},Ref{Float64}), plan, add, mul, fma)
     return (round(Int64, add[]), round(Int64, mul[]), round(Int64, fma[]))
 end
@@ -374,9 +374,9 @@ const has_sprint_plan = version >= v"3.3.4" && fftw_provider == "fftw"
 
 @static if has_sprint_plan
     sprint_plan_(plan::FFTWPlan{<:fftwDouble}) =
-        ccall((:fftw_sprint_plan,libfftw3), Ptr{UInt8}, (PlanPtr,), plan)
+        ccall((:fftw_sprint_plan,libfftw3[]), Ptr{UInt8}, (PlanPtr,), plan)
     sprint_plan_(plan::FFTWPlan{<:fftwSingle}) =
-        ccall((:fftwf_sprint_plan,libfftw3f), Ptr{UInt8}, (PlanPtr,), plan)
+        ccall((:fftwf_sprint_plan,libfftw3f[]), Ptr{UInt8}, (PlanPtr,), plan)
     function sprint_plan(plan::FFTWPlan)
         p = sprint_plan_(plan)
         str = unsafe_string(p)
@@ -457,49 +457,49 @@ _colmajorstrides(p) = ()
 # Execute
 
 unsafe_execute!(plan::FFTWPlan{<:fftwDouble}) =
-    ccall((:fftw_execute,libfftw3), Cvoid, (PlanPtr,), plan)
+    ccall((:fftw_execute,libfftw3[]), Cvoid, (PlanPtr,), plan)
 
 unsafe_execute!(plan::FFTWPlan{<:fftwSingle}) =
-    ccall((:fftwf_execute,libfftw3f), Cvoid, (PlanPtr,), plan)
+    ccall((:fftwf_execute,libfftw3f[]), Cvoid, (PlanPtr,), plan)
 
 unsafe_execute!(plan::cFFTWPlan{T},
                 X::StridedArray{T}, Y::StridedArray{T}) where {T<:fftwDouble} =
-    ccall((:fftw_execute_dft,libfftw3), Cvoid,
+    ccall((:fftw_execute_dft,libfftw3[]), Cvoid,
           (PlanPtr,Ptr{T},Ptr{T}), plan, X, Y)
 
 unsafe_execute!(plan::cFFTWPlan{T},
                 X::StridedArray{T}, Y::StridedArray{T}) where {T<:fftwSingle} =
-    ccall((:fftwf_execute_dft,libfftw3f), Cvoid,
+    ccall((:fftwf_execute_dft,libfftw3f[]), Cvoid,
           (PlanPtr,Ptr{T},Ptr{T}), plan, X, Y)
 
 unsafe_execute!(plan::rFFTWPlan{Float64,FORWARD},
                 X::StridedArray{Float64}, Y::StridedArray{Complex{Float64}}) =
-    ccall((:fftw_execute_dft_r2c,libfftw3), Cvoid,
+    ccall((:fftw_execute_dft_r2c,libfftw3[]), Cvoid,
           (PlanPtr,Ptr{Float64},Ptr{Complex{Float64}}), plan, X, Y)
 
 unsafe_execute!(plan::rFFTWPlan{Float32,FORWARD},
                 X::StridedArray{Float32}, Y::StridedArray{Complex{Float32}}) =
-    ccall((:fftwf_execute_dft_r2c,libfftw3f), Cvoid,
+    ccall((:fftwf_execute_dft_r2c,libfftw3f[]), Cvoid,
           (PlanPtr,Ptr{Float32},Ptr{Complex{Float32}}), plan, X, Y)
 
 unsafe_execute!(plan::rFFTWPlan{Complex{Float64},BACKWARD},
                 X::StridedArray{Complex{Float64}}, Y::StridedArray{Float64}) =
-    ccall((:fftw_execute_dft_c2r,libfftw3), Cvoid,
+    ccall((:fftw_execute_dft_c2r,libfftw3[]), Cvoid,
           (PlanPtr,Ptr{Complex{Float64}},Ptr{Float64}), plan, X, Y)
 
 unsafe_execute!(plan::rFFTWPlan{Complex{Float32},BACKWARD},
                 X::StridedArray{Complex{Float32}}, Y::StridedArray{Float32}) =
-    ccall((:fftwf_execute_dft_c2r,libfftw3f), Cvoid,
+    ccall((:fftwf_execute_dft_c2r,libfftw3f[]), Cvoid,
           (PlanPtr,Ptr{Complex{Float32}},Ptr{Float32}), plan, X, Y)
 
 unsafe_execute!(plan::r2rFFTWPlan{T},
                 X::StridedArray{T}, Y::StridedArray{T}) where {T<:fftwDouble} =
-    ccall((:fftw_execute_r2r,libfftw3), Cvoid,
+    ccall((:fftw_execute_r2r,libfftw3[]), Cvoid,
           (PlanPtr,Ptr{T},Ptr{T}), plan, X, Y)
 
 unsafe_execute!(plan::r2rFFTWPlan{T},
                 X::StridedArray{T}, Y::StridedArray{T}) where {T<:fftwSingle} =
-    ccall((:fftwf_execute_r2r,libfftw3f), Cvoid,
+    ccall((:fftwf_execute_r2r,libfftw3f[]), Cvoid,
           (PlanPtr,Ptr{T},Ptr{T}), plan, X, Y)
 
 # NOTE ON GC (garbage collection):
@@ -556,8 +556,8 @@ end
 
 # low-level FFTWPlan creation (for internal use in FFTW module)
 
-for (Tr,Tc,fftw,lib) in ((:Float64,:(Complex{Float64}),"fftw",:libfftw3),
-                         (:Float32,:(Complex{Float32}),"fftwf",:libfftw3f))
+for (Tr,Tc,fftw,lib) in ((:Float64,:(Complex{Float64}),"fftw",:libfftw3[]),
+                         (:Float32,:(Complex{Float32}),"fftwf",:libfftw3f[]))
     @eval @exclusive function cFFTWPlan{$Tc,K,inplace,N}(X::StridedArray{$Tc,N},
                                               Y::StridedArray{$Tc,N},
                                               region, flags::Integer, timelimit::Real) where {K,inplace,N}

src/providers.jl

@@ -20,6 +20,12 @@ end
 # Read in preferences, see if any users have requested a particular backend
 const fftw_provider = get_provider()
 
+# We'll initialize `libfftw3` here (in the conditionals below), and
+# it will get overwritten again in `__init__()`.  This allows us to
+# `ccall` at build time, and also be relocatable for PackageCompiler.
+const libfftw3 = Ref{String}()
+const libfftw3f = Ref{String}()
+
 """
     set_provider!(provider; export_prefs::Bool = false)
 
@@ -41,7 +47,9 @@ end
 
 # If we're using fftw_jll, load it in
 @static if fftw_provider == "fftw"
-    using FFTW_jll
+    import FFTW_jll
+    libfftw3[] = FFTW_jll.libfftw3_path
+    libfftw3f[] = FFTW_jll.libfftw3f_path
 
     # callback function that FFTW uses to launch `num` parallel
     # tasks (FFTW/fftw3#175):
@@ -58,23 +66,23 @@ end
     #      (Previously, we called fftw_cleanup, but this invalidated existing
     #       plans, causing Base Julia issue #19892.)
     function fftw_init_threads()
-        stat =  ccall((:fftw_init_threads,   libfftw3), Int32, ())
-        statf = ccall((:fftwf_init_threads, libfftw3f), Int32, ())
+        stat =  ccall((:fftw_init_threads,   libfftw3[]), Int32, ())
+        statf = ccall((:fftwf_init_threads, libfftw3f[]), Int32, ())
         if stat == 0 || statf == 0
             error("could not initialize FFTW threads")
         end
 
         if nthreads() > 1
             cspawnloop = @cfunction(spawnloop, Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t, Cint, Ptr{Cvoid}))
-            ccall((:fftw_threads_set_callback,  libfftw3),  Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}), cspawnloop, C_NULL)
-            ccall((:fftwf_threads_set_callback, libfftw3f), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}), cspawnloop, C_NULL)
+            ccall((:fftw_threads_set_callback,  libfftw3[]),  Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}), cspawnloop, C_NULL)
+            ccall((:fftwf_threads_set_callback, libfftw3f[]), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}), cspawnloop, C_NULL)
         end
     end
 end
 
 # If we're using MKL, load it in and set library paths appropriately.
 @static if fftw_provider == "mkl"
-    using MKL_jll
-    const libfftw3 = MKL_jll.libmkl_rt_path
-    const libfftw3f = libfftw3
+    import MKL_jll
+    libfftw3[] = MKL_jll.libmkl_rt_path
+    libfftw3f[] = MKL_jll.libmkl_rt_path
 end

test/runtests.jl

@@ -507,7 +507,7 @@ end # fftw_provider == "fftw"
     end
 
     # check whether FFTW on this architecture has nontrivial alignment requirements
-    nontrivial_alignment = FFTW.fftw_provider == "fftw" && ccall((:fftwf_alignment_of, FFTW.libfftw3f), Int32, (Int,), 8) != 0
+    nontrivial_alignment = FFTW.fftw_provider == "fftw" && ccall((:fftwf_alignment_of, FFTW.libfftw3f[]), Int32, (Int,), 8) != 0
     if nontrivial_alignment
         @test_throws ArgumentError plan_rfft(Array{Float32}(undef, 32)) * view(A, 2:33)
         @test_throws ArgumentError plan_fft(Array{Complex{Float32}}(undef, 32)) * view(Ac, 2:33)