Improve xsimd::expand common implementation

Previous implementation was making the assumption of cheap
xsimd::insert, and it always generated batch::size inserts.

This implementation can take advantage of smaller popcount on the
bitmask.

Note to self: it would be great to have a good implementation for
constant mask.

Author: serge-sans-paille

.github/workflows/cross-arm.yml

@@ -6,12 +6,12 @@ concurrency:
 jobs:
   build:
     runs-on: ubuntu-latest
-    name: '${{ matrix.target.arch }}, ${{ matrix.sys.compiler }} ${{ matrix.sys.version }}'
+    name: '${{ matrix.target.arch }}, ${{ matrix.target.flags }}, ${{ matrix.sys.compiler }} ${{ matrix.sys.version }}'
     strategy:
       matrix:
         target:
           - { platform: 'arm',     arch: 'armv7-a', dir: 'arm-linux-gnueabihf', flags: '-mfpu=neon', full: 'ON'}
-          - { platform: 'arm',     arch: 'armv7-a', dir: 'arm-linux-gnueabihf', flags: '-mfpu=vfpv3-d16', full: 'OFF' } # no neon
+           - { platform: 'arm',     arch: 'armv7-a', dir: 'arm-linux-gnueabihf', flags: '-mfpu=vfpv3-d16', full: 'OFF' } # no neon
           - { platform: 'aarch64', arch: 'armv8-a', dir: 'aarch64-linux-gnu', flags: '', full: 'ON' }
         sys:
           - { compiler: 'gcc',   version: '10' }

include/xsimd/arch/common/xsimd_common_memory.hpp

@@ -88,28 +88,19 @@ namespace xsimd
         }
 
         // expand
-        namespace detail
-        {
-            template <class IT, class A, class I, size_t... Is>
-            XSIMD_INLINE batch<IT, A> create_expand_swizzle_mask(I bitmask, ::xsimd::detail::index_sequence<Is...>)
-            {
-                batch<IT, A> swizzle_mask(IT(0));
-                IT j = 0;
-                (void)std::initializer_list<bool> { ((swizzle_mask = insert(swizzle_mask, j, index<Is>())), (j += ((bitmask >> Is) & 1u)), true)... };
-                return swizzle_mask;
-            }
-        }
-
         template <typename A, typename T>
         XSIMD_INLINE batch<T, A>
         expand(batch<T, A> const& x, batch_bool<T, A> const& mask,
                kernel::requires_arch<common>) noexcept
         {
-            constexpr std::size_t size = batch_bool<T, A>::size;
-            auto bitmask = mask.mask();
-            auto swizzle_mask = detail::create_expand_swizzle_mask<as_unsigned_integer_t<T>, A>(bitmask, ::xsimd::detail::make_index_sequence<size>());
-            auto z = swizzle(x, swizzle_mask);
-            return select(mask, z, batch<T, A>(T(0)));
+            alignas(A::alignment()) T x_in[x.size], x_out[x.size] = {T()};
+            x.store_aligned(x_in);
+            int i = 0, j = 0;
+            for(auto bitmask = m.mask(); mask; mask >>= 1) {
+              if(mask & 1)
+                 x_out[i] = x_int[j++];
+            }
+            return xsimd::batch<T, A>::load_aligned(x_out);
         }
 
         // extract_pair