Tests pass locally for d=5 mixed integer-Cartesian indexing.

Author: chriselrod

.travis.yml

@@ -12,6 +12,8 @@ notifications:
 after_success:
   - julia -e 'using Pkg; Pkg.add("Coverage"); using Coverage; Codecov.submit(process_folder())'
 jobs:
+  allow_failures:
+  - julia: nightly
   include:
     - stage: "Documentation"
       julia: 1.3

src/condense_loopset.jl

@@ -113,23 +113,23 @@ function OperationStruct!(varnames::Vector{Symbol}, ls::LoopSet, op::Operation)
 end
 ## turn a LoopSet into a type object which can be used to reconstruct the LoopSet.
 
+function loop_boundary(loop::Loop)
+    startexact = loop.startexact
+    stopexact = loop.stopexact
+    if startexact & stopexact
+        Expr(:call, Expr(:curly, lv(:StaticUnitRange), loop.starthint, loop.stophint))
+    elseif startexact
+        Expr(:call, Expr(:curly, lv(:StaticLowerUnitRange), loop.starthint), loop.stopsym)
+    elseif stopexact
+        Expr(:call, Expr(:curly, lv(:StaticUpperUnitRange), loop.stophint), loop.startsym)
+    else
+        Expr(:call, :(:), loop.startsym, loop.stopsym)
+    end
+end
 
 function loop_boundaries(ls::LoopSet)
     lbd = Expr(:tuple)
-    for loop ∈ ls.loops
-        startexact = loop.startexact
-        stopexact = loop.stopexact
-        lexpr = if startexact & stopexact
-            Expr(:call, Expr(:curly, lv(:StaticUnitRange), loop.starthint, loop.stophint))
-        elseif startexact
-            Expr(:call, Expr(:curly, lv(:StaticLowerUnitRange), loop.starthint), loop.stopsym)
-        elseif stopexact
-            Expr(:call, Expr(:curly, lv(:StaticUpperUnitRange), loop.stophint), loop.startsym)
-        else
-            Expr(:call, :(:), loop.startsym, loop.stopsym)
-        end
-        push!(lbd.args, lexpr)
-    end
+    foreach(loop -> push!(lbd.args, loop_boundary(loop)), ls.loops)
     lbd
 end
 
@@ -204,6 +204,7 @@ end
     ::Val{UT}, ::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}
+    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)
@@ -279,14 +280,23 @@ function generate_call(ls::LoopSet, IUT, debug::Bool = false)
     add_external_functions!(q, ls)
     q
 end
-
+concat_vals() = Val{()}()
+# @generated concat_vals(::Val{N}) where {N} = Val{(N,)}()
+# @generated concat_vals(::Val{M}, ::Val{N}) where {M, N} = Val{(M,N)}()
+@generated function concat_vals(args...)
+    tup = Expr(:tuple)
+    for n in eachindex(args)
+        push!(tup.args, args[n].parameters[1])
+    end
+    Expr(:call, Expr(:curly, :Val, tup))
+end
 function setup_call_noinline(ls::LoopSet, U = zero(Int8), T = zero(Int8))
     call = generate_call(ls, (false,U,T))
     hasouterreductions = length(ls.outer_reductions) > 0
     q = Expr(:block)
     vptrarrays = Expr(:tuple)
     vptrsubsetvals = Expr(:tuple)
-    vptrsubsetdims = Expr(:tuple)
+    vptrsubsetdims = Expr(:call, lv(:concat_vals))
     vptrindices = Expr(:tuple)
     stridedpointerLHS = Symbol[]
     loopvalueLHS = Symbol[]
@@ -304,7 +314,7 @@ function setup_call_noinline(ls::LoopSet, U = zero(Int8), T = zero(Int8))
                         @assert array ∈ loopvalueLHS
                         push!(vptrarrays.args, -1)
                     end
-                    push!(vptrsubsetdims.args, nothing)
+                    push!(vptrsubsetdims.args, Expr(:call, Expr(:curly, :Val, nothing)))
                     vp = first(ex.args)::Symbol
                     push!(stridedpointerLHS, vp)
                     push!(vptrindices.args, findfirst(a -> vptr(a) == vp, ls.refs_aliasing_syms))
@@ -316,7 +326,7 @@ function setup_call_noinline(ls::LoopSet, U = zero(Int8), T = zero(Int8))
                         @assert vptrarrayid isa Int
                     end
                     push!(vptrarrays.args, vptrarrayid::Int)
-                    push!(vptrsubsetdims.args, ex.args[2].args[3].args[1].args[2])
+                    push!(vptrsubsetdims.args, ex.args[2].args[3])#.args[1].args[2])
                     push!(vptrsubsetvals.args, ex.args[2].args[4])
                     vp = first(ex.args)::Symbol
                     push!(stridedpointerLHS, vp)
@@ -327,7 +337,8 @@ function setup_call_noinline(ls::LoopSet, U = zero(Int8), T = zero(Int8))
         push!(q.args, ex)
     end
     insert!(call.args, 8, Expr(:call, Expr(:curly, :Val, vptrarrays)))
-    insert!(call.args, 9, Expr(:call, Expr(:curly, :Val, vptrsubsetdims)))
+    # insert!(call.args, 9, Expr(:call, Expr(:curly, :Val, vptrsubsetdims)))
+    insert!(call.args, 9, vptrsubsetdims)
     insert!(call.args, 10, Expr(:call, Expr(:curly, :Val, vptrindices)))
     insert!(call.args, 11, vptrsubsetvals)
     if hasouterreductions

src/memory_ops_common.jl

@@ -29,17 +29,46 @@ function add_vptr!(ls::LoopSet, array::Symbol, vptrarray::Symbol = vptr(array),
     end
     nothing
 end
-function subset_vptr!(ls::LoopSet, vptr::Symbol, indnum::Int, ind::Union{Symbol,Int})
+
+@inline valsum() = Val{0}()
+@inline valsum(::Val{M}) where {M} = Val{M}()
+@generated valsum(::Val{M}, ::Val{N}) where {M,N} = Val{M+N}()
+@inline valsum(::Val{M}, ::Val{N}, ::Val{K}, args...) where {M,N,K} = valsum(valsum(Val{M}(), Val{N}()), Val{K}(), args...)
+@inline valdims(::Any) = Val{1}()
+@inline valdims(::CartesianIndices{N}) where {N} = Val{N}()
+
+function append_loop_valdims!(valcall::Expr, loop::Loop)
+    if isstaticloop(loop)
+        push!(valcall.args, :(Val{1}()))
+    else
+        push!(valcall.args, Expr(:call, lv(:valdims), loop_boundary(loop)))
+    end
+    nothing
+end
+function subset_vptr!(ls::LoopSet, vptr::Symbol, indnum::Int, ind, previndices, loopindex)
     subsetvptr = Symbol(vptr, "_subset_$(indnum)_with_$(ind)##")
-    inde = ind isa Symbol ? Expr(:call, :-, ind, 1) : ind - 1
-    pushpreamble!(ls, Expr(:(=), subsetvptr, Expr(:call, lv(:subsetview), vptr, Expr(:call, Expr(:curly, :Val, indnum)), inde)))
+    valcall = Expr(:call, Expr(:curly, :Val, 1))
+    if indnum > 1
+        valcall = Expr(:call, lv(:valsum), valcall)
+        for i ∈ 1:indnum-1
+            if loopindex[i]
+                append_loop_valdims!(valcall, getloop(ls, previndices[i]))
+            else
+                for loopdep ∈ loopdependencies(ls.opdict[previndices[i]])
+                    append_loop_valdims!(valcall, getloop(ls, loopdep))
+                end
+            end
+        end
+    end
+    # @show valcall
+    indm1 = ind isa Integer ? ind - 1 : Expr(:call, :-, ind, 1)
+    pushpreamble!(ls, Expr(:(=), subsetvptr, Expr(:call, lv(:subsetview), vptr, valcall, indm1)))
     subsetvptr
 end
 const DISCONTIGUOUS = Symbol("##DISCONTIGUOUSSUBARRAY##")
 function array_reference_meta!(ls::LoopSet, array::Symbol, rawindices, elementbytes::Int)
     vptrarray = vptr(array)
     add_vptr!(ls, array, vptrarray) # now, subset
-    
     indices = Symbol[]
     loopedindex = Bool[]
     parents = Operation[]
@@ -49,7 +78,7 @@ function array_reference_meta!(ls::LoopSet, array::Symbol, rawindices, elementby
     ninds = 1
     for ind ∈ rawindices        
         if ind isa Integer # subset
-            vptrarray = subset_vptr!(ls, vptrarray, ninds, ind)
+            vptrarray = subset_vptr!(ls, vptrarray, ninds, ind, indices, loopedindex)
             length(indices) == 0 && push!(indices, DISCONTIGUOUS)
         elseif ind isa Expr
             #FIXME: position (in loopnest) wont be length(ls.loopsymbols) in general
@@ -66,12 +95,11 @@ function array_reference_meta!(ls::LoopSet, array::Symbol, rawindices, elementby
             else
                 indop = get(ls.opdict, ind, nothing)
                 if indop !== nothing  && !isconstant(indop)
-                    pushparent!(parents, loopdependencies, reduceddeps, parent)   # FIXME where does `parent` come from?
-                    # var = get(ls.opdict, ind, nothing)
-                    push!(indices, name(parent)); ninds += 1
+                    pushparent!(parents, loopdependencies, reduceddeps, indop)
+                    push!(indices, name(indop)); ninds += 1
                     push!(loopedindex, false)
                 else
-                    vptrarray = subset_vptr!(ls, vptrarray, ninds, ind)
+                    vptrarray = subset_vptr!(ls, vptrarray, ninds, ind, indices, loopedindex)
                     length(indices) == 0 && push!(indices, DISCONTIGUOUS)
                 end
             end

src/reconstruct_loopset.jl

@@ -1,4 +1,4 @@
-const NOpsType = Union{Int,Vector{Int}}
+const NOpsType = Int#Union{Int,Vector{Int}}
 
 function Loop(ls::LoopSet, ex::Expr, sym::Symbol, ::Type{<:AbstractUnitRange})
     ssym = String(sym)
@@ -239,11 +239,12 @@ function calcnops(ls::LoopSet, os::OperationStruct)
     offsets = ls.loopsymbol_offsets
     idxs = loopindex(ls, os.loopdeps, 0x04)  # FIXME DRY
     iszero(length(idxs)) && return 1
-    return map(i->offsets[i+1]-offsets[i], idxs)
+    return maximum(i->offsets[i+1]-offsets[i], idxs)
 end
 function isexpanded(ls::LoopSet, ops::Vector{OperationStruct}, nopsv::Vector{NOpsType}, i::Int)
     nops = nopsv[i]
-    (nops === 1 || nops == [1]) && return false
+    # nops isa Vector{Int} only if accesses_memory(os), which means isexpanded must be false
+    (nops === 1 || isa(nops, Vector{Int})) && return false
     os = ops[i]
     optyp = optype(os)
     if optyp == compute
@@ -260,7 +261,6 @@ function add_op!(
     mrefs::Vector{ArrayReferenceMeta}, opsymbol, elementbytes::Int
 )
     os = ops[i]
-    nops = nopsv[i]
     # opsymbol = (isconstant(os) && instr != LOOPCONSTANT) ? instr.instr : opsymbol
     # If it's a CartesianIndex add or subtract, we may have to add multiple operations
     expanded = expandedv[i]# isexpanded(ls, ops, nopsv, i)
@@ -278,12 +278,7 @@ function add_op!(
         push!(opoffsets, opoffsets[end] + 1)
         return
     end
-    if isa(nops, Vector)
-        n = first(nops)
-        if all(isequal(n), nops)
-            nops = n
-        end
-    end
+    nops = (nopsv[i])::Int # if it were a vector, it would have to have been expanded
     # if expanded, optyp must be either loopvalue, or compute (with loopvalues in its ancestry, not cutoff by loads)
     for offset = 0:nops-1
         sym = nops === 1 ? opsymbol : expandedopname(opsymbol, offset)

test/miscellaneous.jl

@@ -680,30 +680,46 @@ using Test
         function smoothdim_avx!(s, x, α, Rpre, irng::AbstractUnitRange, Rpost)
             ifirst, ilast = first(irng), last(irng)
             ifirst > ilast && return s
-            @avx for Ipost in Rpost
-                # Initialize the first value along the filtered dimension
+            @avx tile=(1,1) for Ipost in Rpost
+                # Handle all other entries
                 for Ipre in Rpre
                     s[Ipre, ifirst, Ipost] = x[Ipre, ifirst, Ipost]
+                    for i = ifirst+1:ilast
+                        s[Ipre, i, Ipost] = α*x[Ipre, i, Ipost] + (1-α)*x[Ipre, i-1, Ipost]
+                    end
                 end
+            end
+            s
+        end
+        function smoothdim_ifelse_avx!(s, x, α, Rpre, irng::AbstractUnitRange, Rpost)
+            ifirst, ilast = first(irng), last(irng)
+            ifirst > ilast && return s
+            @avx tile=(1,1) for Ipost in Rpost
                 # Handle all other entries
-                for i = ifirst+1:ilast
+                for i = ifirst:ilast
                     for Ipre in Rpre
-                        s[Ipre, i, Ipost] = α*x[Ipre, i, Ipost] + (1-α)*x[Ipre, i-1, Ipost]
+                        xi = x[Ipre, i, Ipost]
+                        xim = ifelse(i == ifirst, xi, x[Ipre, i-1, Ipost])
+                        s[Ipre, i, Ipost] = α*xi + (1-α)*xim
                     end
                 end
             end
             s
         end
 
-        x = rand(11,11,11) # ,11,11)
-        dest1, dest2 = similar(x), similar(x)
+        x = rand(11,11,11,11,11);
+        dest1, dest2 = similar(x), similar(x);
         α = 0.3
         for d = 1:ndims(x)
-            Rpre  = CartesianIndices(axes(x)[1:d-1])
-            Rpost = CartesianIndices(axes(x)[d+1:end])
+            # @show d
+            Rpre  = CartesianIndices(axes(x)[1:d-1]);
+            Rpost = CartesianIndices(axes(x)[d+1:end]);
             smoothdim!(dest1, x, α, Rpre, axes(x, d), Rpost)
             smoothdim_avx!(dest2, x, α, Rpre, axes(x, d), Rpost)
             @test dest1 ≈ dest2
+            fill!(dest2, NaN); smoothdim_ifelse_avx!(dest2, x, α, Rpre, axes(x, d), Rpost)
+            @test dest1 ≈ dest2
         end
     end
 end
+