folly::Arena< Alloc > Class Template Reference

#include <Arena.h>

Classes
struct	AllocAndSize
struct	Block

Public Member Functions
	Arena (const Alloc &alloc, size_t minBlockSize=kDefaultMinBlockSize, size_t sizeLimit=kNoSizeLimit, size_t maxAlign=kDefaultMaxAlign)
	~Arena ()
void *	allocate (size_t size)
void	deallocate (void *, size_t=0)
void	merge (Arena &&other)
size_t	totalSize () const
size_t	bytesUsed () const
	Arena (const Arena &)=delete
Arena &	operator= (const Arena &)=delete
	Arena (Arena &&)=delete
Arena &	operator= (Arena &&)=delete

Static Public Attributes
static constexpr size_t	kDefaultMinBlockSize = 4096 - sizeof(Block)
static constexpr size_t	kNoSizeLimit = 0
static constexpr size_t	kDefaultMaxAlign = alignof(Block)
static constexpr size_t	kBlockOverhead = sizeof(Block)

Private Types
typedef boost::intrusive::slist_member_hook< boost::intrusive::tag< Arena > >	BlockLink
typedef boost::intrusive::slist< Block, boost::intrusive::member_hook< Block, BlockLink,&Block::link >, boost::intrusive::constant_time_size< false >, boost::intrusive::cache_last< true > >	BlockList

Private Member Functions
bool	isAligned (uintptr_t address) const
bool	isAligned (void *p) const
size_t	roundUp (size_t size) const
void *	allocateSlow (size_t size)
size_t	minBlockSize () const
Alloc &	alloc ()
const Alloc &	alloc () const

Private Attributes
AllocAndSize	allocAndSize_
BlockList	blocks_
char *	ptr_
char *	end_
size_t	totalAllocatedSize_
size_t	bytesUsed_
const size_t	sizeLimit_
const size_t	maxAlign_

Detailed Description

template<class Alloc>
class folly::Arena< Alloc >

Definition at line 60 of file Arena.h.

Member Typedef Documentation

template<class Alloc>

typedef boost::intrusive::slist_member_hook<boost::intrusive::tag<Arena> > folly::Arena< Alloc >::BlockLink

private

Definition at line 128 of file Arena.h.

template<class Alloc>

typedef boost::intrusive::slist< Block, boost::intrusive::member_hook<Block, BlockLink, &Block::link>, boost::intrusive::constant_time_size<false>, boost::intrusive::cache_last<true> > folly::Arena< Alloc >::BlockList

private

Definition at line 178 of file Arena.h.

Constructor & Destructor Documentation

template<class Alloc>

folly::Arena< Alloc >::Arena ( const Alloc &  alloc, size_t  minBlockSize = kDefaultMinBlockSize, size_t  sizeLimit = kNoSizeLimit, size_t  maxAlign = kDefaultMaxAlign  )

inlineexplicit

Definition at line 62 of file Arena.h.

Referenced by folly::Arena< SysAllocator< void > >::bytesUsed(), and folly::Arena< SysAllocator< void > >::totalSize().

      : allocAndSize_(alloc, minBlockSize),
        ptr_(nullptr),
        end_(nullptr),
        totalAllocatedSize_(0),
        bytesUsed_(0),
        sizeLimit_(sizeLimit),
        maxAlign_(maxAlign) {
    if ((maxAlign_ & (maxAlign_ - 1)) || maxAlign_ > alignof(Block)) {
      throw_exception(std::invalid_argument(
          folly::to<std::string>("Invalid maxAlign: ", maxAlign_)));
    }
  }

template<class Alloc >

folly::Arena< Alloc >::~Arena

(

)

Definition at line 86 of file Arena-inl.h.

References folly::Arena< Alloc >::alloc(), b, and folly::Arena< Alloc >::blocks_.

Referenced by folly::Arena< SysAllocator< void > >::Arena().

                     {
  auto disposer = [this](Block* b) { b->deallocate(this->alloc()); };
  while (!blocks_.empty()) {
    blocks_.pop_front_and_dispose(disposer);
  }
}

template<class Alloc>

folly::Arena< Alloc >::Arena ( const Arena< Alloc > &  )

delete

template<class Alloc>

folly::Arena< Alloc >::Arena ( Arena< Alloc > &&  )

delete

Member Function Documentation

template<class Alloc>

Alloc& folly::Arena< Alloc >::alloc ( )

inlineprivate

Definition at line 194 of file Arena.h.

Referenced by folly::Arena< Alloc >::allocateSlow(), and folly::Arena< Alloc >::~Arena().

                 {
    return allocAndSize_;
  }

template<class Alloc>

const Alloc& folly::Arena< Alloc >::alloc ( ) const

inlineprivate

Definition at line 197 of file Arena.h.

                             {
    return allocAndSize_;
  }

template<class Alloc>

void* folly::Arena< Alloc >::allocate ( size_t  size )

inline

Definition at line 82 of file Arena.h.

Referenced by folly::ThreadCachedArena::allocate(), and TEST().

                              {
    size = roundUp(size);
    bytesUsed_ += size;

    assert(ptr_ <= end_);
    if (LIKELY((size_t)(end_ - ptr_) >= size)) {
      // Fast path: there's enough room in the current block
      char* r = ptr_;
      ptr_ += size;
      assert(isAligned(r));
      return r;
    }

    // Not enough room in the current block
    void* r = allocateSlow(size);
    assert(isAligned(r));
    return r;
  }

template<class Alloc >

void * folly::Arena< Alloc >::allocateSlow ( size_t  size )

private

Definition at line 44 of file Arena-inl.h.

References folly::Arena< Alloc >::alloc(), folly::Arena< Alloc >::Block::allocate(), folly::Arena< Alloc >::Block::Block(), folly::Arena< Alloc >::blocks_, folly::Arena< Alloc >::end_, folly::Arena< Alloc >::kNoSizeLimit, max, folly::Arena< Alloc >::minBlockSize(), folly::Arena< Alloc >::ptr_, folly::size(), folly::Arena< Alloc >::sizeLimit_, folly::Arena< Alloc >::Block::start(), folly::throw_exception(), and folly::Arena< Alloc >::totalAllocatedSize_.

Referenced by folly::Arena< SysAllocator< void > >::allocate().

                                            {
  std::pair<Block*, size_t> p;
  char* start;

  size_t allocSize = std::max(size, minBlockSize()) + sizeof(Block);
  if (sizeLimit_ != kNoSizeLimit &&
      allocSize > sizeLimit_ - totalAllocatedSize_) {
    throw_exception(std::bad_alloc());
  }

  if (size > minBlockSize()) {
    // Allocate a large block for this chunk only, put it at the back of the
    // list so it doesn't get used for small allocations; don't change ptr_
    // and end_, let them point into a normal block (or none, if they're
    // null)
    p = Block::allocate(alloc(), size, false);
    start = p.first->start();
    blocks_.push_back(*p.first);
  } else {
    // Allocate a normal sized block and carve out size bytes from it
    p = Block::allocate(alloc(), minBlockSize(), true);
    start = p.first->start();
    blocks_.push_front(*p.first);
    ptr_ = start + size;
    end_ = start + p.second;
  }

  assert(p.second >= size);
  totalAllocatedSize_ += p.second + sizeof(Block);
  return start;
}

template<class Alloc>

size_t folly::Arena< Alloc >::bytesUsed ( ) const

inline

Definition at line 117 of file Arena.h.

Referenced by TEST().

                           {
    return bytesUsed_;
  }

template<class Alloc>

void folly::Arena< Alloc >::deallocate ( void *  , size_t  = 0  )

inline

Definition at line 101 of file Arena.h.

Referenced by TEST().

                                       {
    // Deallocate? Never!
  }

template<class Alloc>

bool folly::Arena< Alloc >::isAligned ( uintptr_t  address ) const

inlineprivate

Definition at line 159 of file Arena.h.

Referenced by folly::Arena< SysAllocator< void > >::allocate(), and folly::Arena< SysAllocator< void > >::isAligned().

                                          {
    return (address & (maxAlign_ - 1)) == 0;
  }

template<class Alloc>

bool folly::Arena< Alloc >::isAligned ( void *  p ) const

inlineprivate

Definition at line 162 of file Arena.h.

                                {
    return isAligned(reinterpret_cast<uintptr_t>(p));
  }

template<class Alloc>

void folly::Arena< Alloc >::merge

(

Arena< Alloc > &&

other

)

Definition at line 77 of file Arena-inl.h.

References folly::Arena< Alloc >::blocks_, and folly::Arena< Alloc >::totalAllocatedSize_.

Referenced by folly::Arena< SysAllocator< void > >::deallocate().

                                             {
  blocks_.splice_after(blocks_.before_begin(), other.blocks_);
  other.blocks_.clear();
  other.ptr_ = other.end_ = nullptr;
  totalAllocatedSize_ += other.totalAllocatedSize_;
  other.totalAllocatedSize_ = 0;
}

template<class Alloc>

size_t folly::Arena< Alloc >::minBlockSize ( ) const

inlineprivate

Definition at line 191 of file Arena.h.

Referenced by folly::Arena< Alloc >::allocateSlow(), and folly::SysArena::SysArena().

                              {
    return allocAndSize_.minBlockSize;
  }

template<class Alloc>

Arena& folly::Arena< Alloc >::operator= ( const Arena< Alloc > &  )

delete

Referenced by folly::Arena< SysAllocator< void > >::bytesUsed().

template<class Alloc>

Arena& folly::Arena< Alloc >::operator= ( Arena< Alloc > &&  )

delete

template<class Alloc>

size_t folly::Arena< Alloc >::roundUp ( size_t  size ) const

inlineprivate

Definition at line 167 of file Arena.h.

Referenced by folly::Arena< SysAllocator< void > >::allocate().

                                    {
    return (size + maxAlign_ - 1) & ~(maxAlign_ - 1);
  }

template<class Alloc>

size_t folly::Arena< Alloc >::totalSize ( ) const

inline

Definition at line 109 of file Arena.h.

Referenced by TEST().

                           {
    return totalAllocatedSize_ + sizeof(Arena);
  }

Member Data Documentation

template<class Alloc>

AllocAndSize folly::Arena< Alloc >::allocAndSize_

private

Definition at line 201 of file Arena.h.

Referenced by folly::Arena< SysAllocator< void > >::alloc(), and folly::Arena< SysAllocator< void > >::minBlockSize().

template<class Alloc>

BlockList folly::Arena< Alloc >::blocks_

private

Definition at line 202 of file Arena.h.

Referenced by folly::Arena< Alloc >::allocateSlow(), folly::Arena< Alloc >::merge(), and folly::Arena< Alloc >::~Arena().

template<class Alloc>

size_t folly::Arena< Alloc >::bytesUsed_

private

Definition at line 206 of file Arena.h.

Referenced by folly::Arena< SysAllocator< void > >::allocate(), and folly::Arena< SysAllocator< void > >::bytesUsed().

template<class Alloc>

char* folly::Arena< Alloc >::end_

private

Definition at line 204 of file Arena.h.

Referenced by folly::Arena< SysAllocator< void > >::allocate(), and folly::Arena< Alloc >::allocateSlow().

template<class Alloc>

constexpr size_t folly::Arena< Alloc >::kBlockOverhead = sizeof(Block)

static

Definition at line 156 of file Arena.h.

template<class Alloc>

constexpr size_t folly::Arena< Alloc >::kDefaultMaxAlign = alignof(Block)

static

Definition at line 155 of file Arena.h.

template<class Alloc>

constexpr size_t folly::Arena< Alloc >::kDefaultMinBlockSize = 4096 - sizeof(Block)

static

Definition at line 153 of file Arena.h.

template<class Alloc>

constexpr size_t folly::Arena< Alloc >::kNoSizeLimit = 0

static

Definition at line 154 of file Arena.h.

Referenced by folly::Arena< Alloc >::allocateSlow().

template<class Alloc>

const size_t folly::Arena< Alloc >::maxAlign_

private

Definition at line 208 of file Arena.h.

Referenced by folly::Arena< SysAllocator< void > >::Arena(), folly::Arena< SysAllocator< void > >::isAligned(), and folly::Arena< SysAllocator< void > >::roundUp().

template<class Alloc>

char* folly::Arena< Alloc >::ptr_

private

Definition at line 203 of file Arena.h.

Referenced by folly::Arena< SysAllocator< void > >::allocate(), and folly::Arena< Alloc >::allocateSlow().

template<class Alloc>

const size_t folly::Arena< Alloc >::sizeLimit_

private

Definition at line 207 of file Arena.h.

Referenced by folly::Arena< Alloc >::allocateSlow().

template<class Alloc>

size_t folly::Arena< Alloc >::totalAllocatedSize_

private

Definition at line 205 of file Arena.h.

Referenced by folly::Arena< Alloc >::allocateSlow(), folly::Arena< Alloc >::merge(), and folly::Arena< SysAllocator< void > >::totalSize().

---

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

• proxygen/folly/folly/memory/Arena.h
• proxygen/folly/folly/memory/Arena-inl.h