[libcxx] implement <experimental/simd> casts.

[timshen]

Summary

Casts are implemented in terms of static_casts and loops.

[timshen]

s/_LIBCPP_HAS_VECTOR_EXTENSION/_LIBCPP_HAS_NO_VECTOR_EXTENSION/

[timshen]

Rebased.

[timshen]

Rebase.

[mclow.lists]

In general, this looks good to me.
I suggested a lot of test improvements, but not very much to the code.
Needs the same kind of namespace changes in the tests as in D41376, but that's a minor thing.

libcxx/include/experimental/simd

1010

Weird indentation in the enable_if

libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp

19

All the tests should #include "test_macros.h"

22

I think this is worth a comment here - "This conversion is deleted so that it prevents ..."

libcxx/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp

33

General comment: We have a macro called ASSERT_SAME_TYPE that makes this clearer.

Instead of all this, you can just write:

ASSERT_SAME_TYPE(decltype(static_simd_cast<simd<float, simd_abi::scalar>>(fixed_size_simd<int, 1>())), simd<float, simd_abi::scalar);

libcxx/test/std/experimental/simd/simd.casts/to_compatible.pass.cpp

40

Since this is an extension, then the test needs to live in test/libcxx, not test/std.
(and should probably be two tests, one in test/std, and one in test/libcxx).

Same for to_native.pass.cpp below.

libcxx/test/std/experimental/simd/simd.casts/to_fixed_size.pass.cpp

31

All of these tests need to check the "noexcept-ness" of the operation.
Fortunately, we have a macro for that, too:

ASSERT_NOEXCEPT (         to_fixed_size(std::declval<native_simd<int>>()));
ASSERT_SAME_TYPE(decltype(to_fixed_size(std::declval<native_simd<int>>())), fixed_size_simd<int, native_simd<int>::size()>);

libcxx/include/experimental/simd

 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
 
 enum class _StorageKind {
   _Scalar,
   _Array,
   _VecExt,
 };
 
-template <_StorageKind __kind, int _Np>
+template <_StorageKind __kind, size_t _Np>
 struct __simd_abi {};
 
 template <class _Tp, class _Abi>
 class __simd_storage {};
 
-template <class _Tp, int __num_element>
+template <class _Tp, size_t __num_element>
 class __simd_storage<_Tp, __simd_abi<_StorageKind::_Array, __num_element>> {
   std::array<_Tp, __num_element> __storage_;
 
 public:
   using reference = _Tp&;
 
   _Tp __get(size_t __index) const { return __storage_[__index]; };
   reference __ref(size_t __index) { return __storage_[__index]; };

 _SPECIALIZE_VEC_EXT_32(unsigned long long);
 _SPECIALIZE_VEC_EXT_32(float);
 _SPECIALIZE_VEC_EXT_32(double);
 _SPECIALIZE_VEC_EXT_32(long double);
 
 #undef _SPECIALIZE_VEC_EXT_32
 #undef _SPECIALIZE_VEC_EXT
 
-template <class _Tp, int __num_element>
+template <class _Tp, size_t __num_element>
 class __simd_storage<_Tp, __simd_abi<_StorageKind::_VecExt, __num_element>> {
   using _StorageType =
       typename __vec_ext_traits<_Tp, __ceil_pow_of_2(sizeof(_Tp) *
                                                      __num_element)>::type;
 
   _StorageType __storage_;
 
 public:
return std::is_arithmetic<_Tp>::value && !std::is_const<_Tp>::value &&
          !std::is_volatile<_Tp>::value && !std::is_same<_Tp, bool>::value;
 }
 
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI
 
 using scalar = __simd_abi<_StorageKind::_Scalar, 1>;
 
-template <int _Np>
+template <size_t _Np>
 using fixed_size = __simd_abi<_StorageKind::_Array, _Np>;
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) &&     \
     !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES)
 template <class _Tp>
-inline constexpr int max_fixed_size = 32;
+inline constexpr size_t max_fixed_size = 32;
 #endif
 
-template <class _Tp>
-using compatible = fixed_size<16 / sizeof(_Tp)>;
+template <class _Tp, size_t _Np>
+using __compatible = fixed_size<_Np>;
 
-template <class _Tp>
-using native =
+template <class _Tp, size_t _Np>
+using __native =
 #ifdef _LIBCPP_HAS_VECTOR_EXTENSION
-    __simd_abi<_StorageKind::_VecExt,
-               _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
+    __simd_abi<_StorageKind::_VecExt, _Np>;
 #else
-    fixed_size<_Tp, _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
+    __simd_abi<_StorageKind::_Array, _Np>;
 #endif
 
+template <class _Tp>
+using compatible = __compatible<_Tp, 16 / sizeof(_Tp)>;
+
+template <class _Tp>
+using native = __native<_Tp, _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
+
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
 
 template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
 class simd;
 template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
 class simd_mask;
 

 #endif
 #endif
 #endif
 
 // traits [simd.traits]
 template <class _Tp>
 struct is_abi_tag : std::integral_constant<bool, false> {};
 
-template <_StorageKind __kind, int _Np>
+template <_StorageKind __kind, size_t _Np>
 struct is_abi_tag<__simd_abi<__kind, _Np>>
     : std::integral_constant<bool, true> {};
 
 template <class _Tp>
 struct is_simd : std::integral_constant<bool, false> {};
 
 template <class _Tp, class _Abi>
 struct is_simd<simd<_Tp, _Abi>> : std::integral_constant<bool, true> {};

 
 // NOTE: _Abis... is the extension proposed by P0820, allowing the APIs to
 // propagate _StorageKind during transforming input type(s) to the output type.
 template <class _Tp, size_t _Np, class... _Abis>
 struct abi_for_size {
   using type = simd_abi::fixed_size<_Np>;
 };
 
-template <class _Tp, size_t _Np, _StorageKind __kind, int... __old_size>
+template <class _Tp, size_t _Np, _StorageKind __kind, size_t... __old_size>
 struct abi_for_size<_Tp, _Np, __simd_abi<__kind, __old_size>...> {
   using type = __simd_abi<__kind, _Np>;
 };
 
 template <class _Tp, size_t _Np, class... _Abis>
 using abi_for_size_t = typename abi_for_size<_Tp, _Np, _Abis...>::type;
 
 template <class _Tp, size_t _Np, class... _Abis>
 using rebind_abi_t = abi_for_size_t<_Tp, _Np, _Abis...>;
 
 template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
 struct simd_size;
 
-template <class _Tp, _StorageKind __kind, int _Np>
+template <class _Tp, _StorageKind __kind, size_t _Np>
 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>
 struct memory_alignment;
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) &&     \
     !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES)
 template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
 inline constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value;
 
 template <class _Tp, class _Up = typename _Tp::value_type>
 inline constexpr size_t memory_alignment_v = memory_alignment<_Tp, _Up>::value;
 #endif
 
 // class template simd [simd.class]
 template <class _Tp>
 using native_simd = simd<_Tp, simd_abi::native<_Tp>>;
-template <class _Tp, int _Np>
+template <class _Tp, size_t _Np>
 using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>;
 
 // class template simd_mask [simd.mask.class]
 template <class _Tp>
 using native_simd_mask = simd_mask<_Tp, simd_abi::native<_Tp>>;
 
-template <class _Tp, int _Np>
+template <class _Tp, size_t _Np>
 using fixed_size_simd_mask = simd_mask<_Tp, simd_abi::fixed_size<_Np>>;
 
 // casts [simd.casts]
 template <class _Tp>
 struct __static_simd_cast_traits {
   template <class _Up, class _Abi>
-  static simd<_Tp, _Abi> __apply(const simd<_Up, _Abi>& __v);
+  static simd<_Tp, _Abi> __apply(const simd<_Up, _Abi>& __v) {
+    return __static_simd_cast_traits<simd<_Tp, _Abi>>::__apply(__v);
+  }
 };
 
 template <class _Tp, class _NewAbi>
 struct __static_simd_cast_traits<simd<_Tp, _NewAbi>> {
   template <class _Up, class _Abi>
   static typename std::enable_if<simd<_Up, _Abi>::size() ==
                                      simd<_Tp, _NewAbi>::size(),
                                  simd<_Tp, _NewAbi>>::type
-  __apply(const simd<_Up, _Abi>& __v);
+  __apply(const simd<_Up, _Abi>& __v) {
+    simd<_Tp, _NewAbi> __ret;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __ret[__i] = static_cast<_Tp>(__v[__i]);
+    }
+    return __ret;
+  }
 };
 
 template <class _Tp>
 struct __simd_cast_traits {
   template <class _Up, class _Abi>
   static typename std::enable_if<
       __is_non_narrowing_arithmetic_convertible<_Up, _Tp>(),
       simd<_Tp, _Abi>>::type
-  __apply(const simd<_Up, _Abi>& __v);
+  __apply(const simd<_Up, _Abi>& __v) {
+    return __static_simd_cast_traits<_Tp>::__apply(__v);
+  }
 };
 
 template <class _Tp, class _NewAbi>
 struct __simd_cast_traits<simd<_Tp, _NewAbi>> {
   template <class _Up, class _Abi>
   static typename std::enable_if<
       __is_non_narrowing_arithmetic_convertible<_Up, _Tp>() &&
           simd<_Up, _Abi>::size() == simd<_Tp, _NewAbi>::size(),
       simd<_Tp, _NewAbi>>::type
-  __apply(const simd<_Up, _Abi>& __v);
+  __apply(const simd<_Up, _Abi>& __v) {
+    return __static_simd_cast_traits<simd<_Tp, _NewAbi>>::__apply(__v);
+  }
 };
 
 template <class _Tp, class _Up, class _Abi>
 auto simd_cast(const simd<_Up, _Abi>& __v)
     -> decltype(__simd_cast_traits<_Tp>::__apply(__v)) {
   return __simd_cast_traits<_Tp>::__apply(__v);
 }
 
 template <class _Tp, class _Up, class _Abi>
 auto static_simd_cast(const simd<_Up, _Abi>& __v)
     -> decltype(__static_simd_cast_traits<_Tp>::__apply(__v)) {
   return __static_simd_cast_traits<_Tp>::__apply(__v);
 }
 
 template <class _Tp, class _Abi>
 fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>
-to_fixed_size(const simd<_Tp, _Abi>&) noexcept;
+to_fixed_size(const simd<_Tp, _Abi>& __v) noexcept {
+  return simd_cast<fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>>(__v);
+}
 
 template <class _Tp, class _Abi>
 fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
 to_fixed_size(const simd_mask<_Tp, _Abi>&) noexcept;
 
+// NOTE: As an extension, allow transforming to a native type with a size
+// that's not native_simd<T>::size().
 template <class _Tp, size_t _Np>
-native_simd<_Tp> to_native(const fixed_size_simd<_Tp, _Np>&) noexcept;
+simd<_Tp, simd_abi::__native<_Tp, _Np>>
+to_native(const fixed_size_simd<_Tp, _Np>& __v) noexcept {
+  return simd_cast<simd<_Tp, simd_abi::__native<_Tp, _Np>>>(__v);
+}
 
 template <class _Tp, size_t _Np>
 native_simd_mask<_Tp> to_native(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
 
+// NOTE: As an extension, allow transforming to a compatible type with a size
+// that's not simd<T>::size().
 template <class _Tp, size_t _Np>
-simd<_Tp> to_compatible(const fixed_size_simd<_Tp, _Np>&) noexcept;
+simd<_Tp, simd_abi::__compatible<_Tp, _Np>>
+to_compatible(const fixed_size_simd<_Tp, _Np>& __v) noexcept {
+  return simd_cast<simd<_Tp, simd_abi::__compatible<_Tp, _Np>>>(__v);
+}
 
 template <class _Tp, size_t _Np>
 simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
 
 template <class _TupleType, class _Tp, size_t... __indicies>
 _TupleType __split_tuple_impl(_Tp** __buffers,
                               std::index_sequence<__indicies...>) {
   return _TupleType(typename std::tuple_element<__indicies, _TupleType>::type(

libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp

 
 // <experimental/simd>
 //
 // [simd.casts]
 // template <class T, class U, class Abi> see below simd_cast(const simd<U, Abi>&);
 
 #include <experimental/simd>
 #include <cstdint>
 
 using namespace std::experimental::parallelism_v2;
 
+template <class T, class... Args>
+auto unsupported_cast(Args&&... args)
+    -> decltype(simd_cast<T>(std::forward<Args>(args)...), void()) = delete;
+
 static_assert(std::is_same<decltype(simd_cast<int32_t>(native_simd<int32_t>())),
                            native_simd<int32_t>>::value,
               "");
 
 static_assert(
     std::is_same<decltype(simd_cast<int64_t>(fixed_size_simd<int32_t, 4>())),
                  fixed_size_simd<int64_t, 4>>::value,
     "");
 
 static_assert(std::is_same<decltype(simd_cast<fixed_size_simd<int64_t, 1>>(
                                simd<int32_t, simd_abi::scalar>())),
                            fixed_size_simd<int64_t, 1>>::value,
               "");
 
 static_assert(std::is_same<decltype(simd_cast<simd<int64_t, simd_abi::scalar>>(
                                fixed_size_simd<int32_t, 1>())),
                            simd<int64_t, simd_abi::scalar>>::value,
               "");
 
+template <class T>
+void unsupported_cast(...) {}
+
+void compile_narrowing_convert() {
+  unsupported_cast<float>(native_simd<int>());
+  unsupported_cast<int>(native_simd<float>());
+  unsupported_cast<int8_t>(native_simd<int32_t>());
+  unsupported_cast<bool>(native_simd<int32_t>());
+  unsupported_cast<fixed_size_simd<int, 2>>(fixed_size_simd<int, 4>());
+}
+
+void compile_abi_convert() {
+  constexpr size_t ratio = native_simd<int>::size() / simd<int>::size();
+  std::array<simd<int>, ratio> arr;
+
+  auto res = concat(arr);
+  static_assert(!std::is_same<decltype(res), native_simd<int>>::value, "");
+
+  (void)simd_cast<native_simd<int>>(res);
+}
+
 int main() {}

libcxx/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp

static_assert(
     "");
 
 static_assert(std::is_same<decltype(static_simd_cast<fixed_size_simd<float, 1>>(
                                simd<int, simd_abi::scalar>())),
                            fixed_size_simd<float, 1>>::value,
               "");
 
 static_assert(
     std::is_same<decltype(static_simd_cast<simd<float, simd_abi::scalar>>(
                      fixed_size_simd<int, 1>())),
                  simd<float, simd_abi::scalar>>::value,
     "");
 
-int main() {}
+void test_int_float_convert() {
+  assert(static_simd_cast<float>(native_simd<int>(16))[0] == 16.);
+  assert(static_simd_cast<int>(native_simd<float>(15.2f))[0] == 15);
+  assert(static_simd_cast<int>(native_simd<float>(15.9f))[0] == 15);
+}
+
+void test_narrowing_convert() {
+  assert(static_simd_cast<unsigned char>(native_simd<signed char>(-10))[0] ==
+         246);
+  assert(static_simd_cast<signed char>(native_simd<unsigned char>(246))[0] ==
+         -10);
+  assert(static_simd_cast<unsigned char>(native_simd<signed char>(127))[0] ==
+         127);
+  assert(static_simd_cast<signed char>(native_simd<unsigned char>(127))[0] ==
+         127);
+  assert(static_simd_cast<unsigned char>(native_simd<unsigned int>(257))[0] ==
+         1);
+  assert(static_simd_cast<signed char>(native_simd<signed int>(254))[0] == -2);
+}
+
+int main() {
+  test_int_float_convert();
+  test_narrowing_convert();
+}

libcxx/test/std/experimental/simd/simd.casts/to_compatible.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.casts]
+//
+// template <class T, size_t N> simd<T>
+// to_compatible(const fixed_size_simd<T, N>&) noexcept;
+//
+// template <class T, size_t N> simd_mask<T>
+// to_compatible(const fixed_size_simd_mask<T, N>&) noexcept;
+
+#include <experimental/simd>
+#include <cstdint>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_to_compatible() {
+  auto v = to_compatible(
+      fixed_size_simd<int, simd<int>::size()>([](int i) { return i; }));
+  simd<int> w([](int i) { return i; });
+
+  static_assert(std::is_same<decltype(v), decltype(w)>::value, "");
+
+  for (size_t i = 0; i < v.size(); i++) {
+    assert(v[i] == w[i]);
+  }
+}
+
+void test_to_compatible_extension() {
+  auto arr = split_by<32 / simd<int>::size()>(
+      to_compatible(fixed_size_simd<int, 32>([](int i) { return i; })));
+  static_assert(std::is_same<decltype(arr)::value_type, simd<int>>::value, "");
+  int v = 0;
+  for (size_t i = 0; i < arr.size(); i++) {
+    for (size_t j = 0; j < arr[0].size(); j++) {
+      assert(arr[i][j] == v);
+      v++;
+    }
+  }
+}
+
+int main() {
+  test_to_compatible();
+  test_to_compatible_extension();
+}

libcxx/test/std/experimental/simd/simd.casts/to_fixed_size.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.casts]
+//
+// template <class T, class Abi>
+// fixed_size_simd<T, simd_size_v<T, Abi>>
+// to_fixed_size(const simd<T, Abi>&) noexcept;
+//
+// template <class T, class Abi>
+// fixed_size_simd_mask<T, simd_size_v<T, Abi>>
+// to_fixed_size(const simd_mask<T, Abi>&) noexcept;
+
+#include <experimental/simd>
+#include <cstdint>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_to_fixed_size() {
+  auto v = to_fixed_size(native_simd<int>([](int i) { return i; }));
+  static_assert(std::is_same<fixed_size_simd<int, native_simd<int>::size()>,
+                             decltype(v)>::value,
+                "");
+
+  for (size_t i = 0; i < v.size(); i++) {
+    assert(v[i] == (int)i);
+  }
+}
+
+int main() { test_to_fixed_size(); }

libcxx/test/std/experimental/simd/simd.casts/to_native.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.casts]
+//
+// template <class T, size_t N>
+// native_simd<T> to_native(const fixed_size_simd<T, N>&) noexcept;
+//
+// template <class T, size_t N>
+// native_simd_mask<T> to_native(const fixed_size_simd_mask<T, N>&) noexcept;
+
+#include <experimental/simd>
+#include <cstdint>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_to_native() {
+  auto v = to_native(
+      fixed_size_simd<int, native_simd<int>::size()>([](int i) { return i; }));
+  native_simd<int> w([](int i) { return i; });
+
+  static_assert(std::is_same<decltype(v), decltype(w)>::value, "");
+
+  for (size_t i = 0; i < v.size(); i++) {
+    assert(v[i] == w[i]);
+  }
+}
+
+void test_to_native_extension() {
+  auto arr = split_by<32 / native_simd<int>::size()>(
+      to_native(fixed_size_simd<int, 32>([](int i) { return i; })));
+  static_assert(
+      std::is_same<decltype(arr)::value_type, native_simd<int>>::value, "");
+  int v = 0;
+  for (size_t i = 0; i < arr.size(); i++) {
+    for (size_t j = 0; j < arr[0].size(); j++) {
+      assert(arr[i][j] == v);
+      v++;
+    }
+  }
+}
+
+int main() {
+  test_to_native();
+  test_to_native_extension();
+}