Add prefetch statements, minor cost updates.

Author: chriselrod

src/costs.jl

@@ -197,8 +197,20 @@ const COST = Dict{Instruction,InstructionCost}(
     Instruction(:identity) => InstructionCost(0,0.0,0.0,0),
     Instruction(:adjoint) => InstructionCost(0,0.0,0.0,0),
     Instruction(:transpose) => InstructionCost(0,0.0,0.0,0),
-    Instruction(:prefetch) => InstructionCost(0,0.0,0.0,0)
+    Instruction(:prefetch) => InstructionCost(0,0.0,0.0,0),
+    Instruction(:prefetch1) => InstructionCost(0,0.0,0.0,0),
+    Instruction(:prefetch2) => InstructionCost(0,0.0,0.0,0),
+    Instruction(:prefetch3) => InstructionCost(0,0.0,0.0,0)
 )
+@inline prefetch0(x, i) = SIMDPirates.prefetch(gep(stridedpointer(x), (extract_data(i) - 1,)), Val{3}(), Val{0}())
+@inline prefetch0(x, i, j) = SIMDPirates.prefetch(gep(stridedpointer(x), (extract_data(i) - 1, extract_data(j) - 1)), Val{3}(), Val{0}())
+# @inline prefetch0(x, i, j, oi, oj) = SIMDPirates.prefetch(gep(stridedpointer(x), (extract_data(i) + extract_data(oi) - 1, extract_data(j) + extract_data(oj) - 1)), Val{3}(), Val{0}())
+@inline prefetch1(x, i) = SIMDPirates.prefetch(gep(stridedpointer(x), (extract_data(i) - 1,)), Val{2}(), Val{0}())
+@inline prefetch1(x, i, j) = SIMDPirates.prefetch(gep(stridedpointer(x), (extract_data(i) - 1, VectorizationBase.extract_data(j) - 1)), Val{2}(), Val{0}())
+# @inline prefetch1(x, i, j, oi, oj) = SIMDPirates.prefetch(gep(stridedpointer(x), (extract_data(i) + extract_data(oi) - 1, extract_data(j) + extract_data(oj) - 1)), Val{2}(), Val{0}())
+@inline prefetch2(x, i) = SIMDPirates.prefetch(gep(stridedpointer(x), (extract_data(i) - 1,)), Val{1}(), Val{0}())
+@inline prefetch2(x, i, j) = SIMDPirates.prefetch(gep(stridedpointer(x), (VectorizationBase.extract_data(i) - 1, VectorizationBase.extract_data(j) - 1)), Val{1}(), Val{0}())
+# @inline prefetch2(x, i, j, oi, oj) = SIMDPirates.prefetch(gep(stridedpointer(x), (extract_data(i) + extract_data(oi) - 1, extract_data(j) + extract_data(oj) - 1)), Val{1}(), Val{0}())
 
 # const KNOWNINSTRUCTIONS = keys(COST)
 # instruction(f, m) = f ∈ KNOWNINSTRUCTIONS ? Instruction(:LoopVectorization, f) : Instruction(m, f)

src/determinestrategy.jl

@@ -50,18 +50,18 @@ function register_pressure(op::Operation)
     end
 end
 function cost(ls::LoopSet, op::Operation, vectorized::Symbol, Wshift::Int, size_T::Int = op.elementbytes)
-    isconstant(op) && return 0.0, 0, 1
+    isconstant(op) && return 0.0, 0, Int(length(loopdependencies(op)) > 0)
     isloopvalue(op) && return 0.0, 0, 0
     # Wshift == dependson(op, vectorized) ? Wshift : 0
     # c = first(cost(instruction(op), Wshift, size_T))::Int
     instr = Instruction(:LoopVectorization, instruction(op).instr)
     # instr = instruction(op)
     if length(parents(op)) == 1
         if instr == Instruction(:-) || instr === Instruction(:vsub) || instr == Instruction(:+) || instr == Instruction(:vadd)
-            return 0.0, 0, 1
+            return 0.0, 0, 0
         end
-    elseif iscompute(op) && all(isloopvalue, parents(op))
-        return 0.0, 0, 1
+    elseif iscompute(op) && all(opp -> (isloopvalue(opp) | isconstant(opp)), parents(op))
+        return 0.0, 0, 0
     end
     opisvectorized = dependson(op, vectorized)
     srt, sl, srp = opisvectorized ? vector_cost(instr, Wshift, size_T) : scalar_cost(instr)
@@ -524,6 +524,7 @@ function evaluate_cost_tile(
         isunrolled = unrolledtiled[1,id]
         istiled = unrolledtiled[2,id]
         rt, lat, rp = cost(ls, op, vectorized, Wshift, size_T)
+        # @show op rt, lat, rp
         if isload(op)
             factor1, factor2 = convolution_cost_factor(ls, op, unrolled, tiled, vectorized)
             rt *= factor1; rp *= factor2;