You can do this with mapreduce, which has an efficient GPU implementation, which can do this in one pass, and should allocate almost nothing.
For CPU arrays, the above answers suggesting iteration, and zip, or just writing a loop, will be better. The CPU mapreduce with more than one array only has a fallback implementation, which calls map then reduce.
julia> using CUDA, GPUArrays, BenchmarkTools
julia> begin
test1(a, b) = min(findmax(a.+sqrt.(b))[1], findmax(b.+sqrt.(a))[1])
max2((x,y), (x2,y2)) = max(x,x2), max(y, y2)
function test2(as, bs)
xy = mapreduce(max2, as, bs) do a, b
a+sqrt(b), sqrt(a)+b
end
min(xy...)
end
end; # no real need for begin end
julia> let n = 1000
as = rand(n)
bs = rand(n)
r1 = @btime test1($as, $bs)
# on CPU, mapreduce(f, op, x, y) is just map then reduce
r2 = @btime test2($as, $bs)
r1 ≈ r2
end
16.336 μs (2 allocations: 15.88 KiB)
12.779 μs (1 allocation: 15.75 KiB) # hence this allocation
true
# First attempt on GPU tells you what to fix (it needs to reduce in parallel):
ERROR: GPUArrays.jl needs to know the neutral element for your operator `max2`.
Please pass it as an explicit argument to `GPUArrays.mapreducedim!`,
or register it globally by defining `GPUArrays.neutral_element(::typeof(max2), T)`.
julia> GPUArrays.neutral_element(::typeof(max2), ::Type{Tuple{T,T}}) where T = (T(-Inf), T(-Inf))
julia> let n = 10^8
as = cu(rand(n))
bs = cu(rand(n))
# sometimes you need @sync for an honest minimum time, perhaps not here
r1 = @btime CUDA.@sync test1($as, $bs)
r2 = @btime CUDA.@sync test2($as, $bs)
r1 ≈ r2
end
4.875 ms (315 allocations: 15.09 KiB)
1.234 ms (173 allocations: 8.53 KiB) # only CPU allocations, irrelevant
true
julia> let n = 10^8
as = cu(rand(n))
bs = cu(rand(n))
r1 = CUDA.@time test1(as, bs)
# CUDA.@time shows GPU allocations, mapreduce saves almost 1GB
r2 = CUDA.@time test2(as, bs)
r1 ≈ r2
end
0.077483 seconds (14.10 k CPU allocations: 979.863 KiB) (6 GPU allocations: 762.944 MiB, 7.13% memmgmt time)
0.001444 seconds (176 CPU allocations: 8.625 KiB) (2 GPU allocations: 1.258 KiB, 0.89% memmgmt time)
true
ps. Because I initially mis-read the problem, the above test2 is perhaps more complicated than necessary. A simpler one which makes two passes (and does not require you to supply a neutral element) is this:
julia> test3(as, bs) = min(mapreduce((a,b) -> a+sqrt(b), max, as, bs),
mapreduce((a,b) -> sqrt(a)+b, max, as, bs));
julia> let n = 10^9 # not timed on the first run after defining test3
as = cu(rand(n))
bs = cu(rand(n))
r1 = CUDA.@time test1(as, bs)
r2 = CUDA.@time test2(as, bs)
r3 = CUDA.@time test3(as, bs)
r1 ≈ r2 ≈ r3
end
1.651169 seconds (493 CPU allocations: 21.875 KiB, 94.79% gc time) (6 GPU allocations: 7.451 GiB, 97.06% memmgmt time)
0.010663 seconds (176 CPU allocations: 8.625 KiB) (2 GPU allocations: 1.258 KiB, 0.17% memmgmt time)
0.021164 seconds (347 CPU allocations: 17.359 KiB) (4 GPU allocations: 1.258 KiB, 0.25% memmgmt time)
true
