ACE/ace/Shared_Memory_Pool.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file     Shared_Memory_Pool.h
   6  *
   7  *  @author Dougls C. Schmidt <d.schmidt@vanderbilt.edu>
   8  *  @author Prashant Jain <pjain@cs.wustl.edu>
   9  */
  10 //=============================================================================
  11
  12 #ifndef ACE_SHARED_MEMORY_POOL_H
  13 #define ACE_SHARED_MEMORY_POOL_H
  14
  15 #include /**/ "ace/pre.h"
  16
  17 #include /**/ "ace/ACE_export.h"
  18
  19 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  20 # pragma once
  21 #endif /* ACE_LACKS_PRAGMA_ONCE */
  22
  23 #if !defined (ACE_LACKS_SYSV_SHMEM)
  24
  25 #include "ace/ACE.h"
  26 #include "ace/Event_Handler.h"
  27 #include "ace/Sig_Handler.h"
  28 #include "ace/os_include/sys/os_mman.h"
  29
  30 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  31
  32 /**
  33  * @class ACE_Shared_Memory_Pool_Options
  34  *
  35  * @brief Helper class for Shared Memory Pool constructor options.
  36  *
  37  * This should be a nested class, but that breaks too many
  38  * compilers.
  39  */
  40 class ACE_Export ACE_Shared_Memory_Pool_Options
  41 {
  42 public:
  43   /// Initialization method.
  44   ACE_Shared_Memory_Pool_Options (
  45     const char *base_addr = ACE_DEFAULT_BASE_ADDR,
  46     size_t max_segments = ACE_DEFAULT_MAX_SEGMENTS,
  47     size_t file_perms = ACE_DEFAULT_FILE_PERMS,
  48     ACE_OFF_T minimum_bytes = 0,
  49     size_t segment_size = ACE_DEFAULT_SEGMENT_SIZE);
  50
  51   /// Base address of the memory-mapped backing store.
  52   const char *base_addr_;
  53
  54   /// Number of shared memory segments to allocate.
  55   size_t max_segments_;
  56
  57   /// What the minimum bytes of the initial segment should be.
  58   ACE_OFF_T minimum_bytes_;
  59
  60   /// File permissions to use when creating/opening a segment.
  61   size_t file_perms_;
  62
  63   /// Shared memory segment size.
  64   size_t segment_size_;
  65 };
  66
  67 /**
  68  * @class ACE_Shared_Memory_Pool
  69  *
  70  * @brief Make a memory pool that is based on System V shared memory
  71  * (shmget(2) etc.).  This implementation allows memory to be
  72  * shared between processes.  If your platform doesn't support
  73  * System V shared memory (e.g., Win32 and many RTOS platforms
  74  * do not) then you should use ACE_MMAP_Memory_Pool instead of this
  75  * class.  In fact, you should probably use ACE_MMAP_Memory_Pool on
  76  * platforms that *do* support System V shared memory since it
  77  * provides more powerful features, such as persistent backing store
  78  * and greatly scalability.
  79  */
  80 class ACE_Export ACE_Shared_Memory_Pool : public ACE_Event_Handler
  81 {
  82 public:
  83   typedef ACE_Shared_Memory_Pool_Options OPTIONS;
  84
  85   /// Initialize the pool.
  86   ACE_Shared_Memory_Pool (const ACE_TCHAR *backing_store_name = 0,
  87                           const OPTIONS *options = 0);
  88
  89   virtual ~ACE_Shared_Memory_Pool (void);
  90
  91   /// Ask system for initial chunk of local memory.
  92   virtual void *init_acquire (size_t nbytes,
  93                               size_t &rounded_bytes,
  94                               int &first_time);
  95
  96   /**
  97    * Acquire at least @a nbytes from the memory pool. @a rounded_byes is
  98    * the actual number of bytes allocated.  Also acquires an internal
  99    * semaphore that ensures proper serialization of Memory_Pool
 100    * initialization across processes.
 101    */
 102   virtual void *acquire (size_t nbytes,
 103                          size_t &rounded_bytes);
 104
 105   /// Instruct the memory pool to release all of its resources.
 106   virtual int release (int destroy = 1);
 107
 108   /// Sync the memory region to the backing store starting at
 109   /// @c this->base_addr_.
 110   virtual int sync (ssize_t len = -1, int flags = MS_SYNC);
 111
 112   /// Sync the memory region to the backing store starting at @a addr.
 113   virtual int sync (void *addr, size_t len, int flags = MS_SYNC);
 114
 115   /**
 116    * Change the protection of the pages of the mapped region to @a prot
 117    * starting at @c this->base_addr_ up to @a len bytes.  If @a len == -1
 118    * then change protection of all pages in the mapped region.
 119    */
 120   virtual int protect (ssize_t len = -1, int prot = PROT_RDWR);
 121
 122   /// Change the protection of the pages of the mapped region to @a prot
 123   /// starting at @a addr up to @a len bytes.
 124   virtual int protect (void *addr, size_t len, int prot = PROT_RDWR);
 125
 126   /// Return the base address of this memory pool, 0 if base_addr
 127   /// never changes.
 128   virtual void *base_addr (void) const;
 129
 130   /// Dump the state of an object.
 131   virtual void dump (void) const;
 132
 133   /// Declare the dynamic allocation hooks.
 134   ACE_ALLOC_HOOK_DECLARE;
 135
 136 protected:
 137   /// Implement the algorithm for rounding up the request to an
 138   /// appropriate chunksize.
 139   virtual size_t round_up (size_t nbytes);
 140
 141   /**
 142    * Commits a new shared memory segment if necessary after an
 143    * acquire() or a signal.  @a offset is set to the new offset into
 144    * the backing store.
 145    */
 146   virtual int commit_backing_store_name (size_t rounded_bytes,
 147                                          ACE_OFF_T &offset);
 148
 149   /// Keeps track of all the segments being used.
 150   struct SHM_TABLE
 151   {
 152     /// Shared memory segment key.
 153     key_t key_;
 154
 155     /// Shared memory segment internal id.
 156     int shmid_;
 157
 158     /// Is the segment currently used.;
 159     int used_;
 160   };
 161
 162   /**
 163    * Base address of the shared memory segment.  If this has the value
 164    * of 0 then the OS is free to select any address, otherwise this
 165    * value is what the OS must try to use to map the shared memory
 166    * segment.
 167    */
 168   void *base_addr_;
 169
 170   /// File permissions to use when creating/opening a segment.
 171   size_t file_perms_;
 172
 173   /// Number of shared memory segments in the <SHM_TABLE> table.
 174   size_t max_segments_;
 175
 176   /// What the minimim bytes of the initial segment should be.
 177   ACE_OFF_T minimum_bytes_;
 178
 179   /// Shared memory segment size.
 180   size_t segment_size_;
 181
 182   /// Base shared memory key for the segment.
 183   key_t base_shm_key_;
 184
 185   /// Find the segment that contains the @a searchPtr
 186   virtual int find_seg (const void *const searchPtr,
 187                         ACE_OFF_T &offset,
 188                         size_t &counter);
 189
 190   /// Determine how much memory is currently in use.
 191   virtual int in_use (ACE_OFF_T &offset,
 192                       size_t &counter);
 193
 194   /// Handles SIGSEGV.
 195   ACE_Sig_Handler signal_handler_;
 196
 197   /// Handle SIGSEGV and SIGBUS signals to remap shared memory
 198   /// properly.
 199   virtual int handle_signal (int, siginfo_t *siginfo, ucontext_t *);
 200 };
 201
 202 ACE_END_VERSIONED_NAMESPACE_DECL
 203
 204 #endif /* !ACE_LACKS_SYSV_SHMEM */
 205
 206 #include /**/ "ace/post.h"
 207
 208 #endif /* ACE_SHARED_MEMORY_POOL_H */