ACE  6.1.4
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Public Types | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | List of all members
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]

Classes

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

Public Types

typedef
ACE_Shared_Memory_Pool_Options 
OPTIONS
 
- Public Types inherited from ACE_Event_Handler
enum  {
  LO_PRIORITY = 0, HI_PRIORITY = 10, NULL_MASK = 0, READ_MASK = (1 << 0),
  WRITE_MASK = (1 << 1), EXCEPT_MASK = (1 << 2), ACCEPT_MASK = (1 << 3), CONNECT_MASK = (1 << 4),
  TIMER_MASK = (1 << 5), QOS_MASK = (1 << 6), GROUP_QOS_MASK = (1 << 7), SIGNAL_MASK = (1 << 8),
  ALL_EVENTS_MASK, RWE_MASK, DONT_CALL = (1 << 9)
}
 
enum  { ACE_EVENT_HANDLER_NOT_RESUMED = -1, ACE_REACTOR_RESUMES_HANDLER = 0, ACE_APPLICATION_RESUMES_HANDLER }
 
typedef long Reference_Count
 Reference count type.
 

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 Member Functions inherited from ACE_Event_Handler
virtual ~ACE_Event_Handler (void)
 Destructor is virtual to enable proper cleanup.
 
virtual ACE_HANDLE get_handle (void) const
 Get the I/O handle.
 
virtual void set_handle (ACE_HANDLE)
 Set the I/O handle.
 
virtual int priority (void) const
 
virtual void priority (int priority)
 Set the priority of the Event_Handler.
 
virtual int handle_input (ACE_HANDLE fd=ACE_INVALID_HANDLE)
 Called when input events occur (e.g., connection or data).
 
virtual int handle_output (ACE_HANDLE fd=ACE_INVALID_HANDLE)
 
virtual int handle_exception (ACE_HANDLE fd=ACE_INVALID_HANDLE)
 Called when an exceptional events occur (e.g., SIGURG).
 
virtual int handle_timeout (const ACE_Time_Value &current_time, const void *act=0)
 
virtual int handle_exit (ACE_Process *)
 Called when a process exits.
 
virtual int handle_close (ACE_HANDLE handle, ACE_Reactor_Mask close_mask)
 
virtual int resume_handler (void)
 
virtual int handle_qos (ACE_HANDLE=ACE_INVALID_HANDLE)
 
virtual int handle_group_qos (ACE_HANDLE=ACE_INVALID_HANDLE)
 
virtual void reactor (ACE_Reactor *reactor)
 Set the event demultiplexors.
 
virtual ACE_Reactorreactor (void) const
 Get the event demultiplexors.
 
virtual
ACE_Reactor_Timer_Interface
reactor_timer_interface (void) const
 Get only the reactor's timer related interface.
 
virtual Reference_Count add_reference (void)
 Increment reference count on the handler.
 
virtual Reference_Count remove_reference (void)
 Decrement reference count on the handler.
 
Reference_Counting_Policyreference_counting_policy (void)
 Current Reference_Counting_Policy.
 

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 Member Functions inherited from ACE_Event_Handler
 ACE_Event_Handler (ACE_Reactor *=0, int priority=ACE_Event_Handler::LO_PRIORITY)
 Force ACE_Event_Handler to be an abstract base class.
 

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.
 
- Protected Attributes inherited from ACE_Event_Handler
Atomic_Reference_Count reference_count_
 Reference count.
 

Additional Inherited Members

- Static Public Member Functions inherited from ACE_Event_Handler
static ACE_THR_FUNC_RETURN read_adapter (void *event_handler)
 
static int register_stdin_handler (ACE_Event_Handler *eh, ACE_Reactor *reactor, ACE_Thread_Manager *thr_mgr, int flags=THR_DETACHED)
 
static int remove_stdin_handler (ACE_Reactor *reactor, ACE_Thread_Manager *thr_mgr)
 Performs the inverse of the register_stdin_handler() method.
 
- Protected Types inherited from ACE_Event_Handler
typedef ACE_Atomic_Op
< ACE_SYNCH_MUTEX,
Reference_Count
Atomic_Reference_Count
 Typedef for implementation of reference counting.
 

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::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.

void * ACE_Shared_Memory_Pool::base_addr ( void  ) const
virtual

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

int ACE_Shared_Memory_Pool::commit_backing_store_name ( size_t  rounded_bytes,
ACE_OFF_T offset 
)
protectedvirtual

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.

void ACE_Shared_Memory_Pool::dump ( void  ) const
virtual

Dump the state of an object.

int ACE_Shared_Memory_Pool::find_seg ( const void *const  searchPtr,
ACE_OFF_T offset,
size_t &  counter 
)
protectedvirtual

Find the segment that contains the searchPtr.

int ACE_Shared_Memory_Pool::handle_signal ( int  signum,
siginfo_t siginfo,
ucontext_t  
)
protectedvirtual

Handle SIGSEGV and SIGBUS signals to remap shared memory properly.

Reimplemented from ACE_Event_Handler.

int ACE_Shared_Memory_Pool::in_use ( ACE_OFF_T offset,
size_t &  counter 
)
protectedvirtual

Determine how much memory is currently in use.

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.

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.

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

Instruct the memory pool to release all of its resources.

size_t ACE_Shared_Memory_Pool::round_up ( size_t  nbytes)
protectedvirtual

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

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.

Member Data Documentation

ACE_Shared_Memory_Pool::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

void* ACE_Shared_Memory_Pool::base_addr_
protected

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.

key_t ACE_Shared_Memory_Pool::base_shm_key_
protected

Base shared memory key for the segment.

size_t ACE_Shared_Memory_Pool::file_perms_
protected

File permissions to use when creating/opening a segment.

size_t ACE_Shared_Memory_Pool::max_segments_
protected

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

ACE_OFF_T ACE_Shared_Memory_Pool::minimum_bytes_
protected

What the minimim bytes of the initial segment should be.

size_t ACE_Shared_Memory_Pool::segment_size_
protected

Shared memory segment size.

ACE_Sig_Handler ACE_Shared_Memory_Pool::signal_handler_
protected

Handles SIGSEGV.


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