A class template that uses parameterized types to provide an extensible mechanism for encapsulating various dynamic memory management strategies. More...

#include <Malloc_T.h>

Collaboration diagram for ACE_Malloc_T< ACE_MEM_POOL_1, ACE_LOCK, ACE_CB >:

[legend]

List of all members.

Public Types
typedef ACE_MEM_POOL	MEMORY_POOL
typedef ACE_MEM_POOL_OPTIONS	MEMORY_POOL_OPTIONS
typedef ACE_CB::ACE_Name_Node	NAME_NODE
typedef ACE_CB::ACE_Malloc_Header	MALLOC_HEADER
Public Member Functions
	ACE_Malloc_T (const ACE_TCHAR *pool_name=0)
	ACE_Malloc_T (const ACE_TCHAR pool_name, const ACE_TCHAR lock_name, const ACE_MEM_POOL_OPTIONS *options=0)
	ACE_Malloc_T (const ACE_TCHAR pool_name, const ACE_MEM_POOL_OPTIONS options, ACE_LOCK *lock)
	~ACE_Malloc_T (void)
	Destructor.
int	ref_counter (void)
	Get Reference counter.
int	release (int close=0)
	Release ref counter.
int	remove (void)
	Releases resources allocated by this object.
void *	malloc (size_t nbytes)
	Allocate nbytes, but don't give them any initial value.
void *	calloc (size_t nbytes, char initial_value= '\0')
	Allocate nbytes, giving them initial_value.
void *	calloc (size_t n_elem, size_t elem_size, char initial_value= '\0')
void	free (void *ptr)
MEMORY_POOL &	memory_pool (void)
	Returns a reference to the underlying memory pool.
int	bind (const char name, void pointer, int duplicates=0)
int	trybind (const char name, void &pointer)
int	find (const char name, void &pointer)
int	find (const char *name)
	Returns 0 if name is in the mapping. -1, otherwise.
int	unbind (const char *name)
int	unbind (const char name, void &pointer)
int	sync (ssize_t len=-1, int flags=MS_SYNC)
int	sync (void *addr, size_t len, int flags=MS_SYNC)
int	protect (ssize_t len=-1, int prot=PROT_RDWR)
int	protect (void *addr, size_t len, int prot=PROT_RDWR)
ssize_t	avail_chunks (size_t size) const
ACE_LOCK &	mutex (void)
void	dump (void) const
	Dump the state of an object.
void *	base_addr (void)
	Return cb_ptr value.
int	bad (void)
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Private Member Functions
int	open (void)
	Initialize the Malloc pool.
int	shared_bind (const char name, void pointer)
void *	shared_find (const char *name)
void *	shared_malloc (size_t nbytes)
	Allocate memory. Assumes that locks are held by callers.
void	shared_free (void *ptr)
	Deallocate memory. Assumes that locks are held by callers.
Private Attributes
ACE_CB *	cb_ptr_
MEMORY_POOL	memory_pool_
	Pool of memory used by ACE_Malloc to manage its freestore.
ACE_LOCK *	lock_
	Lock that ensures mutual exclusion for the memory pool.
bool	delete_lock_
	True if destructor should delete the lock.
int	bad_flag_
	Keep track of failure in constructor.
Friends
class	ACE_Malloc_LIFO_Iterator_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_CB >
class	ACE_Malloc_FIFO_Iterator_T< ACE_MEM_POOL_2, ACE_LOCK, ACE_CB >

Detailed Description

template<ACE_MEM_POOL_1, class ACE_LOCK, class ACE_CB>
class ACE_Malloc_T< ACE_MEM_POOL_1, ACE_LOCK, ACE_CB >

A class template that uses parameterized types to provide an extensible mechanism for encapsulating various dynamic memory management strategies.

This class can be configured flexibly with different MEMORY_POOL strategies and different types of ACE_LOCK strategies that support the ACE_Thread_Mutex and ACE_Process_Mutex constructor API.

Common MEMORY_POOL strategies to use with this class are:

The MEMORY_POOL class must provide the following methods:

constructor (const ACE_TCHAR *pool_name)
constructor (const ACE_TCHAR *pool_name, const MEMORY_POOL_OPTIONS *options)
void dump (void) const (needed if ACE is built with ACE_HAS_DUMP defined)
void *init_acquire (size_t nbytes, size_t &rounded_bytes, int &first_time);
int release (void)
void *acquire (size_t nbytes, size_t &rounded_bytes)
void *base_addr (void)
seh_selector() (only needed on Windows)

Note that the ACE_Allocator_Adapter class can be used to integrate allocator classes which do not meet the interface requirements of ACE_Malloc_T.

The bind() and find() methods use linear search, so it's not a good idea to use them for managing a large number of entities. If you need to manage a large number of entities, it's recommended that you bind() an ACE_Hash_Map_Manager that resides in shared memory, use find() to locate it, and then store/retrieve the entities in the hash map.