Make a memory pool that is based on "anonymous" memory regions allocated from the Win32 page file.  
 More...
#include <Pagefile_Memory_Pool.h>
|  | 
|  | ACE_Pagefile_Memory_Pool (const ACE_TCHAR *backing_store_name=0, const OPTIONS *options=0) | 
|  | Initialize the pool.  More... 
 | 
|  | 
| virtual | ~ACE_Pagefile_Memory_Pool (void) | 
|  | Destructor.  More... 
 | 
|  | 
| void * | init_acquire (size_t nbytes, size_t &rounded_bytes, int &first_time) | 
|  | Ask system for initial chunk of shared memory.  More... 
 | 
|  | 
| void * | acquire (size_t nbytes, size_t &rounded_bytes) | 
|  | 
| int | release (int destroy=1) | 
|  | Instruct the memory pool to release all of its resources.  More... 
 | 
|  | 
| virtual int | seh_selector (void *) | 
|  | 
| int | remap (void *addr) | 
|  | 
| size_t | round_to_page_size (size_t nbytes) | 
|  | Round up to system page size.  More... 
 | 
|  | 
| size_t | round_to_chunk_size (size_t nbytes) | 
|  | Round up to the chunk size required by the operation system.  More... 
 | 
|  | 
| int | sync (ssize_t=-1, int=MS_SYNC) | 
|  | 
| int | sync (void *, size_t, int=MS_SYNC) | 
|  | 
| int | protect (ssize_t=-1, int=PROT_RDWR) | 
|  | 
| int | protect (void *, size_t, int=PROT_RDWR) | 
|  | 
| virtual void * | base_addr (void) const | 
|  | 
| void | dump (void) const | 
|  | 
|  | 
| int | map (int &firstTime, size_t appendBytes=0) | 
|  | 
| int | unmap (void) | 
|  | Release the mapping.  More... 
 | 
|  | 
Make a memory pool that is based on "anonymous" memory regions allocated from the Win32 page file. 
      
        
          | ACE_Pagefile_Memory_Pool::ACE_Pagefile_Memory_Pool | ( | const ACE_TCHAR * | backing_store_name = 0, | 
        
          |  |  | const OPTIONS * | options = 0 | 
        
          |  | ) |  |  | 
      
 
 
  
  | 
        
          | ACE_Pagefile_Memory_Pool::~ACE_Pagefile_Memory_Pool | ( | void |  | ) |  |  | virtual | 
 
 
      
        
          | void * ACE_Pagefile_Memory_Pool::acquire | ( | size_t | nbytes, | 
        
          |  |  | size_t & | rounded_bytes | 
        
          |  | ) |  |  | 
      
 
Acquire at least nbytes from the memory pool. <rounded_bytes> is the actual number of bytes allocated. 
 
 
  
  | 
        
          | void * ACE_Pagefile_Memory_Pool::base_addr | ( | void |  | ) | const |  | inlinevirtual | 
 
Return the base address of this memory pool, 0 if base_addr never changes. 
 
 
  
  | 
        
          | void ACE_Pagefile_Memory_Pool::dump | ( | void |  | ) | const |  | inline | 
 
 
      
        
          | void * ACE_Pagefile_Memory_Pool::init_acquire | ( | size_t | nbytes, | 
        
          |  |  | size_t & | rounded_bytes, | 
        
          |  |  | int & | first_time | 
        
          |  | ) |  |  | 
      
 
Ask system for initial chunk of shared memory. 
 
 
  
  | 
        
          | int ACE_Pagefile_Memory_Pool::map | ( | int & | firstTime, |  
          |  |  | size_t | appendBytes = 0 |  
          |  | ) |  |  |  | protected | 
 
Map portions or the entire pool into the local virtual address space. To do this, we compute the new file_offset of the backing store and commit the memory. 
 
 
  
  | 
        
          | int ACE_Pagefile_Memory_Pool::protect | ( | void * | , |  
          |  |  | size_t | , |  
          |  |  | int | = PROT_RDWR |  
          |  | ) |  |  |  | inline | 
 
 
      
        
          | int ACE_Pagefile_Memory_Pool::release | ( | int | destroy = 1 | ) |  | 
      
 
Instruct the memory pool to release all of its resources. 
 
 
      
        
          | int ACE_Pagefile_Memory_Pool::remap | ( | void * | addr | ) |  | 
      
 
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 an exception handler for 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_Pagefile_Memory_Pool::round_to_chunk_size | ( | size_t | nbytes | ) |  |  | inline | 
 
Round up to the chunk size required by the operation system. 
 
 
  
  | 
        
          | size_t ACE_Pagefile_Memory_Pool::round_to_page_size | ( | size_t | nbytes | ) |  |  | inline | 
 
Round up to system page size. 
 
 
  
  | 
        
          | int ACE_Pagefile_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_Pagefile_Memory_Pool::sync | ( | void * | , |  
          |  |  | size_t | , |  
          |  |  | int | = MS_SYNC |  
          |  | ) |  |  |  | inline | 
 
 
  
  | 
        
          | int ACE_Pagefile_Memory_Pool::unmap | ( | void |  | ) |  |  | protected | 
 
 
Name of the backing store where the shared memory pool is kept. 
 
 
Description of what our process mapped. 
 
 
  
  | 
        
          | ACE_HANDLE ACE_Pagefile_Memory_Pool::object_handle_ |  | private | 
 
 
  
  | 
        
          | size_t ACE_Pagefile_Memory_Pool::page_size_ |  | private | 
 
 
Shared memory pool statistics. 
 
 
The documentation for this class was generated from the following files: