Slowdown with views in 0.12.119

[ffreyer]

I have a reimplementation of Linearlagebra.qr in my codebase which uses @turbo. In it there is

using LinearAlgebra, LoopVectorization, BenchmarkTools

function reflectorApply!(x::AbstractVector{<: Real}, τ::Real, A::StridedMatrix{<: Real})
    m, n = size(A)
    @inbounds for j = 1:n
        # dot
        vAj = A[1, j]
        @turbo for i = 2:m
            vAj += conj(x[i]) * A[i, j]
        end

        vAj = conj(τ)*vAj

        # ger
        A[1, j] -= vAj
        @turbo for i = 2:m
            A[i, j] -= x[i]*vAj
        end
    end
    return A
end

which is called with two views into the same array:

input = rand(64, 64)
n = 64
j = 17
τ = 1.7
x = LinearAlgebra.view(input, j:n, j)
y = LinearAlgebra.view(input, j:n, j+1:n)
@benchmark reflectorApply!($x, $τ, $y)

I've noticed that after triggering a package update things have been running more slowly and Identified that the problem is here. Trying some different version of LoopVectorization pointed showed that v0.12.119 had made this much slower:

# median times via @benchmark, after julia restart
# no turbo:  2.9µs
# 0.12.124: 48µs
# 0.12.120: 46µs
# 0.12.119: 46µs
# 0.12.118:  0.72µs
# 0.12.115:  0.74µs
# 0.12.110:  0.72µs
# 0.12.100:  0.71µs

Rewriting this to use no views restores the performance from before 0.12.119.

[chriselrod]

Hmm, I cannot reproduce...

julia> @benchmark reflectorApply!($x, $τ, $y)
BenchmarkTools.Trial: 10000 samples with 171 evaluations.
 Range (min … max):  630.281 ns … 855.865 ns  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     635.731 ns               ┊ GC (median):    0.00%
 Time  (mean ± σ):   637.356 ns ±   5.920 ns  ┊ GC (mean ± σ):  0.00% ± 0.00%

           ▃▃▂█▄▄▂▁
  ▂▂▃▃▃▄▄▅▇█████████▇▇▅▄▄▃▂▂▂▂▂▂▂▁▁▁▁▁▁▁▁▁▁▂▂▂▂▂▂▂▃▃▃▃▃▃▃▃▃▃▃▃▂ ▃
  630 ns           Histogram: frequency by time          654 ns <

 Memory estimate: 0 bytes, allocs estimate: 0.

(lvdev) pkg> st -m LoopVectorization
Status `~/Documents/progwork/julia/env/lvdev/Manifest.toml`
  [bdcacae8] LoopVectorization v0.12.125 `~/.julia/dev/LoopVectorization`

julia> versioninfo()
Julia Version 1.9.0-DEV.1130
Commit c80316e125* (2022-08-15 13:05 UTC)
Platform Info:
  OS: Linux (x86_64-redhat-linux)
  CPU: 36 × Intel(R) Core(TM) i9-7980XE CPU @ 2.60GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-14.0.5 (ORCJIT, skylake-avx512)
  Threads: 18 on 36 virtual cores

[chriselrod]

Mind showing me the

@code_typed reflectorApply!(x, τ, y)

and

@code_native debuginfo = :none syntax = :intel reflectorApply!(x, τ, y)

        .text
        .file   "reflectorApply!"
        .globl  "julia_reflectorApply!_4509"    # -- Begin function julia_reflectorApply!_4509
        .p2align        4, 0x90
        .type   "julia_reflectorApply!_4509",@function
"julia_reflectorApply!_4509":           # @"julia_reflectorApply!_4509"
        .cfi_startproc
# %bb.0:                                # %top
        push    rbp
        .cfi_def_cfa_offset 16
        push    r15
        .cfi_def_cfa_offset 24
        push    r14
        .cfi_def_cfa_offset 32
        push    r13
        .cfi_def_cfa_offset 40
        push    r12
        .cfi_def_cfa_offset 48
        push    rbx
        .cfi_def_cfa_offset 56
        .cfi_offset rbx, -56
        .cfi_offset r12, -48
        .cfi_offset r13, -40
        .cfi_offset r14, -32
        .cfi_offset r15, -24
        .cfi_offset rbp, -16
        mov     qword ptr [rsp - 56], rsi       # 8-byte Spill
        mov     qword ptr [rsp - 48], rdi       # 8-byte Spill
        mov     r11, qword ptr [rcx + 32]
        mov     qword ptr [rsp - 80], rcx       # 8-byte Spill
        mov     rcx, qword ptr [rcx + 24]
        mov     rax, rcx
        mov     qword ptr [rsp - 64], rcx       # 8-byte Spill
        sub     r11, rcx
        movabs  rax, 9223372036854775806
        cmp     r11, rax
        jbe     .LBB0_1
.LBB0_26:                               # %L694
        mov     rcx, qword ptr [rsp - 80]       # 8-byte Reload
        mov     rax, qword ptr [rcx]
        mov     rdx, qword ptr [rsp - 56]       # 8-byte Reload
        mov     qword ptr [rdx], rax
        vmovups ymm0, ymmword ptr [rcx]
        vmovups ymm1, ymmword ptr [rcx + 24]
        mov     rax, qword ptr [rsp - 48]       # 8-byte Reload
        vmovups ymmword ptr [rax + 24], ymm1
        vmovups ymmword ptr [rax], ymm0
        pop     rbx
        .cfi_def_cfa_offset 48
        pop     r12
        .cfi_def_cfa_offset 40
        pop     r13
        .cfi_def_cfa_offset 32
        pop     r14
        .cfi_def_cfa_offset 24
        pop     r15
        .cfi_def_cfa_offset 16
        pop     rbp
        .cfi_def_cfa_offset 8
        vzeroupper
        ret
.LBB0_1:                                # %L34.preheader
        .cfi_def_cfa_offset 56
        mov     rdi, qword ptr [rsp - 80]       # 8-byte Reload
        mov     r9, qword ptr [rdi + 8]
        mov     rax, qword ptr [rdi + 16]
        sub     rax, r9
        inc     rax
        mov     rsi, rax
        sar     rsi, 63
        andn    rcx, rsi, rax
        inc     r11
        mov     rax, qword ptr [rdi]
        lea     rsi, [r9 - 1]
        mov     qword ptr [rsp - 8], rsi        # 8-byte Spill
        mov     r12, qword ptr [rax]
        mov     r13, qword ptr [rax + 24]
        mov     rax, qword ptr [rdx]
        mov     r8, qword ptr [rax]
        mov     r10, qword ptr [rdx + 8]
        mov     rsi, qword ptr [rdx + 24]
        dec     rsi
        imul    rsi, qword ptr [rax + 24]
        lea     rax, [r10 + rsi]
        lea     rdx, [r8 + 8*rax]
        mov     rax, qword ptr [rsp - 64]       # 8-byte Reload
        lea     rbp, [rax - 1]
        imul    rbp, r13
        lea     rax, [r9 + rbp]
        dec     rax
        lea     rax, [r12 + 8*rax + 8]
        mov     qword ptr [rsp - 16], rax       # 8-byte Spill
        lea     rax, [rcx - 1]
        mov     rdi, rax
        and     rdi, -32
        and     rax, -16
        lea     ebx, [rcx - 1]
        and     ebx, 7
        mov     r14d, 8
        cmovne  r14d, ebx
        lea     rbx, [rcx - 2]
        shl     r9, 3
        lea     r15, [r9 + 8*rbp]
        lea     rbp, [rcx - 10]
        mov     qword ptr [rsp - 72], rbp       # 8-byte Spill
        shl     r10, 3
        lea     rsi, [r10 + 8*rsi]
        lea     rbp, [rcx - 18]
        mov     qword ptr [rsp - 32], rbp       # 8-byte Spill
        add     rsi, r8
        add     rsi, 192
        mov     ebp, -1
        bzhi    ebp, ebp, r14d
        mov     dword ptr [rsp - 84], ebp       # 4-byte Spill
        mov     r9, rcx
        add     rcx, -26
        mov     qword ptr [rsp - 40], rcx       # 8-byte Spill
        lea     r10, [r12 + r15 + 192]
        lea     rcx, [8*r13]
        mov     qword ptr [rsp - 24], rcx       # 8-byte Spill
        mov     r14d, 1
        jmp     .LBB0_2
        .p2align        4, 0x90
.LBB0_19:                               # %L602
                                        #   in Loop: Header=BB0_2 Depth=1
        mov     ecx, dword ptr [rsp - 84]       # 4-byte Reload
        kmovd   k1, ecx
        vmovupd zmm2 {k1} {z}, zmmword ptr [rdx + 8*rdi]
        vmovupd zmm3 {k1} {z}, zmmword ptr [r8 + 8*rdi]
        vbroadcastsd    zmm1, xmm1
        vfnmadd213pd    zmm1, zmm2, zmm3        # zmm1 = -(zmm2 * zmm1) + zmm3
        vmovupd zmmword ptr [r8 + 8*rdi] {k1}, zmm1
.LBB0_25:                               # %L682
                                        #   in Loop: Header=BB0_2 Depth=1
        lea     rbp, [r14 + 1]
        add     r10, qword ptr [rsp - 24]       # 8-byte Folded Reload
        cmp     r14, r11
        mov     r14, rbp
        je      .LBB0_26
.LBB0_2:                                # %L34
                                        # =>This Loop Header: Depth=1
                                        #     Child Loop BB0_5 Depth 2
                                        #     Child Loop BB0_16 Depth 2
        lea     r8, [8*r14 - 8]
        imul    r8, r13
        cmp     r9, 33
        jae     .LBB0_4
# %bb.3:                                #   in Loop: Header=BB0_2 Depth=1
        vxorpd  xmm1, xmm1, xmm1
        xor     r15d, r15d
        vxorpd  xmm2, xmm2, xmm2
        jmp     .LBB0_7
        .p2align        4, 0x90
.LBB0_4:                                # %L194.preheader
                                        #   in Loop: Header=BB0_2 Depth=1
        vxorpd  xmm2, xmm2, xmm2
        vxorpd  xmm1, xmm1, xmm1
        vxorpd  xmm3, xmm3, xmm3
        vxorpd  xmm4, xmm4, xmm4
        xor     ebp, ebp
        .p2align        4, 0x90
.LBB0_5:                                # %L205
                                        #   Parent Loop BB0_2 Depth=1
                                        # =>  This Inner Loop Header: Depth=2
        vmovupd zmm5, zmmword ptr [rsi + 8*rbp - 192]
        vmovupd zmm6, zmmword ptr [rsi + 8*rbp - 128]
        vmovupd zmm7, zmmword ptr [rsi + 8*rbp - 64]
        vmovupd zmm8, zmmword ptr [rsi + 8*rbp]
        vfmadd231pd     zmm4, zmm5, zmmword ptr [r10 + 8*rbp - 192] # zmm4 = (zmm5 * mem) + zmm4
        vfmadd231pd     zmm3, zmm6, zmmword ptr [r10 + 8*rbp - 128] # zmm3 = (zmm6 * mem) + zmm3
        vfmadd231pd     zmm1, zmm7, zmmword ptr [r10 + 8*rbp - 64] # zmm1 = (zmm7 * mem) + zmm1
        vfmadd231pd     zmm2, zmm8, zmmword ptr [r10 + 8*rbp] # zmm2 = (zmm8 * mem) + zmm2
        add     rbp, 32
        cmp     rdi, rbp
        jne     .LBB0_5
# %bb.6:                                # %L232
                                        #   in Loop: Header=BB0_2 Depth=1
        vaddpd  zmm1, zmm4, zmm1
        vaddpd  zmm2, zmm3, zmm2
        mov     r15, rdi
.LBB0_7:                                # %L237
                                        #   in Loop: Header=BB0_2 Depth=1
        mov     rbp, qword ptr [rsp - 64]       # 8-byte Reload
        add     rbp, r14
        add     rbp, -2
        imul    rbp, r13
        add     r8, qword ptr [rsp - 16]        # 8-byte Folded Reload
        cmp     r15, rax
        jne     .LBB0_9
# %bb.8:                                #   in Loop: Header=BB0_2 Depth=1
        mov     r15, rax
        add     rbp, qword ptr [rsp - 8]        # 8-byte Folded Reload
        cmp     r15, rbx
        jg      .LBB0_14
        jmp     .LBB0_11
        .p2align        4, 0x90
.LBB0_9:                                # %L260
                                        #   in Loop: Header=BB0_2 Depth=1
        vmovupd zmm3, zmmword ptr [rdx + 8*r15]
        vmovupd zmm4, zmmword ptr [rdx + 8*r15 + 64]
        vfmadd231pd     zmm1, zmm3, zmmword ptr [r8 + 8*r15] # zmm1 = (zmm3 * mem) + zmm1
        vfmadd231pd     zmm2, zmm4, zmmword ptr [r8 + 8*r15 + 64] # zmm2 = (zmm4 * mem) + zmm2
        or      r15, 16
        add     rbp, qword ptr [rsp - 8]        # 8-byte Folded Reload
        cmp     r15, rbx
        jg      .LBB0_14
.LBB0_11:                               # %L280
                                        #   in Loop: Header=BB0_2 Depth=1
        cmp     qword ptr [rsp - 72], r15       # 8-byte Folded Reload
        jge     .LBB0_13
# %bb.12:                               # %L291
                                        #   in Loop: Header=BB0_2 Depth=1
        mov     ecx, dword ptr [rsp - 84]       # 4-byte Reload
        kmovd   k1, ecx
        vmovupd zmm3 {k1} {z}, zmmword ptr [rdx + 8*r15]
        vmovupd zmm4 {k1} {z}, zmmword ptr [r8 + 8*r15]
        vfmadd231pd     zmm1 {k1}, zmm3, zmm4   # zmm1 {%k1} = (zmm3 * zmm4) + zmm1
        jmp     .LBB0_14
        .p2align        4, 0x90
.LBB0_13:                               # %L299
                                        #   in Loop: Header=BB0_2 Depth=1
        vmovupd zmm3, zmmword ptr [rdx + 8*r15]
        mov     ecx, dword ptr [rsp - 84]       # 4-byte Reload
        kmovd   k1, ecx
        vmovupd zmm4 {k1} {z}, zmmword ptr [rdx + 8*r15 + 64]
        vmovupd zmm5 {k1} {z}, zmmword ptr [r8 + 8*r15 + 64]
        vfmadd231pd     zmm1, zmm3, zmmword ptr [r8 + 8*r15] # zmm1 = (zmm3 * mem) + zmm1
        vfmadd231pd     zmm2 {k1}, zmm4, zmm5   # zmm2 {%k1} = (zmm4 * zmm5) + zmm2
.LBB0_14:                               # %L309
                                        #   in Loop: Header=BB0_2 Depth=1
        vaddpd  zmm1, zmm1, zmm2
        vmovsd  xmm2, qword ptr [r12 + 8*rbp]   # xmm2 = mem[0],zero
        vextractf64x4   ymm3, zmm1, 1
        vaddpd  zmm1, zmm1, zmm3
        vextractf128    xmm3, ymm1, 1
        vaddpd  xmm1, xmm1, xmm3
        vpermilpd       xmm3, xmm1, 1           # xmm3 = xmm1[1,0]
        vaddsd  xmm1, xmm1, xmm3
        vaddsd  xmm1, xmm2, xmm1
        vmulsd  xmm1, xmm1, xmm0
        vsubsd  xmm2, xmm2, xmm1
        vmovsd  qword ptr [r12 + 8*rbp], xmm2
        test    rdi, rdi
        je      .LBB0_17
# %bb.15:                               # %L563.lr.ph
                                        #   in Loop: Header=BB0_2 Depth=1
        vbroadcastsd    zmm2, xmm1
        xor     ebp, ebp
        .p2align        4, 0x90
.LBB0_16:                               # %L563
                                        #   Parent Loop BB0_2 Depth=1
                                        # =>  This Inner Loop Header: Depth=2
        vmovupd zmm3, zmmword ptr [rsi + 8*rbp - 192]
        vmovupd zmm4, zmmword ptr [rsi + 8*rbp - 128]
        vmovupd zmm5, zmmword ptr [rsi + 8*rbp - 64]
        vmovupd zmm6, zmmword ptr [rsi + 8*rbp]
        vfnmadd213pd    zmm3, zmm2, zmmword ptr [r10 + 8*rbp - 192] # zmm3 = -(zmm2 * zmm3) + mem
        vfnmadd213pd    zmm4, zmm2, zmmword ptr [r10 + 8*rbp - 128] # zmm4 = -(zmm2 * zmm4) + mem
        vfnmadd213pd    zmm5, zmm2, zmmword ptr [r10 + 8*rbp - 64] # zmm5 = -(zmm2 * zmm5) + mem
        vfnmadd213pd    zmm6, zmm2, zmmword ptr [r10 + 8*rbp] # zmm6 = -(zmm2 * zmm6) + mem
        vmovupd zmmword ptr [r10 + 8*rbp - 192], zmm3
        vmovupd zmmword ptr [r10 + 8*rbp - 128], zmm4
        vmovupd zmmword ptr [r10 + 8*rbp - 64], zmm5
        vmovupd zmmword ptr [r10 + 8*rbp], zmm6
        add     rbp, 32
        cmp     rdi, rbp
        jne     .LBB0_16
.LBB0_17:                               # %L589
                                        #   in Loop: Header=BB0_2 Depth=1
        cmp     rdi, rbx
        jg      .LBB0_25
# %bb.18:                               # %L591
                                        #   in Loop: Header=BB0_2 Depth=1
        cmp     qword ptr [rsp - 72], rdi       # 8-byte Folded Reload
        jl      .LBB0_19
# %bb.20:                               # %L613
                                        #   in Loop: Header=BB0_2 Depth=1
        cmp     qword ptr [rsp - 32], rdi       # 8-byte Folded Reload
        jge     .LBB0_22
# %bb.21:                               # %L616
                                        #   in Loop: Header=BB0_2 Depth=1
        vmovupd zmm2, zmmword ptr [rdx + 8*rdi]
        mov     ecx, dword ptr [rsp - 84]       # 4-byte Reload
        kmovd   k1, ecx
        vmovupd zmm3 {k1} {z}, zmmword ptr [rdx + 8*rdi + 64]
        vmovupd zmm4 {k1} {z}, zmmword ptr [r8 + 8*rdi + 64]
        vbroadcastsd    zmm1, xmm1
        vfnmadd213pd    zmm2, zmm1, zmmword ptr [r8 + 8*rdi] # zmm2 = -(zmm1 * zmm2) + mem
        vfnmadd231pd    zmm4, zmm1, zmm3        # zmm4 = -(zmm1 * zmm3) + zmm4
        vmovupd zmmword ptr [r8 + 8*rdi], zmm2
        vmovupd zmmword ptr [r8 + 8*rdi + 64] {k1}, zmm4
        jmp     .LBB0_25
.LBB0_22:                               # %L632
                                        #   in Loop: Header=BB0_2 Depth=1
        vmovupd zmm3, zmmword ptr [rdx + 8*rdi]
        vmovupd zmm2, zmmword ptr [rdx + 8*rdi + 64]
        cmp     qword ptr [rsp - 40], rdi       # 8-byte Folded Reload
        jge     .LBB0_24
# %bb.23:                               # %L635
                                        #   in Loop: Header=BB0_2 Depth=1
        lea     rbp, [rdx + 8*rdi]
        add     rbp, 128
        mov     ecx, dword ptr [rsp - 84]       # 4-byte Reload
        kmovd   k1, ecx
        vmovupd zmm4 {k1} {z}, zmmword ptr [rbp]
        vmovupd zmm5 {k1} {z}, zmmword ptr [r8 + 8*rdi + 128]
        vbroadcastsd    zmm1, xmm1
        vfnmadd213pd    zmm3, zmm1, zmmword ptr [r8 + 8*rdi] # zmm3 = -(zmm1 * zmm3) + mem
        vfnmadd213pd    zmm2, zmm1, zmmword ptr [r8 + 8*rdi + 64] # zmm2 = -(zmm1 * zmm2) + mem
        vfnmadd231pd    zmm5, zmm1, zmm4        # zmm5 = -(zmm1 * zmm4) + zmm5
        vmovupd zmmword ptr [r8 + 8*rdi], zmm3
        vmovupd zmmword ptr [r8 + 8*rdi + 64], zmm2
        vmovupd zmmword ptr [r8 + 8*rdi + 128] {k1}, zmm5
        jmp     .LBB0_25
.LBB0_24:                               # %L656
                                        #   in Loop: Header=BB0_2 Depth=1
        lea     rbp, [rdx + 8*rdi]
        vmovupd zmm4, zmmword ptr [rbp + 128]
        mov     ecx, dword ptr [rsp - 84]       # 4-byte Reload
        kmovd   k1, ecx
        vmovupd zmm5 {k1} {z}, zmmword ptr [rbp + 192]
        vmovupd zmm6 {k1} {z}, zmmword ptr [r8 + 8*rdi + 192]
        vbroadcastsd    zmm1, xmm1
        vfnmadd213pd    zmm3, zmm1, zmmword ptr [r8 + 8*rdi] # zmm3 = -(zmm1 * zmm3) + mem
        vfnmadd213pd    zmm2, zmm1, zmmword ptr [r8 + 8*rdi + 64] # zmm2 = -(zmm1 * zmm2) + mem
        vfnmadd213pd    zmm4, zmm1, zmmword ptr [r8 + 8*rdi + 128] # zmm4 = -(zmm1 * zmm4) + mem
        vfnmadd231pd    zmm6, zmm1, zmm5        # zmm6 = -(zmm1 * zmm5) + zmm6
        vmovupd zmmword ptr [r8 + 8*rdi], zmm3
        vmovupd zmmword ptr [r8 + 8*rdi + 64], zmm2
        vmovupd zmmword ptr [r8 + 8*rdi + 128], zmm4
        vmovupd zmmword ptr [r8 + 8*rdi + 192] {k1}, zmm6
        jmp     .LBB0_25
.Lfunc_end0:
        .size   "julia_reflectorApply!_4509", .Lfunc_end0-"julia_reflectorApply!_4509"
        .cfi_endproc
                                        # -- End function
        .type   .L_j_const1,@object             # @_j_const1
        .section        .rodata.cst8,"aM",@progbits,8
        .p2align        3
.L_j_const1:
        .quad   1                               # 0x1
        .size   .L_j_const1, 8

        .section        ".note.GNU-stack","",@progbits

[chriselrod]

There's basically only one change between 0.12.118 and 0.12.119: v0.12.118...v0.12.119
so if the change were in LoopVectorization.jl itself instead of a dependency, there is only one place I have to look.

However, I cannot reproduce a performance problem with either AVX512 or AVX2.

Additionally, that change should be irrelevant here.
So, more likely there's a problem in a dependency somewhere that in LV itself, and switching versions changed the dependencies.

[ffreyer]

Versioninfo:

Julia Version 1.7.0
Commit 3bf9d17731 (2021-11-30 12:12 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: Intel(R) Core(TM) i5-6600 CPU @ 3.30GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-12.0.1 (ORCJIT, skylake)

I put code_typed and native in a gist since they're quite long:
https://gist.github.com/ffreyer/d8427ec1cf4215f69efed8a30f5ec04d

I checked this on the login node of a cluster now as well and I don't get a slow down there. So maybe it's specific to julia 1.7 or my cpu?

julia> versioninfo()
Julia Version 1.7.1
Commit ac5cc99908* (2021-12-22 19:35 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-12.0.1 (ORCJIT, skylake-avx512)

# with LoopVectorization 0.12.125
julia> @benchmark reflectorApply!($x, $τ, $y)
BenchmarkTools.Trial: 10000 samples with 165 evaluations.
 Range (min … max):  651.345 ns …  2.410 μs  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     692.697 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   703.326 ns ± 64.135 ns  ┊ GC (mean ± σ):  0.00% ± 0.00%

  ▅█  ▁▂▁ ▁▄▆   ▁    ▃▅▆  ▁▂   ▁                       ▃       ▁
  ██▃████▆████▆▇██▆▇████▆▇██▇▇███▇▇▇▇▇▆▅▆▄▆▆▅▄▄▂▄▃▂▃▂▃▄█▅▂▂▅▆▄ █
  651 ns        Histogram: log(frequency) by time       914 ns <

 Memory estimate: 0 bytes, allocs estimate: 0.

[chriselrod]

From your code:

        movabs  rax, offset StrideIndex
        vzeroupper
        call    rax
        mov     r13, qword ptr [r13]
        mov     rax, qword ptr [rsp + 96]
        add     rax, r13
        mov     qword ptr [rsp + 104], rax
        mov     rdi, r12
        mov     rsi, qword ptr [rsp + 32]
        movabs  rax, offset StrideIndex
        call    rax

or

│            invoke LayoutPointers.StrideIndex(x::SubArray{Float64, 1, Matrix{Float64}, Tuple{UnitRange{Int64}, Int64}, true})::ArrayInterface.StrideIndex{1, (1,), 1, Tuple{Static.StaticInt{1}}, Tuple{Static.StaticInt{1}}}
│     %136 = Base.getfield(A, :parent)::Matrix{Float64}
│     %137 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%136)))::Ptr{Float64}
│     %138 = Base.getfield(A, :parent)::Matrix{Float64}
│     %139 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│     %140 = LayoutPointers.getfield(%139, 1, false)::UnitRange{Int64}
│     %141 = Base.getfield(%140, :start)::Int64
│     %142 = Base.sub_int(%141, 1)::Int64
│     %143 = Core.getfield(%139, 2)::UnitRange{Int64}
│     %144 = Base.getfield(%143, :start)::Int64
│     %145 = Base.sub_int(%144, 1)::Int64
│     %146 = Base.arraysize(%138, 1)::Int64
│            Base.arraysize(%138, 2)::Int64
│     %148 = Base.mul_int(1, %146)::Int64
│     %149 = Base.mul_int(%142, 1)::Int64
│     %150 = Base.mul_int(%145, %148)::Int64
│     %151 = Base.add_int(%149, %150)::Int64
│     %152 = Base.mul_int(8, %151)::Int64
│     %153 = Core.bitcast(Core.UInt, %137)::UInt64
│     %154 = Base.bitcast(UInt64, %152)::UInt64
│     %155 = Base.add_ptr(%153, %154)::UInt64
│     %156 = Core.bitcast(Ptr{Float64}, %155)::Ptr{Float64}
│     %157 = invoke LayoutPointers.StrideIndex(A::SubArray{Float64, 2, Matrix{Float64}, Tuple{UnitRange{Int64}, UnitRange{Int64}}, false})::ArrayInterface.StrideIndex{2, (1, 2), 1, Tuple{Static.StaticInt{1}, Int64}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}}

That is bad.

[chriselrod]

What do you get for ] st -m ArrayInterface?

[ffreyer]

(@v1.7) pkg> st -m ArrayInterface
      Status `~/.julia/environments/v1.7/Manifest.toml`
  [4fba245c] ArrayInterface v6.0.22

[ffreyer]

And no slowdown in 1.8.0

[chriselrod]

I'm guessing it is because StrideIndex is not inlining

[ffreyer]

I also tried

(@v1.7) pkg> activate .
  Activating new project at `~/Documents/julia source`
(julia source) pkg> add LoopVectorization BenchmarkTools

and I still get a slowdown in 1.7. The package version match, except for some packages getting version numbers in 1.8 while not having any in 1.7 (ArgTools, Downloads, ...)

[ffreyer]

With JuliaArrays/ArrayInterface.jl#343:

https://gist.github.com/ffreyer/d63a95c21857678e8b76f40fff457a4a

I'm fine with switching to the view-less version/upgrading Julia too

[chriselrod]

Could you share the code typed? That looks really bad, but I don't know what functions are being called.

[ffreyer]

I updated the gist

[chriselrod]

@Tokazama do you want to make sure ArrayInterfaceCore.is_splat_index is elided?

[chriselrod]

I can confirm that I see the regression on 1.7.3:

julia> @benchmark reflectorApply!($x, $τ, $y)
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):   77.337 μs … 142.382 μs  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     127.234 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   127.364 μs ±   2.679 μs  ┊ GC (mean ± σ):  0.00% ± 0.00%

                                                          █▂
  ▂▂▂▁▂▁▂▂▂▂▂▂▂▂▁▂▂▂▁▂▂▂▂▂▂▂▂▂▁▂▂▂▂▁▁▂▂▂▂▂▂▁▂▂▂▁▁▂▂▁▂▁▂▂▂▄██▄▄▃ ▂
  77.3 μs          Histogram: frequency by time          131 μs <

 Memory estimate: 0 bytes, allocs estimate: 0.

julia> versioninfo()
Julia Version 1.7.3
Commit 742b9abb4d (2022-05-06 12:58 UTC)
Platform Info:
  OS: Linux (x86_64-redhat-linux)
  CPU: Intel(R) Core(TM) i9-7980XE CPU @ 2.60GHz