Updates to reflect new load/store! API.

Author: chriselrod

Manifest.toml

@@ -49,19 +49,15 @@ uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
 [[SIMDPirates]]
 deps = ["VectorizationBase"]
-git-tree-sha1 = "4a33e07340324e2d3200c72231b5db829b7bad1f"
-repo-rev = "master"
-repo-url = "https://github.com/chriselrod/SIMDPirates.jl.git"
+git-tree-sha1 = "ecacd3f808e559d9e363f2620041c6286c8efaca"
 uuid = "21efa798-c60a-11e8-04d3-e1a92915a26a"
-version = "0.3.16"
+version = "0.4.0"
 
 [[SLEEFPirates]]
 deps = ["Libdl", "SIMDPirates", "VectorizationBase"]
-git-tree-sha1 = "8e4277a226f4ce3b3d7b5a60ab66d8f9f1ffdbab"
-repo-rev = "master"
-repo-url = "https://github.com/chriselrod/SLEEFPirates.jl.git"
+git-tree-sha1 = "bb99e28c0284de9c3233258a93882429752faa55"
 uuid = "476501e8-09a2-5ece-8869-fb82de89a1fa"
-version = "0.3.7"
+version = "0.3.8"
 
 [[Serialization]]
 uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
@@ -75,8 +71,6 @@ uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [[VectorizationBase]]
 deps = ["CpuId", "LinearAlgebra"]
-git-tree-sha1 = "794a8d4ad8c817f1c7b7598b3d858891ab100722"
-repo-rev = "master"
-repo-url = "https://github.com/chriselrod/VectorizationBase.jl.git"
+git-tree-sha1 = "b9b5c8fa55e9b859989e759f405624d16b0b0ca2"
 uuid = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f"
-version = "0.4.1"
+version = "0.4.2"

Project.toml

@@ -1,7 +1,7 @@
 name = "LoopVectorization"
 uuid = "bdcacae8-1622-11e9-2a5c-532679323890"
 authors = ["Chris Elrod <[email protected]>"]
-version = "0.6.13"
+version = "0.6.14"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -12,9 +12,9 @@ VectorizationBase = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f"
 
 [compat]
 Parameters = "0"
-SIMDPirates = "~0.3.16"
-SLEEFPirates = "~0.3.7"
-VectorizationBase = "~0.4.1"
+SIMDPirates = "~0.4"
+SLEEFPirates = "~0.3.8"
+VectorizationBase = "~0.4.2"
 julia = "1.1"
 
 [extras]

src/add_loads.jl

@@ -73,10 +73,8 @@ end
 
 struct LoopValue end
 @inline VectorizationBase.stridedpointer(::LoopValue) = LoopValue()
-@inline SIMDPirates.vload(::LoopValue, i::Tuple{_MM{W}}) where {W} = _MM{W}(@inbounds(i[1].i) + 1)
-@inline SIMDPirates.vload(::LoopValue, i::Tuple{_MM{W}}, ::Unsigned) where {W} = _MM{W}(@inbounds(i[1].i) + 1)
-# @inline SIMDPirates.vload(::LoopValue, i::Tuple{_MM{W}}) where {W} = SVec(SIMDPirates.vrangeincr(Val{W}(), @inbounds(i[1].i), Val{1}()))
-# @inline SIMDPirates.vload(::LoopValue, i::Tuple{_MM{W}}, ::Unsigned) where {W} = SVec(SIMDPirates.vrangeincr(Val{W}(), @inbounds(i[1].i), Val{1}()))
+@inline VectorizationBase.load(::LoopValue, i::Tuple{_MM{W}}) where {W} = _MM{W}(@inbounds(i[1].i) + 1)
+@inline VectorizationBase.load(::LoopValue, i::Tuple{_MM{W}}, ::Unsigned) where {W} = _MM{W}(@inbounds(i[1].i) + 1)
 @inline VectorizationBase.load(::LoopValue, i::Integer) = i + one(i)
 @inline VectorizationBase.load(::LoopValue, i::Tuple{I}) where {I<:Integer} = @inbounds(i[1]) + one(I)
 @inline Base.eltype(::LoopValue) = Int8

src/filter.jl

@@ -10,14 +10,14 @@ function vfilter!(f::F, x::Vector{T}, y::AbstractArray{T}) where {F,T <: SUPPORT
         ptr_x = pointer(x)
         ptr_y = pointer(y)
         for _ ∈ 1:Nrep
-            vy = vload(Vec{W,T}, gep(ptr_y, i))
+            vy = load(Vec{W,T}, ptr_y, i)
             mask = f(SVec(vy))
             SIMDPirates.compressstore!(gep(ptr_x, j), vy, mask)
             i += W
             j += count_ones(mask)
         end
         rem_mask = VectorizationBase.mask(T, Nrem)
-        vy = vload(Vec{W,T}, gep(ptr_y, i), rem_mask)
+        vy = load(Vec{W,T}, gep(ptr_y, i), rem_mask)
         mask = rem_mask & f(SVec(vy))
         SIMDPirates.compressstore!(gep(ptr_x, j), vy, mask)
         j += count_ones(mask)

src/lower_load.jl

@@ -2,7 +2,7 @@ function pushvectorload!(q::Expr, op::Operation, var::Symbol, td::UnrollArgs, U:
     @unpack u, unrolled = td
     ptr = refname(op)
     name, mo = name_memoffset(var, op, td, W, vecnotunrolled)
-    instrcall = Expr(:call, lv(:vload), ptr, mo)
+    instrcall = Expr(:call, lv(:load), ptr, mo)
     if mask !== nothing && (vecnotunrolled || u == U - 1)
         push!(instrcall.args, mask)
     end

src/lower_store.jl

@@ -103,7 +103,7 @@ function lower_conditionalstore_vectorized!(
         td = UnrollArgs(u, unrolled, tiled, suffix)
         name, mo = name_memoffset(var, op, td, W, vecnotunrolled, parentisunrolled)
         condvarname = varassignname(condvar, u, condunrolled)
-        instrcall = Expr(:call, lv(:vstore!), ptr, name, mo)
+        instrcall = Expr(:call, lv(:store!), ptr, name, mo)
         if mask !== nothing && (vecnotunrolled || u == U - 1)
             push!(instrcall.args, Expr(:call, lv(:combinemasks), condvarname, mask))
         else
@@ -147,7 +147,7 @@ function lower_store_vectorized!(
     for u ∈ 0:U-1
         td = UnrollArgs(u, unrolled, tiled, suffix)
         name, mo = name_memoffset(var, op, td, W, vecnotunrolled, parentisunrolled)
-        instrcall = Expr(:call, lv(:vstore!), ptr, name, mo)
+        instrcall = Expr(:call, lv(:store!), ptr, name, mo)
         if mask !== nothing && (vecnotunrolled || u == U - 1)
             push!(instrcall.args, mask)
         end

src/map.jl

@@ -5,14 +5,14 @@ function vmap_quote(N, ::Type{T}) where {T}
     val = Expr(:call, Expr(:curly, :Val, W))
     q = Expr(:block, Expr(:(=), :M, Expr(:call, :length, :dest)), Expr(:(=), :vdest, Expr(:call, :pointer, :dest)), Expr(:(=), :m, 0))
     fcall = Expr(:call, :f)
-    loopbody = Expr(:block, Expr(:call, :vstore!, :vdest, fcall, :m), Expr(:(+=), :m, W))
+    loopbody = Expr(:block, Expr(:call, :store!, :vdest, fcall, :m), Expr(:(+=), :m, W))
     fcallmask = Expr(:call, :f)
-    bodymask = Expr(:block, Expr(:(=), :__mask__, Expr(:call, :mask, val, Expr(:call, :&, :M, W-1))), Expr(:call, :vstore!, :vdest, fcallmask, :m, :__mask__))
+    bodymask = Expr(:block, Expr(:(=), :__mask__, Expr(:call, :mask, val, Expr(:call, :&, :M, W-1))), Expr(:call, :store!, :vdest, fcallmask, :m, :__mask__))
     for n ∈ 1:N
         arg_n = Symbol(:varg_,n)
         push!(q.args, Expr(:(=), arg_n, Expr(:macrocall, Symbol("@inbounds"), LineNumberNode(@__LINE__,Symbol(@__FILE__)), Expr(:call, :pointer, Expr(:ref, :args, n)))))
-        push!(fcall.args, Expr(:call, :vload, val, arg_n, :m))
-        push!(fcallmask.args, Expr(:call, :vload, val, arg_n, :m, :__mask__))
+        push!(fcall.args, Expr(:call, :load, val, arg_n, :m))
+        push!(fcallmask.args, Expr(:call, :load, val, arg_n, :m, :__mask__))
     end
     loop = Expr(:for, Expr(:(=), :_, Expr(:call, :(:), 0, Expr(:call, :-, Expr(:call, :(>>>), :M, Wshift), 1))), loopbody)
     push!(q.args, loop)

src/precompile.jl

@@ -58,7 +58,8 @@ function _precompile_()
     precompile(Tuple{typeof(Base.Broadcast.broadcasted),Function,Array{Int64,3},LowDimArray{(false, true, true),Int64,3,Array{Int64,3}}})
     precompile(Tuple{typeof(Base.Broadcast.broadcasted),Function,Array{Int64,3},LowDimArray{(true, false, true),Int64,3,Array{Int64,3}}})
     precompile(Tuple{typeof(Base.Broadcast.broadcasted),Function,Array{Int64,3},LowDimArray{(true, true, false),Int64,3,Array{Int64,3}}})
-    precompile(Tuple{typeof(Base.Broadcast.broadcasted),typeof(*ˡ),Array{Int32,2},Array{Int32,1}})
+    precompile(Tuple{typeof(Base.Broadcast.broadcasted),typeof(*ˡ),Array{Float64,2},Array{Float64,1}})
+    precompile(Tuple{typeof(Base.Broadcast.broadcasted),typeof(*ˡ),Array{Int64,2},Array{Int64,1}})
     precompile(Tuple{typeof(LoopVectorization._avx_loopset),Core.SimpleVector,Core.SimpleVector,Core.SimpleVector,Core.SimpleVector,NTuple{4,DataType}})
     precompile(Tuple{typeof(LoopVectorization._avx_loopset),Core.SimpleVector,Core.SimpleVector,Core.SimpleVector,Core.SimpleVector,NTuple{5,DataType}})
     precompile(Tuple{typeof(LoopVectorization._avx_loopset),Core.SimpleVector,Core.SimpleVector,Core.SimpleVector,Core.SimpleVector,NTuple{6,DataType}})