Using views slows down my code

New to Julia
,
1

Several people on the discourse have recently suggested I use views to improve my code’s performance. However, for some reason, it actually slows down my code when I use them. To test this, I wrote the following MWE:

using  FFTW

function with_views(N, M)
    ψ = Array{Complex{Float64}}(undef, M, N)
    ψ[1, :] = rand(N) + im*rand(N)
    F = plan_fft!(@view ψ[1, :]) # Plan
    F̃ = plan_ifft!(@view ψ[1, :]) # Plan

    W = ifftshift(cis.(rand(512)))

    for i = 1:M-1
        @views ψ[i+1, :] = T2(ψ[i,:],W, 1.0/M, F, F̃)
    end #for
    return nothing
end #solve

function without_views(N, M)
    ψ = Array{Complex{Float64}}(undef, M, N)
    ψ[1, :] = rand(N) + im*rand(N)
    F = plan_fft!(ψ[1, :]) # Plan
    F̃ = plan_ifft!(ψ[1, :]) # Plan

    W = ifftshift(cis.(rand(512)))

    for i = 1:M-1
        ψ[i+1, :] = T2(ψ[i,:],W, 1.0/M, F, F̃)
    end #for
    return nothing
end #solve

function T2(ψ, W, dx, F, F̃)
    @inbounds for i in 1:length(ψ)
        ψ[i] *= cis(dx/2 * (-1*abs2(ψ[i]))) 
    end

    F*ψ
    @inbounds for i in 1:length(W)
        ψ[i] *= W[i]
    end
    F̃*ψ

    @inbounds for i in 1:length(ψ)
        ψ[i] *= cis(dx/2 * (-1*abs2(ψ[i]))) 
    end

    return ψ
end #T2

@benchmark with_views(512, 10000)

@benchmark without_views(512, 10000)

Now to bench mark:

@benchmark with_views(512, 10000)
BenchmarkTools.Trial: 
  memory estimate:  157.51 MiB
  allocs estimate:  10072
  --------------
  minimum time:     227.541 ms (1.81% GC)
  median time:      235.816 ms (4.57% GC)
  mean time:        241.442 ms (6.53% GC)
  maximum time:     302.875 ms (25.67% GC)
  --------------
  samples:          21
  evals/sample:     1

And without views:

@benchmark without_views(512, 10000)
BenchmarkTools.Trial: 
  memory estimate:  157.53 MiB
  allocs estimate:  10074
  --------------
  minimum time:     165.236 ms (1.71% GC)
  median time:      172.742 ms (6.32% GC)
  mean time:        176.176 ms (8.19% GC)
  maximum time:     236.072 ms (31.66% GC)
  --------------
  samples:          29
  evals/sample:     1

I am not quite sure what’s going on here. Any advice?

2

Using views didn’t reduce the number of allocations here, so I’m guessing that wasn’t the problem here. I’ve heard that FFTW does a lot of allocating in the background since it’s calling to a C library, so that could be one reason for this. Have you checked your code (or this MWE) with --track-allocation to see where the allocations are coming from?

3

Just an idea, maybe @view works better when it is working with properly memory aligned data? Can you try and change rows and columns in your code? So, in the end it should be @view ψ[:, 1] instead of @view ψ[1, :].

1 Like
4

Since a C library is called it’s likely that a copy is made unless the array is contiguous. So this would definitely be something to try, and should improve performance anyway.

2 Likes
5

I don’t think the allocations are coming from FFTW. Try

@views ψ[i+1, :] .= T2(ψ[i,:],W, 1.0/M, F, F̃)

(note the .=)

3 Likes
6

This was the solution to the problem at hand, thank you.

This has also lead to some small performance gains, I knew Julia is column major but I must have gotten confused with the indexing. Thanks for catching that.

Combining the two recommendations, this is a new MWE:

using FFTW

function attempt2(N, M)
    ψ = Array{Complex{Float64}}(undef, N, M)
    ψ[:, 1] = rand(N) + im*rand(N)
    F = plan_fft!(@view ψ[:, 1]) # Plan
    F̃ = plan_ifft!(@view ψ[:, 1]) # Plan

    W = ifftshift(cis.(rand(512)))

    for i = 1:M-1
        @views ψ[:, i+1] .= T2(ψ[:,i],W, 1.0/M, F, F̃)
    end #for
    return nothing
end #solve

function attempt1(N, M)
    ψ = Array{Complex{Float64}}(undef, M, N)
    ψ[1, :] = rand(N) + im*rand(N)
    F = plan_fft!(ψ[1, :]) # Plan
    F̃ = plan_ifft!(ψ[1, :]) # Plan

    W = ifftshift(cis.(rand(512)))

    for i = 1:M-1
        ψ[i+1, :] = T2(ψ[i,:],W, 1.0/M, F, F̃)
    end #for
    return nothing
end #solve

function T2(ψ, W, dx, F, F̃)
    @inbounds for i in 1:length(ψ)
        ψ[i] *= cis(dx/2 * (-1*abs2(ψ[i]))) 
    end

    F*ψ
    @inbounds for i in 1:length(W)
        ψ[i] *= W[i]
    end
    F̃*ψ

    @inbounds for i in 1:length(ψ)
        ψ[i] *= cis(dx/2 * (-1*abs2(ψ[i]))) 
    end

    return ψ
end #T2

Benchmarking this, we get:

julia> @benchmark attempt1(512, 10000)
BenchmarkTools.Trial: 
  memory estimate:  157.53 MiB
  allocs estimate:  10074
  --------------
  minimum time:     167.911 ms (4.22% GC)
  median time:      175.678 ms (8.73% GC)
  mean time:        176.204 ms (8.71% GC)
  maximum time:     187.611 ms (10.80% GC)
  --------------
  samples:          29
  evals/sample:     1

julia> @benchmark attempt2(512, 10000)
BenchmarkTools.Trial: 
  memory estimate:  78.17 MiB
  allocs estimate:  73
  --------------
  minimum time:     138.274 ms (1.23% GC)
  median time:      143.694 ms (4.12% GC)
  mean time:        144.101 ms (4.02% GC)
  maximum time:     154.579 ms (3.71% GC)
  --------------
  samples:          35
  evals/sample:     1

a nice 20% performance gain!

3 Likes