WIP; added precompile statements, working on writing unroll-lowering of a loop set; still need tiled lowering, and the creating of loop sets from loop expressions, broadcasting expressions, and tensor notation.

Author: chriselrod

Manifest.toml

@@ -1,11 +1,5 @@
 # This file is machine-generated - editing it directly is not advised
 
-[[ArnoldiMethod]]
-deps = ["DelimitedFiles", "LinearAlgebra", "Random", "SparseArrays", "StaticArrays", "Test"]
-git-tree-sha1 = "2b6845cea546604fb4dca4e31414a6a59d39ddcd"
-uuid = "ec485272-7323-5ecc-a04f-4719b315124d"
-version = "0.0.4"
-
 [[Base64]]
 uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 
@@ -23,9 +17,9 @@ version = "0.2.2"
 
 [[DataStructures]]
 deps = ["InteractiveUtils", "OrderedCollections"]
-git-tree-sha1 = "1fe8fad5fc84686dcbc674aa255bc867a64f8132"
+git-tree-sha1 = "a1b652fb77ae8ca7ea328fa7ba5aa151036e5c10"
 uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
-version = "0.17.5"
+version = "0.17.6"
 
 [[Dates]]
 deps = ["Printf"]
@@ -39,12 +33,6 @@ uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"
 deps = ["Random", "Serialization", "Sockets"]
 uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 
-[[Inflate]]
-deps = ["Pkg", "Printf", "Random", "Test"]
-git-tree-sha1 = "b7ec91c153cf8bff9aff58b39497925d133ef7fd"
-uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9"
-version = "0.1.1"
-
 [[InteractiveUtils]]
 deps = ["Markdown"]
 uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
@@ -56,12 +44,6 @@ uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
 [[Libdl]]
 uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 
-[[LightGraphs]]
-deps = ["ArnoldiMethod", "DataStructures", "Distributed", "Inflate", "LinearAlgebra", "Random", "SharedArrays", "SimpleTraits", "SparseArrays", "Statistics"]
-git-tree-sha1 = "a0d4bcea4b9c056da143a5ded3c2b7f7740c2d41"
-uuid = "093fc24a-ae57-5d10-9952-331d41423f4d"
-version = "1.3.0"
-
 [[LinearAlgebra]]
 deps = ["Libdl"]
 uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -88,6 +70,12 @@ git-tree-sha1 = "c4c13474d23c60d20a67b217f1d7f22a40edf8f1"
 uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 version = "1.1.0"
 
+[[Parameters]]
+deps = ["OrderedCollections"]
+git-tree-sha1 = "b62b2558efb1eef1fa44e4be5ff58a515c287e38"
+uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a"
+version = "0.12.0"
+
 [[Pkg]]
 deps = ["Dates", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "UUIDs"]
 uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
@@ -126,25 +114,13 @@ uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
 deps = ["Distributed", "Mmap", "Random", "Serialization"]
 uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"
 
-[[SimpleTraits]]
-deps = ["InteractiveUtils", "MacroTools"]
-git-tree-sha1 = "2bdf3b6300a9d66fe29ee8bb51ba100c4df9ecbc"
-uuid = "699a6c99-e7fa-54fc-8d76-47d257e15c1d"
-version = "0.9.1"
-
 [[Sockets]]
 uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
 
 [[SparseArrays]]
 deps = ["LinearAlgebra", "Random"]
 uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
-[[StaticArrays]]
-deps = ["LinearAlgebra", "Random", "Statistics"]
-git-tree-sha1 = "5a3bcb6233adabde68ebc97be66e95dcb787424c"
-uuid = "90137ffa-7385-5640-81b9-e52037218182"
-version = "0.12.1"
-
 [[Statistics]]
 deps = ["LinearAlgebra", "SparseArrays"]
 uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

Project.toml

@@ -4,8 +4,8 @@ authors = ["Chris Elrod <[email protected]>"]
 version = "0.1.0"
 
 [deps]
-LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
+Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a"
 SIMDPirates = "21efa798-c60a-11e8-04d3-e1a92915a26a"
 SLEEFPirates = "476501e8-09a2-5ece-8869-fb82de89a1fa"
 VectorizationBase = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f"

src/LoopVectorization.jl

@@ -1,6 +1,6 @@
 module LoopVectorization
 
-using VectorizationBase, SIMDPirates, SLEEFPirates, MacroTools
+using VectorizationBase, SIMDPirates, SLEEFPirates, MacroTools, Parameters
 using VectorizationBase: REGISTER_SIZE, extract_data, num_vector_load_expr
 using SIMDPirates: VECTOR_SYMBOLS, evadd, evmul
 using MacroTools: @capture, prewalk, postwalk
@@ -693,4 +693,8 @@ for vec ∈ (false,true)
     end
 end
 
+include("precompile.jl")
+_precompile_()
+
+
 end # module

src/costs.jl

@@ -7,35 +7,36 @@
 # end
 
 struct InstructionCost
-    scalar_latency::Int
-    scalar_reciprical_throughput::Float64
     scaling::Float64 # sentinel values: -3 == no scaling; -2 == offset_scaling, -1 == linear scaling, >0 ->  == latency == reciprical throughput
+    scalar_reciprical_throughput::Float64
+    scalar_latency::Int
     register_pressure::Int
 end
-InstructionCost(sl, srt, scaling = -3.0) = InstructionCost(sl, srt, scaling, 1)
+InstructionCost(sl::Int, srt::Float64, scaling::Float64 = -3.0) = InstructionCost(scaling, srt, sl, srt, 0)
 
 function scalar_cost(instruction::InstructionCost)#, ::Type{T} = Float64) where {T}
-    instruction.scalar_latency, instruction.scalar_reciprical_throughput
+    @unpack scalar_reciprical_throughput, scalar_latency, register_pressure = instruction
+    scalar_reciprical_throughput, scalar_latency, register_pressure
 end
 function vector_cost(instruction::InstructionCost, Wshift, sizeof_T)
-    sl, srt = scalar_cost(instruction)
+    srt, sl, srp = scalar_cost(instruction)
     scaling = instruction.scaling
-    if scaling == -3.0 || Wshift == 0
-        return sl, srt
-    elseif scaling == -2.0
+    if scaling == -3.0 || Wshift == 0 # No scaling
+        return srt, sl, srp
+    elseif scaling == -2.0 # offset scaling
         srt *= 1 << (Wshift + VectorizationBase.intlog2(sizeof_T) - 4)
         if (sizeof_T << Wshift) == 64 # VectorizationBase.REGISTER_SIZE # These instructions experience double latency with zmm
             sl += sl
         end
-    elseif scaling == -1.0
+    elseif scaling == -1.0 # linear scaling
         W = 1 << Wshift
         extra_latency = sl - srt
         srt *= W
         sl = srt + extra_latency
-    else
+    else # we assume custom cost, and that latency == recip_throughput
         sl, srt = scaling, scaling
     end    
-    sl, srt
+    srt, sl, srp
 end
 function cost(instruction::InstructionCost, Wshift, sizeof_T)
     Wshift == 0 ? scalar_cost(instruction) : vector_cost(instruction, Wshift, sizeof_T)
@@ -48,12 +49,19 @@ function cost(instruction::Symbol, Wshift, sizeof_T)
     )
 end
 
+
 # Just a semi-reasonable assumption; should not be that sensitive to anything other than loads
 const OPAQUE_INSTRUCTION = InstructionCost(50, 50.0, -1.0, VectorizationBase.REGISTER_COUNT)
 
+# Comments on setindex!
+# 1. Not a part of dependency chains, so not really twice as expensive as getindex?
+# 2. getindex loads a register, not setindex!, but we place cost on setindex!
+#    as a heuristic means of approximating register pressure, since many loads can be
+#    consolidated into a single register. The number of LICM-ed setindex!, on the other
+#    hand, should indicate how many registers we're keeping live for the sake of eventually storing.
 const COST = Dict{Symbol,InstructionCost}(
-    :getindex => InstructionCost(3,0.5),
-    :setindex! => InstructionCost(3,1.0), # but not a part of dependency chains, so not really twice as expensive?
+    :getindex => InstructionCost(3,0.5,-3.0,0),
+    :setindex! => InstructionCost(3,1.0,-3.0,1), 
     :(+) => InstructionCost(4,0.5),
     :(-) => InstructionCost(4,0.5),
     :(*) => InstructionCost(4,0.5),
@@ -66,7 +74,7 @@ const COST = Dict{Symbol,InstructionCost}(
     :(<) => InstructionCost(1, 0.5),
     :(>=) => InstructionCost(1, 0.5),
     :(<=) => InstructionCost(1, 0.5),
-    :inv => InstructionCost(13,4.0,-2.0,2),
+    :inv => InstructionCost(13,4.0,-2.0,1),
     :muladd => InstructionCost(4,0.5), # + and * will fuse into this, so much of the time they're not twice as expensive
     :fma => InstructionCost(4,0.5), # + and * will fuse into this, so much of the time they're not twice as expensive
     :vmuladd => InstructionCost(4,0.5), # + and * will fuse into this, so much of the time they're not twice as expensive
@@ -76,12 +84,15 @@ const COST = Dict{Symbol,InstructionCost}(
     :vfnmadd => InstructionCost(4,0.5), # + and -* will fuse into this, so much of the time they're not twice as expensive
     :vfnmsub => InstructionCost(4,0.5), # - and -* will fuse into this, so much of the time they're not twice as expensive
     :sqrt => InstructionCost(15,4.0,-2.0),
-    :log => InstructionCost(20,20.0,40.0,21),
-    :exp => InstructionCost(20,20.0,20.0,19),
-    :sin => InstructionCost(18,15.0,68.0,24),
-    :cos => InstructionCost(18,15.0,68.0,27),
-    :sincos => InstructionCost(25,22.0,70.0,27)
+    :log => InstructionCost(20,20.0,40.0,20),
+    :exp => InstructionCost(20,20.0,20.0,18),
+    :sin => InstructionCost(18,15.0,68.0,23),
+    :cos => InstructionCost(18,15.0,68.0,26),
+    :sincos => InstructionCost(25,22.0,70.0,26)
 )
+for (k, v) ∈ COST # so we can look up Symbol(typeof(function))
+    COST[Symbol("typeof(", k, ")")] = v
+end
 
 
 # const SIMDPIRATES_COST = Dict{Symbol,InstructionCost}()