Still working on lowering code.

Author: chriselrod

src/LoopVectorization.jl

@@ -202,8 +202,9 @@ end
         b = macroexpand(LoopVectorization, b)
         ## body preamble must define indexed symbols
         ## we only need that for loads.
+        dicts = (indexed_expressions, reduction_symbols, loaded_exprs, loop_constants_dict)
         push!(main_body.args,
-            _vectorloads!(main_body, q, indexed_expressions, reduction_symbols, loaded_exprs, V, W, T, loop_constants_quote, loop_constants_dict, b;
+            _vectorloads!(main_body, q, dicts, V, W, T, loop_constants_quote, b;
                             itersym = itersym, declared_iter_sym = n, VectorizationDict = vecdict, mod = mod)
         )# |> x -> (@show(x), _pirate(x)))
     end
@@ -382,8 +383,9 @@ end
 end
 
 
-@noinline function _vectorloads!(main_body, pre_quote, indexed_expressions, reduction_symbols, loaded_exprs, V, W, VET, loop_constants_quote, loop_constants_dict, expr;
-                            itersym = :iter, declared_iter_sym = nothing, VectorizationDict = SLEEFPiratesDict, mod = :LoopVectorization)
+@noinline function _vectorloads!(main_body, pre_quote, dicts, V, W, VET, loop_constants_quote, expr;
+                                 itersym = :iter, declared_iter_sym = nothing, VectorizationDict = SLEEFPiratesDict, mod = :LoopVectorization)
+    (indexed_expressions, reduction_symbols, loaded_exprs, loop_constants_dict) = dicts
     _spirate(prewalk(expr) do x
         # @show x
         # @show main_body

src/graphs.jl

@@ -71,7 +71,7 @@ struct Operation
 end
 
 function isreduction(op::Operation)
-    (op.node_type == memstore) && (length(op.symbolic_metadata) < length(op.dependencies)) && issubset(op.symbolic_metadata, op.dependencies)
+    (op.node_type == memstore) && (length(op.symbolic_metadata) < length(op.dependencies))# && issubset(op.symbolic_metadata, op.dependencies)
 end
 isload(op::Operation) = op.node_type == memload
 isstore(op::Operation) = op.node_type == memstore
@@ -91,11 +91,11 @@ function stride(op::Operation, sym::Symbol)
     op.numerical_metadata[findfirst(s -> s === sym, op.symbolic_metadata)]
 end
 # function
-
-struct Node
-    type::DataType
+function unitstride(op::Operation, sym::Symbol)
+    (first(op.symbolic_metadata) === sym) && (first(op.numerical_metadata) == 1)
 end
 
+
 struct Loop
     itersymbol::Symbol
     rangehint::Int
@@ -116,7 +116,8 @@ struct LoopSet
     loadops::Vector{Operation} # Split them to make it easier to iterate over just a subset
     computeops::Vector{Operation}
     storeops::Vector{Operation}
-    reductions::Set{Operation}
+    reductions::Set{UInt} # IDs of reduction operations that need to be reduced at end.
+    strideset::Vector{} 
 end
 num_loops(ls::LoopSet) = length(ls.loops)
 isstaticloop(ls::LoopSet, s::Symbol) = ls.loops[s].hintexact
@@ -147,7 +148,7 @@ function cost(op::Operation, unrolled::Symbol, Wshift::Int, size_T::Int)
     if accesses_memory(op)
         # either vbroadcast/reductionstore, vmov(a/u)pd, or gather/scatter
         if opisunrolled
-            if (stride(op, unrolled) != 1) || !isdense(op) # need gather/scatter
+            if !unitstride(op, unrolled)# || !isdense(op) # need gather/scatter
                 r = (1 << Wshift)
                 c *= r
                 sl *= r
@@ -456,6 +457,35 @@ function depends_on_assigned(op::Operation, assigned::Vector{Bool})
     end
     false
 end
+function lower_load!(q::Expr, op::Operation, unrolled::Symbol, U, Umax, T = nothing, Tmax = nothing)
+    loopdeps = loopdependencies(op)
+    if unrolled ∈ loopdeps # we need a vector
+        if unitstride(op, unrolled) # vload
+            
+        else # gather
+            
+        end
+    else # load scalar; promotion should broadcast as/when neccesary
+        Expr(:call, :(VectorizationBase.load),  )
+    end
+end
+function lower_store!(q::Expr, op::Operation, unrolled::Symbol, U, T = 1)
+
+end
+function lower_compute!(q::Expr, op::Operation, unrolled::Symbol, U, T = 1)
+    for t ∈ T, u ∈ U
+        
+    end
+end
+function lower!(q::Expr, op::Operation, unrolled::Symbol, U, T = 1)
+    if isload(op)
+        lower_load!(q, op, unrolled, U, T)
+    elseif isstore(op)
+        lower_store!(q, op, unrolled, U, T)
+    else
+        lower_compute!(q, op, unrolled, U, T)
+    end
+end
 
 # construction requires ops inserted into operations vectors in dependency order.
 function lower_unroll(ls::LoopSet, order::Vector{Symbol}, U::Int)
@@ -476,13 +506,14 @@ function lower_unroll_inner_block(ls::LoopSet, order::Vector{Symbol}, U::Int)
 
     n = 0
     loopsym = last(order)
+    blockq = Expr(:block, )
+    loopq = Expr(:for, Expr(:(=), itersym, looprange(ls, loopsym)), blockq)
     for (id,op) ∈ enumerate(operations(ls))
         # We add an op the first time all loop dependencies are met
         # when working through loops backwords, that equates to the first time we encounter a loop dependency
         loopsym ∈ dependencies(op) || continue
         included_vars[id] = true
-        
-        
+        lower!(blockq, op, unrolled, U)
     end
     for n ∈ 1:nloops - 2
         loopsym = order[nloops - n]

src/precompile.jl

@@ -2,7 +2,9 @@ function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
     precompile(Tuple{typeof(LoopVectorization.vectorize_body),Int64,Type{Float64},Int64,Symbol,Array{Any,1},Dict{Symbol,Tuple{Symbol,Symbol}},Any,Bool,Module})
     precompile(Tuple{typeof(LoopVectorization.vectorize_body),Int64,Type{Float64},Int64,Symbol,Array{Any,1},Dict{Symbol,Tuple{Symbol,Symbol}},Any,Bool})
-    precompile(Tuple{LoopVectorization.var"#_vectorloads!##kw",NamedTuple{(:itersym, :declared_iter_sym, :VectorizationDict, :mod),Tuple{Symbol,Symbol,Dict{Symbol,Tuple{Symbol,Symbol}},Symbol}},typeof(LoopVectorization._vectorloads!),Expr,Expr,Dict{Symbol,Symbol},Dict{Tuple{Symbol,Symbol},Symbol},Dict{Expr,Symbol},Type,Int64,Type,Expr,Dict{Expr,Symbol},Expr})
-    precompile(Tuple{LoopVectorization.var"#_vectorloads!##kw",NamedTuple{(:itersym, :declared_iter_sym, :VectorizationDict, :mod),Tuple{Symbol,Symbol,Dict{Symbol,Tuple{Symbol,Symbol}},Module}},typeof(LoopVectorization._vectorloads!),Expr,Expr,Dict{Symbol,Symbol},Dict{Tuple{Symbol,Symbol},Symbol},Dict{Expr,Symbol},Type,Int64,Type,Expr,Dict{Expr,Symbol},Expr})
+    precompile(Tuple{LoopVectorization.var"#_vectorloads!##kw",NamedTuple{(:itersym, :declared_iter_sym, :VectorizationDict, :mod),Tuple{Symbol,Symbol,Dict{Symbol,Tuple{Symbol,Symbol}},Module}},typeof(LoopVectorization._vectorloads!),Expr,Expr,Tuple{Dict{Symbol,Symbol},Dict{Tuple{Symbol,Symbol},Symbol},Dict{Expr,Symbol},Dict{Expr,Symbol}},Type,Int64,Type,Expr,Expr})
     precompile(Tuple{typeof(LoopVectorization.vectorize_body),Symbol,Type{Float64},Int64,Symbol,Array{Any,1},Dict{Symbol,Tuple{Symbol,Symbol}},Any,Bool})
+    precompile(Tuple{LoopVectorization.var"#_vectorloads!##kw",NamedTuple{(:itersym, :declared_iter_sym, :VectorizationDict, :mod),Tuple{Symbol,Symbol,Dict{Symbol,Tuple{Symbol,Symbol}},Symbol}},typeof(LoopVectorization._vectorloads!),Expr,Expr,Tuple{Dict{Symbol,Symbol},Dict{Tuple{Symbol,Symbol},Symbol},Dict{Expr,Symbol},Dict{Expr,Symbol}},Type,Int64,Type,Expr,Expr})
+    precompile(Tuple{typeof(LoopVectorization.add_masks),Expr,Symbol,Dict{Tuple{Symbol,Symbol},Symbol},Module})
+    precompile(Tuple{typeof(LoopVectorization.add_masks),Expr,Symbol,Dict{Tuple{Symbol,Symbol},Symbol},Symbol})
 end