debugalign.hh File Reference

#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <functional>
#include <istream>
#include <ostream>
#include <type_traits>
#include <utility>
#include <dune/common/classname.hh>
#include <dune/common/indices.hh>
#include <dune/common/simd/base.hh>
#include <dune/common/simd/defaults.hh>
#include <dune/common/typetraits.hh>

Go to the source code of this file.

Classes
struct	Dune::AlignedBase< align, Impl >
	CRTP base mixin class to check alignment. More...
struct	Dune::Simd::Overloads::ScalarType< AlignedNumber< T, align > >
struct	Dune::Simd::Overloads::RebindType< U, AlignedNumber< T, align > >
struct	Dune::Simd::Overloads::LaneCount< AlignedNumber< T, align > >

Namespaces
	Dune
	Dune namespace
	Dune::Simd
	Namespace for vectorization interface functions used by library developers.
	Dune::Simd::Overloads
	Namespace for the overloads and specializations that make up a SIMD implementation.

Macros
#define	DUNE_ASSIGN_OP(OP)
#define	DUNE_BINARY_OP(OP)
#define	DUNE_UNARY_FUNC(name)

Typedefs
using	Dune::ViolatedAlignmentHandler = std::function< void(const char *, std::size_t, const void *)>
	type of the handler called by violatedAlignment() More...

Functions
ViolatedAlignmentHandler &	Dune::violatedAlignmentHandler ()
	access the handler called by violatedAlignment() More...
void	Dune::violatedAlignment (const char *className, std::size_t expectedAlignment, const void *address)
	called when an alignment violation is detected More...
bool	Dune::isAligned (const void *p, std::size_t align)
	check whether an address conforms to the given alignment More...
template<std::size_t align = debugAlignment, class T >
AlignedNumber< T, align >	Dune::aligned (T value)
	align a value to a certain alignment More...
template<class T , std::size_t align>
AlignedNumber< T, align >	Dune::cond (const AlignedNumber< bool, align > &b, const AlignedNumber< T, align > &v1, const AlignedNumber< T, align > &v2)
template<class T , std::size_t align>
T	Dune::max_value (const AlignedNumber< T, align > &val)
template<class T , std::size_t align>
T	Dune::min_value (const AlignedNumber< T, align > &val)
template<std::size_t align>
bool	Dune::any_true (const AlignedNumber< bool, align > &val)
template<std::size_t align>
bool	Dune::all_true (const AlignedNumber< bool, align > &val)
template<class T , std::size_t align>
T &	Dune::Simd::Overloads::lane (ADLTag< 5 >, std::size_t l, AlignedNumber< T, align > &v)
template<class T , std::size_t align>
T	Dune::Simd::Overloads::lane (ADLTag< 5 >, std::size_t l, const AlignedNumber< T, align > &v)
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)
template<std::size_t align>
bool	Dune::Simd::Overloads::anyTrue (ADLTag< 5 >, const AlignedNumber< bool, align > &mask)

Variables
static constexpr auto	Dune::debugAlignment = 2*alignof(std::max_align_t)
	an alignment large enough to trigger alignment errors More...

Macro Definition Documentation

DUNE_ASSIGN_OP

#define DUNE_ASSIGN_OP

(

OP

)

Value:

template<class U, std::size_t uAlign,                             \
               class = std::enable_if_t<                                \
                         ( uAlign <= align &&                           \
                           sizeof(std::declval<T&>() OP std::declval<U>()) ) \
                           > >                                          \
      AlignedNumber &operator OP(const AlignedNumber<U, uAlign> &u)     \
      {                                                                 \
        value_ OP U(u);                                                 \
        return *this;                                                   \
      }                                                                 \
                                                                        \
      template<class U,                                                 \
               class = std::void_t<decltype(std::declval<T&>() OP       \
                                            std::declval<U>())> >       \
      AlignedNumber &operator OP(const U &u)                            \
      {                                                                 \
        value_ OP u;                                                    \
        return *this;                                                   \
      }                                                                 \
                                                                        \
      static_assert(true, "Require semicolon to unconfuse editors")

DUNE_BINARY_OP

#define DUNE_BINARY_OP

(

OP

)

Value:

template<class T, std::size_t tAlign, class U, std::size_t uAlign,  \
             class = std::void_t<decltype(std::declval<T>()             \
                                     OP std::declval<U>())> >           \
    decltype(auto)                                                      \
      operator OP(const AlignedNumber<T, tAlign> &t,                    \
                  const AlignedNumber<U, uAlign> &u)                    \
    {                                                                   \
      /* can't use std::max(); not constexpr */                         \
      return aligned<(tAlign > uAlign ? tAlign : uAlign)>(T(t) OP U(u)); \
    }                                                                   \
                                                                        \
    template<class T, class U, std::size_t uAlign,                      \
             class = std::void_t<decltype(std::declval<T>()             \
                                     OP std::declval<U>())> >           \
    decltype(auto)                                                      \
      operator OP(const T &t, const AlignedNumber<U, uAlign> &u)        \
    {                                                                   \
      return aligned<uAlign>(t OP U(u));                                \
    }                                                                   \
                                                                        \
    template<class T, std::size_t tAlign, class U,                      \
             class = std::void_t<decltype(std::declval<T>()             \
                                     OP std::declval<U>())> >           \
    decltype(auto)                                                      \
      operator OP(const AlignedNumber<T, tAlign> &t, const U &u)        \
    {                                                                   \
      return aligned<tAlign>(T(t) OP u);                                \
    }                                                                   \
                                                                        \
    static_assert(true, "Require semicolon to unconfuse editors")

DUNE_UNARY_FUNC

#define DUNE_UNARY_FUNC

(

name

)

Value:

template<class T, std::size_t align>                            \
    decltype(auto) name(const AlignedNumber<T, align> &u)           \
    {                                                               \
      using std::name;                                              \
      return aligned<align>(name(T(u)));                            \
    }                                                               \
    static_assert(true, "Require semicolon to unconfuse editors")