Try to reduce recompilation in some circumstances by no longer gensyming symbols that appear as parameters in _avx_! calls

Author: chriselrod

src/add_compute.jl

@@ -65,7 +65,7 @@ function add_parent!(
             opp
         end
     elseif var isa Expr #CSE candidate
-        add_operation!(ls, gensym(:temporary), var, elementbytes, position)
+        add_operation!(ls, gensym!(ls, "temp"), var, elementbytes, position)
     else # assumed constant
         add_constant!(ls, var, elementbytes)
         # add_constant!(ls, var, deps, gensym(:loopredefconst), elementbytes)
@@ -177,8 +177,10 @@ function add_reduction_update_parent!(
         # We add
         reductcombine = reduction_scalar_combine(instrclass)
         # reductcombine = :identity
-        reductsym = gensym(:reduction)
-        reductinit = add_constant!(ls, gensym(:reductzero), loopdependencies(parent), reductsym, elementbytes, :numericconstant)
+        reductsym = gensym!(ls, "reduction")
+        reductzero_sym = gensym!(ls, "reduction##zero")
+        # reductsym = gensym(:reduction)
+        reductinit = add_constant!(ls, reductzero_sym, loopdependencies(parent), reductsym, elementbytes, :numericconstant)
         if reduct_zero === :zero
             push!(ls.preamble_zeros, (identifier(reductinit), IntOrFloat))
         else
@@ -255,7 +257,7 @@ function add_compute!(
                         pushparent!(vparents, deps, reduceddeps, add_load!(ls, argref, elementbytes))
                     end
                 else
-                    argref.varname = gensym(:tempload)
+                    argref.varname = gensym!(ls, "tempload")
                     pushparent!(vparents, deps, reduceddeps, add_load!(ls, argref, elementbytes))
                 end
             else
@@ -353,7 +355,7 @@ function add_pow!(
     ls::LoopSet, var::Symbol, @nospecialize(x), p::Real, elementbytes::Int, position::Int
 )
     xop::Operation = if x isa Expr
-        add_operation!(ls, gensym(:xpow), x, elementbytes, position)
+        add_operation!(ls, Symbol("###xpow###$(length(operations(ls)))###"), x, elementbytes, position)
     elseif x isa Symbol
         if x ∈ ls.loopsymbols
             add_loopvalue!(ls, x, elementbytes)
@@ -377,7 +379,7 @@ function add_pow!(
     if pint == -1
         return add_compute!(ls, var, :inv, [xop], elementbytes)
     elseif pint < 0
-        xop = add_compute!(ls, gensym(:inverse), :inv, [xop], elementbytes)
+        xop = add_compute!(ls, gensym!(ls, "inverse"), :inv, [xop], elementbytes)
         pint = - pint
     end
     if pint == 0
@@ -394,17 +396,17 @@ function add_pow!(
     t = trailing_zeros(pint) + 1
     pint >>= t
     while (t -= 1) > 0
-        varname = (iszero(pint) && isone(t)) ? var : gensym(:pbs)
+        varname = (iszero(pint) && isone(t)) ? var : gensym!(ls, "pbs")
         xop = add_compute!(ls, varname, :abs2, [xop], elementbytes)
     end
     yop = xop
     while pint > 0
         t = trailing_zeros(pint) + 1
         pint >>= t
         while (t -= 1) >= 0
-            xop = add_compute!(ls, gensym(:pbs), :abs2, [xop], elementbytes)
+            xop = add_compute!(ls, gensym!(ls, "pbs"), :abs2, [xop], elementbytes)
         end
-        yop = add_compute!(ls, iszero(pint) ? var : gensym(:pbs), :(*), [xop, yop], elementbytes)
+        yop = add_compute!(ls, iszero(pint) ? var : gensym!(ls, "pbs"), :(*), [xop, yop], elementbytes)
     end
     yop
 end

src/add_constants.jl

@@ -10,7 +10,7 @@ end
 #     add_constant!(ls, sym, elementbytes)
 # end
 function add_constant!(ls::LoopSet, var::Number, elementbytes::Int = 8)
-    op = Operation(length(operations(ls)), gensym(:loopconstnumber), elementbytes, LOOPCONSTANT, constant, NODEPENDENCY, Symbol[], NOPARENTS)
+    op = Operation(length(operations(ls)), gensym!(ls, "loopconstnumber"), elementbytes, LOOPCONSTANT, constant, NODEPENDENCY, Symbol[], NOPARENTS)
     ops = operations(ls)
     typ = var isa Integer ? HardInt : HardFloat
     rop = pushop!(ls, op)
@@ -36,7 +36,7 @@ end
 function add_constant!(ls::LoopSet, mpref::ArrayReferenceMetaPosition, elementbytes::Int)
     op = Operation(length(operations(ls)), varname(mpref), elementbytes, LOOPCONSTANT, constant, NODEPENDENCY, Symbol[], NOPARENTS, mpref.mref)
     add_vptr!(ls, op)
-    temp = gensym(:intermediateconstref)
+    temp = gensym!(ls, "intermediateconstref")
     vloadcall = Expr(:call, lv(:vload), mpref.mref.ptr)
     if length(getindices(op)) > 0
         push!(vloadcall.args, mem_offset(op, UnrollArgs(0, Symbol(""), Symbol(""), Symbol(""), 0, nothing), Bool[]))
@@ -69,7 +69,7 @@ end
 function add_constant!(
     ls::LoopSet, value::Number, deps::Vector{Symbol}, assignedsym::Symbol, elementbytes::Int
 )
-    op = add_constant!(ls, gensym(string(value)), deps, assignedsym, elementbytes, :numericconstant)
+    op = add_constant!(ls, gensym!(ls, string(value)), deps, assignedsym, elementbytes, :numericconstant)
     pushpreamble!(ls, op, value)
     op
 end

src/add_ifelse.jl

@@ -2,7 +2,7 @@
 ## Currently, if/else will create its own local scope
 ## Assignments will not register in the loop's main scope
 ## although stores and return values will.
-negateop!(ls::LoopSet, condop::Operation, elementbytes::Int) = add_compute!(ls, gensym(:negated_mask), :~, [condop], elementbytes)
+negateop!(ls::LoopSet, condop::Operation, elementbytes::Int) = add_compute!(ls, gensym!(ls, "negated#mask"), :~, [condop], elementbytes)
 
 function add_if!(ls::LoopSet, LHS::Symbol, RHS::Expr, elementbytes::Int, position::Int, mpref::Union{Nothing,ArrayReferenceMetaPosition} = nothing)
     # for now, just simple 1-liners
@@ -11,13 +11,13 @@ function add_if!(ls::LoopSet, LHS::Symbol, RHS::Expr, elementbytes::Int, positio
     condop = if condition isa Symbol
         getop(ls, condition, elementbytes)
     elseif isnothing(mpref)
-        add_operation!(ls, gensym(:mask), condition, elementbytes, position)
+        add_operation!(ls, gensym!(ls, "mask"), condition, elementbytes, position)
     else
-        add_operation!(ls, gensym(:mask), condition, mpref, elementbytes, position)
+        add_operation!(ls, gensym!(ls, "mask"), condition, mpref, elementbytes, position)
     end
     iftrue = RHS.args[2]
     if iftrue isa Expr
-        trueop = add_operation!(ls, gensym(:iftrue), iftrue, elementbytes, position)
+        trueop = add_operation!(ls, gensym!(ls, "iftrue"), iftrue, elementbytes, position)
         if iftrue.head === :ref && all(ld -> ld ∈ loopdependencies(trueop), loopdependencies(condop)) && !search_tree(parents(condop), trueop)
             trueop.instruction = Instruction(:conditionalload)
             push!(parents(trueop), condop)
@@ -27,7 +27,7 @@ function add_if!(ls::LoopSet, LHS::Symbol, RHS::Expr, elementbytes::Int, positio
     end
     iffalse = RHS.args[3]
     if iffalse isa Expr
-        falseop = add_operation!(ls, gensym(:iffalse), iffalse, elementbytes, position)
+        falseop = add_operation!(ls, gensym!(ls, "iffalse"), iffalse, elementbytes, position)
         if iffalse.head === :ref && all(ld -> ld ∈ loopdependencies(falseop), loopdependencies(condop)) && !search_tree(parents(condop), falseop)
             falseop.instruction = Instruction(:conditionalload)
             push!(parents(falseop), negateop!(ls, condop, elementbytes))
@@ -49,15 +49,15 @@ function add_andblock!(ls::LoopSet, condop::Operation, LHS, rhsop::Operation, el
     end
 end
 function add_andblock!(ls::LoopSet, condop::Operation, LHS, RHS::Expr, elementbytes::Int, position::Int)
-    rhsop = add_compute!(ls, gensym(:iftruerhs), RHS, elementbytes, position)
+    rhsop = add_compute!(ls, gensym!(ls, "iftruerhs"), RHS, elementbytes, position)
     add_andblock!(ls, condop, LHS, rhsop, elementbytes, position)
 end
 function add_andblock!(ls::LoopSet, condop::Operation, LHS, RHS, elementbytes::Int, position::Int)
     rhsop = getop(ls, RHS, elementbytes)
     add_andblock!(ls, condop, LHS, rhsop, elementbytes, position)
 end
 function add_andblock!(ls::LoopSet, condexpr::Expr, condeval::Expr, elementbytes::Int, position::Int)
-    condop = add_operation!(ls, gensym(:mask), condexpr, elementbytes, position)
+    condop = add_operation!(ls, gensym!(ls, "mask"), condexpr, elementbytes, position)
     if condeval.head === :call
         @assert first(condeval.args) === :setindex!
         array, raw_indices = ref_from_setindex!(ls, condeval)
@@ -90,15 +90,15 @@ function add_orblock!(ls::LoopSet, condop::Operation, LHS, rhsop::Operation, ele
     end
 end
 function add_orblock!(ls::LoopSet, condop::Operation, LHS, RHS::Expr, elementbytes::Int, position::Int)
-    rhsop = add_compute!(ls, gensym(:iffalserhs), RHS, elementbytes, position)
+    rhsop = add_compute!(ls, gensym!(ls, "iffalserhs"), RHS, elementbytes, position)
     add_orblock!(ls, condop, LHS, rhsop, elementbytes, position)
 end
 function add_orblock!(ls::LoopSet, condop::Operation, LHS, RHS, elementbytes::Int, position::Int)
     rhsop = getop(ls, RHS, elementbytes)
     add_orblock!(ls, condop, LHS, rhsop, elementbytes, position)
 end
 function add_orblock!(ls::LoopSet, condexpr::Expr, condeval::Expr, elementbytes::Int, position::Int)
-    condop = add_operation!(ls, gensym(:mask), condexpr, elementbytes, position)
+    condop = add_operation!(ls, gensym!(ls, "mask"), condexpr, elementbytes, position)
     if condeval.head === :call
         @assert first(condeval.args) === :setindex!
         array, raw_indices = ref_from_setindex!(ls, condeval)

src/add_stores.jl

@@ -19,7 +19,7 @@ end
 function add_copystore!(
     ls::LoopSet, parent::Operation, mpref::ArrayReferenceMetaPosition, elementbytes::Int
 )
-    op = add_compute!(ls, gensym(), :identity, [parent], elementbytes)
+    op = add_compute!(ls, gensym!(ls, "identity"), :identity, [parent], elementbytes)
     # pushfirst!(mpref.parents, parent)
     add_store!(ls, mpref, elementbytes, op)
 end

src/broadcast.jl

@@ -102,13 +102,13 @@ function add_broadcast!(
     @nospecialize(prod::Type{<:Product}), elementbytes::Int
 )
     A, B = prod.parameters
-    K = gensym(:K)
-    mA = gensym(:Aₘₖ)
-    mB = gensym(:Bₖₙ)
+    K = gensym!(ls, "K")
+    mA = gensym!(ls, "Aₘₖ")
+    mB = gensym!(ls, "Bₖₙ")
     pushprepreamble!(ls, Expr(:(=), mA, Expr(:(.), bcname, QuoteNode(:a))))
     pushprepreamble!(ls, Expr(:(=), mB, Expr(:(.), bcname, QuoteNode(:b))))
     pushprepreamble!(ls, Expr(:(=), K, Expr(:macrocall, Symbol("@inbounds"), LineNumberNode(@__LINE__,Symbol(@__FILE__)), Expr(:ref, Expr(:call, :size, mB), 1))))
-    k = gensym(:k)
+    k = gensym!(ls, "k")
     add_loop!(ls, Loop(k, 1, K), k)
     m = loopsyms[1];
     if numdims(B) == 1
@@ -126,17 +126,17 @@ function add_broadcast!(
         throw("B must be a vector or matrix.")
     end
     # load A
-    # loadA = add_load!(ls, gensym(:A), productref(A, mA, m, k), elementbytes)
-    loadA = add_broadcast!(ls, gensym(:A), mA, Symbol[m,k], A, elementbytes)
+    # loadA = add_load!(ls, gensym!(ls, :A), productref(A, mA, m, k), elementbytes)
+    loadA = add_broadcast!(ls, gensym!(ls, "A"), mA, Symbol[m,k], A, elementbytes)
     # load B
-    loadB = add_broadcast!(ls, gensym(:B), mB, bloopsyms, B, elementbytes)
+    loadB = add_broadcast!(ls, gensym!(ls, "B"), mB, bloopsyms, B, elementbytes)
     # set Cₘₙ = 0
     # setC = add_constant!(ls, zero(promote_type(recursive_eltype(A), recursive_eltype(B))), cloopsyms, mC, elementbytes)
     # targetC will be used for reduce_to_add
-    mCt = gensym(mC)
-    targetC = add_constant!(ls, gensym(:zero), cloopsyms, mCt, elementbytes, :numericconstant)
+    mCt = gensym!(ls, mC)
+    targetC = add_constant!(ls, gensym!(ls, "zero"), cloopsyms, mCt, elementbytes, :numericconstant)
     push!(ls.preamble_zeros, (identifier(targetC), IntOrFloat))
-    setC = add_constant!(ls, gensym(:zero), cloopsyms, mC, elementbytes, :numericconstant)
+    setC = add_constant!(ls, gensym!(ls, "zero"), cloopsyms, mC, elementbytes, :numericconstant)
     push!(ls.preamble_zeros, (identifier(setC), IntOrFloat))
     setC.reduced_children = kvec
     # compute Cₘₙ += Aₘₖ * Bₖₙ
@@ -226,7 +226,7 @@ function LowDimArray{D}(data::A) where {D,T,N,A <: AbstractArray{T,N}}
     LowDimArray{D,T,N,A}(data)
 end
 function extract_all_1_array!(ls::LoopSet, bcname::Symbol, N::Int, elementbytes::Int)
-    refextract = gensym(bcname)
+    refextract = gensym!(ls, bcname)
     ref = Expr(:ref, bcname); foreach(_ -> push!(ref.args, :begin), 1:N)
     pushprepreamble!(ls, Expr(:(=), refextract, ref))
     return add_constant!(ls, refextract, elementbytes) # or replace elementbytes with sizeof(T) ? u
@@ -247,7 +247,7 @@ end
 function add_broadcast_adjoint_array!(
     ls::LoopSet, destname::Symbol, bcname::Symbol, loopsyms::Vector{Symbol}, ::Type{A}, elementbytes::Int
 ) where {T,N,A<:AbstractArray{T,N}}
-    parent = gensym(:parent)
+    parent = gensym!(ls, "parent")
     pushprepreamble!(ls, Expr(:(=), parent, Expr(:call, :parent, bcname)))
     # isone(length(loopsyms)) && return extract_all_1_array!(ls, bcname, N, elementbytes)
     ref = ArrayReference(parent, Symbol[loopsyms[N + 1 - n] for n ∈ 1:N])
@@ -257,7 +257,7 @@ function add_broadcast_adjoint_array!(
     ls::LoopSet, destname::Symbol, bcname::Symbol, loopsyms::Vector{Symbol}, ::Type{<:AbstractVector}, elementbytes::Int
 )
     # isone(length(loopsyms)) && return extract_all_1_array!(ls, bcname, N, elementbytes)
-    parent = gensym(:parent)
+    parent = gensym!(ls, "parent")
     pushprepreamble!(ls, Expr(:(=), parent, Expr(:call, :parent, bcname)))
 
     ref = ArrayReference(parent, Symbol[loopsyms[2]])
@@ -289,7 +289,7 @@ end
 function add_broadcast!(
     ls::LoopSet, ::Symbol, bcname::Symbol, loopsyms::Vector{Symbol}, ::Type{Base.RefValue{T}}, elementbytes::Int
 ) where {T}
-    refextract = gensym(bcname)
+    refextract = gensym!(ls, bcname)
     pushprepreamble!(ls, Expr(:(=), refextract, Expr(:ref, bcname)))
     add_constant!(ls, refextract, elementbytes) # or replace elementbytes with sizeof(T) ? u
 end
@@ -310,7 +310,7 @@ function add_broadcast!(
 )
     S,_,F,A = B.parameters
     instr = get(FUNCTIONSYMBOLS, F) do
-        f = gensym(:func)
+        f = gensym!(ls, "func")
         pushprepreamble!(ls, Expr(:(=), f, Expr(:(.), bcname, QuoteNode(:f))))
         Instruction(bcname, f)
     end
@@ -322,10 +322,10 @@ function add_broadcast!(
     deps = Symbol[]
     # reduceddeps = Symbol[]
     for (i,arg) ∈ enumerate(args)
-        argname = gensym(:arg)
+        argname = gensym!(ls, "arg")
         pushprepreamble!(ls, Expr(:(=), argname, Expr(:macrocall, Symbol("@inbounds"), LineNumberNode(@__LINE__,Symbol(@__FILE__)), Expr(:ref, bcargs, i))))
         # dynamic dispatch
-        parent = add_broadcast!(ls, gensym(:temp), argname, loopsyms, arg, elementbytes)::Operation
+        parent = add_broadcast!(ls, gensym!(ls, "temp"), argname, loopsyms, arg, elementbytes)::Operation
         push!(parents, parent)
         mergesetdiffv!(deps, loopdependencies(parent), reduceddependencies(parent))
     end
@@ -343,12 +343,12 @@ end
     # we have an N dimensional loop.
     # need to construct the LoopSet
     # @show typeof(dest)
-    loopsyms = [gensym(:n) for n ∈ 1:N]
     ls = LoopSet(Mod)
+    loopsyms = [gensym!(ls, "n") for n ∈ 1:N]
     ls.isbroadcast[] = true
     sizes = Expr(:tuple)
     for (n,itersym) ∈ enumerate(loopsyms)
-        Nsym = gensym(:N)
+        Nsym = gensym!(ls, "N")
         add_loop!(ls, Loop(itersym, 1, Nsym), itersym)
         push!(sizes.args, Nsym)
     end
@@ -377,13 +377,13 @@ end
 ) where {T <: NativeTypes, N, A <: AbstractArray{T,N}, BC <: Union{Broadcasted,Product}, Mod}
     # we have an N dimensional loop.
     # need to construct the LoopSet
-    loopsyms = [gensym(:n) for n ∈ 1:N]
     ls = LoopSet(Mod)
+    loopsyms = [gensym!(ls, "n") for n ∈ 1:N]
     ls.isbroadcast[] = true
     pushprepreamble!(ls, Expr(:(=), :dest, Expr(:call, :parent, :dest′)))
     sizes = Expr(:tuple)
     for (n,itersym) ∈ enumerate(loopsyms)
-        Nsym = gensym(:N)
+        Nsym = gensym!(ls, "N")
         add_loop!(ls, Loop(itersym, 1, Nsym), itersym)
         push!(sizes.args, Nsym)
     end