lsp

Author: chriselrod

src/codegen/lower_load.jl

@@ -140,7 +140,6 @@ function lower_load_no_optranslation!(
     q::Expr, ls::LoopSet, op::Operation, td::UnrollArgs, mask::Bool, inds_calc_by_ptr_offset::Vector{Bool}
 )
   @unpack u₁, u₁loopsym, u₂loopsym, vloopsym, suffix = td
-  loopdeps = loopdependencies(op)
   # @assert isvectorized(op)
   opu₁, opu₂ = isunrolled_sym(op, u₁loopsym, u₂loopsym, vloopsym, ls)
   u = ifelse(opu₁, u₁, 1)
@@ -215,8 +214,6 @@ function lower_load_for_optranslation!(
     for i ∈ eachindex(gespinds.args)
         if i == translationind
             gespinds.args[i] = Expr(:call, lv(Core.ifelse(equal_steps, :firstunroll, :lastunroll)), gespinds.args[i])
-        # else
-        #     gespinds.args[i] = Expr(:call, lv(:unmm), gespinds.args[i])
         end
     end
     ip = GlobalRef(VectorizationBase, :increment_ptr)
@@ -262,7 +259,7 @@ function lower_load_for_optranslation!(
         broadcasted_data = broadcastedname(variable_name_data)
         push!(q.args, :($broadcasted_data = getfield($(broadcastedname(variable_name_u)), 1)))
     end
-    gf = GlobalRef(Core,:getfield)
+    gf = GlobalRef(Core, :getfield)
     for u₂ ∈ 0:u₂max-1
         variable_name_u₂ = Symbol(variable_name(op, u₂), '_', u₁)
         t = Expr(:tuple)
@@ -285,7 +282,7 @@ function lower_load_for_optranslation!(
             push!(q.args, Expr(:(=), broadcastedname(variable_name_u₂), Expr(:call, lv(:VecUnroll), tb)))
         end
     end
-    nothing
+  nothing
 end
 
 # TODO: this code should be rewritten to be more "orthogonal", so that we're just combining separate pieces.
@@ -306,7 +303,6 @@ function lower_load!(
             if -suffix < mno < 0 # already checked that `suffix != -1` above
                 varnew = variable_name(op, suffix)
                 varold = variable_name(operations(ls)[id], suffix + mno)
-                opold = operations(ls)[id]
                 u = isu₁unrolled(op) ? u₁ : 1
                 push!(q.args, Expr(:(=), Symbol(varnew, '_', u), Symbol(varold, '_', u)))
                 return

src/codegen/lowering.jl

@@ -224,7 +224,6 @@ function lower_unrolled_dynamic(ls::LoopSet, us::UnrollSpecification, n::Int, in
   isone(UF) && return lower_no_unroll(ls, us, n, inclmask)
   @unpack u₁loopnum, vloopnum, u₁, u₂ = us
   order = names(ls)
-  loopsym = order[n]
   loop = getloop(ls, n)
   vectorized = order[vloopnum]
   nisunrolled = isunrolled1(us, n)
@@ -274,7 +273,7 @@ function lower_unrolled_dynamic(ls::LoopSet, us::UnrollSpecification, n::Int, in
     end
     remblock = Expr(:block)
     (nisvectorized && (UFt > 0) && isone(num_loops(ls))) && push!(remblock.args, definemask(loop))
-    unroll_cleanup = true
+    # unroll_cleanup = true
   else
     remblock = init_remblock(loop, ls.lssm, n)#loopsym)
     # unroll_cleanup = Ureduct > 0 || (nisunrolled ? (u₂ > 1) : (u₁ > 1))
@@ -463,7 +462,7 @@ end
 @generated function of_same_size(::Type{T}, ::Type{S}) where {T,S}
   sizeof_S = sizeof(S)
   sizeof(T) == sizeof_S && return T
-  Tfloat = T <: Union{Float32,Float64}
+  # Tfloat = T <: Union{Float32,Float64}
   if T <: Union{Float32,Float64}
     sizeof_S ≥ 8 ? Float64 : Float32
   elseif T <: Signed
@@ -504,7 +503,7 @@ function outer_reduction_zero(op::Operation, u₁u::Bool, Umax::Int, reduct_clas
       end
     end
   elseif isifelse
-    Expr(:call, identify, reduct_zero) # type stability within LV
+    Expr(:call, identity, reduct_zero) # type stability within LV
   else
     Expr(:call, reduct_zero, Tsym)
   end
@@ -670,7 +669,7 @@ function reinit_and_update_tiled_outer_reduct!(letblock::Expr, block::Expr, ls::
     instr = instruction(op).instr
     instr === :ifelse && continue # FIXME - skipping this will result in bad performance
     u₁u, u₂u = isunrolled_sym(op, u₁loopsym, u₂loopsym, vloopsym, ls)
-    reduct_class = reduction_instruction_class(instr)
+    reduct_class::Float64 = reduction_instruction_class(instr)
     z = outer_reduction_zero(op, u₁u, Umax, reduct_class, rs)
     reduct = reduce_to_onevecunroll(reduct_class)
     mvar = variable_name(op, -1)
@@ -820,8 +819,6 @@ end
 function setup_preamble!(ls::LoopSet, us::UnrollSpecification, Ureduct::Int)
     @unpack u₁loopnum, u₂loopnum, vloopnum, u₁, u₂ = us
     order = names(ls)
-    u₁loopsym = order[u₁loopnum]
-    u₂loopsym = order[u₂loopnum]
     vectorized = order[vloopnum]
     set_vector_width!(ls, vectorized)
     iszero(length(ls.includedactualarrays) + length(ls.outer_reductions)) || define_eltype_vec_width!(ls.preamble, ls, vectorized, false)
@@ -844,15 +841,15 @@ function setup_preamble!(ls::LoopSet, us::UnrollSpecification, Ureduct::Int)
     end
 end
 function lsexpr(ls::LoopSet, q)
-    Expr(:block, ls.preamble, q)
+  Expr(:block, ls.preamble, q)
 end
 
 function isanouterreduction(ls::LoopSet, op::Operation)
-    opname = name(op)
-    for or ∈ ls.outer_reductions
-        name(ls.operations[or]) === opname && return true
-    end
-    false
+  opname = name(op)
+  for or ∈ ls.outer_reductions
+    name(ls.operations[or]) === opname && return true
+  end
+  false
 end
 
 # tiled_outerreduct_unroll(ls::LoopSet) = tiled_outerreduct_unroll(ls.unrollspecification)
@@ -912,7 +909,6 @@ function lower_unrollspec(ls::LoopSet)
   @unpack vloopnum, u₁, u₂ = us
   order = names(ls)
   init_loop_map!(ls)
-  vectorized = order[vloopnum]
   Ureduct = calc_Ureduct!(ls, us)
   setup_preamble!(ls, us, Ureduct)
   initgesps = add_loop_start_stop_manager!(ls)

src/modeling/graphs.jl

@@ -1138,12 +1138,12 @@ function add_operation!(
     array, rawindices = ref_from_expr!(ls, RHS)
     RHS_ref = array_reference_meta!(ls, array, rawindices, elementbytes, gensym!(ls, LHS_sym))
     op = add_load!(ls, RHS_ref, elementbytes)
-    iop = add_compute!(ls, LHS_sym, :identity, [op], elementbytes)
+    add_compute!(ls, LHS_sym, :identity, [op], elementbytes)
     # pushfirst!(LHS_ref.parents, iop)
   elseif RHS.head === :call
     f = first(RHS.args)
     if f === :getindex
-      add_load!(ls, LHS_sym, LHS_ref, elementbytes)
+      add_load_getindex!(ls, LHS_sym, RHS, elementbytes)
     elseif f isa Symbol && Base.sym_in(f, (:zero, :one, :typemin, :typemax))
       c = gensym!(ls, f)
       op = add_constant!(ls, c, ls.loopsymbols[1:position], LHS_sym, elementbytes, :numericconstant)
@@ -1160,7 +1160,7 @@ function add_operation!(
   elseif RHS.head === :if
     add_if!(ls, LHS_sym, RHS, elementbytes, position, LHS_ref)
   elseif RHS.head === :block
-    add_operation!(ls, LHS, strip_op_linenumber_nodes(RHS), elementbytes, position)
+    add_operation!(ls, LHS_sym, strip_op_linenumber_nodes(RHS), elementbytes, position)
   elseif RHS.head === :(.)
     c = gensym!(ls, "getproperty")
     pushpreamble!(ls, Expr(:(=), c, RHS))
@@ -1169,7 +1169,7 @@ function add_operation!(
     # pushpreamble!(ls, op, c)
     # op
   elseif Meta.isexpr(RHS, :comparison, 5)
-    add_comparison!(ls, LHS, RHS, elementbytes, position)
+    add_comparison!(ls, LHS_sym, RHS, elementbytes, position)
   else
     throw(LoopError("Expression not recognized.", RHS))
   end
@@ -1179,7 +1179,6 @@ function prepare_rhs_for_storage!(ls::LoopSet, RHS::Union{Symbol,Expr}, array, r
   RHS isa Symbol && return add_store!(ls, RHS, array, rawindices, elementbytes)
   mpref = array_reference_meta!(ls, array, rawindices, elementbytes)
   cachedparents = copy(mpref.parents)
-  ref = mpref.mref.ref
   lrhs = gensym!(ls, "RHS")
   mpref.varname = lrhs
   add_operation!(ls, lrhs, RHS, mpref, elementbytes, position)
@@ -1361,7 +1360,6 @@ function check_valid_reorder_dims!(ls::LoopSet)
   fill!(validreorder, 0x03)
   omop = offsetloadcollection(ls)
   @unpack opids = omop
-  num_collections = length(opids)
   ops = operations(ls)
   for i ∈ eachindex(opids)
     opidsᵢ = opids[i]
@@ -1450,7 +1448,7 @@ function fill_offset_memop_collection!(ls::LoopSet)
       collectionsize += 1
     end
   end
-  for (collectionid,opidc) ∈ enumerate(opids)
+  for opidc ∈ opids
     length(opidc) > 1 || continue
     # we check if we can turn the offsets into an unroll
     # we have up to `length(opidc)` loads to do, so we allocate that many "base" vectors

src/modeling/operations.jl

@@ -471,11 +471,22 @@ function ifelse_reduction(f::F, rsym::Symbol, op::Operation) where {F}
 end
 
 # for f ∈ [:reduction_scalar_combine, :reduction_to_scalar, :reduce_number_of_vectors, (:reduce_to_onevecunroll,:IfElseOp),(:reduction_to_single_vector,:IfElseCollapser)]
-for f ∈ [:reduction_scalar_combine, :reduction_to_scalar, :reduce_number_of_vectors,:reduce_to_onevecunroll,:reduction_to_single_vector]
-  @eval begin
-    $f(x) = $f(reduction_instruction_class(x))
-    $f(op::Operation)::GlobalRef = lv($f(instruction(op)))
-  end
-end
+# for f ∈ [:reduction_scalar_combine, :reduction_to_scalar, :reduce_number_of_vectors,:reduce_to_onevecunroll,:reduction_to_single_vector]
+#   @eval begin
+#     $f(x) = $f(reduction_instruction_class(x))
+#     $f(op::Operation)::GlobalRef = lv($f(instruction(op)))
+#   end
+# end
+# No `@eval` to make the language server happy
+reduction_scalar_combine(x) = reduction_scalar_combine(reduction_instruction_class(x))
+reduction_scalar_combine(op::Operation)::GlobalRef = lv(reduction_scalar_combine(instruction(op)))
+reduction_to_scalar(x) = reduction_to_scalar(reduction_instruction_class(x))
+reduction_to_scalar(op::Operation)::GlobalRef = lv(reduction_to_scalar(instruction(op)))
+reduce_number_of_vectors(x) = reduce_number_of_vectors(reduction_instruction_class(x))
+reduce_number_of_vectors(op::Operation)::GlobalRef = lv(reduce_number_of_vectors(instruction(op)))
+reduce_to_onevecunroll(x) = reduce_to_onevecunroll(reduction_instruction_class(x))
+reduce_to_onevecunroll(op::Operation)::GlobalRef = lv(reduce_to_onevecunroll(instruction(op)))
+reduction_to_single_vector(x) = reduction_to_single_vector(reduction_instruction_class(x))
+reduction_to_single_vector(op::Operation)::GlobalRef = lv(reduction_to_single_vector(instruction(op)))
 
 

src/parse/add_loads.jl

@@ -48,7 +48,7 @@ function add_load!(
     mpref = array_reference_meta!(ls, array, rawindices, elementbytes, var)
     add_load!(ls, mpref, elementbytes)
 end
-function load_is_constant(ls::LoopSet, mpref::ArrayReferenceMetaPosition)
+function load_is_constant(mpref::ArrayReferenceMetaPosition)
   li = mpref.mref.loopedindex
   inds = getindicesonly(mpref)
   for i ∈ eachindex(li)
@@ -62,7 +62,7 @@ end
 function add_load!(
   ls::LoopSet, mpref::ArrayReferenceMetaPosition, elementbytes::Int
 )
-  if length(mpref.loopdependencies) == 0 || load_is_constant(ls, mpref)
+  if length(mpref.loopdependencies) == 0 || load_is_constant(mpref)
     return add_constant!(ls, mpref, elementbytes)
   end
   op = Operation( ls, varname(mpref), elementbytes, :getindex, memload, mpref )

src/simdfunctionals/map.jl

@@ -66,7 +66,6 @@ function _vmap_singlethread!(
   i = convert(Int, start)
   V = VectorizationBase.pick_vector_width(promote_type(T, reduce(promote_type, map(eltype, ptrargs))))
   W = unwrap(V)
-  st = VectorizationBase.static_sizeof(T)
   UNROLL = 4
   LOG2UNROLL = 2
   while i < vsub_nsw(N, ((W << LOG2UNROLL) - 1))
@@ -129,6 +128,7 @@ function (m::VmapClosure{NonTemporal,F,D,N,A})(p::Ptr{UInt}) where {NonTemporal,
   (offset, stop ) = ThreadingUtilities.load(p, Int, offset)
 
   _vmap_singlethread!(m.f, dest, start, stop, Val{NonTemporal}(), args)
+  ThreadingUtilities._atomic_store!(p, ThreadingUtilities.SPIN)
   NonTemporal && Threads.atomic_fence()
   nothing
 end
@@ -165,25 +165,6 @@ end
   vmc = VmapClosure{NonTemporal}(f, ptry, ptrargs)
   @cfunction($vmc, Cvoid, (Ptr{UInt},))
 end
-# @inline function _cfunc_closure(f, ptry, ptrargs, ::Val{NonTemporal}) where {NonTemporal}
-#     vmc = VmapClosure{NonTemporal}(f, ptry, ptrargs)
-#     @cfunction($vmc, Cvoid, (Ptr{UInt},))
-# end
-# @generated function vmap_closure(f::F, ptry::D, ptrargs::A, ::Val{NonTemporal}) where {F,D<:StridedPointer,N,A<:Tuple{Vararg{StridedPointer,N}},NonTemporal}
-#     # fsym = get(FUNCTIONSYMBOLS, F, Symbol("##NOTFOUND##"))
-#      # fsym === Symbol("##NOTFOUND##")
-#     if false# iszero(sizeof(F))
-#         quote
-#             $(Expr(:meta,:inline))
-#             VmapKnownClosure{$NonTemporal,$F,$D,$N,$A}()
-#         end
-#     else
-#         quote
-#             $(Expr(:meta,:inline))
-#             _cfunc_closure(f, ptry, ptrargs, Val{$NonTemporal}())
-#         end
-#     end
-# end
 
 function vmap_multithread!(
   f::F,
@@ -203,7 +184,6 @@ function vmap_multithread!(
   end
 
   cfunc = vmap_closure(f, ptry, ptrargs, Val{NonTemporal}())
-  vmc = VmapClosure{NonTemporal}(f, ptry, ptrargs)
   Nveciter = (N + (W-1)) >> Wshift
   Nd, Nr = divrem(Nveciter, nt)
   NdW = Nd << Wshift

src/transforms.jl

@@ -4,7 +4,7 @@ function hoist_constant_memory_accesses!(ls::LoopSet)
   hoist_stores = false
   for op ∈ operations(ls)
     if isload(op)
-      length(getindicesonly(op)) == 0 && host_constant_load!(ls, op)
+      length(getindicesonly(op)) == 0 && hoist_constant_vload!(ls, op)
     elseif isstore(op) && iszero(length(getindicesonly(op)))
       hoist_stores = true
     end
@@ -29,7 +29,7 @@ function hoist_constant_vload!(ls::LoopSet, op::Operation)
 end
 
 function return_empty_reductinit(op::Operation, var::Symbol)
-  for (i,opp) ∈ enumerate(parents(op))
+  for opp ∈ parents(op)
     if (name(opp) === var) && (length(reduceddependencies(opp)) == 0) && (length(loopdependencies(opp)) == 0) && (length(children(opp)) == 1)
       return opp
     end

src/vectorizationbase_compat/contract_pass.jl

@@ -188,7 +188,7 @@ function capture_a_muladd(ex::Expr, mod)
   if mod === nothing
     call.args[1] = f
   else
-    call.args[1] = Expr(:(.), mod, QuoteNote(f))#_fast))
+    call.args[1] = Expr(:(.), mod, QuoteNode(f))
   end
   true, call
 end