Updated tests, fixed broadcasting product example.

Author: chriselrod

src/broadcast.jl

@@ -2,9 +2,25 @@ struct Product{A,B}
     a::A
     b::B
 end
+function Base.size(p::Product)
+    M = size(p.a, 1)
+    (M, Base.tail(size(p.b))...)
+end
+@inline Base.length(p::Product) = prod(size(p))
+@inline Base.broadcastable(p::Product) = p
+@inline Base.ndims(p::Type{Product{A,B}}) where {A,B} = ndims(B)
+
+Base.Broadcast._broadcast_getindex_eltype(::Product{A,B}) where {T, A <: AbstractVecOrMat{T}, B <: AbstractVecOrMat{T}} = T
+function Base.Broadcast._broadcast_getindex_eltype(p::Product)
+    promote_type(
+        Base.Broadcast._broadcast_getindex_eltype(p.a),
+        Base.Broadcast._broadcast_getindex_eltype(p.b)
+    )
+end
+
 
 @inline ∗(a::A, b::B) where {A,B} = Product{A,B}(a, b)
-@inline Base.Broadcast.Broadcasted(::typeof(∗), a::A, b::B) where {A, B} = Product{A,B}(a, b)
+@inline Base.Broadcast.broadcasted(::typeof(∗), a::A, b::B) where {A, B} = Product{A,B}(a, b)
 # TODO: Need to make this handle A or B being (1 or 2)-D broadcast objects.
 function add_broadcast!(
     ls::LoopSet, mC::Symbol, bcname::Symbol, loopsyms::Vector{Symbol},
@@ -19,17 +35,29 @@ function add_broadcast!(
 
     k = gensym(:k)
     ls.loops[k] = Loop(k, K)
-    m = loopsyms[1]; n = loopsyms[2];
+    m = loopsyms[1];
+    if ndims(B) == 1
+        bloopsyms = Symbol[k]
+        cloopsyms = Symbol[m]
+        reductdeps = Symbol[m, k]
+    elseif ndims(B) == 2
+        n = loopsyms[2];
+        bloopsyms = Symbol[k,n]
+        cloopsyms = Symbol[m,n]
+        reductdeps = Symbol[m, k, n]
+    else
+        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, [m,k], A, elementbytes)
+    loadA = add_broadcast!(ls, gensym(:A), mA, Symbol[m,k], A, elementbytes)
     # load B
-    loadB = add_broadcast!(ls, gensym(:B), mB, [k,n], B, elementbytes)
+    loadB = add_broadcast!(ls, gensym(:B), mB, bloopsyms, B, elementbytes)
     # set Cₘₙ = 0
-    setC = add_constant!(ls, 0.0, Symbol[m, k], mC, elementbytes)
+    setC = add_constant!(ls, 0.0, cloopsyms, mC, elementbytes)
     # compute Cₘₙ += Aₘₖ * Bₖₙ
     reductop = Operation(
-        ls, mC, elementbytes, :vmuladd, compute, Symbol[m, k, n], Symbol[k], Operation[loadA, loadB, setC]
+        ls, mC, elementbytes, :vmuladd, compute, reductdeps, Symbol[k], Operation[loadA, loadB, setC]
     )
     pushop!(ls, reductop, mC)    
 end
@@ -102,8 +130,8 @@ end
 # size of dest determines loops
 @generated function vmaterialize!(
     dest::AbstractArray{T,N}, bc::BC
-# ) where {T, N, BC <: Broadcasted}
-) where {N, T, BC <: Broadcasted}
+) where {T, N, BC <: Broadcasted}
+# ) where {N, T, BC <: Broadcasted}
     # we have an N dimensional loop.
     # need to construct the LoopSet
     loopsyms = [gensym(:n) for n ∈ 1:N]

src/determinestrategy.jl

@@ -105,7 +105,12 @@ function depchain_cost!(
     end
     rt, sl
 end
-   
+function parentsnotreduction(op::Operation)
+    for opp ∈ parents(op)
+        isreduction(opp) && return false
+    end
+    return true
+end
 function determine_unroll_factor(
     ls::LoopSet, order::Vector{Symbol}, unrolled::Symbol = first(order)
 )
@@ -116,7 +121,7 @@ function determine_unroll_factor(
     # The assumption here is that unrolling provides no real benefit, unless it is needed to enable OOO execution by breaking up these dependency chains
     num_reductions = 0#sum(isreduction, operations(ls))
     for op ∈ operations(ls)
-        if isreduction(op) & iscompute(op)
+        if isreduction(op) & iscompute(op) && parentsnotreduction(op)
             num_reductions += 1
         end
     end

src/graphs.jl

@@ -146,7 +146,7 @@ end
 
 function Operation(
     ls::LoopSet, variable, elementbytes, instruction,
-    node_type, dependencies, reduced_deps, parents, ref
+    node_type, dependencies, reduced_deps, parents, ref = NOTAREFERENCE
 )
     Operation(
         length(operations(ls)), variable, elementbytes, instruction,
@@ -283,6 +283,16 @@ function mergesetv!(s1::AbstractVector{T}, s2::AbstractVector{T}) where {T}
     end
     nothing
 end
+function mergesetdiffv!(
+    s1::AbstractVector{T},
+    s2::AbstractVector{T},
+    s3::AbstractVector{T}
+) where {T}
+    for s ∈ s2
+        s ∉ s3 && addsetv!(s1, s)
+    end
+    nothing
+end
 function setdiffv!(s3::AbstractVector{T}, s1::AbstractVector{T}, s2::AbstractVector{T}) where {T}
     for s ∈ s1
         (s ∈ s2) || (s ∉ s3 && push!(s3, s))
@@ -311,7 +321,7 @@ function add_constant!(ls::LoopSet, var, deps::Vector{Symbol}, sym::Symbol = gen
 end
 function pushparent!(parents::Vector{Operation}, deps::Vector{Symbol}, reduceddeps::Vector{Symbol}, parent::Operation)
     push!(parents, parent)
-    mergesetv!(deps, loopdependencies(parent))
+    mergesetdiffv!(deps, loopdependencies(parent), reduceddependencies(parent))
     if !(isload(parent) || isconstant(parent))
         mergesetv!(reduceddeps, reduceddependencies(parent))
     end

src/operations.jl

@@ -90,7 +90,7 @@ struct Operation
     # numerical_metadata::Vector{Int} # stride of -1 indicates dynamic
     # symbolic_metadata::Vector{Symbol}
     function Operation(
-        identifier,
+        identifier::Int,
         variable,
         elementbytes,
         instruction,