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>
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.
|
Protected Attributes |
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
Constructor & Destructor Documentation
ACE_MMAP_Memory_Pool::ACE_MMAP_Memory_Pool |
( |
const ACE_TCHAR * |
backing_store_name = 0 , |
|
|
const OPTIONS * |
options = 0 | |
|
) |
| | |
ACE_MMAP_Memory_Pool::~ACE_MMAP_Memory_Pool |
( |
void |
|
) |
[virtual] |
Member Function Documentation
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.
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.
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::sync |
( |
size_t |
len, |
|
|
int |
flags = MS_SYNC | |
|
) |
| | [virtual] |
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 |
( |
void * |
addr, |
|
|
size_t |
len, |
|
|
int |
flags = MS_SYNC | |
|
) |
| | [virtual] |
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::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 |
( |
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::seh_selector |
( |
void * |
ep |
) |
[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::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).
void * ACE_MMAP_Memory_Pool::base_addr |
( |
void |
|
) |
const [virtual] |
Return the base address of this memory pool.
ACE_BEGIN_VERSIONED_NAMESPACE_DECL void ACE_MMAP_Memory_Pool::dump |
( |
void |
|
) |
const [virtual] |
Dump the state of an object.
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Mem_Map const & ACE_MMAP_Memory_Pool::mmap |
( |
void |
|
) |
const |
ACE_INLINE ACE_Mem_Map & ACE_MMAP_Memory_Pool::mmap |
( |
void |
|
) |
|
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.
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.
int ACE_MMAP_Memory_Pool::map_file |
( |
size_t |
map_size |
) |
[protected, virtual] |
Memory map the file up to map_size bytes.
Member Data Documentation
Declare the dynamic allocation hooks.
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.
Must we use the base_addr_
or can we let mmap(2) select it?
Should we write a byte to each page to forceably allocate memory for this backing store?
What the minimum bytes of the initial segment should be.
Name of the backing store where the shared memory pool is kept.
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).
Security attributes object, only used on NT.
Protection mode for mmaped file.
Should we install a signal handler.
The documentation for this class was generated from the following files: