block_pool Class Reference

An abstract base class for pooled memory allocation. More...

#include <blockpool.h>

Inheritance diagram for block_pool:

[legend]Collaboration diagram for block_pool:

[legend]List of all members.

Public Types
typedef block_chain	blk_chain
	This provides a publicly visible "type handle" that references a private type.
Public Member Functions
	block_pool (void)
void	free_pool (void)
	Walk through the block chain and deallocate the blocks.
void *	pool_alloc (unsigned int block_size)
	This function is called to allocate memory from the memory pool.
void	print_block_pool_info (FILE *fp=stdout)
	Print information about the block pool.
virtual void	getinfo (unsigned int &p_size, unsigned int &a_gran)=0
virtual void *	MemAlloc (unsigned int n_bytes)=0
virtual void	MemFree (void *addr)=0
Private Types
typedef block_pool::block_chain_struct	block_chain
enum	bogus { max_block_multiple = 256 }
	the largest block of memory that can be allocated is the page_size * max_block_multiple More...
Private Member Functions
blk_chain *	new_block (unsigned int block_size)
	The new_block function is the "root" memory allocator for the block_pool object.
void *	add_block (unsigned int block_size)
	Add a new memory block to the memory pool.
void	init_pool (void)
Private Attributes
unsigned int	page_size
unsigned int	alloc_gran
block_chain *	block_list_start
	start of the block list for this pool
block_chain *	current_block
	current block memory is being allocated from

---

Detailed Description

An abstract base class for pooled memory allocation.

Definition at line 95 of file blockpool.h.

---

Member Typedef Documentation

typedef block_chain block_pool::blk_chain

This provides a publicly visible "type handle" that references a private type. Sun is quite permissive and does not require this sort of contortion, but HP does. Definition at line 126 of file blockpool.h.

typedef struct block_pool::block_chain_struct block_pool::block_chain [private]

---

Member Enumeration Documentation

enum block_pool::bogus [private]

the largest block of memory that can be allocated is the page_size * max_block_multiple Enumeration values: max_block_multiple  Definition at line 99 of file blockpool.h. { max_block_multiple = 256 } bogus;

---

Constructor & Destructor Documentation

block_pool::block_pool (  void   )

Definition at line 33 of file blockpool.C. References alloc_gran, block_list_start, current_block, NULL, and page_size. { page_size = 0; alloc_gran = 0; current_block = NULL; block_list_start = NULL; } // block_pool constructor

---

Member Function Documentation

void * block_pool::add_block (  unsigned int  block_size  )  [private]

Add a new memory block to the memory pool. This function is called when the amount of memory requested by pool_alloc will not fit in the current block. Definition at line 133 of file blockpool.C. References Chain_next, current_block, new_block(), and NULL. Referenced by pool_alloc(). { block_chain *block = NULL; block_chain *last_block; last_block = current_block; block = new_block( block_size ); Chain_next(current_block) = block; current_block = block; return (void *)block; } // block_chain::add_block

void block_pool::free_pool (  void   )

Walk through the block chain and deallocate the blocks. Note that the block chain structures and the allocatible memory is contained within a single allocated block. The block_chain structure is at the start of this block so passing its address to the memory deallocation function deallocates both the block chain structure and the allocatible memory Definition at line 70 of file blockpool.C. References block_list_start, Chain_next, MemFree(), and NULL. Referenced by big_block_pool::~big_block_pool(). { block_chain *tmp; while (block_list_start != NULL) { tmp = block_list_start; block_list_start = Chain_next(block_list_start); MemFree( (void *)tmp ); } }

virtual void block_pool::getinfo (  unsigned int &  p_size, unsigned int &  a_gran )  [pure virtual]

Implemented in big_block_pool. Referenced by init_pool().

void block_pool::init_pool (  void   )  [private]

Definition at line 47 of file blockpool.C. References alloc_gran, block_list_start, current_block, getinfo(), new_block(), and page_size. Referenced by pool_alloc(). { block_chain *new_link; getinfo(page_size, alloc_gran); new_link = new_block( alloc_gran ); block_list_start = new_link; current_block = new_link; } /* init_pool */

virtual void* block_pool::MemAlloc (  unsigned int  n_bytes  )  [pure virtual]

Implemented in big_block_pool. Referenced by new_block().

virtual void block_pool::MemFree (  void *  addr  )  [pure virtual]

Implemented in big_block_pool. Referenced by free_pool().

block_pool::blk_chain * block_pool::new_block (  unsigned int  block_size  )  [private]

The new_block function is the "root" memory allocator for the block_pool object. The amount of memory allocated is rounded up to the next "block_size" boundary. Both the block_chain structure and the allocatible memory are allocated from a single block that is a multiple of the page size. This should avoid fragmentation in the system memory allocator. Definition at line 90 of file blockpool.C. References alloc_gran, Chain_block, Chain_block_size, Chain_bytes_used, Chain_next, max_block_multiple, MemAlloc(), NULL, and page_size. Referenced by add_block(), and init_pool(). { const unsigned int max_block_size = max_block_multiple * page_size; block_chain *new_link = NULL; unsigned int alloc_amt, total_alloc; // add in the memory needed for the block_chain structure total_alloc = block_size + sizeof(block_chain); if (total_alloc < alloc_gran) alloc_amt = alloc_gran; else { // its larger than the allocation granularity, so round // up the the nearest page. alloc_amt = ((total_alloc + (page_size-1))/page_size) * page_size; } if (alloc_amt <= max_block_size) { /* allocate memory for both the block_chain structure and the memory block */ new_link = (block_chain *)MemAlloc( alloc_amt ); // The new memory block starts after the block_chain structure Chain_block(new_link) = (void *)(((unsigned int)new_link) + sizeof(block_chain)); assert( alloc_amt >= block_size ); Chain_bytes_used(new_link) = 0; Chain_block_size(new_link) = alloc_amt - sizeof(block_chain); Chain_next(new_link) = NULL; } else { printf("block_pool::new_block: allocation request too large\n"); } return new_link; } // block_chain::new_block

void * block_pool::pool_alloc (  unsigned int  num_bytes  )

This function is called to allocate memory from the memory pool. If there is enough free memory in the current block to satisify the memory request, memory is allocated from the current block and the amount of free memory is updated. If the current block does not have enough memory, add_block is called to allocate a new memory block which will be large enough. Definition at line 156 of file blockpool.C. References add_block(), Chain_block, Chain_block_size, Chain_bytes_used, current_block, init_pool(), and NULL. { const unsigned int align = sizeof( int ); void *addr = NULL; unsigned int amt_free; /* the number of bytes allocated must be a multiple of the align size */ num_bytes = ((num_bytes + (align-1))/align) * align; if (current_block == NULL) { init_pool(); } amt_free = Chain_block_size(current_block) - Chain_bytes_used(current_block); if (num_bytes > amt_free) { if (add_block( num_bytes ) != NULL) { amt_free = Chain_block_size(current_block); } } if (amt_free >= num_bytes) { addr = (void *)((unsigned int)Chain_block(current_block) + Chain_bytes_used(current_block)); Chain_bytes_used(current_block) += num_bytes; } else { printf("block_pool::block_alloc: allocation error\n"); exit(1); } return addr; } // block_pool::pool_alloc

void block_pool::print_block_pool_info (  FILE *  fp = stdout  )

Print information about the block pool. Definition at line 194 of file blockpool.C. References block_list_start, Chain_block_size, Chain_bytes_used, Chain_next, and NULL. { int total_allocated = 0; int total_unused = 0; block_chain *ptr = block_list_start; fprintf(fp, "[block size, bytes_used]\n"); while (ptr != NULL) { fprintf(fp, "[%4d, %4d]", Chain_block_size(ptr), Chain_bytes_used(ptr)); total_allocated += Chain_bytes_used(ptr); total_unused += (Chain_block_size(ptr) - Chain_bytes_used(ptr)); if (Chain_next(ptr) != NULL) { fprintf(fp, ", "); } else { fprintf(fp, "\n"); } ptr = Chain_next(ptr); } // while fprintf(fp, "Total allocated = %5d, total unused = %3d\n", total_allocated, total_unused ); }

---

Member Data Documentation

unsigned int block_pool::alloc_gran [private]

Definition at line 113 of file blockpool.h. Referenced by block_pool(), init_pool(), and new_block().

block_chain* block_pool::block_list_start [private]

start of the block list for this pool Definition at line 116 of file blockpool.h. Referenced by block_pool(), free_pool(), init_pool(), and print_block_pool_info().

block_chain* block_pool::current_block [private]

current block memory is being allocated from Definition at line 118 of file blockpool.h. Referenced by add_block(), block_pool(), init_pool(), and pool_alloc().

unsigned int block_pool::page_size [private]

Definition at line 112 of file blockpool.h. Referenced by block_pool(), init_pool(), and new_block().

---

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

• blockpool.h
• blockpool.C

---