dune-common 2.9.0
Loading...
Searching...
No Matches
Classes | Functions
Dune::Simd::Overloads Namespace Reference

Namespace for the overloads and specializations that make up a SIMD implementation. More...

Classes

struct  ADLTag
 Tag used to force late-binding lookup in Dune::Simd::Overloads. More...
 
struct  ADLTag< 0 >
 
struct  ADLTag< i >
 
struct  LaneCount
 should be derived from a Dune::index_constant More...
 
struct  LaneCount< AlignedNumber< T, align > >
 
struct  LaneCount< LoopSIMD< T, S, A > >
 
struct  LaneCount< V, std::enable_if_t< VcImpl::IsVector< V >::value > >
 should be derived from an Dune::index_constant More...
 
struct  RebindType
 should have a member type type More...
 
struct  RebindType< bool, V, std::enable_if_t< VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value > >
 should have a member type type More...
 
struct  RebindType< S, M, std::enable_if_t< VcImpl::IsMask< M >::value &&VcImpl::IsVectorizable< S >::value &&!std::is_same< S, Scalar< typename M::Vector > >::value > >
 should have a member type type More...
 
struct  RebindType< S, V, std::enable_if_t< VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value &&VcImpl::IsVectorizable< S >::value &&!std::is_same< S, Scalar< V > >::value > >
 should have a member type type More...
 
struct  RebindType< S, V, std::enable_if_t< VcImpl::IsVector< V >::value &&!VcImpl::IsVectorizable< S >::value &&!std::is_same< S, bool >::value &&!std::is_same< S, Scalar< V > >::value > >
 should have a member type type More...
 
struct  RebindType< Scalar< typename M::Vector >, M, std::enable_if_t< VcImpl::IsMask< M >::value > >
 should have a member type type More...
 
struct  RebindType< Simd::Scalar< V >, V, std::enable_if_t< VcImpl::IsVector< V >::value > >
 should have a member type type More...
 
struct  RebindType< U, AlignedNumber< T, align > >
 
struct  RebindType< U, LoopSIMD< T, S, A > >
 
struct  ScalarType
 should have a member type type More...
 
struct  ScalarType< AlignedNumber< T, align > >
 
struct  ScalarType< LoopSIMD< T, S, A > >
 
struct  ScalarType< V, std::enable_if_t< VcImpl::IsVector< V >::value > >
 should have a member type type More...
 

Functions

template<class T , std::size_t align>
T & lane (ADLTag< 5 >, std::size_t l, AlignedNumber< T, align > &v)
 
template<class T , std::size_t align>
lane (ADLTag< 5 >, std::size_t l, const AlignedNumber< T, align > &v)
 
template<class T , std::size_t align>
const AlignedNumber< T, align > & cond (ADLTag< 5 >, AlignedNumber< bool, align > mask, const AlignedNumber< T, align > &ifTrue, const AlignedNumber< T, align > &ifFalse)
 
template<std::size_t align>
bool anyTrue (ADLTag< 5 >, const AlignedNumber< bool, align > &mask)
 
template<class T , std::size_t S, std::size_t A>
auto lane (ADLTag< 5 >, std::size_t l, LoopSIMD< T, S, A > &&v) -> decltype(std::move(Simd::lane(l%lanes< T >(), v[l/lanes< T >()])))
 
template<class T , std::size_t S, std::size_t A>
auto lane (ADLTag< 5 >, std::size_t l, const LoopSIMD< T, S, A > &v) -> decltype(Simd::lane(l%lanes< T >(), v[l/lanes< T >()]))
 
template<class T , std::size_t S, std::size_t A>
auto lane (ADLTag< 5 >, std::size_t l, LoopSIMD< T, S, A > &v) -> decltype(Simd::lane(l%lanes< T >(), v[l/lanes< T >()]))
 
template<class T , std::size_t S, std::size_t AM, std::size_t AD>
auto cond (ADLTag< 5 >, Simd::Mask< LoopSIMD< T, S, AM > > mask, LoopSIMD< T, S, AD > ifTrue, LoopSIMD< T, S, AD > ifFalse)
 
template<class M , class T , std::size_t S, std::size_t A>
auto cond (ADLTag< 5, std::is_same< bool, Simd::Scalar< M > >::value &&Simd::lanes< M >()==Simd::lanes< LoopSIMD< T, S, A > >()>, M mask, LoopSIMD< T, S, A > ifTrue, LoopSIMD< T, S, A > ifFalse)
 
template<class M , std::size_t S, std::size_t A>
bool anyTrue (ADLTag< 5 >, LoopSIMD< M, S, A > mask)
 
template<class M , std::size_t S, std::size_t A>
bool allTrue (ADLTag< 5 >, LoopSIMD< M, S, A > mask)
 
template<class M , std::size_t S, std::size_t A>
bool anyFalse (ADLTag< 5 >, LoopSIMD< M, S, A > mask)
 
template<class M , std::size_t S, std::size_t A>
bool allFalse (ADLTag< 5 >, LoopSIMD< M, S, A > mask)
 
Overloadable and default functions

This group contains functions that you, as an abstraction developer, must implement. All functions that are deleted must be provided, functions that have a default implementation may be left unimplemented if the default behaviour is satisfactory.

template<class V >
decltype(auto) lane (ADLTag< 0 >, std::size_t l, V v)=delete
 implements Simd::lane()
 
template<class V >
constexpr V implCast (ADLTag< 0 >, MetaType< V >, const V &u)
 implements Simd::implCast<V>(V)
 
template<class V , class U >
constexpr V implCast (ADLTag< 0 >, MetaType< V >, const U &u)
 implements Simd::implCast<V>(U)
 
template<class V , class S >
auto broadcast (ADLTag< 0 >, MetaType< V >, S s)
 implements Simd::broadcast<V>()
 
template<class V >
cond (ADLTag< 0 >, const Mask< V > &mask, const V &ifTrue, const V &ifFalse)=delete
 implements Simd::cond()
 
template<class V >
auto max (ADLTag< 0 >, const V &v1, const V &v2)
 implements binary Simd::max()
 
template<class V >
auto min (ADLTag< 0 >, const V &v1, const V &v2)
 implements binary Simd::min()
 
template<class Mask >
bool anyTrue (ADLTag< 0 >, const Mask &mask)=delete
 implements Simd::anyTrue()
 
template<class Mask >
bool allTrue (ADLTag< 0 >, const Mask &mask)
 implements Simd::allTrue()
 
template<class Mask >
bool anyFalse (ADLTag< 0 >, const Mask &mask)
 implements Simd::anyFalse()
 
template<class Mask >
bool allFalse (ADLTag< 0 >, const Mask &mask)
 implements Simd::allFalse()
 
template<class V >
auto max (ADLTag< 0 >, const V &v)
 implements Simd::maxValue()
 
template<class V >
auto min (ADLTag< 0 >, const V &v)
 implements Simd::minValue()
 
template<class V >
Mask< V > mask (ADLTag< 0, std::is_same< V, Mask< V > >::value >, const V &v)
 implements Simd::mask()
 
template<class V >
auto mask (ADLTag< 0, !std::is_same< V, Mask< V > >::value >, const V &v)
 implements Simd::mask()
 
template<class V1 , class V2 >
auto maskOr (ADLTag< 0 >, const V1 &v1, const V2 &v2)
 implements Simd::maskOr()
 
template<class V1 , class V2 >
auto maskAnd (ADLTag< 0 >, const V1 &v1, const V2 &v2)
 implements Simd::maskAnd()
 
Specialized classes and overloaded functions
template<class V >
lane (ADLTag< 2 >, std::size_t, V v)
 implements Simd::lane()
 
template<class V >
V & lane (ADLTag< 3 >, std::size_t, V &v)
 
bool anyTrue (ADLTag< 2 >, bool mask)
 implements Simd::anyTrue()
 
bool allTrue (ADLTag< 2 >, bool mask)
 implements Simd::allTrue()
 
bool anyFalse (ADLTag< 2 >, bool mask)
 implements Simd::anyFalse()
 
bool allFalse (ADLTag< 2 >, bool mask)
 implements Simd::allFalse()
 
template<class V >
VcImpl::Proxy< V > lane (ADLTag< 5, VcImpl::IsVector< V >::value >, std::size_t l, V &v)
 implements Simd::lane()
 
template<class V >
Scalar< V > lane (ADLTag< 5, VcImpl::IsVector< V >::value >, std::size_t l, const V &v)
 implements Simd::lane()
 
template<class V , class = std::enable_if_t<!std::is_reference<V>::value>>
Scalar< V > lane (ADLTag< 5, VcImpl::IsVector< V >::value >, std::size_t l, V &&v)
 implements Simd::lane()
 
template<class V >
cond (ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >, const Mask< V > &mask, const V &ifTrue, const V &ifFalse)
 implements Simd::cond()
 
template<class V >
cond (ADLTag< 5, VcImpl::IsMask< V >::value >, const V &mask, const V &ifTrue, const V &ifFalse)
 implements Simd::cond()
 
template<class V >
auto max (ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >, const V &v1, const V &v2)
 implements binary Simd::max()
 
template<class M >
auto max (ADLTag< 5, VcImpl::IsMask< M >::value >, const M &m1, const M &m2)
 implements binary Simd::max()
 
template<class V >
auto min (ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >, const V &v1, const V &v2)
 implements binary Simd::min()
 
template<class M >
auto min (ADLTag< 5, VcImpl::IsMask< M >::value >, const M &m1, const M &m2)
 implements binary Simd::min()
 
template<class M >
bool anyTrue (ADLTag< 5, VcImpl::IsMask< M >::value >, const M &mask)
 implements Simd::anyTrue()
 
template<class M >
bool allTrue (ADLTag< 5, VcImpl::IsMask< M >::value >, const M &mask)
 implements Simd::allTrue()
 
template<class M >
bool allFalse (ADLTag< 5, VcImpl::IsMask< M >::value >, const M &mask)
 implements Simd::allFalse()
 
template<class V >
auto max (ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >, const V &v)
 implements Simd::maxValue()
 
template<class M >
bool max (ADLTag< 5, VcImpl::IsMask< M >::value >, const M &mask)
 implements Simd::maxValue()
 
template<class V >
auto min (ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >, const V &v)
 implements Simd::minValue()
 
template<class M >
bool min (ADLTag< 5, VcImpl::IsMask< M >::value >, const M &mask)
 implements Simd::minValue()
 
template<class S1 , class V2 >
auto maskAnd (ADLTag< 5, std::is_same< Mask< S1 >, bool >::value &&VcImpl::IsVector< V2 >::value >, const S1 &s1, const V2 &v2)
 implements Simd::maskAnd()
 
template<class V1 , class S2 >
auto maskAnd (ADLTag< 5, VcImpl::IsVector< V1 >::value &&std::is_same< Mask< S2 >, bool >::value >, const V1 &v1, const S2 &s2)
 implements Simd::maskAnd()
 
template<class S1 , class V2 >
auto maskOr (ADLTag< 5, std::is_same< Mask< S1 >, bool >::value &&VcImpl::IsVector< V2 >::value >, const S1 &s1, const V2 &v2)
 implements Simd::maskOr()
 
template<class V1 , class S2 >
auto maskOr (ADLTag< 5, VcImpl::IsVector< V1 >::value &&std::is_same< Mask< S2 >, bool >::value >, const V1 &v1, const S2 &s2)
 implements Simd::maskOr()
 

Detailed Description

Namespace for the overloads and specializations that make up a SIMD implementation.

This namespace contains three sets of things: the struct ADLTag, which is used to look up functions in this namespace using argument-dependet lookup, traits classes that must be specialized by abstraction implementations, and functions that must/can be overloaded by abstraction implementations.

Note
Only introduce new names into this namespace to extend the interface. This applies in particular to people in the "abstraction developer" role; they may meddle in this namespace only by providing overloads and/or specializations for existing names (and for ADLTag even that is prohibited).

Function Documentation

◆ allFalse() [1/3]

bool Dune::Simd::Overloads::allFalse ( ADLTag< 2 >  ,
bool  mask 
)
inline

implements Simd::allFalse()

◆ allFalse() [2/3]

template<class M , std::size_t S, std::size_t A>
bool Dune::Simd::Overloads::allFalse ( ADLTag< 5 >  ,
LoopSIMD< M, S, A >  mask 
)

◆ allFalse() [3/3]

template<class M >
bool Dune::Simd::Overloads::allFalse ( ADLTag< 5, VcImpl::IsMask< M >::value >  ,
const M &  mask 
)

implements Simd::allFalse()

◆ allTrue() [1/3]

bool Dune::Simd::Overloads::allTrue ( ADLTag< 2 >  ,
bool  mask 
)
inline

implements Simd::allTrue()

◆ allTrue() [2/3]

template<class M , std::size_t S, std::size_t A>
bool Dune::Simd::Overloads::allTrue ( ADLTag< 5 >  ,
LoopSIMD< M, S, A >  mask 
)

◆ allTrue() [3/3]

template<class M >
bool Dune::Simd::Overloads::allTrue ( ADLTag< 5, VcImpl::IsMask< M >::value >  ,
const M &  mask 
)

implements Simd::allTrue()

◆ anyFalse() [1/2]

bool Dune::Simd::Overloads::anyFalse ( ADLTag< 2 >  ,
bool  mask 
)
inline

implements Simd::anyFalse()

◆ anyFalse() [2/2]

template<class M , std::size_t S, std::size_t A>
bool Dune::Simd::Overloads::anyFalse ( ADLTag< 5 >  ,
LoopSIMD< M, S, A >  mask 
)

◆ anyTrue() [1/4]

bool Dune::Simd::Overloads::anyTrue ( ADLTag< 2 >  ,
bool  mask 
)
inline

implements Simd::anyTrue()

◆ anyTrue() [2/4]

template<std::size_t align>
bool Dune::Simd::Overloads::anyTrue ( ADLTag< 5 >  ,
const AlignedNumber< bool, align > &  mask 
)

◆ anyTrue() [3/4]

template<class M , std::size_t S, std::size_t A>
bool Dune::Simd::Overloads::anyTrue ( ADLTag< 5 >  ,
LoopSIMD< M, S, A >  mask 
)

◆ anyTrue() [4/4]

template<class M >
bool Dune::Simd::Overloads::anyTrue ( ADLTag< 5, VcImpl::IsMask< M >::value >  ,
const M &  mask 
)

implements Simd::anyTrue()

◆ cond() [1/5]

template<class T , std::size_t align>
const AlignedNumber< T, align > & Dune::Simd::Overloads::cond ( ADLTag< 5 >  ,
AlignedNumber< bool, align >  mask,
const AlignedNumber< T, align > &  ifTrue,
const AlignedNumber< T, align > &  ifFalse 
)

◆ cond() [2/5]

template<class T , std::size_t S, std::size_t AM, std::size_t AD>
auto Dune::Simd::Overloads::cond ( ADLTag< 5 >  ,
Simd::Mask< LoopSIMD< T, S, AM > >  mask,
LoopSIMD< T, S, AD >  ifTrue,
LoopSIMD< T, S, AD >  ifFalse 
)

◆ cond() [3/5]

template<class M , class T , std::size_t S, std::size_t A>
auto Dune::Simd::Overloads::cond ( ADLTag< 5, std::is_same< bool, Simd::Scalar< M > >::value &&Simd::lanes< M >()==Simd::lanes< LoopSIMD< T, S, A > >()>  ,
mask,
LoopSIMD< T, S, A >  ifTrue,
LoopSIMD< T, S, A >  ifFalse 
)

◆ cond() [4/5]

template<class V >
V Dune::Simd::Overloads::cond ( ADLTag< 5, VcImpl::IsMask< V >::value >  ,
const V &  mask,
const V &  ifTrue,
const V &  ifFalse 
)

implements Simd::cond()

◆ cond() [5/5]

template<class V >
V Dune::Simd::Overloads::cond ( ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >  ,
const Mask< V > &  mask,
const V &  ifTrue,
const V &  ifFalse 
)

implements Simd::cond()

◆ lane() [1/10]

template<class V >
V Dune::Simd::Overloads::lane ( ADLTag< 2 >  ,
std::size_t  ,
v 
)

implements Simd::lane()

This binds to rvalues and const lvalues. It would bind to non-const lvalues too, but those are caught by the overload with ADLTag<3>. Using a universal reference here would bind to any argument with a perfect match. This would mean ambiguous overloads with other abstractions, if those only declare overloads for const TheirType & and TheirType &, because because universal references match perfectly.

◆ lane() [2/10]

template<class V >
V & Dune::Simd::Overloads::lane ( ADLTag< 3 >  ,
std::size_t  ,
V &  v 
)

◆ lane() [3/10]

template<class T , std::size_t align>
T & Dune::Simd::Overloads::lane ( ADLTag< 5 >  ,
std::size_t  l,
AlignedNumber< T, align > &  v 
)

◆ lane() [4/10]

template<class T , std::size_t align>
T Dune::Simd::Overloads::lane ( ADLTag< 5 >  ,
std::size_t  l,
const AlignedNumber< T, align > &  v 
)

◆ lane() [5/10]

template<class T , std::size_t S, std::size_t A>
auto Dune::Simd::Overloads::lane ( ADLTag< 5 >  ,
std::size_t  l,
const LoopSIMD< T, S, A > &  v 
) -> decltype(Simd::lane(l%lanes<T>(), v[l/lanes<T>()]))

◆ lane() [6/10]

template<class T , std::size_t S, std::size_t A>
auto Dune::Simd::Overloads::lane ( ADLTag< 5 >  ,
std::size_t  l,
LoopSIMD< T, S, A > &&  v 
) -> decltype(std::move(Simd::lane(l%lanes<T>(), v[l/lanes<T>()])))

◆ lane() [7/10]

template<class T , std::size_t S, std::size_t A>
auto Dune::Simd::Overloads::lane ( ADLTag< 5 >  ,
std::size_t  l,
LoopSIMD< T, S, A > &  v 
) -> decltype(Simd::lane(l%lanes<T>(), v[l/lanes<T>()]))

◆ lane() [8/10]

template<class V >
Scalar< V > Dune::Simd::Overloads::lane ( ADLTag< 5, VcImpl::IsVector< V >::value >  ,
std::size_t  l,
const V &  v 
)

implements Simd::lane()

◆ lane() [9/10]

template<class V , class = std::enable_if_t<!std::is_reference<V>::value>>
Scalar< V > Dune::Simd::Overloads::lane ( ADLTag< 5, VcImpl::IsVector< V >::value >  ,
std::size_t  l,
V &&  v 
)

implements Simd::lane()

◆ lane() [10/10]

template<class V >
VcImpl::Proxy< V > Dune::Simd::Overloads::lane ( ADLTag< 5, VcImpl::IsVector< V >::value >  ,
std::size_t  l,
V &  v 
)

implements Simd::lane()

◆ maskAnd() [1/2]

template<class S1 , class V2 >
auto Dune::Simd::Overloads::maskAnd ( ADLTag< 5, std::is_same< Mask< S1 >, bool >::value &&VcImpl::IsVector< V2 >::value >  ,
const S1 &  s1,
const V2 &  v2 
)

implements Simd::maskAnd()

◆ maskAnd() [2/2]

template<class V1 , class S2 >
auto Dune::Simd::Overloads::maskAnd ( ADLTag< 5, VcImpl::IsVector< V1 >::value &&std::is_same< Mask< S2 >, bool >::value >  ,
const V1 &  v1,
const S2 &  s2 
)

implements Simd::maskAnd()

◆ maskOr() [1/2]

template<class S1 , class V2 >
auto Dune::Simd::Overloads::maskOr ( ADLTag< 5, std::is_same< Mask< S1 >, bool >::value &&VcImpl::IsVector< V2 >::value >  ,
const S1 &  s1,
const V2 &  v2 
)

implements Simd::maskOr()

◆ maskOr() [2/2]

template<class V1 , class S2 >
auto Dune::Simd::Overloads::maskOr ( ADLTag< 5, VcImpl::IsVector< V1 >::value &&std::is_same< Mask< S2 >, bool >::value >  ,
const V1 &  v1,
const S2 &  s2 
)

implements Simd::maskOr()

◆ max() [1/4]

template<class M >
auto Dune::Simd::Overloads::max ( ADLTag< 5, VcImpl::IsMask< M >::value >  ,
const M &  m1,
const M &  m2 
)

implements binary Simd::max()

◆ max() [2/4]

template<class M >
bool Dune::Simd::Overloads::max ( ADLTag< 5, VcImpl::IsMask< M >::value >  ,
const M &  mask 
)

implements Simd::maxValue()

◆ max() [3/4]

template<class V >
auto Dune::Simd::Overloads::max ( ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >  ,
const V &  v 
)

implements Simd::maxValue()

◆ max() [4/4]

template<class V >
auto Dune::Simd::Overloads::max ( ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >  ,
const V &  v1,
const V &  v2 
)

implements binary Simd::max()

◆ min() [1/4]

template<class M >
auto Dune::Simd::Overloads::min ( ADLTag< 5, VcImpl::IsMask< M >::value >  ,
const M &  m1,
const M &  m2 
)

implements binary Simd::min()

◆ min() [2/4]

template<class M >
bool Dune::Simd::Overloads::min ( ADLTag< 5, VcImpl::IsMask< M >::value >  ,
const M &  mask 
)

implements Simd::minValue()

◆ min() [3/4]

template<class V >
auto Dune::Simd::Overloads::min ( ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >  ,
const V &  v 
)

implements Simd::minValue()

◆ min() [4/4]

template<class V >
auto Dune::Simd::Overloads::min ( ADLTag< 5, VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value >  ,
const V &  v1,
const V &  v2 
)

implements binary Simd::min()