Move select to amrex::simd::stdx

Will be there eventually with C++26

Author: ax3l

Src/Base/AMReX_SIMD.H

@@ -28,6 +28,44 @@ namespace amrex::simd
 #   if __cplusplus >= 202002L
         using vir::cvt;
 #   endif
+
+        /** Vectorized ternary operator: select(mask, true_val, false_val)
+         *
+         * Selects elements from true_val where mask is true and from false_val
+         * where mask is false. Analogous to (mask ? true_val : false_val) for
+         * scalars.
+         *
+         * Note: both true_val and false_val are eagerly evaluated (function
+         * arguments). To guard against operations like division by zero,
+         * sanitize inputs before the operation rather than relying on
+         * conditional selection.
+         *
+         * Example:
+         * ```cpp
+         * template <typename T>
+         * T compute (T const& a, T const& b)
+         * {
+         *     auto safe_b = amrex::simd::stdx::select(b != T(0), b, T(1));
+         *     return amrex::simd::stdx::select(b != T(0), a / safe_b, T(0));
+         * }
+         * ```
+         *
+         * @see C++26 std::simd select
+         *
+         * @todo Remove when SIMD provider (vir-simd / C++26) provides select.
+         *       https://github.com/mattkretz/vir-simd/issues/49
+         */
+        template <typename T, typename Abi>
+        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
+        simd<T, Abi> select (
+            typename simd<T, Abi>::mask_type const& mask,
+            simd<T, Abi> const& true_val,
+            simd<T, Abi> const& false_val)
+        {
+            simd<T, Abi> result = false_val;
+            where(mask, result) = true_val;
+            return result;
+        }
 #else
         // fallback implementations for functions that are commonly used in portable code paths
 
@@ -82,6 +120,18 @@ namespace amrex::simd
         {
             return {mask, value};
         }
+
+        /** Vectorized ternary operator (scalar fallback for simd select)
+         *
+         * @see select in the AMREX_USE_SIMD path above
+         * @see C++26 std::simd select
+         */
+        template <typename T>
+        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
+        T select (bool const mask, T const& true_val, T const& false_val)
+        {
+            return mask ? true_val : false_val;
+        }
 #endif
     }
 
@@ -214,48 +264,6 @@ namespace amrex::simd
         return val_arr[n];
     }
 
-    /** Vectorized ternary operator: select(mask, true_val, false_val)
-     *
-     * Selects elements from true_val where mask is true and from false_val where
-     * mask is false. Analogous to (mask ? true_val : false_val) for scalars.
-     *
-     * Note: both true_val and false_val are eagerly evaluated (function arguments).
-     * To guard against operations like division by zero, sanitize inputs before
-     * the operation rather than relying on conditional selection.
-     *
-     * Example:
-     * ```cpp
-     * template <typename T>
-     * T compute (T const& a, T const& b)
-     * {
-     *     auto safe_b = amrex::simd::select(b != T(0), b, T(1));
-     *     return amrex::simd::select(b != T(0), a / safe_b, T(0));
-     * }
-     * ```
-     *
-     * @see C++26 std::datapar::select
-     */
-#ifdef AMREX_USE_SIMD
-    template <typename T, typename Abi>
-    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
-    stdx::simd<T, Abi> select (
-        typename stdx::simd<T, Abi>::mask_type const& mask,
-        stdx::simd<T, Abi> const& true_val,
-        stdx::simd<T, Abi> const& false_val)
-    {
-        stdx::simd<T, Abi> result = false_val;
-        stdx::where(mask, result) = true_val;
-        return result;
-    }
-#else
-    template <typename T>
-    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
-    T select (bool const mask, T const& true_val, T const& false_val)
-    {
-        return mask ? true_val : false_val;
-    }
-#endif
-
     /** Load 1D contiguous data from array pointers
      *
      * On GPU and CPU w/o SIMD, this dereferences a 1D array element at the

Tests/SIMD/main.cpp

@@ -426,7 +426,7 @@ int main (int argc, char* argv[])
         }
 
         // ================================================================
-        // Test 14: any_of, where, condition — portable single-source
+        // Test 14: any_of, where, select — portable single-source
         //   Uses SIMDReal<>, which is a SIMD vector when AMREX_USE_SIMD=ON
         //   and a plain scalar when OFF.  The same code path exercises
         //   both the real SIMD and the scalar fallback implementations.
@@ -437,8 +437,8 @@ int main (int argc, char* argv[])
             // safe reciprocal: 1/b where b != 0, else 0
             Real_t b(ParticleReal(2));
             auto mask = b != Real_t(ParticleReal(0));
-            auto safe_b = simd::select(mask, b, Real_t(ParticleReal(1)));
-            auto recip  = simd::select(mask,
+            auto safe_b = simd::stdx::select(mask, b, Real_t(ParticleReal(1)));
+            auto recip  = simd::stdx::select(mask,
                               Real_t(ParticleReal(1)) / safe_b,
                               Real_t(ParticleReal(0)));