UCommon
Public Member Functions | Protected Member Functions | Protected Attributes | Friends
ucommon::memalloc Class Reference

A memory protocol pager for private heap manager. More...

#include <memory.h>

Inheritance diagram for ucommon::memalloc:
Inheritance graph
[legend]
Collaboration diagram for ucommon::memalloc:
Collaboration graph
[legend]

Public Member Functions

virtual void * _alloc (size_t size)
 Allocate memory from the pager heap.
unsigned getAlloc (void)
 Get the size of a memory page.
unsigned getLimit (void)
 Get the maximum number of pages that are permitted.
unsigned getPages (void)
 Get the number of pages that have been allocated from the real heap.
 memalloc (size_t page=0)
 Construct a memory pager.
void purge (void)
 Purge all allocated memory and heap pages immediately.
unsigned utilization (void)
 Determine fragmentation level of acquired heap pages.
virtual ~memalloc ()
 Destroy a memory pager.
- Public Member Functions inherited from ucommon::MemoryProtocol
void * alloc (size_t size)
 Convenience function.
char * dup (const char *string)
 Duplicate NULL terminated string into allocated memory.
void * dup (void *memory, size_t size)
 Duplicate existing memory block into allocated memory.
void * zalloc (size_t size)
 Allocate memory from the pager heap.

Protected Member Functions

page_t * pager (void)
 Acquire a new page from the heap.
- Protected Member Functions inherited from ucommon::MemoryProtocol
virtual void * _alloc (size_t size)=0
 Protocol to allocate memory from the pager heap.
virtual void _lock (void)
virtual void _unlock (void)

Protected Attributes

unsigned limit

Friends

class bufpager

Detailed Description

A memory protocol pager for private heap manager.

This is used to allocate in an optimized manner, as it assumes no mutex locks are held or used as part of it's own internal processing. It also is designed for optimized performance.

Author:
David Sugar dyfet.nosp@m.@gnu.nosp@m.telep.nosp@m.hony.nosp@m..org

Definition at line 56 of file memory.h.


Constructor & Destructor Documentation

ucommon::memalloc::memalloc ( size_t  page = 0)

Construct a memory pager.

Parameters:
pagesize to use or 0 for OS allocation size.
virtual ucommon::memalloc::~memalloc ( )
virtual

Destroy a memory pager.

Release all pages back to the heap at once.


Member Function Documentation

virtual void* ucommon::memalloc::_alloc ( size_t  size)
virtual

Allocate memory from the pager heap.

The size of the request must be less than the size of the memory page used. This implements the memory protocol allocation method.

Parameters:
sizeof memory request.
Returns:
allocated memory or NULL if not possible.

Reimplemented in ucommon::bufpager, and ucommon::mempager.

unsigned ucommon::memalloc::getAlloc ( void  )
inline

Get the size of a memory page.

Returns:
size of each pager heap allocation.

Definition at line 116 of file memory.h.

unsigned ucommon::memalloc::getLimit ( void  )
inline

Get the maximum number of pages that are permitted.

One can use a derived class to set and enforce a maximum limit to the number of pages that will be allocated from the real heap. This is often used to detect and bring down apps that are leaking.

Returns:
page allocation limit.

Definition at line 109 of file memory.h.

unsigned ucommon::memalloc::getPages ( void  )
inline

Get the number of pages that have been allocated from the real heap.

Returns:
pages allocated from heap.

Reimplemented in ucommon::assoc_pointer< T, I, M, P >.

Definition at line 99 of file memory.h.

page_t* ucommon::memalloc::pager ( void  )
protected

Acquire a new page from the heap.

This is mostly used internally.

Returns:
page structure of the newly acquired memory page.
unsigned ucommon::memalloc::utilization ( void  )

Determine fragmentation level of acquired heap pages.

This is represented as an average % utilization (0-100) and represents the used portion of each allocated heap page verse the page size. Since requests that cannot fit on an already allocated page are moved into a new page, there is some unusable space left over at the end of the page. When utilization approaches 100, this is good. A low utilization may suggest a larger page size should be used.

Returns:
pager utilization.

Reimplemented in ucommon::assoc_pointer< T, I, M, P >, and ucommon::mempager.


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