Merge pull request #95 from timholy/teh/u1u2

A big renaming

Author: chriselrod

src/condense_loopset.jl

@@ -208,13 +208,13 @@ end
 # If you change the number of arguments here, make commensurate changes
 # to the `insert!` locations in `setup_call_noinline`.
 @generated function __avx__!(
-    ::Val{UT}, ::Type{OPS}, ::Type{ARF}, ::Type{AM}, ::Type{LPSYM}, lb::LB,
+    ::Val{UNROLL}, ::Type{OPS}, ::Type{ARF}, ::Type{AM}, ::Type{LPSYM}, lb::LB,
     ::Val{AR}, ::Val{D}, ::Val{IND}, subsetvals, arraydescript, vargs::Vararg{<:Any,N}
-) where {UT, OPS, ARF, AM, LPSYM, LB, N, AR, D, IND}
+) where {UNROLL, OPS, ARF, AM, LPSYM, LB, N, AR, D, IND}
     1 + 1
     num_vptrs = length(ARF.parameters)::Int
     vptrs = [gensym(:vptr) for _ ∈ 1:num_vptrs]
-    call = Expr(:call, lv(:_avx_!), Val{UT}(), OPS, ARF, AM, LPSYM, :lb)
+    call = Expr(:call, lv(:_avx_!), Val{UNROLL}(), OPS, ARF, AM, LPSYM, :lb)
     for n ∈ 1:num_vptrs
         push!(call.args, vptrs[n])
     end
@@ -245,7 +245,7 @@ end
 end
 
 # Try to condense in type stable manner
-function generate_call(ls::LoopSet, IUT, debug::Bool = false)
+function generate_call(ls::LoopSet, inline_unroll, debug::Bool = false)
     operation_descriptions = Expr(:curly, :Tuple)
     varnames = Symbol[]
     for op ∈ operations(ls)
@@ -260,20 +260,20 @@ function generate_call(ls::LoopSet, IUT, debug::Bool = false)
     argmeta = argmeta_and_consts_description(ls, arraysymbolinds)
     loop_bounds = loop_boundaries(ls)
     loop_syms = Expr(:curly, :Tuple, map(QuoteNode, ls.loopsymbols)...)
-    inline, U, T = IUT
+    inline, u₁, u₂ = inline_unroll
     if inline | debug
         func = debug ? lv(:_avx_loopset_debug) : lv(:_avx_!)
         lbarg = debug ? Expr(:call, :typeof, loop_bounds) : loop_bounds
         q = Expr(
-            :call, func, Expr(:call, Expr(:curly, :Val, (U,T))),
+            :call, func, Expr(:call, Expr(:curly, :Val, (u₁, u₂))),
             operation_descriptions, arrayref_descriptions, argmeta, loop_syms, lbarg
         )
         debug && deleteat!(q.args, 2)
         foreach(ref -> push!(q.args, vptr(ref)), ls.refs_aliasing_syms)
     else# not forcing inline; calling __avx__! which calls an inlined _avx_!
         arraydescript = Expr(:tuple)
         q = Expr(
-            :call, lv(:__avx__!), Expr(:call, Expr(:curly, :Val, (U,T))),
+            :call, lv(:__avx__!), Expr(:call, Expr(:curly, :Val, (u₁, u₂))),
             operation_descriptions, arrayref_descriptions, argmeta, loop_syms, loop_bounds, arraydescript
         )
         for array ∈ ls.includedactualarrays
@@ -405,15 +405,15 @@ function setup_call_debug(ls::LoopSet)
     pushpreamble!(ls, generate_call(ls, (true,zero(Int8),zero(Int8)), true))
     ls.preamble
 end
-function setup_call(ls::LoopSet, inline::Bool = true, U = zero(Int8), T = zero(Int8))
+function setup_call(ls::LoopSet, inline::Bool = true, u₁ = zero(Int8), u₂ = zero(Int8))
     # We outline/inline at the macro level by creating/not creating an anonymous function.
     # The old API instead was based on inlining or not inline the generated function, but
     # the generated function must be inlined into the initial loop preamble for performance reasons.
     # Creating an anonymous function and calling it also achieves the outlining, while still
     # inlining the generated function into the loop preamble.
     if inline
-        setup_call_inline(ls, U, T)
+        setup_call_inline(ls, u₁, u₂)
     else
-        setup_call_noinline(ls, U, T)
+        setup_call_noinline(ls, u₁, u₂)
     end
 end

src/constructors.jl

@@ -111,8 +111,12 @@ One can find some circumstances where `inline=true` is faster, and other circums
 where `inline=false` is faster, so the best setting may require experimentation.
 
 `unroll` is an integer that specifies the loop unrolling factor, or a
-tuple `(4, 2)` signaling that the generated code should unroll more than
-one loop.
+tuple `(u₁, u₂) = (4, 2)` signaling that the generated code should unroll more than
+one loop. `u₁` is the unrolling factor for the first unrolled loop and `u₂` for the next (if present),
+but it applies to the loop ordering and unrolling that will be chosen by LoopVectorization,
+*not* the order in `body`.
+`uᵢ=0` (the default) indicates that LoopVectorization should pick its own value,
+and `uᵢ=-1` disables unrolling for the correspond loop.
 """
 macro avx(q)
     q = macroexpand(__module__, q)
@@ -133,50 +137,50 @@ function check_unroll(arg)
     a1 = (arg.args[1])::Symbol
     a1 === :unroll || return nothing
     tup = arg.args[2]
-    T = Int8(-1)
+    u₂ = Int8(-1)
     if tup isa Integer
-        U = convert(Int8, tup)
+        u₁ = convert(Int8, tup)
     elseif isa(tup, Expr)
         if length(tup.args) == 1
-            U = convert(Int8, tup.args[1])
+            u₁ = convert(Int8, tup.args[1])
         elseif length(tup.args) == 2
-            U = convert(Int8, tup.args[1])
-            T = convert(Int8, tup.args[2])
+            u₁ = convert(Int8, tup.args[1])
+            u₂ = convert(Int8, tup.args[2])
         else
             return nothing
         end
     else
         return nothing
     end
-    U, T
+    u₁, u₂
 end
-function check_macro_kwarg(arg, inline::Bool = true, U::Int8 = zero(Int8), T::Int8 = zero(Int8))
+function check_macro_kwarg(arg, inline::Bool = true, u₁::Int8 = zero(Int8), u₂::Int8 = zero(Int8))
     @assert arg.head === :(=)
     i = check_inline(arg)
     if i !== nothing
         inline = i
     else
         u = check_unroll(arg)
         if u !== nothing
-            U, T = u
+            u₁, u₂ = u
         end
     end
-    inline, U, T
+    inline, u₁, u₂
 end
 macro avx(arg, q)
     @assert q.head === :for
     @assert arg.head === :(=)
     q = macroexpand(__module__, q)
-    inline, U, T = check_macro_kwarg(arg)
+    inline, u₁, u₂ = check_macro_kwarg(arg)
     ls = LoopSet(q, __module__)
-    esc(setup_call(ls, inline, U, T))
+    esc(setup_call(ls, inline, u₁, u₂))
 end
 macro avx(arg1, arg2, q)
     @assert q.head === :for
     q = macroexpand(__module__, q)
-    inline, U, T = check_macro_kwarg(arg1)
-    inline, U, T = check_macro_kwarg(arg2, inline, U, T)
-    esc(setup_call(LoopSet(q, __module__), inline, U, T))
+    inline, u₁, u₂ = check_macro_kwarg(arg1)
+    inline, u₁, u₂ = check_macro_kwarg(arg2, inline, u₁, u₂)
+    esc(setup_call(LoopSet(q, __module__), inline, u₁, u₂))
 end
 
 
@@ -194,8 +198,8 @@ end
 macro _avx(arg, q)
     @assert q.head === :for
     q = macroexpand(__module__, q)
-    inline, U, T = check_macro_kwarg(arg)
-    esc(lower(LoopSet(q, __module__), U, T))
+    inline, u₁, u₂ = check_macro_kwarg(arg)
+    esc(lower(LoopSet(q, __module__), u₁, u₂))
 end
 
 macro avx_debug(q)