[libcxx: experimental::simd] Support binary operations

[grosser]

Summary

This adds support for the following binary operations

simd operator+(simd, simd);
simd operator-(simd, simd);
simd operator*(simd, simd);
simd operator/(simd, simd);
simd operator%(simd, simd);
simd operator&(simd, simd);
simd operator|(simd, simd);
simd operator^(simd, simd);
simd operator<<(simd, simd);
simd operator>>(simd, simd);
simd operator<<(simd, int);
simd operator>>(simd, int);

In case the _VecExt storage type is used native vector operations are
directly used.

[This patch likely needs some more work to make it compile in case no vector
extensions are available. Before I work out all these things by myself, I
wanted to check if a) tim has already a similar patch in his pipeline,
b) there are certain conventions I should pay attention to]

[timshen]

a) tim has already a similar patch in his pipeline

Yes, I had a full stack of patches (using the dependency feature of Phab), starting with D41412, that implements the whole proposal up to some version (and it's not the latest version), but the patches got into both mclow's and my back-burners sooner than expected.

b) there are certain conventions I should pay attention to

No as of my memory. The review of my stack of patches didn't go that far.

[grosser]

In D64702#1586229, @timshen wrote:

a) tim has already a similar patch in his pipeline

Yes, I had a full stack of patches (using the dependency feature of Phab), starting with D41412, that implements the whole proposal up to some version (and it's not the latest version), but the patches got into both mclow's and my back-burners sooner than expected.

Nice. I looked through your patches and they seem to be very well engineered. We are currently developing code which would very much benefit from std::experimental::simd (and an optimized variant based on LLVM vector types).

b) there are certain conventions I should pay attention to

No as of my memory. The review of my stack of patches didn't go that far.

Any chance I can motivate you to get the patch review process going again. I would be very interested in using (and potentially further optimizing) ex::simd.

[grosser]

Tim's patches look a lot more polished and are better in line with the initial ::simd code he contributed. I feel development should be continued on Tim's patches.

libcxx/include/experimental/simd

 
 enum class _StorageKind {
   _Scalar,
   _Array,
   _VecExt,
 };
 
 template <_StorageKind __kind, int _Np>
-struct __simd_abi {};
+struct __simd_abi {
+  static constexpr _StorageKind kind = __kind;
+};
 
 template <class _Tp, class _Abi>
 class __simd_storage {};
 
 template <class _Tp, int __num_element>
 class __simd_storage<_Tp, __simd_abi<_StorageKind::_Array, __num_element>> {
-  std::array<_Tp, __num_element> __storage_;
+  using _StorageType = std::array<_Tp, __num_element>;
+  _StorageType __storage_;
 
   template <class, class>
   friend struct simd;
 
   template <class, class>
   friend struct simd_mask;
 
 public:
   _Tp __get(size_t __index) const noexcept { return __storage_[__index]; };
   void __set(size_t __index, _Tp __val) noexcept {
     __storage_[__index] = __val;
   }
 };
 
 template <class _Tp>
 class __simd_storage<_Tp, __simd_abi<_StorageKind::_Scalar, 1>> {
-  _Tp __storage_;
+  using _StorageType = _Tp;
+  _StorageType __storage_;
 
   template <class, class>
   friend struct simd;
 
   template <class, class>
   friend struct simd_mask;
 
 public:
public:
 
   static constexpr size_t size() noexcept {
     return simd_size<_Tp, _Abi>::value;
   }
 
 private:
   __simd_storage<_Tp, _Abi> __s_;
 
+  const typename __simd_storage<_Tp, _Abi>::_StorageType &__raw_storage() const {
+    return __s_.__storage_;
+  }
+
+  typename __simd_storage<_Tp, _Abi>::_StorageType &__raw_storage() {
+    return __s_.__storage_;
+  }
+
   template <class _Up>
   static constexpr bool __can_broadcast() {
     return (std::is_arithmetic<_Up>::value &&
             __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) ||
            (!std::is_arithmetic<_Up>::value &&
             std::is_convertible<_Up, _Tp>::value) ||
            std::is_same<typename std::remove_const<_Up>::type, int>::value ||
            (std::is_same<typename std::remove_const<_Up>::type,
public:
   simd& operator--();
   simd operator--(int);
   mask_type operator!() const;
   simd operator~() const;
   simd operator+() const;
   simd operator-() const;
 
   // binary operators [simd.binary]
-  friend simd operator+(const simd&, const simd&);
-  friend simd operator-(const simd&, const simd&);
-  friend simd operator*(const simd&, const simd&);
-  friend simd operator/(const simd&, const simd&);
-  friend simd operator%(const simd&, const simd&);
-  friend simd operator&(const simd&, const simd&);
-  friend simd operator|(const simd&, const simd&);
-  friend simd operator^(const simd&, const simd&);
-  friend simd operator<<(const simd&, const simd&);
-  friend simd operator>>(const simd&, const simd&);
-  friend simd operator<<(const simd&, int);
-  friend simd operator>>(const simd&, int);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator+(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator-(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator*(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator-(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator/(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator%(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator&(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator|(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator^(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator<<(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator>>(const simd<_Tp2, _Abi2> &, const simd<_Tp2, _Abi2>&);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator<<(const simd<_Tp2, _Abi2> &, int);
+  template <class _Tp2, class _Abi2>
+  friend simd<_Tp2, _Abi2> operator>>(const simd<_Tp2, _Abi2> &, int);
 
   // compound assignment [simd.cassign]
   friend simd& operator+=(simd&, const simd&);
   friend simd& operator-=(simd&, const simd&);
   friend simd& operator*=(simd&, const simd&);
   friend simd& operator/=(simd&, const simd&);
   friend simd& operator%=(simd&, const simd&);
 
public:
   friend mask_type operator==(const simd&, const simd&);
   friend mask_type operator!=(const simd&, const simd&);
   friend mask_type operator>=(const simd&, const simd&);
   friend mask_type operator<=(const simd&, const simd&);
   friend mask_type operator>(const simd&, const simd&);
   friend mask_type operator<(const simd&, const simd&);
 };
 
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator+(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+
+  if constexpr (_Abi::kind == _StorageKind::_VecExt) {
+    res.__raw_storage() = A.__raw_storage() + B.__raw_storage();
+  } else {
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] + B[i];
+  }
+
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator-(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() - B.__raw_storage();
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] - B[i];
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator*(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() * B.__raw_storage();
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] * B[i];
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator/(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() / B.__raw_storage();
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] / B[i];
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator%(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() % B.__raw_storage();
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] % B[i];
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator&(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() & B.__raw_storage();
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] & B[i];
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator|(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() | B.__raw_storage();
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] | B[i];
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator^(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() ^ B.__raw_storage();
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] ^ B[i];
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator<<(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() << B.__raw_storage();
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] << B[i];
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator<<(const simd<_Tp, _Abi> &A, int B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() << B;
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] << B;
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator>>(const simd<_Tp, _Abi> &A, const simd<_Tp, _Abi> &B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() >> B.__raw_storage();
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] >> B[i];
+  return res;
+}
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> operator>>(const simd<_Tp, _Abi> &A, int B) {
+  simd<_Tp, _Abi> res;
+  if constexpr (_Abi::kind == _StorageKind::_VecExt)
+    res.__raw_storage() = A.__raw_storage() >> B;
+  else
+    for (size_t i = 0; i < A.size(); i++)
+      res[i] = A[i] >> B;
+  return res;
+}
+
 // [simd.mask.class]
 template <class _Tp, class _Abi>
 // TODO: implement simd_mask
 class simd_mask {
 public:
   using value_type = bool;
   // TODO: this is strawman implementation. Turn it into a proxy type.
   using reference = bool&;

libcxx/test/std/experimental/simd/simd.operand/default.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++98, c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// simd operator+(simd, simd);
+// simd operator-(simd, simd);
+// simd operator*(simd, simd);
+// simd operator/(simd, simd);
+// simd operator%(simd, simd);
+// simd operator&(simd, simd);
+// simd operator|(simd, simd);
+// simd operator^(simd, simd);
+// simd operator<<(simd, simd);
+// simd operator>>(simd, simd);
+// simd operator<<(simd, int);
+// simd operator>>(simd, int);
+
+#include <experimental/simd>
+#include <cassert>
+#include <cstdint>
+
+#include "test_macros.h"
+
+namespace ex = std::experimental::parallelism_v2;
+
+template <typename SimdType>
+void test_operand() {
+  SimdType a, b;
+
+  for (size_t i = 0; i < a.size(); i++) {
+    a[i] = 1 + 7 * i;
+    b[i] = 2 + i;
+  }
+
+  {
+    auto c = a + b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == a[i] + b[i]);
+  }
+  {
+    auto c = a - b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == a[i] - b[i]);
+  }
+  {
+    auto c = a * b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == a[i] * b[i]);
+  }
+  {
+    auto c = a / b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == a[i] / b[i]);
+  }
+  {
+    auto c = a % b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == a[i] % b[i]);
+  }
+  {
+    auto c = a & b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == (a[i] & b[i]));
+  }
+  {
+    auto c = a | b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == (a[i] | b[i]));
+  }
+  {
+    auto c = a ^ b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == (a[i] ^ b[i]));
+  }
+  {
+    auto c = a << b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == (a[i] << b[i]));
+  }
+  {
+    auto c = a >> b;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == (a[i] >> b[i]));
+  }
+  {
+    auto c = a << 1;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == (a[i] << 1));
+  }
+  {
+    auto c = a >> 1;
+    for (size_t i = 0; i < a.size(); i++)
+      assert(c[i] == (a[i] >> 1));
+  }
+}
+
+int main(int, char**) {
+  test_operand<ex::simd<int, ex::simd_abi::scalar>>();
+  test_operand<ex::native_simd<int>>();
+  test_operand<ex::fixed_size_simd<int, 4>>();
+
+  return 0;
+}