Treat view slices as single points and vectorize unmasked point loops

Two launch-machinery fixes, verified locally with the device-free
compilation checker, DataLayouts and Fields unit tests (single- and
multi-threaded, bounds checks on), and interleaved benchmarks:

- num_slice_points(view, arg) = 1: a view slice contains one point by
  definition, so no slice needs to be constructed at launch time. The
  generic method throws for FusedMultiBroadcast launches (point-sliced
  fused broadcasts mix 0-dimensional DataF dest slices with
  dimension-preserving Broadcasted slices, so their inferred_size values
  never agree), and it turned the slice size from a compile-time
  constant into runtime slice construction executed several times per
  GPU launch on the host and once per thread inside every kernel
  (slice_subscope: 16.7-33.3 ns and 18 typed statements down to a
  constant-folded 4.1 ns and 3 statements).
- Point loops with no mask now use @simd and inline f at the call site.
  LLVM cannot vectorize across the carry branches of a flattened
  CartesianIndices iteration, and the inliner gives up on point closures
  over large broadcast expressions, materializing every argument slice
  into a function call at each point; either alone leaves pointwise
  loops scalar (0 vector instructions vs 512 for the equivalent plain
  array broadcast). GPU subscopes iterate Generators, which do not
  support @simd and keep a plain loop with the inlined call. Pointwise
  broadcasts drop from 0.298 to 0.158 ns/point and fill! from 0.303 to
  0.138 ns/point; baroclinic-wave step! recovers from 1.37x of main to
  1.05x, and 100 bubble_2d steps from 1.73x to ~1.2x.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: dennisYatunin

src/DataLayouts/loops.jl

@@ -18,6 +18,11 @@ end
 @generated invalid_mask_string(::M, ::O) where {M, O} =
     "$M cannot be applied to $(O.instance) slices"
 
+# A view slice contains one point by definition, so its size is known without
+# constructing a slice. The generic method cannot handle point slices of fused
+# broadcasts, whose 0-dimensional DataF args and dimension-preserving
+# Broadcasted args have inconsistent values of inferred_size.
+@inline num_slice_points(::typeof(view), arg) = 1
 @inline function num_slice_points(op::O, arg) where {O}
     first_slice = op(arg, Tuple(first(each_slice_index(op, arg)))...)
     has_inferred_size(first_slice) && return prod(inferred_size(first_slice))
@@ -64,24 +69,55 @@ also be used to skip over a particular subset of slices.
     isone(num_threads(scope)) ? foreach_slice(ThisThread(), op, f, args...; mask) :
     parallelize_over(scope) do
         subscope = slice_subscope(scope, op, args...)
-        for index in subscope_slice_indices(subscope, scope, mask, op, args...)
-            slices = unrolled_map(args) do arg
-                Base.@_inline_meta # Slices must be constructed without closures.
-                @inbounds reassign(op(arg, Tuple(index)...), subscope)
-            end
-            f(slices...)
-        end
+        indices = subscope_slice_indices(subscope, scope, mask, op, args...)
+        slice_loop(indices, subscope, op, f, mask, args...)
     end
 
 # Reassign each slice to ThisThread so nested loops in f dispatch here statically: the
 # runtime thread-count check, though cheap, blocks removal of the parallelized closures.
 @inline foreach_slice(::ThisThread, op::O, f::F, args...; mask) where {O, F} =
-    for index in subscope_slice_indices(ThisThread(), ThisThread(), mask, op, args...)
-        slices = unrolled_map(args) do arg
-            Base.@_inline_meta # Slices must be constructed without closures.
-            @inbounds reassign(op(arg, Tuple(index)...), ThisThread())
+    slice_loop(
+        subscope_slice_indices(ThisThread(), ThisThread(), mask, op, args...),
+        ThisThread(),
+        op,
+        f,
+        mask,
+        args...,
+    )
+
+# Unmasked point loops need @simd and an inlined call to f in order to vectorize: LLVM
+# cannot vectorize across the carry branches of a flattened CartesianIndices iteration
+# unless @simd splits it into an outer loop and a unit-stride inner loop, and Julia's
+# inliner gives up on point closures over large broadcast expressions, which forces
+# every argument slice to be materialized and passed to a function call at each point.
+# Without these, pointwise loops are several times slower than plain array broadcasts.
+# Masked index iterators do not support @simd, and slice operators do too much work per
+# slice for vectorization to apply to them.
+@inline function slice_loop(indices, subscope, op::O, f::F, mask, args...) where {O, F}
+    if op === view && mask isa NoMask
+        point_loop(indices, subscope, op, f, args...)
+    else
+        for index in indices
+            f(slices_at(op, subscope, index, args...)...)
         end
-        f(slices...)
+    end
+end
+
+# @simd only supports indexable iterators; GPU subscopes iterate Generators over strided
+# ranges, so their point loops just inline f (each GPU thread gets at most a few points,
+# and there is nothing for LLVM to vectorize across them).
+@inline point_loop(indices::AbstractArray, subscope, op::O, f::F, args...) where {O, F} =
+    @simd for index in indices
+        @inline f(slices_at(op, subscope, index, args...)...)
+    end
+@inline point_loop(indices, subscope, op::O, f::F, args...) where {O, F} =
+    for index in indices
+        @inline f(slices_at(op, subscope, index, args...)...)
+    end
+@inline slices_at(op::O, subscope, index, args...) where {O} =
+    unrolled_map(args) do arg
+        Base.@_inline_meta # Slices must be constructed without closures.
+        @inbounds reassign(op(arg, Tuple(index)...), subscope)
     end
 
 """