Fix LTS-stack silent corruption in reductions and workgroup barriers

Two distinct correctness bugs surfaced as intermittent KernelAbstractions
example failures (naive_transpose, histogram) on the Aurora LTS NEO/IGC stack:

- mapreducedim! over a strided/transposed input (e.g. `a == transpose(b)`,
  `sum(transpose(x))`, `isequal`, `ishermitian`) hit the LTS IGC miscompile of
  non-coalesced global loads, silently corrupting the result. Detect
  non-contiguous inputs and materialize them to a dense array before reducing,
  so every global read is coalesced. (src/mapreduce.jl)

- KA `@synchronize` lowered to `barrier(0)`, emitting OpControlBarrier with
  SequentiallyConsistent but WITHOUT the WorkgroupMemory storage-class bit,
  which orders no memory per the SPIR-V spec. On the LTS stack shared-local
  writes were not made visible across the barrier, dropping updates (the
  histogram example's local-atomic accumulation lost counts). Fence local+global
  memory in `__synchronize`, and local memory in the mapreduce reduce_group SLM
  tree. (src/oneAPIKernels.jl, src/mapreduce.jl)

Validated on the LTS stack: kernelabstractions 2218 pass / 0 fail; gpuarrays
reductions+statistics 2962/2962; histogram 0 failures over 1100 iters; strided
==/sum/isequal/ishermitian correct.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: michel2323

src/mapreduce.jl

@@ -33,7 +33,12 @@
     # perform a reduction
     d = 1
     while d < items
-        barrier(0)
+        # LOCAL_MEM_FENCE: `barrier(0)` lowers to an OpControlBarrier without the
+        # WorkgroupMemory storage-class bit, which on the NEO/IGC LTS stack does not order the
+        # shared-local tree accesses across the barrier (proven by the histogram example's lost
+        # local-atomic updates). Fence local memory so each tree step sees the previous step's
+        # `shared[]` writes. See ISSUE_mapreduce_corruption.md.
+        barrier(SPIRVIntrinsics.LOCAL_MEM_FENCE)
         index = 2 * d * (item-1) + 1
         @inbounds if index <= items
             other_val = if index + d <= items
@@ -133,12 +138,32 @@ end
 
 ## COV_EXCL_STOP
 
+# Aurora LTS workaround: the NEO/IGC LTS stack miscompiles *strided* (non-coalesced) global
+# reads inside the reduction kernel, silently corrupting results whenever an input is read
+# along a non-contiguous axis (e.g. `a == transpose(b)`, `sum(transpose(x))`, `ishermitian`).
+# Elementwise copies are NOT affected. `_dense_reduce_input` returns false for any input that
+# reads non-contiguous memory (a transposed/permuted/strided view, or a broadcast containing
+# one), so such inputs get materialized to a dense `oneArray` before reducing. See
+# ISSUE_mapreduce_corruption.md and the `naive_transpose` (`a == transpose(b)`) failure.
+@inline _dense_reduce_input(::oneArray) = true
+@inline _dense_reduce_input(x::Base.ReshapedArray) = _dense_reduce_input(parent(x))
+@inline _dense_reduce_input(::AbstractArray) = false   # Transpose/Adjoint/PermutedDims/SubArray/…
+@inline _dense_reduce_input(::Any) = true              # scalars/Refs/tuples carried in a broadcast
+@inline _dense_reduce_input(bc::Broadcast.Broadcasted) = all(_dense_reduce_input, bc.args)
+
 function GPUArrays.mapreducedim!(f::F, op::OP, R::oneWrappedArray{T},
                                  A::Union{AbstractArray,Broadcast.Broadcasted};
                                  init=nothing) where {F, OP, T}
     Base.check_reducedims(R, A)
     length(A) == 0 && return R # isempty(::Broadcasted) iterates
 
+    # Aurora LTS workaround (see `_dense_reduce_input` above): materialize strided inputs to a
+    # dense array first so every global read in the reduction kernel is coalesced.
+    if !_dense_reduce_input(A)
+        Acontig = Broadcast.materialize(Broadcast.broadcasted(f, A))
+        return GPUArrays.mapreducedim!(identity, op, R, Acontig; init=init)
+    end
+
     # add singleton dimensions to the output container, if needed
     if ndims(R) < ndims(A)
         dims = Base.fill_to_length(size(R), 1, Val(ndims(A)))

src/oneAPIKernels.jl

@@ -214,7 +214,15 @@ end
 ## Synchronization and Printing
 
 @device_override @inline function KA.__synchronize()
-    barrier(0)
+    # Fence both local and global memory across the workgroup barrier, matching CUDA
+    # `__syncthreads` semantics. `barrier(0)` lowers to `OpControlBarrier` with
+    # `SequentiallyConsistent` but WITHOUT the `WorkgroupMemory` storage-class bit, which the
+    # SPIR-V spec treats as ordering *no* memory — so on the NEO/IGC LTS stack shared-local
+    # writes (e.g. the histogram example's local-atomic accumulation) are not made visible
+    # before the next phase reads them, silently dropping updates. Passing
+    # `LOCAL_MEM_FENCE | GLOBAL_MEM_FENCE` ORs in the WorkgroupMemory/CrossWorkgroupMemory
+    # fence bits. See ISSUE_mapreduce_corruption.md (the barrier WorkgroupMemory-bit regression).
+    barrier(SPIRVIntrinsics.LOCAL_MEM_FENCE | SPIRVIntrinsics.GLOBAL_MEM_FENCE)
 end
 
 @device_override @inline function KA.__print(args...)