ACE_Shared_Memory_Pool Class Reference

Make a memory pool that is based on System V shared memory (shmget(2) etc.). This implementation allows memory to be shared between processes. If your platform doesn't support System V shared memory (e.g., Win32 and many RTOS platforms do not) then you should use ACE_MMAP_Memory_Pool instead of this class. In fact, you should probably use ACE_MMAP_Memory_Pool on platforms that *do* support System V shared memory since it provides more powerful features, such as persistent backing store and greatly scalability. More...

#include <Shared_Memory_Pool.h>

Inheritance diagram for ACE_Shared_Memory_Pool:

Inheritance graph
[legend]
Collaboration diagram for ACE_Shared_Memory_Pool:

Collaboration graph
[legend]

List of all members.

Public Types

typedef
ACE_Shared_Memory_Pool_Options 
OPTIONS

Public Member Functions

 ACE_Shared_Memory_Pool (const ACE_TCHAR *backing_store_name=0, const OPTIONS *options=0)
 Initialize the pool.
virtual ~ACE_Shared_Memory_Pool (void)
virtual void * init_acquire (size_t nbytes, size_t &rounded_bytes, int &first_time)
 Ask system for initial chunk of local 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 (ssize_t len=-1, 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 (ssize_t len=-1, int prot=PROT_RDWR)
virtual int protect (void *addr, size_t len, int prot=PROT_RDWR)
virtual void * base_addr (void) const
virtual void dump (void) const
 Dump the state of an 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, ACE_OFF_T &offset)
virtual int find_seg (const void *const searchPtr, ACE_OFF_T &offset, size_t &counter)
 Find the segment that contains the searchPtr.
virtual int in_use (ACE_OFF_T &offset, size_t &counter)
 Determine how much memory is currently in use.
virtual int handle_signal (int signum, siginfo_t *, ucontext_t *)

Protected Attributes

void * base_addr_
size_t file_perms_
 File permissions to use when creating/opening a segment.
size_t max_segments_
 Number of shared memory segments in the <SHM_TABLE> table.
ACE_OFF_T minimum_bytes_
 What the minimim bytes of the initial segment should be.
size_t segment_size_
 Shared memory segment size.
key_t base_shm_key_
 Base shared memory key for the segment.
ACE_Sig_Handler signal_handler_
 Handles SIGSEGV.

Classes

struct  SHM_TABLE
 Keeps track of all the segments being used. More...


Detailed Description

Make a memory pool that is based on System V shared memory (shmget(2) etc.). This implementation allows memory to be shared between processes. If your platform doesn't support System V shared memory (e.g., Win32 and many RTOS platforms do not) then you should use ACE_MMAP_Memory_Pool instead of this class. In fact, you should probably use ACE_MMAP_Memory_Pool on platforms that *do* support System V shared memory since it provides more powerful features, such as persistent backing store and greatly scalability.

Member Typedef Documentation


Constructor & Destructor Documentation

ACE_Shared_Memory_Pool::ACE_Shared_Memory_Pool ( const ACE_TCHAR backing_store_name = 0,
const OPTIONS options = 0 
)

Initialize the pool.

ACE_Shared_Memory_Pool::~ACE_Shared_Memory_Pool ( void   )  [virtual]


Member Function Documentation

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

Ask system for initial chunk of local memory.

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

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

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

Instruct the memory pool to release all of its resources.

int ACE_Shared_Memory_Pool::sync ( ssize_t  len = -1,
int  flags = MS_SYNC 
) [virtual]

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

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

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

int ACE_Shared_Memory_Pool::protect ( ssize_t  len = -1,
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_Shared_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.

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

Return the base address of this memory pool, 0 if base_addr never changes.

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

Dump the state of an object.

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

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

int ACE_Shared_Memory_Pool::commit_backing_store_name ( size_t  rounded_bytes,
ACE_OFF_T offset 
) [protected, virtual]

Commits a new shared memory segment if necessary after an <acquire> or a signal. offset is set to the new offset into the backing store.

int ACE_Shared_Memory_Pool::find_seg ( const void *const   searchPtr,
ACE_OFF_T offset,
size_t &  counter 
) [protected, virtual]

Find the segment that contains the searchPtr.

int ACE_Shared_Memory_Pool::in_use ( ACE_OFF_T offset,
size_t &  counter 
) [protected, virtual]

Determine how much memory is currently in use.

int ACE_Shared_Memory_Pool::handle_signal ( int  signum,
siginfo_t siginfo,
ucontext_t  
) [protected, virtual]

Handle SIGSEGV and SIGBUS signals to remap shared memory properly.

Reimplemented from ACE_Event_Handler.


Member Data Documentation

Declare the dynamic allocation hooks.

Base address of the shared memory segment. If this has the value of 0 then the OS is free to select any address, otherwise this value is what the OS must try to use to map the shared memory segment.

File permissions to use when creating/opening a segment.

Number of shared memory segments in the <SHM_TABLE> table.

What the minimim bytes of the initial segment should be.

Shared memory segment size.

Base shared memory key for the segment.

Handles SIGSEGV.


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

Generated on Wed Apr 23 02:41:28 2008 for ACE by  doxygen 1.5.5