stdsimd.hh

Go to the documentation of this file.

// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_COMMON_SIMD_STDSIMD_HH
#define DUNE_COMMON_SIMD_STDSIMD_HH
 
#include <dune-common-config.hh> // DUNE_HAVE_CXX_EXPERIMENTAL_SIMD
 
#if DUNE_HAVE_CXX_EXPERIMENTAL_SIMD
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
#include <experimental/simd>
 
#include <dune/common/indices.hh>
#include <dune/common/simd/base.hh>
#include <dune/common/simd/defaults.hh> // for anyFalse()
#include <dune/common/simd/loop.hh>
#include <dune/common/simd/valueproxy.hh>
#include <dune/common/typetraits.hh>
 
namespace Dune {
  namespace Simd {
 
    namespace StdSimdImpl {
 
      namespace stdx = std::experimental;
 
      template<class V>
      struct IsMask : std::bool_constant<stdx::is_simd_mask_v<V> > {};
 
      template<class V>
      struct IsVector
        : std::bool_constant<stdx::is_simd_v<V> || stdx::is_simd_mask_v<V> >
      {};
 
      template<class T>
      struct IsVectorizable
        : std::bool_constant<std::is_arithmetic<T>::value &&
                             !std::is_same<T, bool>::value> {};
 
      template<class V, class = void>
      struct VectorType { using type = V; };
 
      template<class M>
      struct VectorType<M, std::enable_if_t<IsMask<M>::value> >
      {
        using type = typename M::simd_type;
      };
 
 
      template<class Proxy, class ValueType>
      struct ProxyOperations
      {
        using value_type = ValueType;
 
#define DUNE_SIMD_STDSIMD_BINARY(OP)                                    \
        template<class T, class Abi>                                    \
        friend auto operator OP(const stdx::simd<T, Abi> &l, Proxy&& r) \
          -> decltype(l OP std::declval<value_type>())                  \
        {                                                               \
          return l OP value_type(r);                                    \
        }                                                               \
        template<class T, class Abi>                                    \
        friend auto operator OP(Proxy&& l, const stdx::simd<T, Abi> &r) \
          -> decltype(std::declval<value_type>() OP r)                  \
        {                                                               \
          return value_type(l) OP r;                                    \
        }
 
        DUNE_SIMD_STDSIMD_BINARY(*);
        DUNE_SIMD_STDSIMD_BINARY(/);
        DUNE_SIMD_STDSIMD_BINARY(%);
        DUNE_SIMD_STDSIMD_BINARY(+);
        DUNE_SIMD_STDSIMD_BINARY(-);
        DUNE_SIMD_STDSIMD_BINARY(<<);
        DUNE_SIMD_STDSIMD_BINARY(>>);
        DUNE_SIMD_STDSIMD_BINARY(&);
        DUNE_SIMD_STDSIMD_BINARY(^);
        DUNE_SIMD_STDSIMD_BINARY(|);
        DUNE_SIMD_STDSIMD_BINARY(<);
        DUNE_SIMD_STDSIMD_BINARY(>);
        DUNE_SIMD_STDSIMD_BINARY(<=);
        DUNE_SIMD_STDSIMD_BINARY(>=);
        DUNE_SIMD_STDSIMD_BINARY(==);
        DUNE_SIMD_STDSIMD_BINARY(!=);
#undef DUNE_SIMD_STDSIMD_BINARY
 
#define DUNE_SIMD_STDSIMD_ASSIGN(OP)                                    \
        template<class T, class Abi>                                    \
        friend auto operator OP(stdx::simd<T, Abi> &l, Proxy&& r)       \
          -> decltype(l OP std::declval<value_type>())                  \
        {                                                               \
          return l OP value_type(r);                                    \
        }
 
        DUNE_SIMD_STDSIMD_ASSIGN(*=);
        DUNE_SIMD_STDSIMD_ASSIGN(/=);
        DUNE_SIMD_STDSIMD_ASSIGN(%=);
        DUNE_SIMD_STDSIMD_ASSIGN(+=);
        DUNE_SIMD_STDSIMD_ASSIGN(-=);
        DUNE_SIMD_STDSIMD_ASSIGN(&=);
        DUNE_SIMD_STDSIMD_ASSIGN(^=);
        DUNE_SIMD_STDSIMD_ASSIGN(|=);
        DUNE_SIMD_STDSIMD_ASSIGN(<<=);
        DUNE_SIMD_STDSIMD_ASSIGN(>>=);
#undef DUNE_SIMD_STDSIMD_ASSIGN
      };
 
      template<class V>
      using Proxy = Impl::ValueProxy<V, ProxyOperations>;
 
    } // namespace StdSimdImpl
 
    namespace Overloads {
 
 
      template<class V>
      struct ScalarType<V,
                        std::enable_if_t<StdSimdImpl::IsVector<V>::value> >
      {
        using type = typename V::value_type;
      };
 
 
      template<class V>
      struct RebindType<Simd::Scalar<V>, V,
                        std::enable_if_t<StdSimdImpl::IsVector<V>::value> >
      {
        using type = V;
      };
 
 
      template<class V>
      struct RebindType<bool, V,
                        std::enable_if_t<StdSimdImpl::IsVector<V>::value &&
                                         !StdSimdImpl::IsMask<V>::value> >
      {
        using type = typename V::mask_type;
      };
 
 
      template<class M>
      struct RebindType<Scalar<typename M::simd_type>, M,
                        std::enable_if_t<StdSimdImpl::IsMask<M>::value> >
      {
        using type = typename M::simd_type;
      };
 
 
      template<class S, class V>
      struct RebindType<S, V,
                        std::enable_if_t<
                          StdSimdImpl::IsVector<V>::value &&
                          StdSimdImpl::IsVectorizable<S>::value &&
                          !std::is_same<
                            S, Scalar<typename StdSimdImpl::VectorType<V>::type>
                            >::value> >
      {
        using type = std::experimental::rebind_simd_t<
          S, typename StdSimdImpl::VectorType<V>::type>;
      };
 
 
      template<class S, class V>
      struct RebindType<S, V,
                        std::enable_if_t<
                          StdSimdImpl::IsVector<V>::value &&
                          !StdSimdImpl::IsVectorizable<S>::value &&
                          !std::is_same<S, bool>::value &&
                          !std::is_same<S, Scalar<V> >::value> >
      {
        using type = LoopSIMD<S, Simd::lanes<V>()>;
      };
 
 
      template<class V>
      struct LaneCount<V,
                       std::enable_if_t<StdSimdImpl::IsVector<V>::value> >
        : public index_constant<V::size()>
      { };
 
      template<class V>
      StdSimdImpl::Proxy<V> lane(ADLTag<5, StdSimdImpl::IsVector<V>::value>,
                                 std::size_t l, V &v)
      {
        return { l, v };
      }
 
      template<class V>
      Scalar<V> lane(ADLTag<5, StdSimdImpl::IsVector<V>::value>,
                     std::size_t l, const V &v)
      {
        return v[l];
      }
 
      template<class V,
               class = std::enable_if_t<!std::is_reference<V>::value> >
      Scalar<V> lane(ADLTag<5, StdSimdImpl::IsVector<V>::value>,
                     std::size_t l, V &&v)
      {
        return std::as_const(v)[l];
      }
 
      template<class V>
      V cond(ADLTag<5, StdSimdImpl::IsVector<V>::value>,
             const Mask<V> &mask, const V &ifTrue, const V &ifFalse)
      {
        V result = ifFalse;
        std::experimental::where(mask, result) = ifTrue;
        return result;
      }
 
      template<class V>
      V max(ADLTag<5, StdSimdImpl::IsVector<V>::value &&
                      !StdSimdImpl::IsMask<V>::value>,
            const V &v1, const V &v2)
      {
        return std::experimental::max(v1, v2);
      }
 
      template<class M>
      M max(ADLTag<5, StdSimdImpl::IsMask<M>::value>,
            const M &m1, const M &m2)
      {
        return m1 || m2;
      }
 
      template<class V>
      V min(ADLTag<5, StdSimdImpl::IsVector<V>::value &&
                      !StdSimdImpl::IsMask<V>::value>,
            const V &v1, const V &v2)
      {
        return std::experimental::min(v1, v2);
      }
 
      template<class M>
      M min(ADLTag<5, StdSimdImpl::IsMask<M>::value>,
            const M &m1, const M &m2)
      {
        return m1 && m2;
      }
 
      template<class M>
      bool anyTrue (ADLTag<5, StdSimdImpl::IsMask<M>::value>, const M &mask)
      {
        return std::experimental::any_of(mask);
      }
 
      template<class M>
      bool allTrue (ADLTag<5, StdSimdImpl::IsMask<M>::value>, const M &mask)
      {
        return std::experimental::all_of(mask);
      }
 
      // anyFalse() is handled by defaults.hh
 
      template<class M>
      bool allFalse(ADLTag<5, StdSimdImpl::IsMask<M>::value>, const M &mask)
      {
        return std::experimental::none_of(mask);
      }
 
      template<class V>
      auto max(ADLTag<5, StdSimdImpl::IsVector<V>::value &&
                         !StdSimdImpl::IsMask<V>::value>,
               const V &v)
      {
        return std::experimental::hmax(v);
      }
 
      template<class M>
      bool max(ADLTag<5, StdSimdImpl::IsMask<M>::value>, const M &mask)
      {
        return std::experimental::any_of(mask);
      }
 
      template<class V>
      auto min(ADLTag<5, StdSimdImpl::IsVector<V>::value &&
                         !StdSimdImpl::IsMask<V>::value>,
               const V &v)
      {
        return std::experimental::hmin(v);
      }
 
      template<class M>
      bool min(ADLTag<5, StdSimdImpl::IsMask<M>::value>, const M &mask)
      {
        return std::experimental::all_of(mask);
      }
 
      template<class S1, class V2>
      auto maskAnd(ADLTag<5, std::is_same<Mask<S1>, bool>::value &&
                             StdSimdImpl::IsVector<V2>::value>,
                   const S1 &s1, const V2 &v2)
      {
        return Simd::Mask<V2>(Simd::mask(s1)) && Simd::mask(v2);
      }
 
      template<class V1, class S2>
      auto maskAnd(ADLTag<5, StdSimdImpl::IsVector<V1>::value &&
                             std::is_same<Mask<S2>, bool>::value>,
                   const V1 &v1, const S2 &s2)
      {
        return Simd::mask(v1) && Simd::Mask<V1>(Simd::mask(s2));
      }
 
      template<class S1, class V2>
      auto maskOr(ADLTag<5, std::is_same<Mask<S1>, bool>::value &&
                            StdSimdImpl::IsVector<V2>::value>,
                  const S1 &s1, const V2 &v2)
      {
        return Simd::Mask<V2>(Simd::mask(s1)) || Simd::mask(v2);
      }
 
      template<class V1, class S2>
      auto maskOr(ADLTag<5, StdSimdImpl::IsVector<V1>::value &&
                            std::is_same<Mask<S2>, bool>::value>,
                  const V1 &v1, const S2 &s2)
      {
        return Simd::mask(v1) || Simd::Mask<V1>(Simd::mask(s2));
      }
 
 
    } // namespace Overloads
 
  } // namespace Simd
 
  /*
   * Specialize IsNumber for std::experimental::simd to be able to use it as a
   * scalar in DenseMatrix etc.
   */
  template<class T, class Abi>
  struct IsNumber<std::experimental::simd<T, Abi> >
    : public std::integral_constant<bool, IsNumber<T>::value> {
  };
 
} // namespace Dune
 
#endif // DUNE_HAVE_CXX_EXPERIMENTAL_SIMD
 
#endif // DUNE_COMMON_SIMD_STDSIMD_HH