A large memory block that gets carved into smaller uniform elements. More...

#include <ArenaBlock.h>

Collaboration diagram for SG::ArenaBlock:

Public Types
typedef char *	pointer
	Type for a pointer to an element. More...

typedef const char *	const_pointer

typedef void	func_t(pointer)
	Function that operates on an element. More...

Public Member Functions
size_t	size () const
	Return the number of elements in the block. More...

size_t	eltSize () const
	Return the size of the elements in the block. More...

ArenaBlock *&	link ()
	Return the link pointer of the block. More...

const ArenaBlock *	link () const
	Return the link pointer of the block. More...

pointer	index (size_t i)
	Return a pointer to element `i` in the block. More...

const_pointer	index (size_t i) const
	Return a pointer to element `i` in the block. More...

pointer	index (size_t i, size_t elt_size)
	Return a pointer to element `i` in the block. More...

const_pointer	index (size_t i, size_t elt_size) const
	Return a pointer to element `i` in the block. More...

void	protect ()
	Write-protect this block. More...

void	unprotect ()
	Write-enable this block. More...

Static Public Member Functions
static ArenaBlock *	newBlock (size_t n, size_t elt_size, func_t *ctor)
	Create a new block. More...

static void	destroy (ArenaBlock p, func_t dtor)
	Destroy a block. More...

static void	destroyList (ArenaBlock p, func_t dtor)
	Destroy all blocks in a list. More...

static void	appendList (ArenaBlock *headp, ArenaBlock tail)
	Concatenate two lists of blocks. More...

static void	applyList (ArenaBlock p, func_t func, size_t n)
	Call a function on elements in a list of blocks. More...

static size_t	overhead ()
	Return the per-block memory overhead, in bytes. More...

static size_t	nactive ()
	Return the global number of blocks in use. More...

static void	protectList (ArenaBlock *p)
	Write-protect all blocks in a list. More...

static void	unprotectList (ArenaBlock *p)
	Write-enable all blocks in a list. More...

Private Member Functions
	ArenaBlock (size_t n, size_t elt_size)
	Prohibit calling these. More...

	~ArenaBlock ()

	ArenaBlock (const ArenaBlock &)

ArenaBlock &	operator= (const ArenaBlock &)

Private Attributes
ArenaBlock *	m_link
	The link for the linked list. More...

size_t	m_size
	Number of elements in this block. More...

size_t	m_elt_size
	Size, in bytes, of each element in this block. More...

ArenaBlockAlignDetail::padForAlign	m_dummy

Static Private Attributes
static std::atomic< size_t >	s_nactive
	Global count of the number of blocks in use. More...

Friends
class	ArenaAllocatorBase

Detailed Description

A large memory block that gets carved into smaller uniform elements.

See Arena.h for an overview of the arena-based memory allocators.

The block-based memory allocators allocate memory in large blocks and then carve them up into smaller, uniform elements. This class is used for those large blocks. Actually, the contents of this class is a fixed header for the block; the contents of the block itself will immediately follow the class contents.

Each block keeps some housekeeping information: the element size in bytes, the number of elements in the block, and a pointer that can be used to chain blocks together in singly-linked lists. There are a few functions available to help manage such lists.

Definition at line 42 of file ArenaBlock.h.

Member Typedef Documentation

◆ const_pointer

typedef const char* SG::ArenaBlock::const_pointer

Definition at line 47 of file ArenaBlock.h.

◆ func_t

typedef void SG::ArenaBlock::func_t(pointer)

Function that operates on an element.

Definition at line 50 of file ArenaBlock.h.

◆ pointer

typedef char* SG::ArenaBlock::pointer

Type for a pointer to an element.

Definition at line 46 of file ArenaBlock.h.

Constructor & Destructor Documentation

◆ ArenaBlock() [1/2]

SG::ArenaBlock::ArenaBlock	(	size_t	n,
		size_t	elt_size
	)

private

Prohibit calling these.

◆ ~ArenaBlock()

SG::ArenaBlock::~ArenaBlock ( )

inlineprivate

Definition at line 227 of file ArenaBlock.h.

227 {}

◆ ArenaBlock() [2/2]

SG::ArenaBlock::ArenaBlock ( const ArenaBlock & )

private

Member Function Documentation

◆ appendList()

void SG::ArenaBlock::appendList	(	ArenaBlock **	link,
		ArenaBlock *	tail
	)

static

Concatenate two lists of blocks.

Parameters

headp	Pointer to pointer to the head of the list.
tail	Pointer to list to append to the end.

The list tail is appended to the end of the list *headp. (headp is a pointer-to-pointer to be able to handle the case of an empty list.)

Definition at line 110 of file ArenaBlock.cxx.

 {
   while (*link) {
     link = &(*link)->link();
   }
   *link = tail;
 }

◆ applyList()

void SG::ArenaBlock::applyList	(	ArenaBlock *	p,
		func_t *	func,
		size_t	n
	)

static

Call a function on elements in a list of blocks.

Parameters

p	Pointer to the head of the list.
func	Function to apply.
n	Number of elements in the first block on which to call the function.

This will loop through the elements in all blocks on the list, calling func. In the first block, we apply the function only to the first n elements. In subsequent blocks, the function is applied to all elements.

Parameters

p	Pointer to the head of the list.
func	Function to apply.
Number	of elements in the first block on which to call the function.

This will loop through the elements in all blocks on the list, calling func. In the first block, we apply the function only to the first n elements. In subsequent blocks, the function is applied to all elements.

Definition at line 131 of file ArenaBlock.cxx.

 {
   if (!p) return;
   size_t elt_size = p->eltSize();
   if (n > p->size()) {
     n = p->size();
   }
   while (1) {
     for (size_t i = 0; i < n; i++) {
       func (p->index (i, elt_size));
     }
     p = p->link();
     if (!p) break;
     n = p->size();
   }
 }

◆ destroy()

void SG::ArenaBlock::destroy	(	ArenaBlock *	p,
		func_t *	dtor
	)

static

Destroy a block.

Parameters

p	The block to destroy.
dtor	If non-null, call this function on each element in the block.

Definition at line 69 of file ArenaBlock.cxx.

 {
   if (dtor) {
     size_t elt_size = p->eltSize();
     size_t n = p->size();
     for (size_t i = 0; i < n; i++) {
       dtor (p->index (i, elt_size));
     }
   }
   --s_nactive;
   std::free (p);
 }

◆ destroyList()

void SG::ArenaBlock::destroyList	(	ArenaBlock *	p,
		func_t *	dtor
	)

static

Destroy all blocks in a list.

Parameters

p	The first block to destroy.
dtor	If non-null, call this function on each element in the blocks.

Will destroy all blocks in the linked list headed by p.

Parameters

p	The first block to destroy.
dtor	If non-null, call this function on each element the blocks.

Will destroy all blocks in the linked list headed by p.

Definition at line 91 of file ArenaBlock.cxx.

 {
   while (p) {
     ArenaBlock* next = p->link();
     destroy (p, dtor);
     p = next;
   }
 }

◆ eltSize()

size_t SG::ArenaBlock::eltSize ( ) const

Return the size of the elements in the block.

◆ index() [1/4]

pointer SG::ArenaBlock::index ( size_t i )

Return a pointer to element i in the block.

Parameters

i	The index of the desired element.

◆ index() [2/4]

const_pointer SG::ArenaBlock::index ( size_t i ) const

Return a pointer to element i in the block.

Parameters

i	The index of the desired element.

◆ index() [3/4]

pointer SG::ArenaBlock::index	(	size_t	i,
		size_t	elt_size
	)

Return a pointer to element i in the block.

Parameters

i	The index of the desired element.
elt_size	The block's element size.

This is provided in addition to the previous function as it may allow for better inlined code in when used in a loop, if elt_size is saved in a local.

◆ index() [4/4]

const_pointer SG::ArenaBlock::index	(	size_t	i,
		size_t	elt_size
	)		const

Return a pointer to element i in the block.

Parameters

i	The index of the desired element.
elt_size	The block's element size.

This is provided in addition to the previous function as it may allow for better inlined code in when used in a loop, if elt_size is saved in a local.

◆ link() [1/2]

ArenaBlock* & SG::ArenaBlock::link ( )

Return the link pointer of the block.

◆ link() [2/2]

const ArenaBlock* SG::ArenaBlock::link ( ) const

Return the link pointer of the block.

◆ nactive()

static size_t SG::ArenaBlock::nactive ( )

static

Return the global number of blocks in use.

◆ newBlock()

ArenaBlock * SG::ArenaBlock::newBlock	(	size_t	n,
		size_t	elt_size,
		func_t *	ctor
	)

static

Create a new block.

Parameters

n	The number of elements in the new block.
elt_size	The size in bytes of each element.
ctor	If non-null, call this function on each element in the new block.

The block will be allocated so that it entirely occupies a set of contiguous pages. The requested size may be rounded up for this.

Definition at line 41 of file ArenaBlock.cxx.

 {
   static const size_t pageSize = sysconf (_SC_PAGESIZE);
   size_t tot_size = n*elt_size + ArenaBlockBodyOffset;
   // Round up to a multiple of pageSize.
   size_t tot_size_rounded = (tot_size + (pageSize-1)) & ~(pageSize-1);
   // Number of elements after rounding up.
   size_t n_rounded = (tot_size_rounded - ArenaBlockBodyOffset) / elt_size;
   assert (n_rounded >= n);
   ArenaBlock* p = reinterpret_cast<ArenaBlock*>
     (std::aligned_alloc (pageSize, tot_size_rounded));
   ++s_nactive;
   p->m_link = nullptr;
   p->m_elt_size = elt_size;
   p->m_size = n_rounded;
   if (ctor) {
     for (size_t i = 0; i < n_rounded; i++)
       ctor (p->index (i, elt_size));
   }
   return p;
 }

◆ operator=()

ArenaBlock& SG::ArenaBlock::operator= ( const ArenaBlock & )

private

◆ overhead()

size_t SG::ArenaBlock::overhead ( )

static

Return the per-block memory overhead, in bytes.

This tries to include malloc overhead as well, but that may just be an estimate. Don't rely on this to be exact.

Definition at line 157 of file ArenaBlock.cxx.

 {
   // The extra size_t is a guesstimate of malloc overhead.
   return ArenaBlockBodyOffset + sizeof (size_t);
 }

◆ protect()

void SG::ArenaBlock::protect ( )

Write-protect this block.

Adjust protection on the memory allocated for this block to disallow writes.

Definition at line 170 of file ArenaBlock.cxx.

 {
   int stat = mprotect (this, m_size*m_elt_size+ArenaBlockBodyOffset,
                        PROT_READ);
   if (stat) {
     throw SG::ExcProtection (errno);
   }
 }

◆ protectList()

void SG::ArenaBlock::protectList ( ArenaBlock * p )

static

Write-protect all blocks in a list.

Parameters

p	The first block to protect.

Adjust protection on the memory allocated for these blocks to disallow writes.

Definition at line 203 of file ArenaBlock.cxx.

 {
   for (; p; p = p->link()) {
     p->protect();
   }
 }

◆ size()

size_t SG::ArenaBlock::size ( ) const

Return the number of elements in the block.

◆ unprotect()

void SG::ArenaBlock::unprotect ( )

Write-enable this block.

Adjust protection on the memory allocated for this block to allow writes.

Definition at line 186 of file ArenaBlock.cxx.

 {
   int stat = mprotect (this, m_size*m_elt_size+ArenaBlockBodyOffset,
                        PROT_READ + PROT_WRITE);
   if (stat) {
     throw SG::ExcProtection (errno);
   }
 }

◆ unprotectList()

void SG::ArenaBlock::unprotectList ( ArenaBlock * p )

static

Write-enable all blocks in a list.

Parameters

p	The first block to protect.

Adjust protection on the memory allocated for these blocks to allow writes.

Definition at line 218 of file ArenaBlock.cxx.

 {
   for (; p; p = p->link()) {
     p->unprotect();
   }
 }

Friends And Related Function Documentation

◆ ArenaAllocatorBase

friend class ArenaAllocatorBase

friend

Definition at line 233 of file ArenaBlock.h.

Member Data Documentation

◆ m_dummy

ArenaBlockAlignDetail::padForAlign SG::ArenaBlock::m_dummy

private

Definition at line 246 of file ArenaBlock.h.

◆ m_elt_size

size_t SG::ArenaBlock::m_elt_size

private

Size, in bytes, of each element in this block.

Definition at line 242 of file ArenaBlock.h.

◆ m_link

ArenaBlock* SG::ArenaBlock::m_link

private

The link for the linked list.

Definition at line 236 of file ArenaBlock.h.

◆ m_size

size_t SG::ArenaBlock::m_size

private

Number of elements in this block.

Definition at line 239 of file ArenaBlock.h.

◆ s_nactive

std::atomic< size_t > SG::ArenaBlock::s_nactive

staticprivate

Global count of the number of blocks in use.

Global number of blocks in use.

Definition at line 249 of file ArenaBlock.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ const_pointer

◆ func_t

◆ pointer

Constructor & Destructor Documentation

◆ ArenaBlock() [1/2]

◆ ~ArenaBlock()

◆ ArenaBlock() [2/2]

Member Function Documentation

◆ appendList()

◆ applyList()

◆ destroy()

◆ destroyList()

◆ eltSize()

◆ index() [1/4]

◆ index() [2/4]

◆ index() [3/4]

◆ index() [4/4]

◆ link() [1/2]

◆ link() [2/2]

◆ nactive()

◆ newBlock()

◆ operator=()

◆ overhead()

◆ protect()

◆ protectList()

◆ size()

◆ unprotect()

◆ unprotectList()

Friends And Related Function Documentation

◆ ArenaAllocatorBase

Member Data Documentation

◆ m_dummy

◆ m_elt_size

◆ m_link

◆ m_size

◆ s_nactive