Merge pull request #1710 from swh/pm_unchecked_store

Add `unchecked_store`

GIT_ORIGIN_FUTURE_CPP_REV_ID: a918e4cbf819b424b9b16db95947f5e1322da901

Author: BMW-Contributor

score/language/futurecpp/include/score/private/simd/data_types.hpp

@@ -471,31 +471,6 @@ class basic_vec<T, Abi, true>
     /// [parallel] 9.6.1 4
     explicit SCORE_LANGUAGE_FUTURECPP_SIMD_ALWAYS_INLINE operator typename Abi::impl::type() const { return v_; }
 
-    /// \brief Replaces the elements of the simd object from an aligned memory address.
-    ///
-    /// @pre [v, v + size()) is a valid range.
-    /// @pre v shall point to storage aligned to score::cpp::simd::alignment_v<basic_vec>.
-    ///
-    /// [parallel] 9.6.5 4, 5 and 6
-    void SCORE_LANGUAGE_FUTURECPP_SIMD_ALWAYS_INLINE copy_to(value_type* const v, vector_aligned_tag) const
-    {
-        static_assert(detail::is_simd_flag_type_v<vector_aligned_tag>, "vector_aligned_tag not a simd flag type tag");
-        SCORE_LANGUAGE_FUTURECPP_PRECONDITION_DBG((score::cpp::bit_cast<std::uintptr_t>(v) % alignment_v<basic_vec>) == 0U);
-        Abi::impl::store_aligned(v, v_);
-    }
-
-    /// \brief Replaces the elements of the simd object from an unaligned memory address.
-    ///
-    /// @pre [v, v + size()) is a valid range.
-    /// @pre v shall point to storage aligned to alignof(value_type).
-    ///
-    /// [parallel] 9.6.5 4, 5 and 6
-    void SCORE_LANGUAGE_FUTURECPP_SIMD_ALWAYS_INLINE copy_to(value_type* const v, element_aligned_tag = {}) const
-    {
-        static_assert(detail::is_simd_flag_type_v<element_aligned_tag>, "element_aligned_tag not a simd flag type tag");
-        Abi::impl::store(v, v_);
-    }
-
     /// \brief The value of the ith element.
     ///
     /// @pre i < size()
@@ -790,6 +765,47 @@ inline where_expression<basic_mask<T, Abi>, basic_vec<T, Abi>> where(const typen
     return {m, v};
 }
 
+/// \brief Stores the elements of the simd object to an aligned range.
+///
+/// Note: `R` is currently more constrained than the standard requires. It expects `r` be convertible to
+/// `span<T, N>{r}` with static_extent `N`, where `N` is `basic_vec<T, Abi>::size()`. The current definition of `span`
+/// essentially restricts the value type of `R` to be also `T` and the size of `R` to be a constant expression.
+///
+/// @pre r shall point to storage aligned to score::cpp::simd::alignment_v<basic_vec>.
+///
+/// [parallel] 9.6.5 4, 5 and 6
+template <typename T,
+          typename Abi,
+          typename R,
+          typename = std::enable_if_t<std::is_constructible_v<span<T, basic_vec<T, Abi>::size()>, R>  //
+                                      && std::is_convertible_v<R, span<T, basic_vec<T, Abi>::size()>> //
+                                      >>
+inline void unchecked_store(const basic_vec<T, Abi>& v, R&& r, vector_aligned_tag)
+{
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION_DBG((score::cpp::bit_cast<std::uintptr_t>(std::data(r)) % alignment_v<basic_vec<T, Abi>>) == 0U);
+    Abi::impl::store_aligned(std::data(std::forward<R>(r)), static_cast<typename Abi::impl::type>(v));
+}
+
+/// \brief Store the elements of the simd object to an unaligned range.
+///
+/// Note: `R` is currently more constrained than the standard requires. It expects `r` be convertible to
+/// `span<T, N>{r}` with static_extent `N`, where `N` is `basic_vec<T, Abi>::size()`. The current definition of `span`
+/// essentially restricts the value type of `R` to be also `T` and the size of `R` to be a constant expression.
+///
+/// @pre r shall point to storage aligned to alignof(value_type).
+///
+/// [parallel] 9.6.5 4, 5 and 6
+template <typename T,
+          typename Abi,
+          typename R,
+          typename = std::enable_if_t<std::is_constructible_v<span<T, basic_vec<T, Abi>::size()>, R>  //
+                                      && std::is_convertible_v<R, span<T, basic_vec<T, Abi>::size()>> //
+                                      >>
+inline void unchecked_store(const basic_vec<T, Abi>& v, R&& r, element_aligned_tag = {})
+{
+    Abi::impl::store(std::data(std::forward<R>(r)), static_cast<typename Abi::impl::type>(v));
+}
+
 } // namespace simd
 } // namespace score::cpp
 

score/language/futurecpp/tests/simd_vec_test.cpp

@@ -241,7 +241,7 @@ TYPED_TEST(simd_vec_fixture, StoreByDefaultIsUnaligned)
     const auto scalars{integer_sequence<TypeParam>()};
     const TypeParam vector{scalars};
     std::array<typename TypeParam::value_type, vector.size()> result;
-    vector.copy_to(result.data());
+    score::cpp::simd::unchecked_store(vector, result);
 
     EXPECT_EQ(result, scalars);
 }
@@ -253,7 +253,7 @@ TYPED_TEST(simd_vec_fixture, StoreUnaligned)
     const auto scalars{integer_sequence<TypeParam>()};
     const TypeParam vector{scalars};
     std::array<typename TypeParam::value_type, vector.size()> result;
-    vector.copy_to(result.data(), score::cpp::simd::element_aligned);
+    score::cpp::simd::unchecked_store(vector, result, score::cpp::simd::element_aligned);
 
     EXPECT_EQ(result, scalars);
 }
@@ -266,7 +266,7 @@ TYPED_TEST(simd_vec_fixture, StoreAligned)
     const auto scalars{integer_sequence<TypeParam>()};
     const TypeParam vector{scalars};
     alignas(score::cpp::simd::alignment_v<TypeParam>) std::array<value_type, vector.size()> result;
-    vector.copy_to(result.data(), score::cpp::simd::vector_aligned);
+    score::cpp::simd::unchecked_store(vector, result, score::cpp::simd::vector_aligned);
 
     EXPECT_EQ(result, scalars);
 }
@@ -283,8 +283,38 @@ TYPED_TEST(simd_vec_fixture, StoreAligned_WhenCopyingToUnalignedMemory_ThenPreco
     using value_type = typename TypeParam::value_type;
     const TypeParam vector{value_type{23}};
     alignas(score::cpp::simd::alignment_v<TypeParam>) std::array<value_type, vector.size() + 1U> scalars;
+    const score::cpp::span<value_type, TypeParam::size()> result{&scalars[1U], vector.size()};
 
-    SCORE_LANGUAGE_FUTURECPP_EXPECT_CONTRACT_VIOLATED(vector.copy_to(&scalars[1], score::cpp::simd::vector_aligned));
+    SCORE_LANGUAGE_FUTURECPP_EXPECT_CONTRACT_VIOLATED(score::cpp::simd::unchecked_store(vector, result, score::cpp::simd::vector_aligned));
+}
+
+/// @testmethods TM_REQUIREMENT
+/// @requirement CB-#18398050
+TYPED_TEST(simd_vec_fixture, CannotConstruct_WhenSizeIsNotAConstantExpression)
+{
+    const auto test = [](auto&& r) -> decltype(score::cpp::simd::unchecked_store(std::declval<TypeParam>(),
+                                                                          std::forward<decltype(r)>(r))) {};
+
+    using value_type = typename TypeParam::value_type;
+
+    { // cannot call `unchecked_store` because types have runtime size
+        static_assert(!std::is_invocable_v<decltype(test), std::vector<value_type>>);
+        static_assert(!std::is_invocable_v<decltype(test), std::vector<value_type>&>);
+        static_assert(!std::is_invocable_v<decltype(test), score::cpp::span<value_type>>);
+        static_assert(!std::is_invocable_v<decltype(test), score::cpp::span<value_type>&>);
+    }
+
+    { // cannot store to range because it is `const`, i.e., non-modifiable
+        static_assert(!std::is_invocable_v<decltype(test), score::cpp::span<const value_type, TypeParam::size()>>);
+        static_assert(!std::is_invocable_v<decltype(test), score::cpp::span<const value_type, TypeParam::size()>&>);
+        static_assert(!std::is_invocable_v<decltype(test), std::array<value_type, TypeParam::size()>>);
+    }
+
+    { // sanity check that test works
+        static_assert(std::is_invocable_v<decltype(test), score::cpp::span<value_type, TypeParam::size()>>);
+        static_assert(std::is_invocable_v<decltype(test), score::cpp::span<value_type, TypeParam::size()>&>);
+        static_assert(std::is_invocable_v<decltype(test), std::array<value_type, TypeParam::size()>&>);
+    }
 }
 
 /// @testmethods TM_REQUIREMENT