Enable juliac build

Author: johroj

src/FFTW.jl

@@ -31,19 +31,19 @@ end
 
 if VERSION >= v"1.11.0"
 # This can be be deleted once FFTW_jll is upgraded to the real lazy jll code, to get the real benefits of this mess
-mutable struct FakeLazyLibrary
+mutable struct FakeLazyLibrary{T}
     reallibrary::Symbol
-    on_load_callback
+    on_load_callback::T
     @atomic h::Ptr{Cvoid}
 end
 import Libdl: LazyLibrary, dlopen
-function dlopen(lib::FakeLazyLibrary)
+function dlopen(lib::FakeLazyLibrary{T}) where T
     h = @atomic :monotonic lib.h
     h != C_NULL && return h
     @lock fftwlock begin
         h = @atomic :monotonic lib.h
         h != C_NULL && return h
-        h = dlopen(getglobal(FFTW, lib.reallibrary))
+        h = dlopen(getglobal(FFTW, lib.reallibrary)::String)
         lib.on_load_callback()
         @atomic :release lib.h = h
     end

src/fft.jl

@@ -320,14 +320,26 @@ unsafe_convert(::Type{PlanPtr}, p::FFTWPlan) = p.plan
 # pushing the plan to be destroyed to the deferred_destroy_plans (which itself is protected by a lock).
 # This is accomplished by the maybe_destroy_plan function, which is used as the plan finalizer.
 
+struct FFTWPlanDestructor
+    ptr::PlanPtr
+    use_32bit_lib::Bool
+end
+
+FFTWPlanDestructor(plan::FFTWPlan{<:fftwSingle}) = FFTWPlanDestructor(plan.plan, true)
+FFTWPlanDestructor(plan::FFTWPlan{<:fftwDouble}) = FFTWPlanDestructor(plan.plan, false)
+
 # these functions should only be called while the fftwlock is held
-unsafe_destroy_plan(@nospecialize(plan::FFTWPlan{<:fftwDouble})) =
-    ccall((:fftw_destroy_plan,libfftw3), Cvoid, (PlanPtr,), plan)
-unsafe_destroy_plan(@nospecialize(plan::FFTWPlan{<:fftwSingle})) =
-    ccall((:fftwf_destroy_plan,libfftw3f), Cvoid, (PlanPtr,), plan)
+unsafe_destroy_plan(plan::FFTWPlan) = unsafe_destroy_plan(FFTWPlanDestructor(plan))
+function unsafe_destroy_plan(destructor::FFTWPlanDestructor)
+    if destructor.use_32bit_lib
+        ccall((:fftwf_destroy_plan,libfftw3f), Cvoid, (PlanPtr,), destructor.ptr)
+    else
+        ccall((:fftw_destroy_plan,libfftw3), Cvoid, (PlanPtr,), destructor.ptr)
+    end
+end
 
 const deferred_destroy_lock = ReentrantLock() # lock protecting the deferred_destroy_plans list
-const deferred_destroy_plans = FFTWPlan[]
+const deferred_destroy_plans = FFTWPlanDestructor[]
 
 function destroy_deferred()
     lock(deferred_destroy_lock)
@@ -375,7 +387,7 @@ function maybe_destroy_plan(plan::FFTWPlan)
                 unlock(fftwlock)
             end
         else
-            push!(deferred_destroy_plans, plan)
+            push!(deferred_destroy_plans, FFTWPlanDestructor(plan))
         end
     finally
         unlock(deferred_destroy_lock)
@@ -495,11 +507,11 @@ function assert_applicable(p::FFTWPlan{T,K,inplace}, X::StridedArray{T}, Y::Stri
     elseif alignment_of(Y) != p.oalign && p.flags & UNALIGNED == 0
         throw(ArgumentError("FFTW plan applied to output with wrong memory alignment"))
     elseif inplace != (pointer(X) == pointer(Y))
-        throw(ArgumentError(string("FFTW ",
+        throw(ArgumentError(join(["FFTW ",
                                    inplace ? "in-place" : "out-of-place",
                                    " plan applied to ",
                                    inplace ? "out-of-place" : "in-place",
-                                   " data")))
+                                   " data"])))
     end
 end
 

src/providers.jl

@@ -45,8 +45,20 @@ end
     # callback function that FFTW uses to launch `num` parallel
     # tasks (FFTW/fftw3#175):
     function spawnloop(f::Ptr{Cvoid}, fdata::Ptr{Cvoid}, elsize::Csize_t, num::Cint, callback_data::Ptr{Cvoid})
-        @sync for i = 0:num-1
-            Threads.@spawn ccall(f, Ptr{Cvoid}, (Ptr{Cvoid},), fdata + elsize*i)
+        # Wrap the for-loop in a simplified @sync, achieving type stability by not depending on a Channel{Any}.
+        # This is necessary for JuliaC to compile. The result runs as long as fftw only uses on thread. 
+        # If FFTW.set_num_threads is used to activate more threads, there will still be a runtime error due to @spawn,
+        # which is limited by https://github.com/JuliaLang/julia/issues/58818 anyway. 
+        tasks = Channel{Task}(Inf)
+        try
+            for i = 0:num-1
+                put!(tasks, Threads.@spawn ccall(f, Ptr{Cvoid}, (Ptr{Cvoid},), fdata + elsize*i))
+            end
+            while isready(tasks)
+                wait(take!(tasks))
+            end
+        finally
+            close(tasks)
         end
     end