`no method matching promote_vtype(::Type{SVec{8,Float64}}, ::Type{SVec{4,Float64}})`, etc.

[mcabbott]

I was trying things which keep only the first match, related to this thread. And I get some errors I don't understand, seemingly mixing SVec of different lengths. Are these bugs or am I doing something too weird?

using LoopVectorization # LoopVectorization v0.8.24
using LoopVectorization.VectorizationBase: SVec, Mask, prevpow2

@inline onlyone(cond::Bool, seen::Union{Int,SVec}) = cond && allzero(seen)
@inline onlyone(cond::Mask{W}, seen::Union{Int,SVec}) where {W} =
    allzero(seen) ? Mask(prevpow2(cond.u)) : zero(cond) 

@inline allzero(seen::Int) = iszero(seen)
@inline allzero(seen::SVec{N,Int}) where {N} = iszero((!iszero(seen)).u)

sv = SVec{4,Int}(1,2,3,4) # SVec{4,Int64}<1, 2, 3, 4>
ms = Mask(0x03) # Mask{8,Bool}<1, 1, 0, 0, 0, 0, 0, 0>
onlyone(ms, 0) == Mask(0x02)
onlyone(ms, sv) == Mask(0x00)
onlyone(ms, zero(sv)) == Mask(0x02)

function match!(y, x, res, zed)
    seen = 0
    @avx for i in 1:4
        flag = onlyone(res == x[i], seen)
        y[i] = ifelse(flag, zed, 0.0)
        seen += any(flag)
    end
    y
end
match!(rand(4), 1:4, 3, 5.6) # ERROR: MethodError: no method matching vstore!(::Ptr{Float64}, ::NTuple{8,VecElement{Float64}}, ::VectorizationBase._MM{4,Int64})

function grad1!(𝛥x, 𝛥ℛ::AbstractArray{𝒯}, ℛ, x) where {𝒯}
    seen = 0
    @avx for i = 1:4
        flag = onlyone(ℛ[1] == x[i], seen)
        𝛥x[i] += ifelse(flag, 𝛥ℛ[1], zero(𝒯))
        seen += any(flag)
    end
    𝛥x
end
grad1!(zeros(4), [5.6], [3], [1,2,3,3]) # MethodError: no method matching promote_vtype(::Type{SVec{8,Float64}}, ::Type{SVec{4,Float64}})

[chriselrod]

julia> ms4 = Mask{4}(0x03) # Mask{8,Bool}<1, 1, 0, 0>
 Mask{4,Bool}<1, 1, 0, 0>

julia> onlyone(ms4, 0)
 Mask{8,Bool}<0, 1, 0, 0, 0, 0, 0, 0>

This is why you get the mixing of different vector widths: LoopVectorization chooses 4 as the width (there are only 4 iterations total, after all), but onlyone then returns a vector of width 8.

It's also of course really weird to want the vectorized version to behave differently from broadcasting the scalar version. That is:

julia> onlyone(true, 0)
 true

julia> onlyone(false, 0)
 false

So this means onlyone(Mask{4}(0x03), 0) should normally yield the equivalent of <true, true, false, false> as well.

But I understand that here that's to get around the fact that we would otherwise possibly get multiple zeds.
So let's just make sure we get the same sized mask out as we put in:

@inline onlyone(cond::Mask{W}, seen::Union{Int,SVec}) where {W} =
    allzero(seen) ? Mask{W}(prevpow2(cond.u)) : zero(cond) 

julia> function match!(y, x, res, zed)
           seen = 0
           @avx for i in 1:4
               flag = onlyone(res == x[i], seen)
               y[i] = ifelse(flag, zed, 0.0)
               seen += any(flag)
           end
           y
       end
 match! (generic function with 1 method)

julia> match!(rand(4), 1:4, 3, 5.6)
 4-element Array{Float64,1}:
 0.0
 0.0
 5.6
 0.0

Maybe I should make Mask(u) an error so others don't make the same mistake?

[chriselrod]

Although I'm not sure how to feel about any here. seen has the wrong value at the end of the loop, because any does a reduction rather than returning another mask.
I don't know if that means I should make any in the loop behave more like identity?

[mcabbott]

Great, thank you! I had Mask{W} and then stupidly tidied up at some point (on examples which didn't care).

I guess it is weird that any doesn't return a mask. My onlyone is deliberately weird, but Base functions probably shouldn't be.

[chriselrod]

I guess it is weird that any doesn't return a mask.

All the reduction functions show that behavior:

julia> using VectorizationBase, SIMDPirates

julia> sum(SVec{8}(2.3))
 18.4

julia> maximum(SVec(-4, 8, 3, 2))
 8

julia> any(Mask{8}(0x0a))
 true

julia> any(Mask{8}(0x00))
 false

Perhaps I shouldn't overload base functions for these reductions?

[mcabbott]

That would be cleaner, since these do allow scalars:

julia> sum(2.3)
2.3

julia> maximum(-8)
-8

julia> any(true)
true

I guess these trivial methods sometimes allow you to be generic over scalars & vectors, although it's hard to picture doing that at the same time as using @avx.

[chriselrod]

Hmm, okay. I guess I'll go with a v prefix on each of the reductions.

In the update, I renamed SVec -> Vec, and made it a subtype of number, which already has fallback definitions for sum and maximum as the identity.

[mcabbott]

Maybe I close this issue, since the core problem was just my deleting {W}.

I'll avoid using any for this purpose, for now. And will update SVec -> Vec when that's released.