When unrolling outer reductions, currently don't switch unrolled axis contextually. May be nice to add that back in codegen eventually, but for now it's safer to disable. Also handle condvar & loopmasks correctly when the condvar isn't unrolled.

Author: chriselrod

src/codegen/lower_compute.jl

@@ -41,18 +41,18 @@ end
 
 struct FalseCollection end
 Base.getindex(::FalseCollection, i...) = false
-function parent_unroll_status(op::Operation, u₁loop::Symbol, u₂loop::Symbol)
-    # map(opp -> isunrolled_sym(opp, u₁loop), parents(op)), map(opp -> isunrolled_sym(opp, u₂loop), parents(op))
+function parent_unroll_status(op::Operation, u₁loop::Symbol)
     map(opp -> isunrolled_sym(opp, u₁loop), parents(op)), fill(false, length(parents(op)))
 end
-function parent_unroll_status(op::Operation, u₁loop::Symbol, u₂loop::Symbol, u₂max::Int)
-    u₂max ≥ 0 || return parent_unroll_status(op, u₁loop, u₂loop)
+function parent_unroll_status(op::Operation, u₁loop::Symbol, u₂loop::Symbol, vloop::Symbol, u₂max::Int)
+    # u₂max ≥ 0 || return parent_unroll_status(op, u₁loop)
+    u₂max == -1 && return parent_unroll_status(op, u₁loop)
     vparents = parents(op);
     # parent_names = Vector{Symbol}(undef, length(vparents))
     parents_u₁syms = Vector{Bool}(undef, length(vparents))
     parents_u₂syms = Vector{Bool}(undef, length(vparents))
     for i ∈ eachindex(vparents)
-        parents_u₁syms[i], parents_u₂syms[i] = isunrolled_sym(vparents[i], u₁loop, u₂loop, u₂max)
+        parents_u₁syms[i], parents_u₂syms[i] = isunrolled_sym(vparents[i], u₁loop, u₂loop, vloop)#, u₂max)
     end
     # parent_names, parents_u₁syms, parents_u₂syms
     parents_u₁syms, parents_u₂syms
@@ -317,11 +317,14 @@ function lower_compute!(
     instr = instruction(op)
     parents_op = parents(op)
     nparents = length(parents_op)
-    mvar, u₁unrolledsym, u₂unrolledsym = variable_name_and_unrolled(op, u₁loopsym, u₂loopsym, u₂max, suffix)
-    opunrolled = u₁unrolledsym || u₁loopsym ∈ loopdependencies(op)
+    # __u₂max = ls.unrollspecification[].u₂
+    # TODO: perhaps allos for swithcing unrolled axis again
+    # mvar, u₁unrolledsym, u₂unrolledsym = variable_name_and_unrolled(op, u₁loopsym, u₂loopsym, vloopsym, u₂max, suffix)
+    mvar, u₁unrolledsym, u₂unrolledsym = variable_name_and_unrolled(op, u₁loopsym, u₂loopsym, vloopsym, suffix)
+    opunrolled = u₁unrolledsym || isu₁unrolled(op)
     # parent_names, parents_u₁syms, parents_u₂syms = parent_unroll_status(op, u₁loop, u₂loop, suffix)
-    parents_u₁syms, parents_u₂syms = parent_unroll_status(op, u₁loopsym, u₂loopsym, u₂max)
-    tiledouterreduction = if suffix == -1
+    parents_u₁syms, parents_u₂syms = parent_unroll_status(op, u₁loopsym, u₂loopsym, vloopsym, u₂max)
+    tiledouterreduction = if (suffix == -1)# || (vloopsym === u₂loopsym)
         suffix_ = Symbol("")
         -1
     else
@@ -401,8 +404,15 @@ function lower_compute!(
     varsym = if tiledouterreduction > 0 # then suffix ≠ -1
         # modsuffix = ((u + suffix*(Uiter + 1)) & 7)
         isouterreduct = true
-        modsuffix = suffix % tiled_outerreduct_unroll(ls)
-        Symbol(mangledvar(op), modsuffix)
+        # if u₁unrolledsym
+        #     modsuffix = ls.unrollspecification[].u₁#getu₁full(ls, u₁)#u₁
+        #     Symbol(mangledvar(op), '_', modsuffix)
+        # else
+            modsuffix = suffix % tiled_outerreduct_unroll(ls)
+            Symbol(mangledvar(op), modsuffix)
+        # end
+        # dopartialmap = u₁ > 1
+
         # Symbol(mvar, modsuffix)
         # elseif u₁unrolledsym
         #     Symbol(mvar, u)
@@ -419,7 +429,6 @@ function lower_compute!(
     else
         Symbol(mvar, '_', 1)
     end
-    # @show getu₁forreduct(ls, op, u₁)
     selfopname = varsym
     selfdep = 0
     for n ∈ 1:nparents
@@ -435,7 +444,6 @@ function lower_compute!(
                 selfopname = parent_op_name(ls, parents_op, n, modsuffix, suffix_, parents_u₁syms, parents_u₂syms, u₁, opisvectorized, tiledouterreduction)
                 push!(instrcall.args, selfopname)
             else
-                # @show varsym
                 push!(instrcall.args, varsym)
             end
         elseif ((!isu₂unrolled(op)) & isu₂unrolled(opp)) && (isouterreduction(ls, opp) != -1)
@@ -447,6 +455,11 @@ function lower_compute!(
         end
     end
     selfdepreduce = ifelse(((!u₁unrolledsym) & isu₁unrolled(op)) & (u₁ > 1), selfdep, 0)
+    # if selfdep ≠ 0
+    #     @show mvar
+    #     # @show isu₁unrolled(op), u₁unrolledsym, u₁, u₂max
+    #     # @show selfdep, selfdepreduce#, op
+    # end
     # push!(q.args, (isreduct, u₁, (!u₁unrolledsym), isu₁unrolled(op), dopartialmap, varsym))
     if maskreduct
         ifelsefunc = if ls.unrollspecification[].u₁ == 1
@@ -486,7 +499,7 @@ function lower_compute!(
         end
     elseif selfdep != 0 && (dopartialmap ||
         (isouterreduct && (opunrolled) && (u₁ < ls.unrollspecification[].u₁)) ||
-        (isreduct & (u₁ > 1) & (!u₁unrolledsym) & isu₁unrolled(op)))
+        (isreduct & (u₁ > 1) & (!u₁unrolledsym) & isu₁unrolled(op))) # TODO: DRY `selfdepreduce` definition
         # first possibility (`isouterreduct && opunrolled && (u₁ < ls.unrollspecification[].u₁)`):
         # checks if we're in the "reduct" part of an outer reduction
         #

src/codegen/lower_constant.jl

@@ -47,7 +47,8 @@ function lower_zero!(
     q::Expr, op::Operation, ls::LoopSet, ua::UnrollArgs, zerotyp::NumberType = zerotype(ls, op)
 )
     @unpack u₁, u₁loopsym, u₂loopsym, vloopsym, u₂max, suffix = ua
-    mvar, opu₁, opu₂ = variable_name_and_unrolled(op, u₁loopsym, u₂loopsym, u₂max, suffix)
+    # mvar, opu₁, opu₂ = variable_name_and_unrolled(op, u₁loopsym, u₂loopsym, vloopsym, u₂max, suffix)
+    mvar, opu₁, opu₂ = variable_name_and_unrolled(op, u₁loopsym, u₂loopsym, vloopsym, suffix)
     !opu₂ && suffix > 0 && return
     # TODO: for u₁, needs to consider if reducedchildren are u₁-unrolled
     #       reductions need to consider reduct-status
@@ -94,7 +95,8 @@ function lower_constant!(
     q::Expr, op::Operation, ls::LoopSet, ua::UnrollArgs
 )
     @unpack u₁, u₁loopsym, u₂loopsym, vloopsym, u₂max, suffix = ua
-    mvar, opu₁, opu₂ = variable_name_and_unrolled(op, u₁loopsym, u₂loopsym, u₂max, suffix)
+    # mvar, opu₁, opu₂ = variable_name_and_unrolled(op, u₁loopsym, u₂loopsym, vloopsym, u₂max, suffix)
+    mvar, opu₁, opu₂ = variable_name_and_unrolled(op, u₁loopsym, u₂loopsym, vloopsym, suffix)
     !opu₂ && suffix > 0 && return
     mvar = Symbol(mvar, '_', Core.ifelse(opu₁, u₁, 1))
     instruction = op.instruction

src/codegen/lower_memory_common.jl

@@ -7,9 +7,9 @@ end
 function symbolind(ind::Symbol, op::Operation, td::UnrollArgs)
     id = parentind(ind, op)
     id == -1 && return ind, op
-    @unpack u₁, u₁loopsym, u₂loopsym, u₂max, suffix = td
+    @unpack u₁, u₁loopsym, u₂loopsym, vloopsym, u₂max, suffix = td
     parent = parents(op)[id]
-    pvar, u₁op, u₂op = variable_name_and_unrolled(parent, u₁loopsym, u₂loopsym, u₂max, suffix)
+    pvar, u₁op, u₂op = variable_name_and_unrolled(parent, u₁loopsym, u₂loopsym, vloopsym, suffix)
     Symbol(pvar, '_', Core.ifelse(u₁op, u₁, 1)), parent
 end
 
@@ -57,7 +57,7 @@ function _addoffset!(ret::Expr, vloopstride, indexstride, index, offset, calcbyp
         addoffset!(ret, gethint(vloopstride)*gethint(indexstride), index, offset, calcbypointeroffset)
     else
         addoffset!(ret, mulexpr(vloopstride,indexstride), index, offset, calcbypointeroffset)
-    end    
+    end
 end
 # multiply `index` by `indexstride`
 function addoffset!(ret::Expr, vloopstride, indexstride, index, offset, calcbypointeroffset::Bool) # 6 -> (5 or 6) args
@@ -163,7 +163,6 @@ function mem_offset(op::Operation, td::UnrollArgs, inds_calc_by_ptr_offset::Vect
     end
     ret
 end
-isconditionalmemop(op::Operation) = (instruction(op).instr === :conditionalload) || (instruction(op).instr === :conditionalstore!)
 # function unrolled_curly(op::Operation, u₁::Int, u₁loopsym::Symbol, vectorized::Symbol, mask::Bool)
 
 # interleave: `0` means `false`, positive means literal, negative means multiplier
@@ -328,34 +327,56 @@ end
 @generated function and_last(v::VecUnroll{N}, m) where {N}
     q = Expr(:block, Expr(:meta,:inline), :(vd = data(v)))
     t = Expr(:call, lv(:promote))
+    gf = GlobalRef(Core, :getfield)
     for n ∈ 1:N
-        push!(t.args, :(getfield(vd, $n, false)))
+        push!(t.args, :($gf(vd, $n, false)))
     end
-    push!(t.args, :(getfield(vd, $(N+1), false) & m))
+    push!(t.args, :($gf(vd, $(N+1), false) & m))
     push!(q.args, Expr(:call, lv(:VecUnroll), t))
     q
 end
 
+
+isconditionalmemop(op::Operation) = (instruction(op).instr === :conditionalload) || (instruction(op).instr === :conditionalstore!)
 function add_memory_mask!(memopexpr::Expr, op::Operation, td::UnrollArgs, mask::Bool)
     @unpack u₁, u₁loopsym, u₂loopsym, vloopsym, u₂max, suffix = td
     if isconditionalmemop(op)
         condop = last(parents(op))
         opu₂ = (suffix ≠ -1) && isu₂unrolled(op)
-        condvar, condu₁unrolled = condvarname_and_unroll(condop, u₁loopsym, u₂loopsym, u₂max, suffix, opu₂)
+        condvar, condu₁unrolled = condvarname_and_unroll(condop, u₁loopsym, u₂loopsym, vloopsym, suffix, opu₂)
         # if it isn't unrolled, then `m`
         u = condu₁unrolled ? u₁ : 1
         # u = isu₁unrolled(condop) ? u₁ : 1
         condvar = Symbol(condvar, '_', u)
-        # @show condvar
+        # If we need to apply `MASKSYMBOL` and the condvar
+        # 2 condvar possibilities:
+        #   `VecUnroll` applied everywhere
+        #    single mask "broadcast"
+        # 2 mask possibilities
+        #    u₁loopsym ≠  vloopsym, and we mask all
+        #    u₁loopsym == vloopsym, and we mask last
+        # broadcast both, so can do so implicitly
+        # this is true whether or not `condbroadcast`
         if !mask || (!isvectorized(op))
             push!(memopexpr.args, condvar)
-        else
-            # we only want to apply mask to `u₁`
+        elseif (u₁loopsym ≢ vloopsym) | (u₁ == 1) # mask all equivalenetly
+            push!(memopexpr.args, Expr(:call, lv(:&), condvar, MASKSYMBOL))
+            # if the condition `(u₁loopsym ≢ vloopsym) | (u₁ == 1)` failed, we need to apply `MASKSYMBOL` only to last unroll.
+        elseif !condu₁unrolled && isu₁unrolled(op) # condbroadcast
+            # explicitly broadcast `condvar`, and apply `MASKSYMBOL` to end
+            t = Expr(:call, lv(:promote))
+            for um ∈ 1:u₁-1
+                push!(t.args, condvar)
+            end
+            push!(t.args, Expr(:call, lv(:&), condvar, MASKSYMBOL))
+            push!(memopexpr.args, Expr(:call, lv(:VecUnroll), t))
+        else# !condbroadcast && !vecunrolled
             push!(memopexpr.args, Expr(:call, lv(:and_last), condvar, MASKSYMBOL))
         end
     elseif mask && isvectorized(op)
         push!(memopexpr.args, MASKSYMBOL)
     end
+    nothing
 end
 
 varassignname(var::Symbol, u::Int, isunrolled::Bool) = isunrolled ? Symbol(var, u) : var
@@ -372,7 +393,7 @@ function name_memoffset(var::Symbol, op::Operation, td::UnrollArgs, u₁unrolled
     name, mo
 end
 
-function condvarname_and_unroll(cond, u₁loop, u₂loop, u₂max, suffix, opu₂)
-    condvar, condu₁, condu₂ = variable_name_and_unrolled(cond, u₁loop, u₂loop, u₂max, Core.ifelse(opu₂, suffix, -1))
+function condvarname_and_unroll(cond::Operation, u₁loop::Symbol, u₂loop::Symbol, vloop::Symbol, suffix::Int, opu₂::Bool)
+    condvar, condu₁, condu₂ = variable_name_and_unrolled(cond, u₁loop, u₂loop, vloop, Core.ifelse(opu₂, suffix, -1))
     condvar, condu₁
 end

src/codegen/lower_store.jl

@@ -27,11 +27,6 @@ function reduce_expr_u₂(toreduct::Symbol, instr::Instruction, u₂::Int)
     Expr(:call, lv(:reduce_tup), reduce_to_onevecunroll(instr), t)
 end
 function reduce_expr!(q::Expr, toreduct::Symbol, instr::Instruction, u₁::Int, u₂::Int, isu₁unrolled::Bool, isu₂unrolled::Bool)
-    # if u₂ == -1
-    #     u₁u, u₂u = (true, false)
-    # else
-    #     u₁u, u₂u = isunrolled_sym(op, getloop(ls, us.u₁loopnum).itersymbol, getloop(ls, us.u₂loopnum).itersymbol, _Umax)
-    # end
     if isu₂unrolled# u₂ != -1
         _toreduct = Symbol(toreduct, 0)
         push!(q.args, Expr(:(=), _toreduct, reduce_expr_u₂(toreduct, instr, u₂)))
@@ -59,7 +54,7 @@ function lower_store_collection!(
 
     @unpack u₁, u₁loopsym, u₂loopsym, vloopsym, vloop, u₂max, suffix = ua
     ops = operations(ls)
-
+    # __u₂max = ls.unrollspecification[].u₂
     nouter = length(idsformap)
 
     t = Expr(:tuple)
@@ -68,7 +63,7 @@ function lower_store_collection!(
     for (i,(opid,_)) ∈ enumerate(idsformap)
         opp = first(parents(ops[opidmap[opid]]))
 
-        isu₁, isu₂ = isunrolled_sym(opp, u₁loopsym, u₂loopsym, u₂max)
+        isu₁, isu₂ = isunrolled_sym(opp, u₁loopsym, u₂loopsym, vloopsym)#, __u₂max)
         u = Core.ifelse(isu₁, u₁, 1)
         mvar = Symbol(variable_name(opp, ifelse(isu₂, suffix, -1)), '_', u)
         # mvar = Symbol(variable_name(_op, suffix), '_', u)
@@ -122,7 +117,8 @@ function lower_store!(
     if (opp.instruction.instr === reductfunc) && isone(length(parents(opp)))
         opp = only(parents(opp))
     end
-    isu₁, isu₂ = isunrolled_sym(opp, u₁loopsym, u₂loopsym, u₂max)
+    # __u₂max = ls.unrollspecification[].u₂
+    isu₁, isu₂ = isunrolled_sym(opp, u₁loopsym, u₂loopsym, vloopsym)#, __u₂max)
     u = isu₁ ? u₁ : 1
     mvar = Symbol(variable_name(opp, ifelse(isu₂, suffix, -1)), '_', u)
     if all(op.ref.loopedindex)
@@ -208,7 +204,7 @@ function lower_tiled_store!(blockq::Expr, op::Operation, ls::LoopSet, ua::Unroll
         throw("Operation $opp's instruction is $reductfunc, shouldn't be able to reach here.")
         # opp = only(parents(opp))
     end
-    isu₁, isu₂ = isunrolled_sym(opp, u₁loopsym, u₂loopsym, u₂)
+    isu₁, isu₂ = isunrolled_sym(opp, u₁loopsym, u₂loopsym, vloopsym)#, u₂)
     @assert isu₂
     # It's reasonable forthis to be `!isu₁`
     u = Core.ifelse(isu₁, u₁, 1)

src/codegen/lowering.jl

@@ -1,4 +1,5 @@
 
+
 # the `lowernonstore` and `lowerstore` options are there as a means of lowering all non-store operations before lowering the stores.
 function lower!(
     q::Expr, ops::AbstractVector{Operation}, ls::LoopSet, unrollsyms::UnrollSymbols, u₁::Int, u₂::Int,
@@ -443,7 +444,7 @@ function initialize_outer_reductions!(
     isvectorized = vectorized ∈ reduceddependencies(op)
     typeTr = ELTYPESYMBOL
     z = if isvectorized
-        if Umax == 1
+        if Umax == 1 || u₂ ≠ -1
             if reduct_zero === :zero
                 Expr(:call, lv(:_vzero), VECTORWIDTHSYMBOL, typeTr, rs)
             else
@@ -460,14 +461,14 @@ function initialize_outer_reductions!(
         Expr(:call, reduct_zero, typeTr)
     end
     mvar = variable_name(op, -1)
-    # u1u, u2u = isunrolled_sym(op, getloop(ls, us.u₁loopnum).itersymbol, u₂loop, u₂max)
     if u₂ == -1
         push!(q.args, Expr(:(=), Symbol(mvar, '_', _Umax), z))
-    else
-        u₁u, u₂u = isunrolled_sym(op, getloop(ls, us.u₁loopnum).itersymbol, getloop(ls, us.u₂loopnum).itersymbol, u₂)
+    else#if isu₂unrolled(op) #& (us.vloopnum ≠ us.u₂loopnum) # tiled outer reduction, u₂unrolled
+        # TODO: add `(us.vloopnum ≠ us.u₂loopnum)` check to avoid unrolling and vectorizing a reduction along the same axis
+        u₁u, u₂u = isunrolled_sym(op, getloop(ls, us.u₁loopnum).itersymbol, getloop(ls, us.u₂loopnum).itersymbol, getloop(ls, us.vloopnum).itersymbol)#, u₂)
         if u₁u
-            push!(q.args, Expr(:(=), Symbol(mvar, '_', _Umax), z))
-        else            
+            push!(q.args, Expr(:(=), Symbol(mvar, '_', u₁), z))
+        else
             for u ∈ 0:_Umax-1
                 # push!(q.args, Expr(:(=), Symbol(mvar, '_', u), z))
                 push!(q.args, Expr(:(=), Symbol(mvar, u), z))
@@ -536,21 +537,22 @@ end
 ## This performs reduction to one `Vec`
 function reduce_expr!(q::Expr, ls::LoopSet, U::Int)
     us = ls.unrollspecification[]
-    u₁f, u₂f = if us.u₂ == -1 # TODO: these multiple meanings make code hard to follow. Simplify.
+    u₁f, u₂f = if us.u₂ == -1
         ifelse(U == -1, us.u₁, U), -1
     else
         us.u₁, U
     end
     # u₁loop, u₂loop = getunrolled(ls)
     u₁loop = getloop(ls, us.u₁loopnum).itersymbol
     u₂loop = getloop(ls, us.u₂loopnum).itersymbol
+    vloop  = getloop(ls,  us.vloopnum).itersymbol
     for or ∈ ls.outer_reductions
         op = ls.operations[or]
         var = name(op)
         mvar = mangledvar(op)
         instr = instruction(op)
-        u₁u, u₂u = isunrolled_sym(op, u₁loop, u₂loop, u₂f)
-        reduce_expr!(q, mvar, instr, u₁f, u₂f, u₁u, u₂u)#isu₁unrolled(op))
+        u₁u, u₂u = isunrolled_sym(op, u₁loop, u₂loop, vloop)#, u₂f)
+        reduce_expr!(q, mvar, instr, u₁f, u₂f, u₁u, u₂u)
         if !iszero(length(ls.opdict))
             if (isu₁unrolled(op) | isu₂unrolled(op))
                 push!(q.args, Expr(:(=), var, Expr(:call, lv(reduction_scalar_combine(instr)), Symbol(mvar, "##onevec##"), var)))
@@ -838,7 +840,7 @@ It returns `true`/`false` for each loop, indicating whether they're unrolled.
 If there is a third argument, it will avoid unrolling that symbol along reductions if said symbol is part of the reduction chain.
 
 """
-function isunrolled_sym(op::Operation, u₁loop::Symbol, u₂loop::Symbol)
+function isunrolled_sym(op::Operation, u₁loop::Symbol, u₂loop::Symbol, vloop::Symbol)
     u₁ild = isu₁unrolled(op)
     u₂ild = isu₂unrolled(op)
     (accesses_memory(op) | isloopvalue(op)) && return (u₁ild, u₂ild)
@@ -859,8 +861,16 @@ function isunrolled_sym(op::Operation, u₁loop::Symbol, u₂loop::Symbol)
     u₂reduced = u₂loop ∈ reductops
     # If they're being reduced, we want to only unroll the reduced variable along one of the two loops.
     # @show u₁reduced, u₂reduced
-    if u₂reduced # if both are reduced, we unroll u₁
-        true, false
+    if u₂reduced
+        if u₁reduced# if both are reduced, we unroll u₁
+            if vloop === u₁loop
+                false,true
+            else
+                true, false
+            end
+        else
+            true,false
+        end
     elseif u₁reduced
         false, true
         # true, false
@@ -873,24 +883,19 @@ function isunrolled_sym(op::Operation, u₁loop::Symbol)
     isu₁unrolled(op) || (isconstant(op) & (u₁loop ∈ reducedchildren(op)))
 end
 
-# isunrolled_sym(op::Operation, u₁loop::Symbol, u₂loop::Symbol) = (isunrolled_sym(op, u₁loop), false)
-# isunrolled_sym(op::Operation, u₁loop::Symbol, u₂loop::Symbol, ::Int) = isunrolled_sym(op, u₁loop, u₂loop)
-function isunrolled_sym(op::Operation, u₁loop::Symbol, u₂loop::Symbol, u₂max::Int)
-    ((u₂max > 1) | accesses_memory(op)) ? isunrolled_sym(op, u₁loop, u₂loop) : (isunrolled_sym(op, u₁loop), false)
+function isunrolled_sym(op::Operation, u₁loop::Symbol, u₂loop::Symbol, vloop::Symbol, u₂max::Int)
+    ((u₂max > 1) | accesses_memory(op)) ? isunrolled_sym(op, u₁loop, u₂loop, vloop) : (isunrolled_sym(op, u₁loop), false)
 end
 
 function variable_name(op::Operation, suffix::Int)
     mvar = mangledvar(op)
     suffix == -1 ? mvar : Symbol(mvar, suffix, :_)
 end
 
-function variable_name_and_unrolled(op::Operation, u₁loop::Symbol, u₂loop::Symbol, u₂max::Int, u₂iter::Int)
-    # we require
-    if (u₂iter == -1) | ((u₂max ≤ 1) & (!accesses_memory(op)))
-        return mangledvar(op), isunrolled_sym(op, u₁loop), false
-    end
-    u₁op, u₂op = isunrolled_sym(op, u₁loop, u₂loop)
+# function variable_name_and_unrolled(op::Operation, u₁loop::Symbol, u₂loop::Symbol, vloop::Symbol, u₂max::Int, u₂iter::Int)
+function variable_name_and_unrolled(op::Operation, u₁loop::Symbol, u₂loop::Symbol, vloop::Symbol, u₂iter::Int)
+    # u₁op, u₂op = isunrolled_sym(op, u₁loop, u₂loop, vloop, Core.ifelse(u₂iter == -1, 1, u₂max))
+    u₁op, u₂op = isunrolled_sym(op, u₁loop, u₂loop, vloop)#, u₂max)
     mvar = u₂op ? variable_name(op, u₂iter) : mangledvar(op)
-    # mvar = mangledvar(op)
     mvar, u₁op, u₂op
 end