[libcxx] clean up and complete <experimental/simd>

[timshen]

Summary

The cleanup patch adds sevreal TODOs for the following unimplemented
features:
*) aligned load
*) simd<> version of <cmath> functions

This patch declares the completion of my implementation of
<experimental/simd>.

[timshen]

Implement memory_alignment.

[timshen]

Update on template variable #ifdefs in tests.

[timshen]

Rebase.

libcxx/include/experimental/simd

 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI
 
 using scalar = __simd_abi<_StorageKind::_Scalar, 1>;
 
 template <int _Np>
 using fixed_size = __simd_abi<_StorageKind::_Array, _Np>;
 
-#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
+#if _LIBCPP_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR constexpr size_t max_fixed_size = 32;
 #endif
 
 template <class _Tp, size_t _Np>
 using __compatible = fixed_size<_Np>;
 
 template <class _Tp, size_t _Np>

 class simd;
 template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
 class simd_mask;
 
 struct element_aligned_tag {};
 struct vector_aligned_tag {};
 template <size_t>
 struct overaligned_tag {};
-#if _LIBCPP_STD_VER > 14
 _LIBCPP_INLINE_VAR constexpr element_aligned_tag element_aligned{};
 _LIBCPP_INLINE_VAR constexpr vector_aligned_tag vector_aligned{};
 #if !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <size_t _Np>
 _LIBCPP_INLINE_VAR constexpr overaligned_tag<_Np> overaligned{};
 #endif
-#endif
 
 // traits [simd.traits]
 template <class _Tp>
 struct is_abi_tag : std::integral_constant<bool, false> {};
 
 template <_StorageKind __kind, int _Np>
 struct is_abi_tag<__simd_abi<__kind, _Np>>
     : std::integral_constant<bool, true> {};

 template <>
 struct is_simd_flag_type<vector_aligned_tag>
     : std::integral_constant<bool, true> {};
 
 template <size_t _Align>
 struct is_simd_flag_type<overaligned_tag<_Align>>
     : std::integral_constant<bool, true> {};
 
-#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
+#if _LIBCPP_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value;
 template <class _Tp>
 _LIBCPP_INLINE_VAR constexpr bool is_simd_v = is_simd<_Tp>::value;
 template <class _Tp>
 _LIBCPP_INLINE_VAR constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value;
 template <class _Tp>
 _LIBCPP_INLINE_VAR constexpr bool is_simd_flag_type_v =

 struct simd_size<_Tp, __simd_abi<__kind, _Np>>
     : std::integral_constant<size_t, _Np> {
   static_assert(
       std::is_arithmetic<_Tp>::value &&
           !std::is_same<typename std::remove_const<_Tp>::type, bool>::value,
       "Element type should be vectorizable");
 };
 
-// TODO: implement it.
-template <class _Tp, class _Up = typename _Tp::value_type>
+template <class _SimdType, class _ValueType = typename _SimdType::value_type>
 struct memory_alignment;
 
-#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
+// TODO: May extend this after implementing vector_aligned.
+template <class _Tp, class _Abi, class _Up>
+struct memory_alignment<simd<_Tp, _Abi>, _Up>
+    : std::integral_constant<size_t, alignof(simd<_Tp, _Abi>)> {};
+
+template <class _Tp, class _Abi>
+struct memory_alignment<simd_mask<_Tp, _Abi>, bool>
+    : std::integral_constant<size_t, alignof(simd_mask<_Tp, _Abi>)> {};
+
+#if _LIBCPP_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
 _LIBCPP_INLINE_VAR constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value;
 
 template <class _Tp, class _Up = typename _Tp::value_type>
 _LIBCPP_INLINE_VAR constexpr size_t memory_alignment_v =
     memory_alignment<_Tp, _Up>::value;
 #endif
 
for (size_t __i = 0; __i < size(); __i++) {
       (*this)[__i] = static_cast<_Tp>(__v[__i]);
     }
   }
 
   // implicit broadcast constructor
   template <class _Up,
             class = typename std::enable_if<__can_broadcast<_Up>()>::type>
   simd(_Up&& __rv) {
-    auto __v = static_cast<_Tp>(__rv);
+    auto __val = static_cast<_Tp>(__rv);
     for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = __v;
+      (*this)[__i] = __val;
     }
   }
 
   // generator constructor
   template <class _Generator,
             int = typename std::enable_if<
                 __can_generate<_Generator>(std::make_index_sequence<size()>()),
                 int>::type()>
public:
 
   static constexpr size_t size() noexcept {
     return simd<__element_type, _Abi>::size();
   }
 
   simd_mask() = default;
 
   // broadcast constructor
-  explicit simd_mask(value_type __value) noexcept {
+  explicit simd_mask(value_type __val) noexcept {
     for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = __value;
+      (*this)[__i] = __val;
     }
   }
 
   // implicit type conversion constructor
   template <
       class _Up,
       class = typename std::enable_if<
           !std::is_void<_Up>::value &&
           std::is_same<abi_type, simd_abi::fixed_size<size()>>::value>::type>
   simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>& __v) noexcept {
     for (size_t __i = 0; __i < size(); __i++) {
       (*this)[__i] = __v[__i];
     }
   }
 
   // load constructor
   template <class _Flags, class = typename std::enable_if<
                               is_simd_flag_type<_Flags>::value>::type>
   simd_mask(const value_type* __buffer, _Flags) {
+    // TODO: optimize for overaligned flags
     for (size_t __i = 0; __i < size(); __i++) {
       (*this)[__i] = __buffer[__i];
     }
   }
 
   // loads [simd.mask.copy]
   template <class _Flags>
   typename std::enable_if<is_simd_flag_type<_Flags>::value>::type
   copy_from(const value_type* __buffer, _Flags) {
     *this = simd_mask(__buffer, _Flags());
   }
 
   template <class _Flags>
   typename std::enable_if<is_simd_flag_type<_Flags>::value>::type
   copy_to(value_type* __buffer, _Flags) const {
+    // TODO: optimize for overaligned flags
     for (size_t __i = 0; __i < size(); __i++) {
       __buffer[__i] = (*this)[__i];
     }
   }
 
   // scalar access [simd.mask.subscr]
   reference operator[](size_t __i) { return reference(&__s_.__s_, __i); }
 
friend simd_mask operator!=(const simd_mask& __a,
                               const simd_mask& __b) noexcept {
     return __a ^ __b;
   }
 };
 
 template <class _Tp, class _Abi, class _Up, class _Flags>
 void __mask_copy_to(const simd<_Tp, _Abi>& __v, const simd_mask<_Tp, _Abi>& __m,
                     _Up* __buffer, _Flags) {
+  // TODO: optimize for overaligned flags
   for (size_t __i = 0; __i < __v.size(); __i++) {
     if (__m[__i]) {
       __buffer[__i] = static_cast<_Up>(__v[__i]);
     }
   }
 }
 
 template <class _Tp, class _Abi, class _Up, class _Flags>
 void __mask_copy_to(const simd_mask<_Tp, _Abi>& __v,
                     const simd_mask<_Tp, _Abi>& __m, _Up* __buffer, _Flags) {
+  // TODO: optimize based on bool's bit pattern.
   for (size_t __i = 0; __i < __v.size(); __i++) {
     if (__m[__i]) {
       __buffer[__i] = static_cast<_Up>(__v[__i]);
     }
   }
 }
 
 template <class _Tp, class _Up, class _Flags>
-void __mask_copy_to(_Tp __v, bool __m, _Up* __buffer, _Flags) {
+void __mask_copy_to(_Tp __val, bool __m, _Up* __buffer, _Flags) {
   if (__m) {
-    *__buffer = static_cast<_Up>(__v);
+    *__buffer = static_cast<_Up>(__val);
   }
 }
 
 template <class _Tp, class _Abi, class _Up, class _Flags>
 void __mask_copy_from(simd<_Tp, _Abi>& __v, const simd_mask<_Tp, _Abi>& __m,
                       const _Up* __buffer, _Flags) {
   // TODO: optimize for overaligned flags
   for (size_t __i = 0; __i < __v.size(); __i++) {
void __mask_copy_from(simd_mask<_Tp, _Abi>& __v,
   for (size_t __i = 0; __i < __v.size(); __i++) {
     if (__m[__i]) {
       __v[__i] = static_cast<bool>(__buffer[__i]);
     }
   }
 }
 
 template <class _Tp, class _Up, class _Flags>
-void __mask_copy_from(_Tp& __v, bool __m, const _Up* __buffer, _Flags) {
+void __mask_copy_from(_Tp& __val, bool __m, const _Up* __buffer, _Flags) {
   if (__m) {
-    __v = static_cast<_Tp>(*__buffer);
+    __val = static_cast<_Tp>(*__buffer);
   }
 }
 
 template <class _ValueType>
 struct __simd_value_type_traits {
   static_assert(std::is_arithmetic<_ValueType>::value, "");
   using type = _ValueType;
 };

 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 hmax(const const_where_expression<_MaskType, _SimdType>& __w) {
   return __hmax(__simd_mask_friend::__simd_select(
       _SimdType(std::numeric_limits<typename _SimdType::value_type>::lowest()),
       __w.__v_, __w.__m_));
 }
 
+// TODO: Implement <cmath> functions for simd.
+
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
 
 #endif /* _LIBCPP_EXPERIMENTAL_SIMD */

libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp

void test_load_ctor() {
   {
     fixed_size_simd<int32_t, 4> a(buffer, overaligned_tag<32>());
     assert(a[0] == 4);
     assert(a[1] == 3);
     assert(a[2] == 2);
     assert(a[3] == 1);
   }
 
-#if TEST_STD_VER > 14
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
   {
     fixed_size_simd<int32_t, 4> a(buffer, element_aligned);
     assert(a[0] == 4);
     assert(a[1] == 3);
     assert(a[2] == 2);
     assert(a[3] == 1);
   }
   {

libcxx/test/std/experimental/simd/simd.mask.cons/load.pass.cpp

void test_load_ctor() {
   {
     bool buf[] = {false, true, true, false};
     fixed_size_simd_mask<int, 4> m(buf, overaligned_tag<32>());
     assert(buf[0] == m[0]);
     assert(buf[1] == m[1]);
     assert(buf[2] == m[2]);
     assert(buf[3] == m[3]);
   }
-#if TEST_STD_VER > 14
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
   {
     bool buf[] = {false, true, true, false};
     fixed_size_simd_mask<int, 4> m(buf, element_aligned);
     assert(buf[0] == m[0]);
     assert(buf[1] == m[1]);
     assert(buf[2] == m[2]);
     assert(buf[3] == m[3]);
   }

libcxx/test/std/experimental/simd/simd.mask.mem/load.pass.cpp

alignas(32) bool buffer[] = {false, true, true, false};
     fixed_size_simd_mask<int32_t, 4> a;
     a.copy_from(buffer, overaligned_tag<32>());
     assert(!a[0]);
     assert(a[1]);
     assert(a[2]);
     assert(!a[3]);
   }
 
-#if TEST_STD_VER > 14
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
   {
     fixed_size_simd_mask<int32_t, 4> a;
     a.copy_from(buffer, element_aligned);
     assert(!a[0]);
     assert(a[1]);
     assert(a[2]);
     assert(!a[3]);
   }

libcxx/test/std/experimental/simd/simd.mask.mem/store.pass.cpp

a[3] = false;
     alignas(32) bool buffer[4] = {0};
     a.copy_to(buffer, overaligned_tag<32>());
     assert(!buffer[0]);
     assert(buffer[1]);
     assert(buffer[2]);
     assert(!buffer[3]);
   }
 
-#if TEST_STD_VER > 14
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
   {
     alignas(32) bool buffer[4] = {0};
     a.copy_to(buffer, element_aligned);
     assert(!buffer[0]);
     assert(buffer[1]);
     assert(buffer[2]);
     assert(!buffer[3]);
   }

libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp

alignas(32) int32_t buffer[] = {4, 3, 2, 1};
     fixed_size_simd<int32_t, 4> a;
     a.copy_from(buffer, overaligned_tag<32>());
     assert(a[0] == 4);
     assert(a[1] == 3);
     assert(a[2] == 2);
     assert(a[3] == 1);
   }
 
-#if TEST_STD_VER > 14
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
   {
     fixed_size_simd<int32_t, 4> a;
     a.copy_from(buffer, element_aligned);
     assert(a[0] == 4);
     assert(a[1] == 3);
     assert(a[2] == 2);
     assert(a[3] == 1);
   }

libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp

fixed_size_simd<int32_t, 4> a([](int i) { return 4 - i; });
     alignas(32) int32_t buffer[4] = {0};
     a.copy_to(buffer, overaligned_tag<32>());
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
     assert(buffer[2] == 2);
     assert(buffer[3] == 1);
   }
 
-#if TEST_STD_VER > 14
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
   {
     alignas(32) int32_t buffer[4] = {0};
     a.copy_to(buffer, element_aligned);
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
     assert(buffer[2] == 2);
     assert(buffer[3] == 1);
   }

libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp

 
 static_assert(is_abi_tag<simd_abi::fixed_size<1>>::value, "");
 static_assert(is_abi_tag<simd_abi::fixed_size<2>>::value, "");
 static_assert(is_abi_tag<simd_abi::fixed_size<3>>::value, "");
 static_assert(is_abi_tag<simd_abi::fixed_size<4>>::value, "");
 static_assert(is_abi_tag<simd_abi::fixed_size<5>>::value, "");
 static_assert(is_abi_tag<simd_abi::fixed_size<32>>::value, "");
 
-#if TEST_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) &&        \
-    !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES)
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 
 static_assert(is_abi_tag_v<simd_abi::native<int8_t>>, "");
 static_assert(is_abi_tag_v<simd_abi::native<int16_t>>, "");
 static_assert(is_abi_tag_v<simd_abi::native<int32_t>>, "");
 static_assert(is_abi_tag_v<simd_abi::native<int64_t>>, "");
 static_assert(is_abi_tag_v<simd_abi::native<uint8_t>>, "");
 static_assert(is_abi_tag_v<simd_abi::native<uint16_t>>, "");
 static_assert(is_abi_tag_v<simd_abi::native<uint32_t>>, "");

libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp

 static_assert(is_simd<fixed_size_simd<uint16_t, 32>>::value, "");
 static_assert(is_simd<fixed_size_simd<uint32_t, 32>>::value, "");
 static_assert(is_simd<fixed_size_simd<uint64_t, 32>>::value, "");
 static_assert(is_simd<fixed_size_simd<float, 32>>::value, "");
 static_assert(is_simd<fixed_size_simd<double, 32>>::value, "");
 
 static_assert(!is_simd<int>::value, "");
 
-#if TEST_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) &&        \
-    !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES)
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 
 static_assert(is_simd_v<native_simd<int8_t>>, "");
 static_assert(is_simd_v<native_simd<int16_t>>, "");
 static_assert(is_simd_v<native_simd<int32_t>>, "");
 static_assert(is_simd_v<native_simd<int64_t>>, "");
 static_assert(is_simd_v<native_simd<uint8_t>>, "");
 static_assert(is_simd_v<native_simd<uint16_t>>, "");
 static_assert(is_simd_v<native_simd<uint32_t>>, "");

libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp

 
 using namespace std::experimental::parallelism_v2;
 
 static_assert(is_simd_flag_type<element_aligned_tag>::value, "");
 static_assert(is_simd_flag_type<vector_aligned_tag>::value, "");
 static_assert(is_simd_flag_type<overaligned_tag<16>>::value, "");
 static_assert(is_simd_flag_type<overaligned_tag<32>>::value, "");
 
-#if TEST_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) &&        \
-    !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES)
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 
 static_assert(is_simd_flag_type_v<element_aligned_tag>, "");
 static_assert(is_simd_flag_type_v<vector_aligned_tag>, "");
 static_assert(is_simd_flag_type_v<overaligned_tag<16>>, "");
 static_assert(is_simd_flag_type_v<overaligned_tag<32>>, "");
 
 #endif
 
 int main() {}

libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp

 static_assert(is_simd_mask<fixed_size_simd_mask<uint16_t, 32>>::value, "");
 static_assert(is_simd_mask<fixed_size_simd_mask<uint32_t, 32>>::value, "");
 static_assert(is_simd_mask<fixed_size_simd_mask<uint64_t, 32>>::value, "");
 static_assert(is_simd_mask<fixed_size_simd_mask<float, 32>>::value, "");
 static_assert(is_simd_mask<fixed_size_simd_mask<double, 32>>::value, "");
 
 static_assert(!is_simd_mask<int>::value, "");
 
-#if TEST_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) &&        \
-    !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES)
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 
 static_assert(is_simd_mask_v<native_simd_mask<int8_t>>, "");
 static_assert(is_simd_mask_v<native_simd_mask<int16_t>>, "");
 static_assert(is_simd_mask_v<native_simd_mask<int32_t>>, "");
 static_assert(is_simd_mask_v<native_simd_mask<int64_t>>, "");
 static_assert(is_simd_mask_v<native_simd_mask<uint8_t>>, "");
 static_assert(is_simd_mask_v<native_simd_mask<uint16_t>>, "");
 static_assert(is_simd_mask_v<native_simd_mask<uint32_t>>, "");

libcxx/test/std/experimental/simd/simd.traits/memory_alignment.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// [simd.traits]
+// template <class T, class U = typename T::value_type> struct memory_alignment;
+// template <class T, class U = typename T::value_type>
+// inline constexpr size_t memory_alignment_v = memory_alignment<T, U>::value;
+
+#include <experimental/simd>
+#include "test_macros.h"
+
+using namespace std::experimental::parallelism_v2;
+
+static_assert(std::is_same<const size_t,
+                           decltype(memory_alignment<simd<int>>::value)>::value,
+              "");
+static_assert(
+    std::is_same<const size_t,
+                 decltype(memory_alignment<simd<int>, int>::value)>::value,
+    "");
+static_assert(
+    std::is_same<
+        const size_t,
+        decltype(memory_alignment<simd<int>, unsigned int>::value)>::value,
+    "");
+static_assert(
+    std::is_same<const size_t,
+                 decltype(memory_alignment<simd_mask<int>>::value)>::value,
+    "");
+static_assert(
+    std::is_same<const size_t, decltype(memory_alignment<simd_mask<int>,
+                                                         bool>::value)>::value,
+    "");
+
+#if TEST_STD_VER >= 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
+
+static_assert(
+    std::is_same<const size_t, decltype(memory_alignment_v<simd<int>>)>::value,
+    "");
+static_assert(std::is_same<const size_t,
+                           decltype(memory_alignment_v<simd<int>, int>)>::value,
+              "");
+static_assert(
+    std::is_same<const size_t,
+                 decltype(memory_alignment_v<simd<int>, unsigned int>)>::value,
+    "");
+static_assert(std::is_same<const size_t,
+                           decltype(memory_alignment_v<simd_mask<int>>)>::value,
+              "");
+static_assert(
+    std::is_same<const size_t,
+                 decltype(memory_alignment_v<simd_mask<int>, bool>)>::value,
+    "");
+
+#endif
+
+int main() {}