regression on inferring inbounds for `eachindex()`

[Moelf]

julia> function f(N)
           res = zeros(N)
           a = 1.1
           b = 2.2
           @inbounds for i in eachindex(res)
               res[i] = a*i + b*i
           end
           res
       end

the @inbounds makes about 2x performance different in 1.8 but seems to be fixed on master, it would be nice to find the fix and backport to 1.8

[jishnub]

On a 1-day-old nightly build, I find

julia> function f(N)
           res = zeros(N)
           a = 1.1
           b = 2.2
           @inbounds for i in eachindex(res)
               res[i] = a*i + b*i
           end
           res
       end
f (generic function with 1 method)

julia> function g(N)
                  res = zeros(N)
                  a = 1.1
                  b = 2.2
                  for i in eachindex(res)
                      res[i] = a*i + b*i
                  end
                  res
              end
g (generic function with 1 method)

julia> using BenchmarkTools

julia> @btime f(1000);
  811.738 ns (1 allocation: 7.94 KiB)

julia> @btime g(1000);
  1.358 μs (1 allocation: 7.94 KiB)

julia> VERSION
v"1.9.0-DEV.672"

There still seems to be a 1.5x performance hit, which is the same that I find on 1.8

julia> @btime g(1000);
  1.372 μs (1 allocation: 7.94 KiB)

julia> VERSION
v"1.8.0-beta3"

although it's much slower on 1.7

julia> @btime g(1000);
  2.088 μs (1 allocation: 7.94 KiB)

julia> VERSION
v"1.7.3"

[chriselrod]

I prefer @benchmark over @btime, particularly whenever GC is involved. In a fresh Julia session:

julia> @btime f(1000);
  557.613 ns (1 allocation: 7.94 KiB)

julia> @btime g(1000);
  594.895 ns (1 allocation: 7.94 KiB)

julia> VERSION
v"1.9.0-DEV.633"

Now, running @benchmark:

julia> @benchmark f(1000)
BenchmarkTools.Trial: 10000 samples with 170 evaluations.
 Range (min … max):  600.206 ns …   9.560 μs  ┊ GC (min … max):  0.00% … 77.31%
 Time  (median):     641.762 ns               ┊ GC (median):     0.00%
 Time  (mean ± σ):   810.300 ns ± 936.513 ns  ┊ GC (mean ± σ):  18.28% ± 13.77%

  █▃                                                            ▁
  ███▃▁▄▃▁▁▁▁▁▁▁▁▁▁▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▆▆███ █
  600 ns        Histogram: log(frequency) by time       6.15 μs <

 Memory estimate: 7.94 KiB, allocs estimate: 1.

julia> @benchmark g(1000)
BenchmarkTools.Trial: 10000 samples with 171 evaluations.
 Range (min … max):  602.830 ns … 9.943 μs  ┊ GC (min … max):  0.00% … 83.07%
 Time  (median):     639.380 ns             ┊ GC (median):     0.00%
 Time  (mean ± σ):   831.574 ns ± 1.063 μs  ┊ GC (mean ± σ):  20.81% ± 14.33%

  █▃                                                      ▁▁  ▁
  ██▆▁▄▁▁▁▁▁▁▁▁▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███ █
  603 ns       Histogram: log(frequency) by time      6.87 μs <

 Memory estimate: 7.94 KiB, allocs estimate: 1.

Now, restarting and switching the order of @btime-ing f and g:

julia> @btime g(1000);
  562.523 ns (1 allocation: 7.94 KiB)

julia> @btime f(1000);
  586.472 ns (1 allocation: 7.94 KiB)

The faster one is the one you run first, because the GC has a cleaner slate without fragementation.

The assembly/llvm show that g and f have both SIMDed successfully on master.

Definitely no 1.5x regression. At least on DEV.633. I guess it's possible DEV.672 regressed.

[jishnub]

Unfortunately, I obtain a similar result using @benchmark, and switching the orders:

julia> @benchmark g(1000)
BenchmarkTools.Trial: 10000 samples with 10 evaluations.
 Range (min … max):  1.380 μs … 119.132 μs  ┊ GC (min … max): 0.00% … 94.64%
 Time  (median):     1.547 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   1.775 μs ±   3.835 μs  ┊ GC (mean ± σ):  8.07% ±  3.71%

  ▄▇▇█▆▅▁▁▁▂▁▁                                                ▂
  █████████████▇▇▇▆█▇▇▆▅▄▄▄▄▄▄▆▄▄▄▁▁▁▄▃▁▃▁▁▁▁▃▃▃▁▁▁▁▁▄▆▇██▇▇█ █
  1.38 μs      Histogram: log(frequency) by time      4.36 μs <

 Memory estimate: 7.94 KiB, allocs estimate: 1.

julia> @benchmark f(1000)
BenchmarkTools.Trial: 10000 samples with 40 evaluations.
 Range (min … max):  834.825 ns … 32.122 μs  ┊ GC (min … max):  0.00% … 94.84%
 Time  (median):     979.900 ns              ┊ GC (median):     0.00%
 Time  (mean ± σ):     1.186 μs ±  2.063 μs  ┊ GC (mean ± σ):  14.08% ±  7.80%

    █▆                                                          
  ▂▆██▇▄▄▃▂▂▂▂▂▂▂▂▂▂▁▂▂▁▁▁▁▁▁▂▁▁▁▁▂▁▁▁▁▁▁▁▁▁▁▁▁▂▁▁▁▁▁▁▁▁▁▁▁▂▂▂ ▂
  835 ns          Histogram: frequency by time         3.61 μs <

 Memory estimate: 7.94 KiB, allocs estimate: 1.

julia> VERSION
v"1.9.0-DEV.680"

Looking at @code_llvm, I find a difference in the setindex! section for the two:

julia> @code_llvm f(8)
[...]
; ┌ @ array.jl:959 within `setindex!`
   %26 = getelementptr inbounds double, double* %9, i64 %index
   %27 = bitcast double* %26 to <4 x double>*
   store <4 x double> %22, <4 x double>* %27, align 8
   %28 = getelementptr inbounds double, double* %26, i64 4
   %29 = bitcast double* %28 to <4 x double>*
   store <4 x double> %23, <4 x double>* %29, align 8
   %30 = getelementptr inbounds double, double* %26, i64 8
   %31 = bitcast double* %30 to <4 x double>*
   store <4 x double> %24, <4 x double>* %31, align 8
   %32 = getelementptr inbounds double, double* %26, i64 12
   %33 = bitcast double* %32 to <4 x double>*
   store <4 x double> %25, <4 x double>* %33, align 8
   %index.next = add nuw i64 %index, 16
   %vec.ind.next = add <4 x i64> %vec.ind, <i64 16, i64 16, i64 16, i64 16>
   %34 = icmp eq i64 %index.next, %n.vec
   br i1 %34, label %middle.block, label %vector.body
[...]

julia> @code_llvm g(8)
[...]
; ┌ @ array.jl:959 within `setindex!`
   %broadcast.splatinsert = insertelement <4 x double*> undef, double* %.pre41, i32 0
   %broadcast.splat = shufflevector <4 x double*> %broadcast.splatinsert, <4 x double*> undef, <4 x i32> zeroinitializer
   %29 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %9
   %30 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %10
   %31 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %11
   %32 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %12
   call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %25, <4 x double*> %29, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
   call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %26, <4 x double*> %30, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
   call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %27, <4 x double*> %31, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
   call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %28, <4 x double*> %32, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
   %index.next = add nuw i64 %index, 16
   %vec.ind.next = add <4 x i64> %vec.ind, <i64 16, i64 16, i64 16, i64 16>
   %33 = icmp eq i64 %index.next, %n.vec
   br i1 %33, label %middle.block, label %vector.body
[...]

I don't know any llvm, but naively it appears that simd is indeed working as expected (from the 4x doubles), and I don't see any @ijl_bounds_error_ints in the full llvm code. Would be great to understand why there's the performance difference on my machine.

[chriselrod]

Huh, that is bizarre. Scatter instructions are very slow, and there is no reason to use them here.
My code llvm/native is not using scatters.

Mind sharing your versioninfo() (in particular, I want to confirm the CPU) and the full @code_llvm debuginfo=:none g(8)? Note that llvm is supported by github's syntax highlighting.

[jishnub]

julia> versioninfo()
Julia Version 1.9.0-DEV.680
Commit 0057d75620 (2022-05-30 04:06 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: 8 × 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-13.0.1 (ORCJIT, tigerlake)
  Threads: 1 on 8 virtual cores
Environment:
  JULIA_EDITOR = vim

Output from @code_llvm:

julia> @code_llvm debuginfo=:none g(8)
define nonnull {}* @julia_g_1175(i64 signext %0) #0 {
top:
  %1 = call nonnull {}* inttoptr (i64 140478306985888 to {}* ({}*, i64)*)({}* inttoptr (i64 140477964824080 to {}*), i64 %0)
  %2 = bitcast {}* %1 to { i8*, i64, i16, i16, i32 }*
  %3 = getelementptr inbounds { i8*, i64, i16, i16, i32 }, { i8*, i64, i16, i16, i32 }* %2, i64 0, i32 1
  %4 = load i64, i64* %3, align 8
  %.not.not = icmp eq i64 %4, 0
  br i1 %.not.not, label %L33, label %L15.preheader

L15.preheader:                                    ; preds = %top
  %5 = bitcast {}* %1 to i8**
  %6 = load i8*, i8** %5, align 8
  %7 = shl nuw i64 %4, 3
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 %6, i8 0, i64 %7, i1 false)
  br label %L33

L33:                                              ; preds = %L15.preheader, %top
  %.inv = icmp sgt i64 %0, 0
  %.18 = select i1 %.inv, i64 %0, i64 0
  br i1 %.inv, label %L49.preheader, label %L68

L49.preheader:                                    ; preds = %L33
  %8 = load i64, i64* %3, align 8
  %9 = bitcast {}* %1 to double**
  %10 = add nuw nsw i64 %8, 1
  %11 = add nsw i64 %.18, -1
  %umin = call i64 @llvm.umin.i64(i64 %8, i64 %11)
  %12 = add nuw nsw i64 %umin, 1
  %min.iters.check = icmp ult i64 %umin, 16
  br i1 %min.iters.check, label %L49, label %vector.ph

vector.ph:                                        ; preds = %L49.preheader
  %n.mod.vf = and i64 %12, 15
  %13 = icmp eq i64 %n.mod.vf, 0
  %14 = select i1 %13, i64 16, i64 %n.mod.vf
  %n.vec = sub nsw i64 %12, %14
  %ind.end = add i64 %n.vec, 1
  %.pre = load double*, double** %9, align 8
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i64> [ <i64 1, i64 2, i64 3, i64 4>, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %step.add = add <4 x i64> %vec.ind, <i64 4, i64 4, i64 4, i64 4>
  %step.add22 = add <4 x i64> %vec.ind, <i64 8, i64 8, i64 8, i64 8>
  %step.add23 = add <4 x i64> %vec.ind, <i64 12, i64 12, i64 12, i64 12>
  %15 = add nsw <4 x i64> %vec.ind, <i64 -1, i64 -1, i64 -1, i64 -1>
  %16 = add <4 x i64> %vec.ind, <i64 3, i64 3, i64 3, i64 3>
  %17 = add <4 x i64> %vec.ind, <i64 7, i64 7, i64 7, i64 7>
  %18 = add <4 x i64> %vec.ind, <i64 11, i64 11, i64 11, i64 11>
  %19 = sitofp <4 x i64> %vec.ind to <4 x double>
  %20 = sitofp <4 x i64> %step.add to <4 x double>
  %21 = sitofp <4 x i64> %step.add22 to <4 x double>
  %22 = sitofp <4 x i64> %step.add23 to <4 x double>
  %23 = fmul <4 x double> %19, <double 1.100000e+00, double 1.100000e+00, double 1.100000e+00, double 1.100000e+00>
  %24 = fmul <4 x double> %20, <double 1.100000e+00, double 1.100000e+00, double 1.100000e+00, double 1.100000e+00>
  %25 = fmul <4 x double> %21, <double 1.100000e+00, double 1.100000e+00, double 1.100000e+00, double 1.100000e+00>
  %26 = fmul <4 x double> %22, <double 1.100000e+00, double 1.100000e+00, double 1.100000e+00, double 1.100000e+00>
  %27 = fmul <4 x double> %19, <double 2.200000e+00, double 2.200000e+00, double 2.200000e+00, double 2.200000e+00>
  %28 = fmul <4 x double> %20, <double 2.200000e+00, double 2.200000e+00, double 2.200000e+00, double 2.200000e+00>
  %29 = fmul <4 x double> %21, <double 2.200000e+00, double 2.200000e+00, double 2.200000e+00, double 2.200000e+00>
  %30 = fmul <4 x double> %22, <double 2.200000e+00, double 2.200000e+00, double 2.200000e+00, double 2.200000e+00>
  %31 = fadd <4 x double> %23, %27
  %32 = fadd <4 x double> %24, %28
  %33 = fadd <4 x double> %25, %29
  %34 = fadd <4 x double> %26, %30
  %broadcast.splatinsert = insertelement <4 x double*> undef, double* %.pre, i32 0
  %broadcast.splat = shufflevector <4 x double*> %broadcast.splatinsert, <4 x double*> undef, <4 x i32> zeroinitializer
  %35 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %15
  %36 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %16
  %37 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %17
  %38 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %18
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %31, <4 x double*> %35, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %32, <4 x double*> %36, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %33, <4 x double*> %37, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %34, <4 x double*> %38, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  %index.next = add nuw i64 %index, 16
  %vec.ind.next = add <4 x i64> %vec.ind, <i64 16, i64 16, i64 16, i64 16>
  %39 = icmp eq i64 %index.next, %n.vec
  br i1 %39, label %L49, label %vector.body

L49:                                              ; preds = %idxend, %vector.body, %L49.preheader
  %value_phi12 = phi i64 [ %48, %idxend ], [ 1, %L49.preheader ], [ %ind.end, %vector.body ]
  %exitcond.not = icmp eq i64 %value_phi12, %10
  br i1 %exitcond.not, label %oob, label %idxend

L68:                                              ; preds = %idxend, %L33
  ret {}* %1

oob:                                              ; preds = %L49
  %40 = alloca i64, align 8
  store i64 %10, i64* %40, align 8
  call void @ijl_bounds_error_ints({}* %1, i64* nonnull %40, i64 1)
  unreachable

idxend:                                           ; preds = %L49
  %41 = add nsw i64 %value_phi12, -1
  %42 = sitofp i64 %value_phi12 to double
  %43 = fmul double %42, 1.100000e+00
  %44 = fmul double %42, 2.200000e+00
  %45 = fadd double %43, %44
  %46 = load double*, double** %9, align 8
  %47 = getelementptr inbounds double, double* %46, i64 %41
  store double %45, double* %47, align 8
  %.not = icmp eq i64 %value_phi12, %.18
  %48 = add nuw i64 %value_phi12, 1
  br i1 %.not, label %L68, label %L49
}

[Moelf]

it's so weird, is this CPU dependent?

julia> versioninfo()
Julia Version 1.9.0-DEV.680
Commit 0057d75620 (2022-05-30 04:06 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: 24 × AMD Ryzen 9 3900X 12-Core Processor
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-13.0.1 (ORCJIT, znver2)
  Threads: 4 on 24 virtual cores
Environment:
  JULIA_NUM_THREADS = 4

julia> @benchmark g(1000)
BenchmarkTools.Trial: 10000 samples with 134 evaluations.
 Range (min … max):  1.013 μs …   8.617 μs  ┊ GC (min … max): 0.00% … 72.82%
 Time  (median):     1.107 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   1.313 μs ± 857.596 ns  ┊ GC (mean ± σ):  8.62% ± 11.31%

  ██▂▂        ▃▃▂                                             ▂
  █████▆▆▆▆▆▆▇███▇▆▅▄▁▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▅▃▅▅▆▆▆▆▅▆▆▆▆▆▃▅▅▄ █
  1.01 μs      Histogram: log(frequency) by time      6.22 μs <

 Memory estimate: 7.94 KiB, allocs estimate: 1.

julia> @benchmark f(1000)
BenchmarkTools.Trial: 10000 samples with 19 evaluations.
 Range (min … max):  910.684 ns … 61.372 μs  ┊ GC (min … max):  0.00% … 95.31%
 Time  (median):       1.020 μs              ┊ GC (median):     0.00%
 Time  (mean ± σ):     1.227 μs ±  2.528 μs  ┊ GC (mean ± σ):  10.42% ±  5.02%

   ▄███▇▇▆▅▄▃▂▁▁  ▁▁                           ▁▁▂▁▁        ▁  ▂
  ██████████████████████▆▇▆▅▆▆▃▅▅▃▄▄▅▁▁▄▁▃▁▃▃▄▆██████▇▅▆▆▅▆███ █
  911 ns        Histogram: log(frequency) by time      2.33 μs <

 Memory estimate: 7.94 KiB, allocs estimate: 1.

LLVM for `g`

julia> @code_llvm debuginfo=:none g(8)
define nonnull {}* @julia_g_732(i64 signext %0) #0 {
top:
  %1 = call nonnull {}* inttoptr (i64 140057835662320 to {}* ({}*, i64)*)({}* inttoptr (i64 140057501386912 to {}*), i64 %0)
  %2 = bitcast {}* %1 to { i8*, i64, i16, i16, i32 }*
  %3 = getelementptr inbounds { i8*, i64, i16, i16, i32 }, { i8*, i64, i16, i16, i32 }* %2, i64 0, i32 1
  %4 = load i64, i64* %3, align 8
  %.not.not = icmp eq i64 %4, 0
  br i1 %.not.not, label %L65, label %L33

L33:                                              ; preds = %top
  %5 = bitcast {}* %1 to i8**
  %6 = load i8*, i8** %5, align 8
  %7 = shl nuw i64 %4, 3
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 %6, i8 0, i64 %7, i1 false)
  %.pre = load i64, i64* %3, align 8
  %.not.not20 = icmp eq i64 %.pre, 0
  br i1 %.not.not20, label %L65, label %L46.preheader23

L46.preheader23:                                  ; preds = %L33
  %8 = bitcast {}* %1 to double**
  %.pre32 = load double*, double** %8, align 8
  br label %idxend

L65:                                              ; preds = %idxend, %L33, %top
  ret {}* %1

idxend:                                           ; preds = %idxend, %L46.preheader23
  %value_phi11 = phi i64 [ %15, %idxend ], [ 1, %L46.preheader23 ]
  %9 = add nsw i64 %value_phi11, -1
  %10 = sitofp i64 %value_phi11 to double
  %11 = fmul double %10, 1.100000e+00
  %12 = fmul double %10, 2.200000e+00
  %13 = fadd double %11, %12
  %14 = getelementptr inbounds double, double* %.pre32, i64 %9
  store double %13, double* %14, align 8
  %15 = add nuw nsw i64 %value_phi11, 1
  %16 = icmp ult i64 %value_phi11, %.pre
  br i1 %16, label %idxend, label %L65
}

[chriselrod]

it's so weird, is this CPU dependent?

Yeah, your CPU does not have the scatter instructions that @jishnub's CPU is inappropriately using.
But the weird thing then, is that it was able to figure out on your CPU that it doesn't need to use these scatter instructions, and instead used ordinary stores.
Presumably then, it could've found this out on the tiger lake CPU, too.
And I didn't have this problem on the similar (but older) skylake-avx512 CPU (although I also started Julia with -C"native,-prefer-256-bit").

I have the same CPU jishnub has (tigerlake), so I'll try looking at it more later.

But this is a really stupid piece of code:

   %broadcast.splatinsert = insertelement <4 x double*> undef, double* %.pre41, i32 0
   %broadcast.splat = shufflevector <4 x double*> %broadcast.splatinsert, <4 x double*> undef, <4 x i32> zeroinitializer
   %29 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %9
   %30 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %10
   %31 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %11
   %32 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %12

[Moelf]

yeah I can reproduce the LLVM:

  %29 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %9
  %30 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %10
  %31 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %11
  %32 = getelementptr inbounds double, <4 x double*> %broadcast.splat, <4 x i64> %12
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %25, <4 x double*> %29, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %26, <4 x double*> %30, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %27, <4 x double*> %31, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %28, <4 x double*> %32, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  %index.next = add nuw i64 %index, 16
  %vec.ind.next = add <4 x i64> %vec.ind, <i64 16, i64 16, i64 16, i64 16>
  %33 = icmp eq i64 %index.next, %n.vec
  br i1 %33, label %middle.block, label %vector.body

on:

julia> versioninfo()
Julia Version 1.9.0-DEV.680
Commit 0057d75620 (2022-05-30 04:06 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: 8 × 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-13.0.1 (ORCJIT, tigerlake)
  Threads: 4 on 8 virtual cores
Environment:
  JULIA_NUM_THREADS = 4

[jishnub]

Interestingly, the following actually seems to work correctly on tigerlake without inbounds:

julia> unsafe_fill!(x) = @inbounds(for i in eachindex(x); x[i] = i; end)
unsafe_fill! (generic function with 1 method)

julia> function g!(x)
            for i in eachindex(x)
                x[i] = i
            end
            x
        end
g! (generic function with 1 method)

julia> x = Array{Float64}(undef, 2*dim);

julia> @btime g!($x);
  161.302 ns (0 allocations: 0 bytes)

julia> @btime unsafe_fill!($x);
  161.256 ns (0 allocations: 0 bytes)

although it produces similar suboptimal llvm instructions if an OffsetArray is passed to it

julia> y = OffsetArray{Float64}(undef, -dim + 1 : dim);

julia> @btime g!($y);
  1.595 μs (0 allocations: 0 bytes)

llvm code

julia> @code_llvm debuginfo=:none g!(y)
define void @"julia_g!_1038"({ {}*, [1 x i64] }* noalias nocapture sret({ {}*, [1 x i64] }) %0, [1 x {}*]* noalias nocapture %1, { {}*, [1 x i64] }* nocapture nonnull readonly align 8 dereferenceable(16) %2) #0 {
top:
  %3 = alloca [1 x i64], align 8
  %4 = bitcast { {}*, [1 x i64] }* %2 to { i8*, i64, i16, i16, i32 }**
  %5 = load atomic { i8*, i64, i16, i16, i32 }*, { i8*, i64, i16, i16, i32 }** %4 unordered, align 8
  %6 = getelementptr inbounds { i8*, i64, i16, i16, i32 }, { i8*, i64, i16, i16, i32 }* %5, i64 0, i32 1
  %7 = load i64, i64* %6, align 8
  %8 = getelementptr inbounds { {}*, [1 x i64] }, { {}*, [1 x i64] }* %2, i64 0, i32 1, i64 0
  %9 = load i64, i64* %8, align 8
  %10 = add i64 %9, 1
  %11 = add i64 %9, %7
  %.not = icmp sgt i64 %10, %11
  %value_phi = select i1 %.not, i64 %9, i64 %11
  %.not11 = icmp slt i64 %value_phi, %10
  %12 = bitcast { i8*, i64, i16, i16, i32 }* %5 to {}*
  br i1 %.not11, label %L83, label %L30.preheader

L30.preheader:                                    ; preds = %top
  %13 = bitcast { i8*, i64, i16, i16, i32 }* %5 to double**
  %14 = getelementptr inbounds [1 x i64], [1 x i64]* %3, i64 0, i64 0
  %15 = xor i64 %9, -1
  %16 = add i64 %value_phi, %15
  %umin = call i64 @llvm.umin.i64(i64 %7, i64 %16)
  %17 = add nuw nsw i64 %umin, 1
  %min.iters.check = icmp ult i64 %umin, 16
  br i1 %min.iters.check, label %L30, label %vector.ph

vector.ph:                                        ; preds = %L30.preheader
  %n.mod.vf = and i64 %17, 15
  %18 = icmp eq i64 %n.mod.vf, 0
  %19 = select i1 %18, i64 16, i64 %n.mod.vf
  %n.vec = sub nsw i64 %17, %19
  %ind.end = add i64 %10, %n.vec
  %.splatinsert = insertelement <4 x i64> poison, i64 %10, i32 0
  %.splat = shufflevector <4 x i64> %.splatinsert, <4 x i64> poison, <4 x i32> zeroinitializer
  %induction = add <4 x i64> %.splat, <i64 0, i64 1, i64 2, i64 3>
  %broadcast.splatinsert28 = insertelement <4 x i64> poison, i64 %15, i32 0
  %broadcast.splat29 = shufflevector <4 x i64> %broadcast.splatinsert28, <4 x i64> poison, <4 x i32> zeroinitializer
  %.pre45 = load double*, double** %13, align 8
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i64> [ %induction, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %step.add = add <4 x i64> %vec.ind, <i64 4, i64 4, i64 4, i64 4>
  %step.add19 = add <4 x i64> %vec.ind, <i64 8, i64 8, i64 8, i64 8>
  %step.add20 = add <4 x i64> %vec.ind, <i64 12, i64 12, i64 12, i64 12>
  %20 = shl <4 x i64> %vec.ind, <i64 1, i64 1, i64 1, i64 1>
  %21 = shl <4 x i64> %step.add, <i64 1, i64 1, i64 1, i64 1>
  %22 = shl <4 x i64> %step.add19, <i64 1, i64 1, i64 1, i64 1>
  %23 = shl <4 x i64> %step.add20, <i64 1, i64 1, i64 1, i64 1>
  %24 = or <4 x i64> %20, <i64 1, i64 1, i64 1, i64 1>
  %25 = or <4 x i64> %21, <i64 1, i64 1, i64 1, i64 1>
  %26 = or <4 x i64> %22, <i64 1, i64 1, i64 1, i64 1>
  %27 = or <4 x i64> %23, <i64 1, i64 1, i64 1, i64 1>
  %28 = sitofp <4 x i64> %24 to <4 x double>
  %29 = sitofp <4 x i64> %25 to <4 x double>
  %30 = sitofp <4 x i64> %26 to <4 x double>
  %31 = sitofp <4 x i64> %27 to <4 x double>
  %32 = add <4 x i64> %vec.ind, %broadcast.splat29
  %33 = add <4 x i64> %step.add, %broadcast.splat29
  %34 = add <4 x i64> %step.add19, %broadcast.splat29
  %35 = add <4 x i64> %step.add20, %broadcast.splat29
  %broadcast.splatinsert36 = insertelement <4 x double*> undef, double* %.pre45, i32 0
  %broadcast.splat37 = shufflevector <4 x double*> %broadcast.splatinsert36, <4 x double*> undef, <4 x i32> zeroinitializer
  %36 = getelementptr inbounds double, <4 x double*> %broadcast.splat37, <4 x i64> %32
  %37 = getelementptr inbounds double, <4 x double*> %broadcast.splat37, <4 x i64> %33
  %38 = getelementptr inbounds double, <4 x double*> %broadcast.splat37, <4 x i64> %34
  %39 = getelementptr inbounds double, <4 x double*> %broadcast.splat37, <4 x i64> %35
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %28, <4 x double*> %36, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %29, <4 x double*> %37, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %30, <4 x double*> %38, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  call void @llvm.masked.scatter.v4f64.v4p0f64(<4 x double> %31, <4 x double*> %39, i32 8, <4 x i1> <i1 true, i1 true, i1 true, i1 true>)
  %index.next = add nuw i64 %index, 16
  %vec.ind.next = add <4 x i64> %vec.ind, <i64 16, i64 16, i64 16, i64 16>
  %40 = icmp eq i64 %index.next, %n.vec
  br i1 %40, label %L30, label %vector.body

L30:                                              ; preds = %L52, %vector.body, %L30.preheader
  %value_phi4 = phi i64 [ %50, %L52 ], [ %10, %L30.preheader ], [ %ind.end, %vector.body ]
  %41 = sub i64 %value_phi4, %9
  %42 = icmp ugt i64 %41, %7
  br i1 %42, label %L49, label %L52

L49:                                              ; preds = %L30
  store i64 %value_phi4, i64* %14, align 8
  %43 = call nonnull {}* @j_throw_boundserror_1040({ {}*, [1 x i64] }* nocapture nonnull readonly %2, [1 x i64]* nocapture readonly %3) #0
  call void @llvm.trap()
  unreachable

L52:                                              ; preds = %L30
  %44 = shl i64 %value_phi4, 1
  %45 = or i64 %44, 1
  %46 = sitofp i64 %45 to double
  %47 = add i64 %value_phi4, %15
  %48 = load double*, double** %13, align 8
  %49 = getelementptr inbounds double, double* %48, i64 %47
  store double %46, double* %49, align 8
  %.not13 = icmp eq i64 %value_phi4, %value_phi
  %50 = add i64 %value_phi4, 1
  br i1 %.not13, label %L83.loopexit, label %L30

L83.loopexit:                                     ; preds = %L52
  store i64 %value_phi, i64* %14, align 8
  %.phi.trans.insert = getelementptr inbounds { {}*, [1 x i64] }, { {}*, [1 x i64] }* %2, i64 0, i32 0
  %.pre = load {}*, {}** %.phi.trans.insert, align 8
  br label %L83

L83:                                              ; preds = %L83.loopexit, %top
  %51 = phi {}* [ %.pre, %L83.loopexit ], [ %12, %top ]
  %52 = getelementptr inbounds [1 x {}*], [1 x {}*]* %1, i64 0, i64 0
  store {}* %51, {}** %52, align 8
  %53 = bitcast { {}*, [1 x i64] }* %0 to i8*
  %54 = bitcast { {}*, [1 x i64] }* %2 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(16) %53, i8* noundef nonnull align 8 dereferenceable(16) %54, i64 16, i1 false)
  ret void
}

[jishnub]

More interestingly, the functions in the original post work as expected if the allocation is done outside:

julia> function g(res)
           a = 1.1
           b = 2.2
           for i in eachindex(res)
               res[i] = a*i + b*i
           end
           res
       end
g (generic function with 1 method)

julia> function f(res)
           a = 1.1
           b = 2.2
           @inbounds for i in eachindex(res)
               res[i] = a*i + b*i
           end
           res
       end
f (generic function with 1 method)

julia> res = zeros(2000);

julia> @btime f($res);
  417.799 ns (0 allocations: 0 bytes)

julia> @btime g($res);
  417.774 ns (0 allocations: 0 bytes)

[jishnub]

Also, using v1,7.3 on the same machine, I don't see the masked scatter instructions, although performance is inferior to 1.8 for reasons that I've not looked into.

llvm code on v1.7.3

julia> @code_llvm debuginfo=:none g(8)
define nonnull {}* @julia_g_446(i64 signext %0) #0 {
top:
  %1 = call nonnull {}* inttoptr (i64 140411211578993 to {}* ({}*, i64)*)({}* inttoptr (i64 140410883754640 to {}*), i64 %0)
  %2 = bitcast {}* %1 to {}**
  %3 = getelementptr inbounds {}*, {}** %2, i64 3
  %4 = bitcast {}** %3 to i64*
  %5 = load i64, i64* %4, align 8
  %.not.not = icmp eq i64 %5, 0
  br i1 %.not.not, label %L67, label %L15.preheader

L15.preheader:                                    ; preds = %top
  %6 = bitcast {}* %1 to double**
  %7 = load double*, double** %6, align 8
  %min.iters.check = icmp ult i64 %5, 16
  br i1 %min.iters.check, label %L15, label %vector.ph

vector.ph:                                        ; preds = %L15.preheader
  %n.vec = and i64 %5, 9223372036854775792
  %ind.end = or i64 %n.vec, 1
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %8 = getelementptr inbounds double, double* %7, i64 %index
  %9 = bitcast double* %8 to <4 x double>*
  store <4 x double> zeroinitializer, <4 x double>* %9, align 8
  %10 = getelementptr inbounds double, double* %8, i64 4
  %11 = bitcast double* %10 to <4 x double>*
  store <4 x double> zeroinitializer, <4 x double>* %11, align 8
  %12 = getelementptr inbounds double, double* %8, i64 8
  %13 = bitcast double* %12 to <4 x double>*
  store <4 x double> zeroinitializer, <4 x double>* %13, align 8
  %14 = getelementptr inbounds double, double* %8, i64 12
  %15 = bitcast double* %14 to <4 x double>*
  store <4 x double> zeroinitializer, <4 x double>* %15, align 8
  %index.next = add i64 %index, 16
  %16 = icmp eq i64 %index.next, %n.vec
  br i1 %16, label %middle.block, label %vector.body

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %5, %n.vec
  br i1 %cmp.n, label %L47.preheader, label %L15

L15:                                              ; preds = %L15, %middle.block, %L15.preheader
  %value_phi3 = phi i64 [ %19, %L15 ], [ %ind.end, %middle.block ], [ 1, %L15.preheader ]
  %17 = add nsw i64 %value_phi3, -1
  %18 = getelementptr inbounds double, double* %7, i64 %17
  store double 0.000000e+00, double* %18, align 8
  %.not = icmp eq i64 %value_phi3, %5
  %19 = add nuw nsw i64 %value_phi3, 1
  br i1 %.not, label %L47.preheader, label %L15

L47.preheader:                                    ; preds = %L15, %middle.block
  %20 = bitcast {}* %1 to { i8*, i64, i16, i16, i32 }*
  %21 = getelementptr inbounds { i8*, i64, i16, i16, i32 }, { i8*, i64, i16, i16, i32 }* %20, i64 0, i32 1
  %22 = load i64, i64* %21, align 8
  %23 = add nuw nsw i64 %22, 1
  br label %L47

L47:                                              ; preds = %idxend, %L47.preheader
  %value_phi11 = phi i64 [ %31, %idxend ], [ 1, %L47.preheader ]
  %exitcond.not = icmp eq i64 %value_phi11, %23
  br i1 %exitcond.not, label %oob, label %idxend

L67:                                              ; preds = %idxend, %top
  ret {}* %1

oob:                                              ; preds = %L47
  %24 = alloca i64, align 8
  store i64 %23, i64* %24, align 8
  call void @jl_bounds_error_ints({}* %1, i64* nonnull %24, i64 1)
  unreachable

idxend:                                           ; preds = %L47
  %25 = add nsw i64 %value_phi11, -1
  %26 = sitofp i64 %value_phi11 to double
  %27 = fmul double %26, 1.100000e+00
  %28 = fmul double %26, 2.200000e+00
  %29 = fadd double %27, %28
  %30 = getelementptr inbounds double, double* %7, i64 %25
  store double %29, double* %30, align 8
  %.not20 = icmp eq i64 %value_phi11, %5
  %31 = add nuw nsw i64 %value_phi11, 1
  br i1 %.not20, label %L67, label %L47
}

julia> VERSION
v"1.7.3"

[Moelf]

seems to be fixed in 1.9