Loading...
Searching...
No Matches
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 > >
class | Dune::AlignedNumber< T, align >
| aligned wrappers for arithmetic types More...

## Namespaces

namespace | Dune
| Dune namespace
namespace | Dune::Simd
| Namespace for vectorization interface functions used by library developers.
namespace | 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
| type of the handler called by violatedAlignment()

## Functions

ViolatedAlignmentHandler & | Dune::violatedAlignmentHandler ()
| access the handler called by violatedAlignment()
void | Dune::violatedAlignment (const char *className, std::size_t expectedAlignment, const void *address)
| called when an alignment violation is detected
bool | Dune::isAligned (const void *p, std::size_t align)
| check whether an address conforms to the given alignment
template<std::size_t align = debugAlignment, class T>
AlignedNumber< T, align > | Dune::aligned (T value)
| align a value to a certain alignment
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

## 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")
std
STL namespace.
Dune::AlignedNumber
aligned wrappers for arithmetic types
Definition debugalign.hh:128

## 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")