folly::AlignedSysAllocator< T, Align > Class Template Reference

#include <Memory.h>

Inheritance diagram for folly::AlignedSysAllocator< T, Align >:

Public Types
using	value_type = T
using	propagate_on_container_copy_assignment = std::true_type
using	propagate_on_container_move_assignment = std::true_type
using	propagate_on_container_swap = std::true_type

Public Member Functions
template<typename S = Align, _t< std::enable_if< std::is_default_constructible< S >::value, int >> = 0>
constexpr	AlignedSysAllocator () noexcept(noexcept(Align()))
template<typename U >
constexpr	AlignedSysAllocator (AlignedSysAllocator< U, Align > const &other) noexcept
T *	allocate (size_t count)
void	deallocate (T *p, size_t)

Private Types
using	Self = AlignedSysAllocator< T, Align >

Private Member Functions
constexpr Align const &	align () const

Friends
template<typename , typename >
class	AlignedSysAllocator
bool	operator== (Self const &a, Self const &b) noexcept
bool	operator!= (Self const &a, Self const &b) noexcept

Detailed Description

template<typename T, typename Align = DefaultAlign>
class folly::AlignedSysAllocator< T, Align >

AlignedSysAllocator

Resembles std::allocator, the default Allocator, but wraps aligned_malloc and aligned_free.

Accepts a policy parameter for providing the alignment, which must:

• be invocable as std::size_t() noexcept, returning the alignment
• be noexcept-copy-constructible
• have noexcept operator==
• have noexcept operator!=
• not be final

DefaultAlign and FixedAlign<std::size_t>, provided above, are valid policies.

Definition at line 453 of file Memory.h.

Member Typedef Documentation

template<typename T, typename Align = DefaultAlign>

using folly::AlignedSysAllocator< T, Align >::propagate_on_container_copy_assignment = std::true_type

Definition at line 470 of file Memory.h.

template<typename T, typename Align = DefaultAlign>

using folly::AlignedSysAllocator< T, Align >::propagate_on_container_move_assignment = std::true_type

Definition at line 471 of file Memory.h.

template<typename T, typename Align = DefaultAlign>

using folly::AlignedSysAllocator< T, Align >::propagate_on_container_swap = std::true_type

Definition at line 472 of file Memory.h.

template<typename T, typename Align = DefaultAlign>

using folly::AlignedSysAllocator< T, Align >::Self = AlignedSysAllocator<T, Align>

private

Definition at line 455 of file Memory.h.

template<typename T, typename Align = DefaultAlign>

using folly::AlignedSysAllocator< T, Align >::value_type = T

Definition at line 468 of file Memory.h.

Constructor & Destructor Documentation

template<typename T, typename Align = DefaultAlign>

template<typename S = Align, _t< std::enable_if< std::is_default_constructible< S >::value, int >> = 0>

constexpr folly::AlignedSysAllocator< T, Align >::AlignedSysAllocator ( )

inlinenoexcept

Definition at line 480 of file Memory.h.

: Align() {}

template<typename T, typename Align = DefaultAlign>

template<typename U >

constexpr folly::AlignedSysAllocator< T, Align >::AlignedSysAllocator ( AlignedSysAllocator< U, Align > const &  other )

inlineexplicitnoexcept

Definition at line 483 of file Memory.h.

      : Align(other.align()) {}

Member Function Documentation

template<typename T, typename Align = DefaultAlign>

constexpr Align const& folly::AlignedSysAllocator< T, Align >::align ( ) const

inlineprivate

Definition at line 460 of file Memory.h.

References value.

                                       {
    return *this;
  }

template<typename T, typename Align = DefaultAlign>

T* folly::AlignedSysAllocator< T, Align >::allocate ( size_t  count )

inline

Definition at line 487 of file Memory.h.

References folly::aligned_malloc(), FOLLY_UNLIKELY, and folly::T.

                            {
    using lifted = typename detail::lift_void_to_char<T>::type;
    auto const p = aligned_malloc(sizeof(lifted) * count, align()());
    if (!p) {
      if (FOLLY_UNLIKELY(errno != ENOMEM)) {
        std::terminate();
      }
      throw_exception<std::bad_alloc>();
    }
    return static_cast<T*>(p);
  }

template<typename T, typename Align = DefaultAlign>

void folly::AlignedSysAllocator< T, Align >::deallocate ( T *  p, size_t    )

inline

Definition at line 498 of file Memory.h.

References folly::aligned_free().

                                  {
    aligned_free(p);
  }

Friends And Related Function Documentation

template<typename T, typename Align = DefaultAlign>

template<typename , typename >

friend class AlignedSysAllocator

friend

Definition at line 458 of file Memory.h.

template<typename T, typename Align = DefaultAlign>

bool operator!= ( Self const &  a, Self const &  b  )

friend

Definition at line 505 of file Memory.h.

                                                                {
    return a.align() != b.align();
  }

template<typename T, typename Align = DefaultAlign>

bool operator== ( Self const &  a, Self const &  b  )

friend

Definition at line 502 of file Memory.h.

                                                                {
    return a.align() == b.align();
  }

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/Memory.h