Expand crossover tests and fix CUDA effective bounds merge.

Add unit tests for implied-bound branches, backend agreement, pipeline
consistency, and optional CUDA coverage. Replace in-kernel atomic bound
updates with row scan plus host merge so CuSparseMatrixCSR matches CSC/JL
results on equality rows.

Author: Charles Vielzeuf

src/components/crossover.jl

@@ -152,19 +152,56 @@ function _crossover_effective_bounds!(
     return lv_eff, uv_eff
 end
 
-@kernel function crossover_effective_bounds_csr!(
-        lv_eff::DenseVector{T},
-        uv_eff::DenseVector{T},
+function _crossover_merge_row_bounds!(
+        lv_eff,
+        uv_eff,
+        row_active,
+        row_upper,
+        row_j,
+        row_implied,
+    )
+    lv_cpu = Vector(lv_eff)
+    uv_cpu = Vector(uv_eff)
+    @inbounds for i in eachindex(row_active)
+        row_active[i] || continue
+        j = row_j[i]
+        implied = row_implied[i]
+        if row_upper[i]
+            if !isfinite(uv_cpu[j])
+                uv_cpu[j] = implied
+            else
+                uv_cpu[j] = min(uv_cpu[j], implied)
+            end
+        else
+            if !isfinite(lv_cpu[j])
+                lv_cpu[j] = implied
+            else
+                lv_cpu[j] = max(lv_cpu[j], implied)
+            end
+        end
+    end
+    backend = get_backend(lv_eff)
+    copyto!(lv_eff, adapt(backend, lv_cpu))
+    copyto!(uv_eff, adapt(backend, uv_cpu))
+    return lv_eff, uv_eff
+end
+
+@kernel function crossover_effective_bounds_csr_scan!(
+        row_active::DenseVector{UInt8},
+        row_upper::DenseVector{UInt8},
+        row_j::DenseVector{Ti},
+        row_implied::DenseVector{T},
         A_rowptr::DenseVector{Ti},
         A_colval::DenseVector{Ti},
         A_nzval::DenseVector{T},
         lc::DenseVector{T},
         uc::DenseVector{T},
         x::DenseVector{T},
-        at_box::DenseVector{Bool},
+        at_box::DenseVector{UInt8},
         eq_atol::T,
     ) where {T, Ti}
     i = @index(Global, Linear)
+    row_active[i] = zero(UInt8)
     if abs(lc[i] - uc[i]) <= eq_atol
         slack = lc[i]
         free_j = zero(Ti)
@@ -173,7 +210,7 @@ end
         for k in A_rowptr[i]:(A_rowptr[i + Ti(1)] - Ti(1))
             j = A_colval[k]
             aij = A_nzval[k]
-            if at_box[j]
+            if at_box[j] != zero(UInt8)
                 slack -= aij * x[j]
             else
                 n_free += Ti(1)
@@ -184,24 +221,12 @@ end
             end
         end
         if n_free == Ti(1)
-            j = free_j
             aij = free_aij
-            if aij > zero(T)
-                implied = slack / aij
-                old = Atomix.@atomic uv_eff[j]
-                while implied < old
-                    (old2, success) = Atomix.@atomicreplace uv_eff[j] old => implied
-                    success && break
-                    old = old2
-                end
-            elseif aij < zero(T)
-                implied = slack / aij
-                old = Atomix.@atomic lv_eff[j]
-                while implied > old
-                    (old2, success) = Atomix.@atomicreplace lv_eff[j] old => implied
-                    success && break
-                    old = old2
-                end
+            if aij != zero(T)
+                row_active[i] = one(UInt8)
+                row_j[i] = free_j
+                row_implied[i] = slack / aij
+                row_upper[i] = aij > zero(T) ? one(UInt8) : zero(UInt8)
             end
         end
     end
@@ -217,37 +242,57 @@ function _crossover_effective_bounds!(
         at_box;
         eq_atol::Real = 1.0e-12,
     )
-    backend = common_backend(lv_eff, uv_eff, A, lc, uc, x, at_box)
-    eq_tol = eltype(x)(eq_atol)
-    kernel! = crossover_effective_bounds_csr!(backend)
+    T = eltype(x)
+    Ti = eltype(A.rowptr)
+    m = size(A, 1)
+    backend = common_backend(A, lc, uc, x, at_box)
+    eq_tol = T(eq_atol)
+    at_box_u8 = adapt(backend, UInt8.(at_box))
+    row_active = allocate(backend, UInt8, m)
+    row_upper = allocate(backend, UInt8, m)
+    row_j = allocate(backend, Ti, m)
+    row_implied = allocate(backend, T, m)
+    kernel! = crossover_effective_bounds_csr_scan!(backend)
     kernel!(
-        lv_eff,
-        uv_eff,
+        row_active,
+        row_upper,
+        row_j,
+        row_implied,
         A.rowptr,
         A.colval,
         A.nzval,
         lc,
         uc,
         x,
-        at_box,
+        at_box_u8,
         eq_tol;
-        ndrange = size(A, 1),
+        ndrange = m,
+    )
+    return _crossover_merge_row_bounds!(
+        lv_eff,
+        uv_eff,
+        Vector(row_active) .!= 0,
+        Vector(row_upper) .!= 0,
+        Vector(row_j),
+        Vector(row_implied),
     )
-    return lv_eff, uv_eff
 end
 
-@kernel function crossover_effective_bounds_ell!(
-        lv_eff::DenseVector{T},
-        uv_eff::DenseVector{T},
+@kernel function crossover_effective_bounds_ell_scan!(
+        row_active::DenseVector{UInt8},
+        row_upper::DenseVector{UInt8},
+        row_j::DenseVector{Ti},
+        row_implied::DenseVector{T},
         A_colval::AbstractMatrix{Ti},
         A_nzval::AbstractMatrix{T},
         lc::DenseVector{T},
         uc::DenseVector{T},
         x::DenseVector{T},
-        at_box::DenseVector{Bool},
+        at_box::DenseVector{UInt8},
         eq_atol::T,
     ) where {T, Ti}
     i = @index(Global, Linear)
+    row_active[i] = zero(UInt8)
     if abs(lc[i] - uc[i]) <= eq_atol
         slack = lc[i]
         free_j = zero(Ti)
@@ -257,7 +302,7 @@ end
             j = A_colval[i, k]
             if j != zero(Ti)
                 aij = A_nzval[i, k]
-                if at_box[j]
+                if at_box[j] != zero(UInt8)
                     slack -= aij * x[j]
                 else
                     n_free += Ti(1)
@@ -269,24 +314,12 @@ end
             end
         end
         if n_free == Ti(1)
-            j = free_j
             aij = free_aij
-            if aij > zero(T)
-                implied = slack / aij
-                old = Atomix.@atomic uv_eff[j]
-                while implied < old
-                    (old2, success) = Atomix.@atomicreplace uv_eff[j] old => implied
-                    success && break
-                    old = old2
-                end
-            elseif aij < zero(T)
-                implied = slack / aij
-                old = Atomix.@atomic lv_eff[j]
-                while implied > old
-                    (old2, success) = Atomix.@atomicreplace lv_eff[j] old => implied
-                    success && break
-                    old = old2
-                end
+            if aij != zero(T)
+                row_active[i] = one(UInt8)
+                row_j[i] = free_j
+                row_implied[i] = slack / aij
+                row_upper[i] = aij > zero(T) ? one(UInt8) : zero(UInt8)
             end
         end
     end
@@ -302,22 +335,39 @@ function _crossover_effective_bounds!(
         at_box;
         eq_atol::Real = 1.0e-12,
     )
-    backend = common_backend(lv_eff, uv_eff, A, lc, uc, x, at_box)
-    eq_tol = eltype(x)(eq_atol)
-    kernel! = crossover_effective_bounds_ell!(backend)
+    T = eltype(x)
+    Ti = eltype(A.colval)
+    m = size(A, 1)
+    backend = common_backend(A, lc, uc, x, at_box)
+    eq_tol = T(eq_atol)
+    at_box_u8 = adapt(backend, UInt8.(at_box))
+    row_active = allocate(backend, UInt8, m)
+    row_upper = allocate(backend, UInt8, m)
+    row_j = allocate(backend, Ti, m)
+    row_implied = allocate(backend, T, m)
+    kernel! = crossover_effective_bounds_ell_scan!(backend)
     kernel!(
-        lv_eff,
-        uv_eff,
+        row_active,
+        row_upper,
+        row_j,
+        row_implied,
         A.colval,
         A.nzval,
         lc,
         uc,
         x,
-        at_box,
+        at_box_u8,
         eq_tol;
-        ndrange = size(A, 1),
+        ndrange = m,
+    )
+    return _crossover_merge_row_bounds!(
+        lv_eff,
+        uv_eff,
+        Vector(row_active) .!= 0,
+        Vector(row_upper) .!= 0,
+        Vector(row_j),
+        Vector(row_implied),
     )
-    return lv_eff, uv_eff
 end
 
 function _crossover_effective_bounds!(