Improve coverage slightly by removing unused code and adding a couple tests.

Author: chriselrod

src/graphs.jl

@@ -22,8 +22,8 @@ function UnrollArgs(ua::UnrollArgs, u::Int)
 end
 # UnrollSymbols(ua::UnrollArgs) = UnrollSymbols(ua.u₁loopsym, ua.u₂loopsym, ua.vectorized)
 
-isfirst(ua::UnrollArgs{Nothing}) = iszero(ua.u₁)
-isfirst(ua::UnrollArgs{Int}) = iszero(ua.u₁) & iszero(ua.suffix)
+# isfirst(ua::UnrollArgs{Nothing}) = iszero(ua.u₁)
+# isfirst(ua::UnrollArgs{Int}) = iszero(ua.u₁) & iszero(ua.suffix)
 
 struct UnrollSpecification
     u₁loopnum::Int
@@ -191,12 +191,12 @@ struct LoopOrder <: AbstractArray{Vector{Operation},5}
     loopnames::Vector{Symbol}
     bestorder::Vector{Symbol}
 end
-function LoopOrder(N::Int)
-    LoopOrder(
-        [ Operation[] for _ ∈ 1:8N ],
-        Vector{Symbol}(undef, N), Vector{Symbol}(undef, N)
-    )
-end
+# function LoopOrder(N::Int)
+#     LoopOrder(
+#         [ Operation[] for _ ∈ 1:8N ],
+#         Vector{Symbol}(undef, N), Vector{Symbol}(undef, N)
+#     )
+# end
 LoopOrder() = LoopOrder(Vector{Operation}[],Symbol[],Symbol[])
 Base.empty!(lo::LoopOrder) = foreach(empty!, lo.oporder)
 function Base.resize!(lo::LoopOrder, N::Int)
@@ -300,18 +300,18 @@ function pushpreamble!(ls::LoopSet, op::Operation, v::Number)
     end
 end
 pushpreamble!(ls::LoopSet, ex::Expr) = push!(ls.preamble.args, ex)
-function pushpreamble!(ls::LoopSet, op::Operation, RHS::Expr)
-    c = gensym(:licmconst)
-    if RHS.head === :call && first(RHS.args) === :zero
-        push!(ls.preamble_zeros, (identifier(op), IntOrFloat))
-    elseif RHS.head === :call && first(RHS.args) === :one
-        push!(ls.preamble_funcofeltypes, (identifier(op), :one))
-    else
-        pushpreamble!(ls, Expr(:(=), c, RHS))
-        pushpreamble!(ls, op, c)
-    end
-    nothing
-end
+# function pushpreamble!(ls::LoopSet, op::Operation, RHS::Expr)
+#     c = gensym(:licmconst)
+#     if RHS.head === :call && first(RHS.args) === :zero
+#         push!(ls.preamble_zeros, (identifier(op), IntOrFloat))
+#     elseif RHS.head === :call && first(RHS.args) === :one
+#         push!(ls.preamble_funcofeltypes, (identifier(op), :one))
+#     else
+#         pushpreamble!(ls, Expr(:(=), c, RHS))
+#         pushpreamble!(ls, op, c)
+#     end
+#     nothing
+# end
 function zerotype(ls::LoopSet, op::Operation)
     opid = identifier(op)
     for (id,typ) ∈ ls.preamble_zeros
@@ -363,9 +363,9 @@ getloop(ls::LoopSet, s::Symbol) = ls.loops[getloopid(ls, s)]
 getloopsym(ls::LoopSet, i::Integer) = ls.loopsymbols[i]
 Base.length(ls::LoopSet, s::Symbol) = length(getloop(ls, s))
 
-isstaticloop(ls::LoopSet, s::Symbol) = isstaticloop(getloop(ls,s))
-looprangehint(ls::LoopSet, s::Symbol) = length(getloop(ls, s))
-looprangesym(ls::LoopSet, s::Symbol) = getloop(ls, s).rangesym
+# isstaticloop(ls::LoopSet, s::Symbol) = isstaticloop(getloop(ls,s))
+# looprangehint(ls::LoopSet, s::Symbol) = length(getloop(ls, s))
+# looprangesym(ls::LoopSet, s::Symbol) = getloop(ls, s).rangesym
 getop(ls::LoopSet, var::Number, elementbytes) = add_constant!(ls, var, elementbytes)
 function getop(ls::LoopSet, var::Symbol, elementbytes::Int)
     get!(ls.opdict, var) do
@@ -546,14 +546,13 @@ function maybe_const_compute!(ls::LoopSet, op::Operation, elementbytes::Int, pos
     end
 end
 function strip_op_linenumber_nodes(q::Expr)
-    non_lnn_ind = 0
-    for i ∈ eachindex(q.args)
-        if !(q.args[i] isa LineNumberNode)
-            @assert iszero(non_lnn_ind) "There should only be one non-LineNumberNode in the expression."
-            non_lnn_ind = i
-        end
+    filtered = filter(x -> !isa(x, LineNumberNode), q.args)
+    if VERSION ≥ v"1.4"
+        only(filtered)
+    else
+        @assert isone(length(filtered))
+        first(filtered)
     end
-    q.args[non_lnn_ind]
 end
 
 function add_operation!(

src/operations.jl

@@ -277,12 +277,11 @@ vptr(x::Symbol) = Symbol("##vptr##_", x)
 vptr(x::ArrayReference) = vptr(x.array)
 vptr(x::ArrayReferenceMeta) = x.ptr
 vptr(x::Operation) = x.ref.ptr
-vptrbase(x) = Symbol(vptr(x), "##BASE##")
+# vptrbase(x) = Symbol(vptr(x), "##BASE##")
 name(x::ArrayReference) = x.array
 name(x::ArrayReferenceMeta) = x.ref.array
 name(op::Operation) = op.variable
 instruction(op::Operation) = op.instruction
-isreductionzero(op::Operation, instr::Symbol) = op.instruction.mod === REDUCTION_ZERO[instr]
 isreductcombineinstr(op::Operation) = iscompute(op) && isreductcombineinstr(instruction(op))
 """
     mvar = mangledvar(op)
@@ -327,9 +326,9 @@ mutable struct ArrayReferenceMetaPosition
     reduceddeps::Vector{Symbol}
     varname::Symbol
 end
-function ArrayReferenceMetaPosition(parents::Vector{Operation}, ldref::Vector{Symbol}, reduceddeps::Vector{Symbol}, varname::Symbol)
-    ArrayReferenceMetaPosition( NOTAREFERENCE, parents, ldref, reduceddeps, varname )
-end
+# function ArrayReferenceMetaPosition(parents::Vector{Operation}, ldref::Vector{Symbol}, reduceddeps::Vector{Symbol}, varname::Symbol)
+#     ArrayReferenceMetaPosition( NOTAREFERENCE, parents, ldref, reduceddeps, varname )
+# end
 function Operation(id::Int, var::Symbol, elementbytes::Int, instr, optype::OperationType, mpref::ArrayReferenceMetaPosition)
     Operation( id, var, elementbytes, instr, optype, mpref.loopdependencies, mpref.reduceddeps, mpref.parents, mpref.mref )
 end

test/dot.jl

@@ -25,7 +25,8 @@ using Test
     function mydot_avx(a, b)
         s = zero(eltype(a))
         @_avx for i ∈ eachindex(a,b)
-            s += a[i]*b[i]
+            aᵢ = getindex(a, i)
+            s += aᵢ*b[i]
         end
         s
     end

test/mapreduce.jl

@@ -21,6 +21,7 @@
             R = T(1):T(100)
             x7 = rand(R, 7); y7 = rand(R, 7);
             x = rand(R, 127, 7, 7); y = rand(R, 127, 7, 7);
+            z = rand(R, 3, 3, 3, 3, 3, 3);
         else
             x7 = rand(T, 7); y7 = rand(T, 7);
             x = rand(T, 127, 7, 7); y = rand(T, 127, 7, 7);
@@ -31,9 +32,12 @@
                 @test vmapreduce(hypot, +, x, y) ≈ sum(hypot.(x, y))
                 @test vmapreduce(^, (a,b) -> a + b, x7, y7) ≈ sum(x7 .^ y7)
             end
+            z = rand(T, 3, 3, 3, 3, 3, 3);
         end;
         @test vreduce(+, x7) ≈ sum(x7)
         @test vreduce(+, x) ≈ sum(x)
+        @test vmapreduce(abs2, max, x) ≈ mapreduce(abs2, max, x)
+        @test vmapreduce(abs2, min, x) ≈ mapreduce(abs2, min, x)
         @test_throws AssertionError vmapreduce(hypot, +, x7, x)
         if VERSION ≥ v"1.4"
             @test vmapreduce(a -> 2a, *, x) ≈ mapreduce(a -> 2a, *, x)
@@ -55,6 +59,11 @@
             @test vreduce(min, x; dims = d) == minimum(x; dims = d)
             @test vreduce(+, x; dims = d) ≈ sum(x; dims = d)
         end
+        for d in 1:ndims(z)
+            vreduce(max, z, dims = d) == maximum(z, dims = d)
+            vreduce(min, z, dims = d) == minimum(z, dims = d)
+            vreduce(+, z, dims = d) ≈ sum(z, dims = d)
+        end
     end
 
 end