WIP

Author: serge-sans-paille

include/xsimd/arch/common/xsimd_common_memory.hpp

@@ -391,28 +391,6 @@ namespace xsimd
         }
 
         // Scatter with runtime indexes.
-        namespace detail
-        {
-            template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N == 0, int>::type = 0>
-            XSIMD_INLINE void scatter(batch<T, A> const& src, U* dst,
-                                      batch<V, A> const& index,
-                                      ::xsimd::index<N> I) noexcept
-            {
-                dst[index.get(I)] = static_cast<U>(src.get(I));
-            }
-
-            template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N != 0, int>::type = 0>
-            XSIMD_INLINE void
-            scatter(batch<T, A> const& src, U* dst, batch<V, A> const& index,
-                    ::xsimd::index<N> I) noexcept
-            {
-                static_assert(N <= batch<V, A>::size, "Incorrect value in recursion!");
-
-                kernel::detail::scatter<N - 1, T, A, U, V>(
-                    src, dst, index, {});
-                dst[index.get(I)] = static_cast<U>(src.get(I));
-            }
-        } // namespace detail
 
         template <typename A, typename T, typename V>
         XSIMD_INLINE void
@@ -422,8 +400,13 @@ namespace xsimd
         {
             static_assert(batch<T, A>::size == batch<V, A>::size,
                           "Source and index sizes must match");
-            kernel::detail::scatter<batch<V, A>::size - 1, T, A, T, V>(
-                src, dst, index, {});
+            alignas(A::alignment()) T src_buffer[batch<T, A>::size];
+            kernel::store_aligned<A>(&src_buffer[0], batch<T, A>(src), A {});
+
+            alignas(A::alignment()) V index_buffer[batch<T, A>::size];
+            kernel::store_aligned<A>(&index_buffer[0], batch<V, A>(index), A {});
+            for (size_t i = 0; i < batch<T, A>::size; ++i)
+                dst[index_buffer[i]] = src_buffer[i];
         }
 
         template <typename A, typename T, typename U, typename V>
@@ -434,8 +417,13 @@ namespace xsimd
         {
             static_assert(batch<T, A>::size == batch<V, A>::size,
                           "Source and index sizes must match");
-            kernel::detail::scatter<batch<V, A>::size - 1, T, A, U, V>(
-                src, dst, index, {});
+            alignas(A::alignment()) T src_buffer[batch<T, A>::size];
+            kernel::store_aligned<A>(&src_buffer[0], batch<T, A>(src), A {});
+
+            alignas(A::alignment()) V index_buffer[batch<T, A>::size];
+            kernel::store_aligned<A>(&index_buffer[0], batch<V, A>(index), A {});
+            for (size_t i = 0; i < batch<T, A>::size; ++i)
+                dst[index_buffer[i]] = src_buffer[i];
         }
 
         template <typename A, typename T, typename U, typename V>
@@ -447,7 +435,13 @@ namespace xsimd
             static_assert(batch<T, A>::size == batch<V, A>::size,
                           "Source and index sizes must match");
             const auto tmp = batch_cast<U>(src);
-            kernel::scatter<A>(tmp, dst, index, A {});
+            alignas(A::alignment()) U src_buffer[batch<T, A>::size];
+            kernel::store_aligned<A>(&src_buffer[0], batch<U, A>(tmp), A {});
+
+            alignas(A::alignment()) V index_buffer[batch<T, A>::size];
+            kernel::store_aligned<A>(&index_buffer[0], batch<V, A>(index), A {});
+            for (size_t i = 0; i < batch<T, A>::size; ++i)
+                dst[index_buffer[i]] = src_buffer[i];
         }
 
         // shuffle

include/xsimd/arch/xsimd_altivec.hpp

@@ -518,7 +518,7 @@ namespace xsimd
         template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<altivec>) noexcept
         {
-            return *(typename batch<T, A>::register_type const*)mem;
+            return vec_xl(0, (typename batch<T, A>::register_type const*)mem);
         }
 
         // load_complex
@@ -925,7 +925,7 @@ namespace xsimd
         template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value, void>::type>
         XSIMD_INLINE void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<altivec>) noexcept
         {
-            *(typename batch<T, A>::register_type*)mem = self.data;
+            return vec_xst(self.data, 0, reinterpret_cast<typename batch<T, A>::register_type*>(mem));
         }
 
         // sub

test/test_memory.cpp

@@ -46,7 +46,7 @@ TEST_CASE("[is_aligned]")
     float f[100];
     void* unaligned_f = static_cast<void*>(&f[0]);
     constexpr std::size_t alignment = xsimd::default_arch::alignment();
-    std::size_t aligned_f_size;
+    std::size_t aligned_f_size = sizeof(f);
     void* aligned_f = std::align(alignment, sizeof(f), unaligned_f, aligned_f_size);
     CHECK_UNARY(xsimd::is_aligned(aligned_f));