[libcxx] <experimental/simd> Added aliagned flag types, traits is_simd_flag_type[_v], memory_alignment[_v] and related tests

[Joy12138]

Fix macro _LIBCPP_HIDE_FROM_ABI

[Joy12138]

Fix clang-tidy

[philnik]

libcxx/include/CMakeLists.txt

882

Looks like you forgot to update the status page.

libcxx/include/experimental/__simd/aligned_tag.h

37

Let's add __assume_aligned in __memory/assume_aligned.h to avoid using builtins randomly in the code. This lets us also assert if the alignment assumption isn't met (Please add a test for that!).

libcxx/include/experimental/__simd/traits.h

80

Same here - does this even work with variables and this needs a SFINAE test.

80

Isn't this implicit through is_simd_mask_v?

libcxx/include/experimental/__simd/utility.h

26–32

let's instead add a __bit_ceil for pre-C++20 usage.

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

27

Also the comment here - _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES is libc++-specific, so it shouldn't be used in a stdtest.

libcxx/test/std/experimental/simd/test_utils.h

20

I don't think this is really an action item. The experimental implementation will probably be C++17 until we remove it. Only once it's (hopefully) landed in C++26 we can move the implementation and tests out of experimental and refactor any code.

21

Since you already mentioned that they are equivalent.

[Joy12138]

Fix some comments

[Joy12138]

libcxx/include/experimental/__simd/traits.h

80

I don't think so. _Up should be able to be provided by the user. _Tp::value_type is just a default type.

[Joy12138]

Fix CI

[Joy12138]

Fix CI

[Joy12138]

libcxx/include/experimental/__simd/aligned_tag.h

37

If I understand correctly, what you want is a false test when provides incorrect alignment. Then both tests in this patch do not involve alignment inputs. Can we add these false tests in subsequent patches about constructors and load/store that involved with alignment inputs?

[philnik]

libcxx/include/experimental/__simd/aligned_tag.h

37

Oh yeah, sure. We can test it through the public interface.

libcxx/include/experimental/__simd/traits.h

80

Ah, I missed that _Up may be provided by the user. Never mind then.

libcxx/include/experimental/__simd/utility.h

27–44

Let's add these in their respective implementation detail headers. That way we avoid code duplication and can use them in other places in the codebase.

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

27

Again, to make sure the value is static.

29–30

It looks to me like this is technically implementation-defined. Am I correct in that interpretation?

39–40

I think this is technically also the case for float and double. It just happens to be the case that they are the IEEE types on about every platform.

libcxx/test/std/experimental/simd/test_utils.h

54

Newline!

[Joy12138]

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

29–30

If my understanding of the document is correct, the basic type of the simd_mask is bool, while the storage type in the internal implementation layer is implementation-defined. Alignment should be calculated using bool.

[Joy12138]

Fix comments

[Joy12138]

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

39–40

is there any other modify required here?

[Joy12138]

Add SFINAE test for memory_alignment

[philnik]

Please rebase. It looks like the CI didn't run properly.

libcxx/docs/Status/ParallelismProjects.csv

7

There doesn't seem to be a [parallel.simd.aligned] section. AFAICT this is just [parallel.simd.synopsis].

libcxx/include/__bit/bit_ceil.h

25 ↗

(On Diff #539989)

Otherwise you're lying.

libcxx/include/__memory/assume_aligned.h

26 ↗

(On Diff #539989)

This will break C++03 otherwise.

libcxx/include/experimental/__simd/aligned_tag.h

35

libcxx/include/experimental/__simd/traits.h

86

I think this might actually be wrong. The wording says that memory_alignment shouldn't contain value, not that the class should fail to instantiate.

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

29–30

I can't find any wording that suggests a required alignment. Consider a platform with a 32byte vector. If the platform can load that vector from a 16byte aligned address without any loss of performance, there is no reason to make memory_alignment return 32 instead of 16.

39–40

I guess technically yes, but I think it's fine as-is. So no.

[Joy12138]

Rebase and fix some comments

[Joy12138]

Fix CI

[Joy12138]

libcxx/include/experimental/__simd/traits.h

86

I'm a bit confuse about this. If no `class = enable_if_t<...>' here, there will be errors coming out. You can see the same situation in D144363#4497271 with 'simd_size'.

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

29–30

In that case, how should we modify this? Just add LIBCPP_STATIC_ASSERT temporarily?

[philnik]

libcxx/include/experimental/__simd/traits.h

86

I think we have to do something like

template <
    class _Tp,
    class _Up = typename _Tp::value_type,
    bool = (is_simd_v<_Tp> && __is_vectorizable_v<_Up>) || (is_simd_mask_v<_Tp> && is_same_v<_Up, bool>)>
struct memory_alignment : integral_constant<size_t, memory_alignment_v<_Tp, _Up>> {};

template <class _Tp, class _Up>
struct memory_alignment<Tp, _Up, false> {};

And yeah, this also applies to simd_size. The SFINAE tests you added are correct in that they ensure that there is no value member. I think the enable_if and test for simd_size_v can be removed, since they aren't required.

Sorry for not spotting this earlier.

[Joy12138]

Fix memory_alignment

[philnik]

Thanks! LGTM with comments addressed.

libcxx/include/__bit/bit_ceil.h

31 ↗

(On Diff #540628)

I think it should be fine to just remove the _LIBCPP_CONSTEXPR_SINCE_CXX14. It's not like it makes much of a difference in compile times.

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

2

I think you're missing a test that you can instantiate memory_alignment with an invalid type.

29–30

Yeah, I thin a LIBCPP_STATIC_ASSERT is the right call here.

[Joy12138]

Fix some comments and CI errors

[Joy12138]

Fix transitive includes

[Joy12138]

Fix memory_alignment_v

[Joy12138]

Add newline at end of file

[Joy12138]

@philnik Could you please help me to look at the CI errors? I'm not very familiar with these issues. Thank you.

[philnik]

I think that should fix the tests.

libcxx/include/__bit/bit_ceil.h

32 ↗

(On Diff #540939)

43 ↗

(On Diff #540939)

You forgot _LIBCPP_NODISCARD_EXT here.

[Joy12138]

Fix CI

[Joy12138]

Fix CI

libcxx/include/__bit/bit_ceil.h

32 ↗

(On Diff #540939)

Seems we can't use brace-initialization of scalar types in C++03.

I tried to fix using:

return static_cast<_Tp>(1) << __n;

[Joy12138]

@philnik It seems the CI errors related to constexpr for bit_ceil? I'm not sure how to fix. Do you have any solutions?

[philnik]

In D153319#4524560, @Joy12138 wrote:

@philnik It seems the CI errors related to constexpr for bit_ceil? I'm not sure how to fix. Do you have any solutions?

I think the problem is that you changed the if constexpr to an if. The simplest solution is probably to change it back to an if constexpr and constraining __bit_ceil to _LIBCPP_STD_VER >= 17.

[Joy12138]

Rebase and fix bit_ceil

[Joy12138]

Fix CI

[Joy12138]

Rebase

[Joy12138]

Rebase

[Joy12138]

Rebase

libcxx/docs/Status/ParallelismProjects.csv

 Section,Description,Dependencies,Assignee,Complete
 | `[parallel.exceptions] <https://wg21.link/N4808>`_, "Parallel Exceptions", None, unassigned, |Not Started|
 | `[parallel.execpol] <https://wg21.link/N4808>`_, "Execution policies", None, unassigned, |Not Started|
 | `[parallel.alg] <https://wg21.link/N4808>`_, "Parallel algorithms", None, unassigned, |Not Started|
 | `[parallel.taskblock] <https://wg21.link/N4808>`_, "Task Block", None, unassigned, |Not Started|
 | `[parallel.simd.abi] <https://wg21.link/N4808>`_, "`simd ABI tags <https://reviews.llvm.org/D144362>`_", [parallel.simd.class] [parallel.simd.mask.class] declarations and alias, Yin Zhang, |Complete|
+| `[parallel.simd.aligned] <https://wg21.link/N4808>`_, "`simd aligned tags <https://reviews.llvm.org/D153319>`_", [parallel.simd.class] [parallel.simd.mask.class] declarations, Yin Zhang, |Complete|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "`simd type traits is_abi_tag[_v] <https://reviews.llvm.org/D144362>`_", [parallel.simd.abi], Yin Zhang, |Complete|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "`simd type traits is_simd[_v] <https://reviews.llvm.org/D144362>`_", [parallel.simd.class] declaration and alias, Yin Zhang, |Complete|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "`simd type traits is_simd_mask[_v] <https://reviews.llvm.org/D144362>`_", [parallel.simd.mask.class] declaration and alias, Yin Zhang, |Complete|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "simd type traits is_simd_flag_type", None, Yin Zhang, |In Progress|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "`simd type traits simd_size[_v] <https://reviews.llvm.org/D144363>`_", [parallel.simd.traits] is_abi_tag[_v], Yin Zhang, |Complete|
-| `[parallel.simd.traits] <https://wg21.link/N4808>`_, "simd type traits memory_alignment", None, Yin Zhang, |In Progress|
+| `[parallel.simd.traits] <https://wg21.link/N4808>`_, "`simd type traits memory_alignment <https://reviews.llvm.org/D153319>`_", [parallel.simd.aligned] simd aligned tags, Yin Zhang, |Complete|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "simd type traits rebind_simd", None, Yin Zhang, |In Progress|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "simd type traits resize_simd", None, Yin Zhang, |In Progress|
 | `[parallel.simd.whereexpr] <https://wg21.link/N4808>`_, "Where expression class templates", None, Yin Zhang, |In Progress|
 | `[parallel.simd.class] <https://wg21.link/N4808>`_, "`Class template simd declaration and alias <https://reviews.llvm.org/D144362>`_", [parallel.simd.abi], Yin Zhang, |Complete|
 | `[parallel.simd.class] <https://wg21.link/N4808>`_, "`simd<>::size() <https://reviews.llvm.org/D144363>`_", [parallel.simd.traits] simd_size[_v], Yin Zhang, |Complete|
 | `[parallel.simd.class] <https://wg21.link/N4808>`_, "Class template simd implementation", None, Yin Zhang, |In Progress|
 | `[parallel.simd.nonmembers] <https://wg21.link/N4808>`_, "simd non-member operations", None, Yin Zhang, |In Progress|
 | `[parallel.simd.mask.class] <https://wg21.link/N4808>`_, "`Class template simd_mask declaration and alias <https://reviews.llvm.org/D144362>`_", [parallel.simd.abi], Yin Zhang, |Complete|
 | `[parallel.simd.mask.class] <https://wg21.link/N4808>`_, "`simd_mask<>::size() <https://reviews.llvm.org/D144363>`_", [parallel.simd.class] simd<>::size(), Yin Zhang, |Complete|
 | `[parallel.simd.mask.class] <https://wg21.link/N4808>`_, "Class template simd_mask implementation", None, Yin Zhang, |In Progress|
 | `[parallel.simd.mask.nonmembers] <https://wg21.link/N4808>`_, "simd_mask non-member operations", None, Yin Zhang, |In Progress|

libcxx/include/CMakeLists.txt

set(files
   cstring
   ctgmath
   ctime
   ctype.h
   cuchar
   cwchar
   cwctype
   deque
   errno.h
   exception
   execution
   expected
   experimental/__config
   experimental/__memory
   experimental/__simd/abi_tag.h
+  experimental/__simd/aligned_tag.h
   experimental/__simd/declaration.h
   experimental/__simd/scalar.h
   experimental/__simd/simd.h
   experimental/__simd/simd_mask.h
   experimental/__simd/traits.h
   experimental/__simd/utility.h
   experimental/__simd/vec_ext.h
   experimental/deque

libcxx/include/experimental/__simd/aligned_tag.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_ALIGNED_TAG_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_ALIGNED_TAG_H
+
+#include <experimental/__simd/utility.h>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+// memory alignment
+struct element_aligned_tag {
+  template <class _Tp, class _Up = typename _Tp::value_type>
+  static constexpr size_t __alignment = alignof(_Up);
+
+  template <class _Tp, class _Up>
+  static _LIBCPP_HIDE_FROM_ABI constexpr _Up* __apply(_Up* __ptr) {
+    return __ptr;
+  }
+};
+
+struct vector_aligned_tag {
+  template <class _Tp, class _Up = typename _Tp::value_type>
+  static constexpr size_t __alignment = std::experimental::parallelism_v2::__bit_ceil(sizeof(_Up) * _Tp::size());
+
+  template <class _Tp, class _Up>
+  static _LIBCPP_HIDE_FROM_ABI constexpr _Up* __apply(_Up* __ptr) {
+    return __assume_aligned<__alignment<_Tp, _Up>, _Up>(__ptr);
+  }
+};
+
+template <size_t _Np>
+struct overaligned_tag {
+  template <class _Tp, class _Up = typename _Tp::value_type>
+  static constexpr size_t __alignment = _Np;
+
+  template <class _Tp, class _Up>
+  static _LIBCPP_HIDE_FROM_ABI constexpr _Up* __apply(_Up* __ptr) {
+    return __assume_aligned<__alignment<_Tp, _Up>, _Up>(__ptr);
+  }
+};
+
+inline constexpr element_aligned_tag element_aligned{};
+
+inline constexpr vector_aligned_tag vector_aligned{};
+
+template <size_t _Np>
+inline constexpr overaligned_tag<_Np> overaligned{};
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_ALIGNED_TAG_H

libcxx/include/experimental/__simd/traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_EXPERIMENTAL___SIMD_TRAITS_H
 #define _LIBCPP_EXPERIMENTAL___SIMD_TRAITS_H
 
 #include <experimental/__simd/abi_tag.h>
+#include <experimental/__simd/aligned_tag.h>
 #include <experimental/__simd/declaration.h>
 #include <experimental/__simd/utility.h>
 
 #if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 inline namespace parallelism_v2 {
 

 inline constexpr bool is_simd_mask_v = false;
 
 template <class _Tp, class _Abi>
 inline constexpr bool is_simd_mask_v<simd_mask<_Tp, _Abi>> = true;
 
 template <class _Tp>
 struct is_simd_mask : bool_constant<is_simd_mask_v<_Tp>> {};
 
+template <class _Tp>
+inline constexpr bool is_simd_flag_type_v = false;
+
+template <>
+inline constexpr bool is_simd_flag_type_v<element_aligned_tag> = true;
+
+template <>
+inline constexpr bool is_simd_flag_type_v<vector_aligned_tag> = true;
+
+template <size_t _Np>
+inline constexpr bool is_simd_flag_type_v<overaligned_tag<_Np>> = true;
+
+template <class _Tp>
+struct is_simd_flag_type : bool_constant<is_simd_flag_type_v<_Tp>> {};
+
 template <class _Tp,
           class _Abi = simd_abi::compatible<_Tp>,
           class      = enable_if_t<__is_vectorizable_v<_Tp> && is_abi_tag_v<_Abi>>>
 inline constexpr size_t simd_size_v = _Abi::__simd_size;
 
 template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
 struct simd_size : integral_constant<size_t, simd_size_v<_Tp, _Abi>> {};
 
+template <
+    class _Tp,
+    class _Up = typename _Tp::value_type,
+    class = enable_if_t<(is_simd_v<_Tp> && __is_vectorizable_v<_Up>) || (is_simd_mask_v<_Tp> && is_same_v<_Up, bool>)>>
+inline constexpr size_t memory_alignment_v = vector_aligned_tag::__alignment<_Tp, _Up>;
+
+template <class _Tp, class _Up = typename _Tp::value_type>
+struct memory_alignment : integral_constant<size_t, memory_alignment_v<_Tp, _Up>> {};
+
 } // namespace parallelism_v2
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 #endif // _LIBCPP_EXPERIMENTAL___SIMD_TRAITS_H

libcxx/include/experimental/__simd/utility.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H
 #define _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H
 
 #include <__type_traits/is_arithmetic.h>
 #include <__type_traits/is_const.h>
+#include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_volatile.h>
 
 #if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 inline namespace parallelism_v2 {
 template <class _Tp>
 constexpr bool __is_vectorizable_v =
     is_arithmetic_v<_Tp> && !is_const_v<_Tp> && !is_volatile_v<_Tp> && !is_same_v<_Tp, bool>;
+
+_LIBCPP_HIDE_FROM_ABI constexpr size_t __bit_ceil(size_t __val) {
+  size_t __pow = 1;
+  while (__pow < __val)
+    __pow <<= 1;
+  return __pow;
+}
+
+template <size_t _Np, class _Tp>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp* __assume_aligned(_Tp* __ptr) {
+  static_assert(_Np != 0 && (_Np & (_Np - 1)) == 0, "std::assume_aligned<N>(p) requires N to be a power of two");
+
+  if (__libcpp_is_constant_evaluated()) {
+    return __ptr;
+  } else {
+    _LIBCPP_ASSERT(reinterpret_cast<uintptr_t>(__ptr) % _Np == 0, "Alignment assumption is violated");
+    return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Np));
+  }
+}
 } // namespace parallelism_v2
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 #endif // _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H

libcxx/include/experimental/simd

inline namespace parallelism_v2 {
   template <class T> using native_simd = simd<T, simd_abi::native<T>>;
   template <class T, int N> using fixed_size_simd = simd<T, simd_abi::fixed_size<N>>;
 
   // class template simd_mask [simd.mask.class]
   template <class T, class Abi = simd_abi::compatible<T>> class simd_mask;
   template <class T> using native_simd_mask = simd_mask<T, simd_abi::native<T>>;
   template <class T, int N> using fixed_size_simd_mask = simd_mask<T, simd_abi::fixed_size<N>>;
 
+  // memory alignment
+  struct element_aligned_tag {};
+  struct vector_aligned_tag {};
+  template <size_t> struct overaligned_tag {};
+  inline constexpr element_aligned_tag element_aligned{};
+  inline constexpr vector_aligned_tag vector_aligned{};
+  template <size_t N> inline constexpr overaligned_tag<N> overaligned{};
+
   // traits [simd.traits]
   template<class T> struct is_abi_tag;
   template<class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value;
 
   template <class T> struct is_simd;
   template <class T> inline constexpr bool is_simd_v = is_simd<T>::value;
 
   template <class T> struct is_simd_mask;
   template <class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value;
 
+  template<class T> struct is_simd_flag_type;
+  template<class T> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<T>::value;
+
   template<class T, class Abi = simd_abi::compatible<T>> struct simd_size;
   template<class T, class Abi = simd_abi::compatible<T>>
     inline constexpr size_t simd_size_v = simd_size<T,Abi>::value;
 
+  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;
+
 } // namespace parallelism_v2
 } // namespace std::experimental
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #include <experimental/__config>
 #include <experimental/__simd/abi_tag.h>
+#include <experimental/__simd/aligned_tag.h>
 #include <experimental/__simd/scalar.h>
 #include <experimental/__simd/simd.h>
 #include <experimental/__simd/simd_mask.h>
 #include <experimental/__simd/traits.h>
 #include <experimental/__simd/vec_ext.h>
 
 #endif /* _LIBCPP_EXPERIMENTAL_SIMD */

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.traits]
+// template <class T> struct is_simd_flag_type;
+// template <class T> inline constexpr bool ex::is_simd_flag_type_v = ex::is_simd_flag_type<T>::value;
+
+#include "../test_utils.h"
+
+namespace ex = std::experimental::parallelism_v2;
+
+template <class T, std::size_t N>
+struct CheckIsSimdFlagType {
+  template <class SimdAbi>
+  void operator()() {
+    static_assert(ex::is_simd_flag_type<ex::element_aligned_tag>::value);
+    static_assert(ex::is_simd_flag_type<ex::vector_aligned_tag>::value);
+    static_assert(ex::is_simd_flag_type<ex::overaligned_tag<N>>::value);
+
+    static_assert(!ex::is_simd_flag_type<T>::value);
+    static_assert(!ex::is_simd_flag_type<ex::simd<T, SimdAbi>>::value);
+    static_assert(!ex::is_simd_flag_type<ex::simd_mask<T, SimdAbi>>::value);
+
+    static_assert(ex::is_simd_flag_type_v<ex::element_aligned_tag>);
+    static_assert(ex::is_simd_flag_type_v<ex::vector_aligned_tag>);
+    static_assert(ex::is_simd_flag_type_v<ex::overaligned_tag<N>>);
+
+    static_assert(!ex::is_simd_flag_type_v<T>);
+    static_assert(!ex::is_simd_flag_type_v<ex::simd<T, SimdAbi>>);
+    static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<T, SimdAbi>>);
+  }
+};
+
+int main(int, char**) {
+  test_all_simd_abi<CheckIsSimdFlagType>();
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <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 std::size_t memory_alignment_v = memory_alignment<T, U>::value;
+
+#include "../test_utils.h"
+
+namespace ex = std::experimental::parallelism_v2;
+
+template <class T, std::size_t N>
+struct CheckMemoryAlignmentMask {
+  template <class SimdAbi>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd_mask<T, SimdAbi>>{}.value ==
+                  bit_ceil(sizeof(bool) * ex::simd_size_v<T, SimdAbi>));
+    static_assert(
+        ex::memory_alignment_v<ex::simd_mask<T, SimdAbi>> == bit_ceil(sizeof(bool) * ex::simd_size_v<T, SimdAbi>));
+  }
+};
+
+template <class T, std::size_t N>
+struct CheckMemoryAlignmentLongDouble {
+  template <class SimdAbi>
+  void operator()() {
+    if constexpr (std::is_same_v<T, long double>) {
+      // The size of long double is platform-specific. For instance, on i686-w64-mingw32-clang++,
+      // the size of long double is 12 bytes. Hence, disambiguation is needed.
+      static_assert(
+          ex::memory_alignment<ex::simd<T, SimdAbi>>{}.value == bit_ceil(sizeof(T) * ex::simd_size_v<T, SimdAbi>));
+      static_assert(ex::memory_alignment_v<ex::simd<T, SimdAbi>> == bit_ceil(sizeof(T) * ex::simd_size_v<T, SimdAbi>));
+    }
+  }
+};
+
+struct CheckMemAlignmentFixedDeduce {
+  template <class T, std::size_t N>
+  void check() {
+    if constexpr (!std::is_same_v<T, long double>) {
+      static_assert(ex::memory_alignment_v<ex::simd<T, ex::simd_abi::fixed_size<N>>> == sizeof(T) * bit_ceil(N),
+                    "Memory Alignment mismatch with abi fixed_size");
+      static_assert(ex::memory_alignment<ex::simd<T, ex::simd_abi::fixed_size<N>>>{}.value == sizeof(T) * bit_ceil(N),
+                    "Memory Alignment mismatch with abi fixed_size");
+
+      static_assert(ex::memory_alignment_v<ex::simd<T, ex::simd_abi::deduce_t<T, N>>> == sizeof(T) * bit_ceil(N),
+                    "Memory Alignment mismatch with abi deduce");
+      static_assert(ex::memory_alignment<ex::simd<T, ex::simd_abi::deduce_t<T, N>>>{}.value == sizeof(T) * bit_ceil(N),
+                    "Memory Alignment mismatch with abi deduce");
+    }
+  }
+
+  template <class T, std::size_t... N>
+  void performChecks(std::index_sequence<N...>) {
+    (check<T, N + 1>(), ...);
+  }
+
+  template <class T>
+  void operator()() {
+    performChecks<T>(std::make_index_sequence<max_simd_size>{});
+  }
+};
+
+struct CheckMemAlignmentScalarNativeCompatible {
+  template <class T>
+  void operator()() {
+    if constexpr (!std::is_same_v<T, long double>) {
+      static_assert(ex::memory_alignment<ex::simd<T, ex::simd_abi::scalar>>{}.value == sizeof(T));
+      static_assert(ex::memory_alignment_v<ex::simd<T, ex::simd_abi::scalar>> == sizeof(T));
+
+      LIBCPP_STATIC_ASSERT(ex::memory_alignment<ex::simd<T, ex::simd_abi::compatible<T>>>{}.value == 16);
+      LIBCPP_STATIC_ASSERT(ex::memory_alignment_v<ex::simd<T, ex::simd_abi::compatible<T>>> == 16);
+
+      LIBCPP_STATIC_ASSERT(
+          ex::memory_alignment<ex::simd<T, ex::simd_abi::native<T>>>{}.value == _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES);
+      LIBCPP_STATIC_ASSERT(
+          ex::memory_alignment_v<ex::simd<T, ex::simd_abi::native<T>>> == _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES);
+    }
+  }
+};
+
+int main(int, char**) {
+  types::for_each(arithmetic_no_bool_types(), CheckMemAlignmentFixedDeduce());
+  types::for_each(arithmetic_no_bool_types(), CheckMemAlignmentScalarNativeCompatible());
+  test_all_simd_abi<CheckMemoryAlignmentMask>();
+  test_all_simd_abi<CheckMemoryAlignmentLongDouble>();
+  return 0;
+}

libcxx/test/std/experimental/simd/test_utils.h

 #include <utility>
 #include <experimental/simd>
 #include "type_algorithms.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 constexpr std::size_t max_simd_size = 32;
 
 template <template <class T, std::size_t N> class F>
 struct TestAllSimdAbiFunctor {
   template <class T, std::size_t N>
   using sized_abis = types::type_list<ex::simd_abi::fixed_size<N>, ex::simd_abi::deduce_t<T, N>>;
 
   template <class T, std::size_t... Ns>
   void instantiate_with_n(std::index_sequence<Ns...>) {
     (types::for_each(sized_abis<T, Ns + 1>{}, F<T, Ns + 1>{}), ...);
   }
 
   template <class T>
   void operator()() {
     using abis = types::type_list<ex::simd_abi::scalar, ex::simd_abi::native<T>, ex::simd_abi::compatible<T>>;
     types::for_each(abis{}, F<T, 1>());
 
     instantiate_with_n<T>(std::make_index_sequence<max_simd_size - 1>{});
   }
 };
 
 using arithmetic_no_bool_types = types::concatenate_t<types::integer_types, types::floating_point_types>;
 
 template <template <class T, std::size_t N> class Func>
 void test_all_simd_abi() {
   types::for_each(arithmetic_no_bool_types(), TestAllSimdAbiFunctor<Func>());
 }
 
+constexpr size_t bit_ceil(size_t val) {
+  size_t pow = 1;
+  while (pow < val)
+    pow <<= 1;
+  return pow;
+}
+
 #endif // TEST_UTIL_H
 No newline at end of file