Improve generic version of complex masked store

[serge-sans-paille]

Use the usual kernel mechanism which allows for specialization. Leverage existing masked store mechanism instead of implementing a new one.

Follow-up to #1391

[serge-sans-paille]

@DiamonDinoia this is the generic implementation I mentioned in #1391

[serge-sans-paille]

@DiamonDinoia : (edit: not) ready for review!

[DiamonDinoia]

I did not implement it like this in one go because it is not that trivial as you can see :)

[serge-sans-paille]

@DiamonDinoia should be good for review now

[DiamonDinoia]

These changes have better codegen on my machine for the generic and sse case.

--- a/include/xsimd/arch/common/xsimd_common_memory.hpp
+++ b/include/xsimd/arch/common/xsimd_common_memory.hpp
@@ -457,20 +457,10 @@ namespace xsimd
             // Scalar fallback: only active lanes are touched. Arches with
             // hardware predicated loads should override this.
             constexpr std::size_t size = batch<T, A>::size;
-            alignas(A::alignment()) std::array<T, size> buffer_real;
-            alignas(A::alignment()) std::array<T, size> buffer_imag;
+            alignas(A::alignment()) std::array<std::complex<T>, size> buffer;
             for (std::size_t i = 0; i < size; ++i)
-                if (mask.get(i))
-                {
-                    buffer_real[i] = mem[i].real();
-                    buffer_imag[i] = mem[i].imag();
-                }
-                else
-                {
-                    buffer_real[i] = T(0);
-                    buffer_imag[i] = T(0);
-                }
-            return batch<std::complex<T>, A>::load_aligned(buffer_real.data(), buffer_imag.data());
+                buffer[i] = mask.get(i) ? mem[i] : std::complex<T>(0);
+            return batch<std::complex<T>, A>::load_aligned(buffer.data());
         }
 
         template <class A, class T_in, class T_out, bool... Values, class alignment>
@@ -829,6 +819,40 @@ namespace xsimd
             {
                 static_assert(std::is_same_v<T, void>, "complex_low not implemented for the required architecture");
             }
+
+            // Split a complex mask into the two real masks covering the first and
+            // the second half of memory, by duplicating each lane. A bitmask arch
+            // spreads the lane bits instead;
+            template <class A, class T>
+            XSIMD_INLINE std::array<batch_bool<T, A>, 2> zip_complex_mask_vector(batch_bool<T, A> mask) noexcept
+            {
+                batch<T, A> nmask(mask.to_native());
+                return { batch_bool<T, A>(zip_lo(nmask, nmask).to_native()),
+                         batch_bool<T, A>(zip_hi(nmask, nmask).to_native()) };
+            }
+
+            // A complex batch occupies two real registers, so one masked complex
+            // access is two masked real accesses over the two halves of memory.
+            template <class A, class T, class Mode>
+            XSIMD_INLINE batch<std::complex<T>, A>
+            load_complex_masked_halves(std::complex<T> const* mem, std::array<batch_bool<T, A>, 2> masks, Mode mode) noexcept
+            {
+                batch<T, A> res_lo = batch<T, A>::load(reinterpret_cast<T const*>(mem), masks[0], mode);
+                batch<T, A> res_hi = batch<T, A>::load(reinterpret_cast<T const*>(mem) + batch<T, A>::size, masks[1], mode);
+                return load_complex(res_lo, res_hi, A {});
+            }
+
+            template <class A, class T, class Mode>
+            XSIMD_INLINE void
+            store_complex_masked_halves(std::complex<T>* mem, batch<std::complex<T>, A> const& src, std::array<batch_bool<T, A>, 2> masks, Mode mode) noexcept
+            {
+                batch<T, A> src_lo = complex_low(src, A {});
+                batch<T, A> src_hi = complex_high(src, A {});
+                // Qualified: kernel::detail has its own store_masked overloads, which
+                // would hide the arch dispatchers in kernel.

[DiamonDinoia]

this needs XSIMD_INLINE sometimes does not get inlined