performance improvements for any and all

[nsajko]

• Help ensure vectorization of any and all for homogeneous tuples of Bool, by avoiding bounds-checking and avoiding short-circuiting. Inspired by fast methods for any and all for Bool tuples #55673, but more general by relying on a loop instead of on recursion, thus being performant for any input length.
• Delete a bunch of now-useless methods. The dispatch doesn't happen on Bool or on Missing any more.
  • eight methods of all are deleted
  • four methods of any are deleted

Closes #55673

[nsajko]

Here's the code_llvm:

julia> code_llvm(all, Tuple{Tuple{Vararg{Bool, 32}}}; debuginfo=:none)
; Function Signature: all(NTuple{32, Bool})
define i8 @julia_all_2401(ptr nocapture noundef nonnull readonly align 1 dereferenceable(32) %"itr::Tuple") #0 {
top:
  %0 = load <32 x i8>, ptr %"itr::Tuple", align 1
  %1 = icmp eq <32 x i8> %0, zeroinitializer
  %2 = bitcast <32 x i1> %1 to i32
  %3 = icmp eq i32 %2, 0
  %4 = zext i1 %3 to i8
  ret i8 %4
}

julia> code_llvm(any, Tuple{Tuple{Vararg{Bool, 32}}}; debuginfo=:none)
; Function Signature: any(NTuple{32, Bool})
define i8 @julia_any_2403(ptr nocapture noundef nonnull readonly align 1 dereferenceable(32) %"itr::Tuple") #0 {
top:
  %0 = load <32 x i8>, ptr %"itr::Tuple", align 1
  %1 = call i8 @llvm.vector.reduce.or.v32i8(<32 x i8> %0)
  %2 = icmp ne i8 %1, 0
  %3 = zext i1 %2 to i8
  ret i8 %3
}

julia> code_llvm(all, Tuple{Tuple{Vararg{Bool, 64}}}; debuginfo=:none)
; Function Signature: all(NTuple{64, Bool})
define i8 @julia_all_2405(ptr nocapture noundef nonnull readonly align 1 dereferenceable(64) %"itr::Tuple") #0 {
top:
  %wide.load = load <32 x i8>, ptr %"itr::Tuple", align 1
  %0 = icmp ne <32 x i8> %wide.load, zeroinitializer
  %1 = getelementptr inbounds i8, ptr %"itr::Tuple", i64 32
  %wide.load.1 = load <32 x i8>, ptr %1, align 1
  %2 = icmp ne <32 x i8> %wide.load.1, zeroinitializer
  %3 = and <32 x i1> %0, %2
  %4 = bitcast <32 x i1> %3 to i32
  %5 = icmp eq i32 %4, -1
  %6 = zext i1 %5 to i8
  ret i8 %6
}

julia> code_llvm(any, Tuple{Tuple{Vararg{Bool, 64}}}; debuginfo=:none)
; Function Signature: any(NTuple{64, Bool})
define i8 @julia_any_2407(ptr nocapture noundef nonnull readonly align 1 dereferenceable(64) %"itr::Tuple") #0 {
top:
  %wide.load = load <32 x i8>, ptr %"itr::Tuple", align 1
  %0 = getelementptr inbounds i8, ptr %"itr::Tuple", i64 32
  %wide.load.1 = load <32 x i8>, ptr %0, align 1
  %1 = or <32 x i8> %wide.load, %wide.load.1
  %2 = icmp ne <32 x i8> %1, zeroinitializer
  %3 = bitcast <32 x i1> %2 to i32
  %4 = icmp ne i32 %3, 0
  %5 = zext i1 %4 to i8
  ret i8 %5
}

julia> versioninfo()
Julia Version 1.12.0-DEV.unknown
Commit 319082c (2025-01-18 07:54 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: 8 × AMD Ryzen 3 5300U with Radeon Graphics
  WORD_SIZE: 64
  LLVM: libLLVM-18.1.7 (ORCJIT, znver2)
  GC: Built with stock GC
Threads: 1 default, 0 interactive, 1 GC (on 8 virtual cores)

So it vectorizes, like in #55673, but it also vectorizes for lengths above 32.

[Seelengrab]

Do you have some benchmarks showing the improved performance?

[nsajko]

Benchmarking script

using BenchmarkTools

for f ∈ (all, any)
    println("f: $f")
    for b ∈ (false, true)
        println("  b: $b")
        for l ∈ 32:32:96
            println("    l: $l")
            print("    ")
            @btime ($f)(t) setup=(t = ntuple(Returns($b), $l);)
        end
    end
end

Results

master branch

Commit 1740287 (0 days old master):

f: all
  b: false
    l: 32
      13.392 ns (0 allocations: 0 bytes)
    l: 64
      13.143 ns (0 allocations: 0 bytes)
    l: 96
      18.287 ns (0 allocations: 0 bytes)
  b: true
    l: 32
      24.725 ns (0 allocations: 0 bytes)
    l: 64
      46.582 ns (0 allocations: 0 bytes)
    l: 96
      64.334 ns (0 allocations: 0 bytes)
f: any
  b: false
    l: 32
      29.442 ns (0 allocations: 0 bytes)
    l: 64
      54.097 ns (0 allocations: 0 bytes)
    l: 96
      74.817 ns (0 allocations: 0 bytes)
  b: true
    l: 32
      13.652 ns (0 allocations: 0 bytes)
    l: 64
      13.160 ns (0 allocations: 0 bytes)
    l: 96
      22.520 ns (0 allocations: 0 bytes)

PR branch

any_all_vectorized_tuple_bool/e022f12cce1 (fork: 7 commits, 0 days):

f: all
  b: false
    l: 32
      13.472 ns (0 allocations: 0 bytes)
    l: 64
      18.027 ns (0 allocations: 0 bytes)
    l: 96
      13.913 ns (0 allocations: 0 bytes)
  b: true
    l: 32
      16.995 ns (0 allocations: 0 bytes)
    l: 64
      21.898 ns (0 allocations: 0 bytes)
    l: 96
      14.746 ns (0 allocations: 0 bytes)
f: any
  b: false
    l: 32
      13.662 ns (0 allocations: 0 bytes)
    l: 64
      19.315 ns (0 allocations: 0 bytes)
    l: 96
      13.662 ns (0 allocations: 0 bytes)
  b: true
    l: 32
      18.279 ns (0 allocations: 0 bytes)
    l: 64
      13.512 ns (0 allocations: 0 bytes)
    l: 96
      24.966 ns (0 allocations: 0 bytes)

Interpretation

Speedups for (all, true) and (any, false).

[nsajko]

Be more conservative by restricting the new methods to homogeneous tuples.