folly::ThreadCachedArena Class Reference

#include <ThreadCachedArena.h>

Classes
struct	ThreadLocalPtrTag

Public Member Functions
	ThreadCachedArena (size_t minBlockSize=SysArena::kDefaultMinBlockSize, size_t maxAlign=SysArena::kDefaultMaxAlign)
void *	allocate (size_t size)
void	deallocate (void *, size_t=0)
size_t	totalSize () const

Private Member Functions
	ThreadCachedArena (const ThreadCachedArena &)=delete
	ThreadCachedArena (ThreadCachedArena &&)=delete
ThreadCachedArena &	operator= (const ThreadCachedArena &)=delete
ThreadCachedArena &	operator= (ThreadCachedArena &&)=delete
SysArena *	allocateThreadLocalArena ()
void	zombify (SysArena &&arena)

Private Attributes
const size_t	minBlockSize_
const size_t	maxAlign_
ThreadLocalPtr< SysArena, ThreadLocalPtrTag >	arena_
Synchronized< SysArena >	zombies_

Detailed Description

Thread-caching arena: allocate memory which gets freed when the arena gets destroyed.

The arena itself allocates memory using malloc() in blocks of at least minBlockSize bytes.

For speed, each thread gets its own Arena (see Arena.h); when threads exit, the Arena gets merged into a "zombie" Arena, which will be deallocated when the ThreadCachedArena object is destroyed.

Definition at line 39 of file ThreadCachedArena.h.

Constructor & Destructor Documentation

folly::ThreadCachedArena::ThreadCachedArena ( size_t  minBlockSize = SysArena::kDefaultMinBlockSize, size_t  maxAlign = SysArena::kDefaultMaxAlign  )

explicit

Definition at line 23 of file ThreadCachedArena.cpp.

Referenced by totalSize().

    : minBlockSize_(minBlockSize), maxAlign_(maxAlign) {}

folly::ThreadCachedArena::ThreadCachedArena ( const ThreadCachedArena &  )

privatedelete

folly::ThreadCachedArena::ThreadCachedArena ( ThreadCachedArena &&  )

privatedelete

Member Function Documentation

void* folly::ThreadCachedArena::allocate ( size_t  size )

inline

Definition at line 45 of file ThreadCachedArena.h.

References folly::Arena< Alloc >::allocate(), allocateThreadLocalArena(), arena_, and UNLIKELY.

Referenced by TEST().

                              {
    SysArena* arena = arena_.get();
    if (UNLIKELY(!arena)) {
      arena = allocateThreadLocalArena();
    }

    return arena->allocate(size);
  }

SysArena * folly::ThreadCachedArena::allocateThreadLocalArena ( )

private

Definition at line 26 of file ThreadCachedArena.cpp.

References arena_, folly::Arena< SysAllocator< void > >::kNoSizeLimit, maxAlign_, minBlockSize_, mode, folly::gen::move, folly::pushmi::detail::t, folly::THIS_THREAD, folly::pushmi::__adl::tp, and zombify().

Referenced by allocate().

                                                      {
  SysArena* arena =
      new SysArena(minBlockSize_, SysArena::kNoSizeLimit, maxAlign_);
  auto disposer = [this](SysArena* t, TLPDestructionMode mode) {
    std::unique_ptr<SysArena> tp(t); // ensure it gets deleted
    if (mode == TLPDestructionMode::THIS_THREAD) {
      zombify(std::move(*t));
    }
  };
  arena_.reset(arena, disposer);
  return arena;
}

void folly::ThreadCachedArena::deallocate ( void *  , size_t  = 0  )

inline

Definition at line 54 of file ThreadCachedArena.h.

References totalSize().

                                       {
    // Deallocate? Never!
  }

ThreadCachedArena& folly::ThreadCachedArena::operator= ( const ThreadCachedArena &  )

privatedelete

ThreadCachedArena& folly::ThreadCachedArena::operator= ( ThreadCachedArena &&  )

privatedelete

size_t folly::ThreadCachedArena::totalSize

(

)

const

Definition at line 43 of file ThreadCachedArena.cpp.

References arena_, ThreadCachedArena(), and zombies_.

Referenced by deallocate(), and TEST().

                                          {
  size_t result = sizeof(ThreadCachedArena);
  for (const auto& arena : arena_.accessAllThreads()) {
    result += arena.totalSize();
  }
  result += zombies_->totalSize() - sizeof(SysArena);
  return result;
}

void folly::ThreadCachedArena::zombify ( SysArena &&  arena )

private

Definition at line 39 of file ThreadCachedArena.cpp.

References folly::gen::move, and zombies_.

Referenced by allocateThreadLocalArena().

                                                {
  zombies_->merge(std::move(arena));
}

Member Data Documentation

ThreadLocalPtr<SysArena, ThreadLocalPtrTag> folly::ThreadCachedArena::arena_

private

Definition at line 78 of file ThreadCachedArena.h.

Referenced by allocate(), allocateThreadLocalArena(), and totalSize().

const size_t folly::ThreadCachedArena::maxAlign_

private

Definition at line 76 of file ThreadCachedArena.h.

Referenced by allocateThreadLocalArena().

const size_t folly::ThreadCachedArena::minBlockSize_

private

Definition at line 75 of file ThreadCachedArena.h.

Referenced by allocateThreadLocalArena().

Synchronized<SysArena> folly::ThreadCachedArena::zombies_

private

Definition at line 81 of file ThreadCachedArena.h.

Referenced by totalSize(), and zombify().

---

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

• proxygen/folly/folly/memory/ThreadCachedArena.h
• proxygen/folly/folly/memory/ThreadCachedArena.cpp