[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

36

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

24–30

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

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

26

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

22

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.

23

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

36

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

36

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

22–39

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

66

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 ↗

(On Diff #539989)

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/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::__next_pow_of_2(sizeof(_Up) * _Tp::size());
+
+  template <class _Tp, class _Up>
+  static _LIBCPP_HIDE_FROM_ABI constexpr _Up* __apply(_Up* __ptr) {
+    return static_cast<_Up*>(__builtin_assume_aligned(__ptr, __alignment<_Tp, _Up>));
+  }
+};
+
+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 static_cast<_Up*>(__builtin_assume_aligned(__ptr, _Np));
+  }
+};
+
+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<_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<_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

 
 #if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 inline namespace parallelism_v2 {
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr bool __is_vectorizable() {
   return is_arithmetic_v<_Tp> && !is_const_v<_Tp> && !is_volatile_v<_Tp> && !is_same_v<_Tp, bool>;
 }
+
+// TODO: replace it by std::bit_ceil when bump to C++20
+_LIBCPP_HIDE_FROM_ABI constexpr size_t __next_pow_of_2(size_t __val) {
+  size_t __pow = 1;
+  while (__pow < __val)
+    __pow <<= 1;
+  return __pow;
+}
 } // 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"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+class EmptyEntry {};
+
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  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<_Np>>::value);
+
+  static_assert(!ex::is_simd_flag_type<_Tp>::value);
+  static_assert(!ex::is_simd_flag_type<ex::simd<_Tp, SimdAbi>>::value);
+  static_assert(!ex::is_simd_flag_type<ex::simd_mask<_Tp, 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<_Np>>);
+
+  static_assert(!ex::is_simd_flag_type_v<_Tp>);
+  static_assert(!ex::is_simd_flag_type_v<ex::simd<_Tp, SimdAbi>>);
+  static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<_Tp, SimdAbi>>);
+
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<EmptyEntry>();
+  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 size_t memory_alignment_v = memory_alignment<T, U>::value;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+struct CheckMemoryAlignmentNative {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES);
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES);
+  }
+};
+
+struct CheckMemoryAlignmentCompatible {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == 16);
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == 16);
+  }
+};
+
+struct CheckMemoryAlignmentScalar {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == sizeof(_Tp));
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == sizeof(_Tp));
+  }
+};
+
+struct CheckMemoryAlignmentFixedSize {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == sizeof(_Tp) * next_pow2(_Np));
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == sizeof(_Tp) * next_pow2(_Np));
+  }
+};
+
+struct CheckMemoryAlignmentDeduce {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd<_Tp, SimdAbi>>{}.value == sizeof(_Tp) * next_pow2(_Np));
+    static_assert(ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>> == sizeof(_Tp) * next_pow2(_Np));
+  }
+};
+
+struct CheckMemoryAlignmentMask {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    static_assert(ex::memory_alignment<ex::simd_mask<_Tp, SimdAbi>>{}.value ==
+                  next_pow2(sizeof(bool) * ex::simd_size_v<_Tp, SimdAbi>));
+    static_assert(
+        ex::memory_alignment_v<ex::simd_mask<_Tp, SimdAbi>> == next_pow2(sizeof(bool) * ex::simd_size_v<_Tp, SimdAbi>));
+  }
+};
+
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  if constexpr (std::is_same_v<F, CheckMemoryAlignmentNative>) {
+    F{}.template operator()<_Tp, ex::simd_abi::native<_Tp>, _Np>();
+  } else if constexpr (std::is_same_v<F, CheckMemoryAlignmentCompatible>) {
+    F{}.template operator()<_Tp, ex::simd_abi::compatible<_Tp>, _Np>();
+  } else if constexpr (std::is_same_v<F, CheckMemoryAlignmentScalar>) {
+    F{}.template operator()<_Tp, ex::simd_abi::scalar, _Np>();
+  } else if constexpr (std::is_same_v<F, CheckMemoryAlignmentFixedSize>) {
+    F{}.template operator()<_Tp, ex::simd_abi::fixed_size<_Np>, _Np>();
+  } else {
+    F{}.template operator()<_Tp, ex::simd_abi::deduce_t<_Tp, _Np>, _Np>();
+  }
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckMemoryAlignmentNative>();
+  test_all_simd_abi<CheckMemoryAlignmentCompatible>();
+  test_all_simd_abi<CheckMemoryAlignmentScalar>();
+  test_all_simd_abi<CheckMemoryAlignmentFixedSize>();
+  test_all_simd_abi<CheckMemoryAlignmentFixedSize>();
+  return 0;
+}

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

 #include "type_algorithms.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 constexpr std::size_t max_simd_size = 32;
 
 using arithmetic_no_bool_types = types::concatenate_t<types::integer_types, types::floating_point_types>;
 
+// TODO: replace it by std::bit_ceil when bump to C++20
+constexpr size_t next_pow2(size_t val) {
+  size_t pow = 1;
+  while (pow < val)
+    pow <<= 1;
+  return pow;
+}
+
 template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
 void test_simd_abi();
 
 template <class F, class _Tp>
 void test_native_compatible_scalar() {
   test_simd_abi<F, 1, _Tp, ex::simd_abi::scalar, ex::simd_abi::native<_Tp>, ex::simd_abi::compatible<_Tp>>();
 }
 
struct TestAllSimdAbiFunctor {
   }
 };
 
 template <class F>
 void test_all_simd_abi() {
   types::for_each(arithmetic_no_bool_types(), TestAllSimdAbiFunctor<F>());
 }
 
 #endif // TEST_UTIL_H