Added a few tests.

Author: chriselrod

src/add_compute.jl

@@ -79,6 +79,13 @@ function search_tree(opv::Vector{Operation}, var::Symbol) # relies on cycles bei
     end
     false
 end
+function search_tree(opv::Vector{Operation}, var::Operation) # relies on cycles being forbidden
+    for opp ∈ opv
+        opp === var && return true
+        search_tree(parents(opp), var) && return true
+    end
+    false
+end
 function update_reduction_status!(parentvec::Vector{Operation}, deps::Vector{Symbol}, parent::Symbol)
     for opp ∈ parentvec
         if name(opp) === parent

src/add_ifelse.jl

@@ -8,15 +8,15 @@ function add_if!(ls::LoopSet, LHS::Symbol, RHS::Expr, elementbytes::Int, positio
     # for now, just simple 1-liners
     @assert length(RHS.args) == 3 "if statements without an else cannot be assigned to a variable."
     condition = first(RHS.args)
-    condop = if mpref === nothing
+    condop = if isnothing(mpref)
         add_operation!(ls, gensym(:mask), condition, elementbytes, position)
     else
         add_operation!(ls, gensym(:mask), condition, mpref, elementbytes, position)
     end
     iftrue = RHS.args[2]
     if iftrue isa Expr
         trueop = add_operation!(ls, Symbol(:iftrue), iftrue, elementbytes, position)
-        if iftrue.head === :ref && all(ld -> ld ∈ loopdependencies(trueop), loopdependencies(condop))
+        if iftrue.head === :ref && all(ld -> ld ∈ loopdependencies(trueop), loopdependencies(condop)) && !search_tree(parents(condop), trueop)
             trueop.instruction = Instruction(:conditionalload)
             push!(parents(trueop), condop)
         end
@@ -26,7 +26,7 @@ function add_if!(ls::LoopSet, LHS::Symbol, RHS::Expr, elementbytes::Int, positio
     iffalse = RHS.args[3]
     if iffalse isa Expr
         falseop = add_operation!(ls, Symbol(:iffalse), iffalse, elementbytes, position)
-        if iffalse.head === :ref && all(ld -> ld ∈ loopdependencies(falseop), loopdependencies(condop))
+        if iffalse.head === :ref && all(ld -> ld ∈ loopdependencies(falseop), loopdependencies(condop)) && !search_tree(parents(condop), falseop)
             falseop.instruction = Instruction(:conditionalload)
             push!(parents(falseop), negateop!(ls, condop, elementbytes))
         end

test/ifelsemasks.jl

@@ -181,6 +181,36 @@ T = Float32
         end
     end
 
+    function notacondload!(C, A, b)
+        @inbounds for n ∈ 1:size(C,2), m ∈ 1:size(C,1)
+            C[m,n] = A[m,n] * (b[n] > 0 ? b[n] : -b[n])
+        end
+    end
+    function notacondloadavx!(C, A, b)
+        @avx for n ∈ 1:size(C,2), m ∈ 1:size(C,1)
+            C[m,n] = A[m,n] * (b[n] > 0 ? b[n] : -b[n])
+        end
+    end
+    function condloadscalar!(C, A, c, b)
+        @inbounds for n ∈ 1:size(C,2), m ∈ 1:size(C,1)
+            C[m,n] = A[m,n] * (c[n] > 0 ? b[n] : 1) + c[n]
+        end
+    end
+    function condloadscalaravx!(C, A, c, b)
+        @avx for n ∈ 1:size(C,2), m ∈ 1:size(C,1)
+            C[m,n] = A[m,n] * (c[n] > 0 ? b[n] : 1) + c[n]
+        end
+    end
+    function maskedloadscalar!(C, A, b)
+        @inbounds for n ∈ 1:size(C,2), m ∈ 1:size(C,1)
+            C[m,n] = A[m,n] * (A[m,n] > 0 ? b[n] : 1)
+        end
+    end
+    function maskedloadscalaravx!(C, A, b)
+        @avx for n ∈ 1:size(C,2), m ∈ 1:size(C,1)
+            C[m,n] = A[m,n] * (A[m,n] > 0 ? b[n] : 1)
+        end
+    end
     function AtmulBpos!(C, A, B)
         @inbounds for n ∈ 1:size(C,2), m ∈ 1:size(C,1)
             Cₘₙ = zero(eltype(C))
@@ -368,17 +398,32 @@ T = Float32
             A = rand(T(-100):T(100), K, M);
             B = rand(T(-100):T(100), K, N);
             C1 = rand(T(-100):T(100), M, N);
+            b = rand(T(-100):T(100), N);
+            d = rand(T(-100):T(100), N);
         else
             A = randn(T, K, M);
             B = randn(T, K, N);
             C1 = randn(T, M, N);
+            b = randn(T, N);
+            d = randn(T, N);
         end;
         C2 = copy(C1); C3 = copy(C1);
         AtmulBpos!(C1, A, B)
         AtmulBposavx!(C2, A, B)
         AtmulBpos_avx!(C3, A, B)
         @test C1 ≈ C2
         @test C1 ≈ C3
+        C1 = similar(B);
+        C2 = similar(B);
+        notacondload!(C1, B, b)
+        notacondloadavx!(C2, B, b)
+        @test C1 ≈ C2
+        maskedloadscalar!(C1, B, b)
+        maskedloadscalaravx!(C2, B, b)
+        @test C1 ≈ C2
+        condloadscalar!(C1, B, b, d)
+        condloadscalaravx!(C2, B, b, d)
+        @test C1 ≈ C2
     end