ACE_MMAP_Memory_Pool Class Reference

Make a memory pool that is based on mmap(2). This implementation allows memory to be shared between processes. More...

#include <MMAP_Memory_Pool.h>

Inheritance diagram for ACE_MMAP_Memory_Pool:

[legend]

Collaboration diagram for ACE_MMAP_Memory_Pool:

[legend]

List of all members.

Public Types
typedef ACE_MMAP_Memory_Pool_Options	OPTIONS
Public Member Functions
	ACE_MMAP_Memory_Pool (const ACE_TCHAR backing_store_name=0, const OPTIONS options=0)
	Initialize the pool.
virtual	~ACE_MMAP_Memory_Pool (void)
	Destructor.
virtual void *	init_acquire (size_t nbytes, size_t &rounded_bytes, int &first_time)
	Ask system for initial chunk of shared memory.
virtual void *	acquire (size_t nbytes, size_t &rounded_bytes)
virtual int	release (int destroy=1)
	Instruct the memory pool to release all of its resources.
virtual int	sync (size_t len, int flags=MS_SYNC)
virtual int	sync (int flags=MS_SYNC)
virtual int	sync (void *addr, size_t len, int flags=MS_SYNC)
	Sync the memory region to the backing store starting at addr.
virtual int	protect (size_t len, int prot=PROT_RDWR)
virtual int	protect (int prot=PROT_RDWR)
virtual int	protect (void *addr, size_t len, int prot=PROT_RDWR)
virtual int	seh_selector (void *)
virtual int	remap (void *addr)
virtual void *	base_addr (void) const
	Return the base address of this memory pool.
virtual void	dump (void) const
	Dump the state of an object.
ACE_Mem_Map const &	mmap (void) const
	Get reference to underlying ACE_Mem_Map object.
ACE_Mem_Map &	mmap (void)
	Get reference to underlying ACE_Mem_Map object.
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Protected Member Functions
virtual size_t	round_up (size_t nbytes)
virtual int	commit_backing_store_name (size_t rounded_bytes, size_t &map_size)
virtual int	map_file (size_t map_size)
	Memory map the file up to map_size bytes.
virtual int	handle_signal (int signum, siginfo_t , ucontext_t )
Protected Attributes
ACE_Sig_Handler	signal_handler_
	Handles SIGSEGV.
ACE_Mem_Map	mmap_
	Memory-mapping object.
void *	base_addr_
int	use_fixed_addr_
	Must we use the `base_addr_` or can we let mmap(2) select it?
int	flags_
	Flags passed into ACE_OS::mmap().
bool	write_each_page_
size_t	minimum_bytes_
	What the minimum bytes of the initial segment should be.
ACE_TCHAR	backing_store_name_ [MAXPATHLEN+1]
	Name of the backing store where the shared memory pool is kept.
bool	guess_on_fault_
LPSECURITY_ATTRIBUTES	sa_
	Security attributes object, only used on NT.
mode_t	file_mode_
	Protection mode for mmaped file.
bool	install_signal_handler_
	Should we install a signal handler.

Detailed Description

Make a memory pool that is based on mmap(2). This implementation allows memory to be shared between processes.

Member Typedef Documentation

typedef ACE_MMAP_Memory_Pool_Options ACE_MMAP_Memory_Pool::OPTIONS

Constructor & Destructor Documentation

ACE_MMAP_Memory_Pool::ACE_MMAP_Memory_Pool	(	const ACE_TCHAR *	backing_store_name = `0`,
		const OPTIONS *	options = `0`
	)

Initialize the pool.

ACE_MMAP_Memory_Pool::~ACE_MMAP_Memory_Pool ( void ) [virtual]

Destructor.

Member Function Documentation

void * ACE_MMAP_Memory_Pool::acquire	(	size_t	nbytes,
		size_t &	rounded_bytes
	)			`[virtual]`

Acquire at least nbytes from the memory pool. rounded_bytes is the actual number of bytes allocated. Also acquires an internal semaphore that ensures proper serialization of ACE_MMAP_Memory_Pool initialization across processes.

void * ACE_MMAP_Memory_Pool::base_addr ( void ) const [virtual]

Return the base address of this memory pool.

int ACE_MMAP_Memory_Pool::commit_backing_store_name	(	size_t	rounded_bytes,
		size_t &	map_size
	)			`[protected, virtual]`

Compute the new map_size of the backing store and commit the memory.

virtual void ACE_MMAP_Memory_Pool::dump ( void ) const [virtual]

Dump the state of an object.

int ACE_MMAP_Memory_Pool::handle_signal	(	int	signum,
		siginfo_t *	siginfo,
		ucontext_t *
	)			`[protected, virtual]`

Handle SIGSEGV and SIGBUS signals to remap memory properly. When a process reads or writes to non-mapped memory a signal (SIGBUS or SIGSEGV) will be triggered. At that point, the ACE_Sig_Handler (which is part of the ACE_Reactor) will catch the signal and dispatch the handle_signal() method defined here. If the SIGSEGV signal occurred due to the fact that the mapping wasn't uptodate with respect to the backing store, the handler method below will update the mapping accordingly. When the signal handler returns, the instruction should be restarted and the operation should work.

Reimplemented from ACE_Event_Handler.

void * ACE_MMAP_Memory_Pool::init_acquire	(	size_t	nbytes,
		size_t &	rounded_bytes,
		int &	first_time
	)			`[virtual]`

Ask system for initial chunk of shared memory.

int ACE_MMAP_Memory_Pool::map_file ( size_t map_size ) [protected, virtual]

Memory map the file up to map_size bytes.

ACE_Mem_Map & ACE_MMAP_Memory_Pool::mmap ( void )

Get reference to underlying ACE_Mem_Map object.

ACE_Mem_Map const & ACE_MMAP_Memory_Pool::mmap ( void ) const

Get reference to underlying ACE_Mem_Map object.

int ACE_MMAP_Memory_Pool::protect	(	void *	addr,
		size_t	len,
		int	prot = `PROT_RDWR`
	)			`[virtual]`

Change the protection of the pages of the mapped region to prot starting at addr up to len bytes.

int ACE_MMAP_Memory_Pool::protect ( int prot = PROT_RDWR ) [virtual]

Change the protection of all the pages of the mapped region to prot starting at this->base_addr_.

int ACE_MMAP_Memory_Pool::protect	(	size_t	len,
		int	prot = `PROT_RDWR`
	)			`[virtual]`

Change the protection of the pages of the mapped region to prot starting at this->base_addr_ up to len bytes. If len == -1 then change protection of all pages in the mapped region.

int ACE_MMAP_Memory_Pool::release ( int destroy = 1 ) [virtual]

Instruct the memory pool to release all of its resources.

int ACE_MMAP_Memory_Pool::remap ( void * addr ) [virtual]

Try to extend the virtual address space so that addr is now covered by the address mapping. The method succeeds and returns 0 if the backing store has adequate memory to cover this address. Otherwise, it returns -1. This method is typically called by a UNIX signal handler for SIGSEGV or a Win32 structured exception when another process has grown the backing store (and its mapping) and our process now incurs a fault because our mapping isn't in range (yet).

size_t ACE_MMAP_Memory_Pool::round_up ( size_t nbytes ) [protected, virtual]

Implement the algorithm for rounding up the request to an appropriate chunksize.

virtual int ACE_MMAP_Memory_Pool::seh_selector ( void * ) [virtual]

Win32 Structural exception selector. The return value decides how to handle memory pool related structural exceptions. Returns 1, 0, or , -1.

int ACE_MMAP_Memory_Pool::sync	(	void *	addr,
		size_t	len,
		int	flags = `MS_SYNC`
	)			`[virtual]`

Sync the memory region to the backing store starting at addr.

Reimplemented in ACE_Lite_MMAP_Memory_Pool.

int ACE_MMAP_Memory_Pool::sync ( int flags = MS_SYNC ) [virtual]

Sync the memory region to the backing store starting at this->base_addr_. Will sync as much as the backing file allows.

Reimplemented in ACE_Lite_MMAP_Memory_Pool.

int ACE_MMAP_Memory_Pool::sync	(	size_t	len,
		int	flags = `MS_SYNC`
	)			`[virtual]`

Sync the memory region to the backing store starting at this->base_addr_.

Reimplemented in ACE_Lite_MMAP_Memory_Pool.

Member Data Documentation

ACE_MMAP_Memory_Pool::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

ACE_TCHAR ACE_MMAP_Memory_Pool::backing_store_name_[MAXPATHLEN+1] [protected]

Name of the backing store where the shared memory pool is kept.

void* ACE_MMAP_Memory_Pool::base_addr_ [protected]

Base of mapped region. If this has the value of 0 then the OS is free to select any address to map the file, otherwise this value is what the OS must try to use to mmap the file.

mode_t ACE_MMAP_Memory_Pool::file_mode_ [protected]

Protection mode for mmaped file.

int ACE_MMAP_Memory_Pool::flags_ [protected]

Flags passed into ACE_OS::mmap().

bool ACE_MMAP_Memory_Pool::guess_on_fault_ [protected]

Try to remap without knowing the faulting address. This parameter is ignored on platforms that know the faulting address (UNIX with SI_ADDR and Win32).

bool ACE_MMAP_Memory_Pool::install_signal_handler_ [protected]

Should we install a signal handler.

size_t ACE_MMAP_Memory_Pool::minimum_bytes_ [protected]

What the minimum bytes of the initial segment should be.

ACE_Mem_Map ACE_MMAP_Memory_Pool::mmap_ [protected]

Memory-mapping object.

LPSECURITY_ATTRIBUTES ACE_MMAP_Memory_Pool::sa_ [protected]

Security attributes object, only used on NT.

ACE_Sig_Handler ACE_MMAP_Memory_Pool::signal_handler_ [protected]

Handles SIGSEGV.

int ACE_MMAP_Memory_Pool::use_fixed_addr_ [protected]

Must we use the base_addr_ or can we let mmap(2) select it?