dep/ACE_wrappers/ace/MEM_SAP.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    MEM_SAP.h
   6  *
   7  *  $Id: MEM_SAP.h 80826 2008-03-04 14:51:23Z wotte $
   8  *
   9  *  @author Nanbor Wang <nanbor@cs.wustl.edu>
  10  */
  11 //=============================================================================
  12
  13 #ifndef ACE_MEM_SAP_H
  14 #define ACE_MEM_SAP_H
  15
  16 #include /**/ "ace/pre.h"
  17
  18 #include /**/ "ace/ACE_export.h"
  19
  20 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  21 # pragma once
  22 #endif /* ACE_LACKS_PRAGMA_ONCE */
  23
  24 // MEM_SAP requries position independent pointers to work
  25 #if (ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1)
  26
  27 #include "ace/PI_Malloc.h"
  28 #include "ace/Malloc_T.h"
  29 #include "ace/MMAP_Memory_Pool.h"
  30 #include "ace/Process_Mutex.h"
  31
  32 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  33
  34 class ACE_MEM_SAP;
  35 class ACE_Reactive_MEM_IO;
  36 class ACE_MT_MEM_IO;
  37 class ACE_MEM_IO;
  38
  39 // Internal data structure
  40 // MEM_SAP uses to queue up
  41 // data.
  42 class ACE_MEM_SAP_Node
  43 {
  44 public:
  45 //    friend class ACE_MEM_SAP;
  46 //    friend class ACE_Reactive_MEM_IO;
  47 //    friend class ACE_MT_MEM_IO;
  48 //    friend class ACE_MEM_IO;
  49
  50   typedef ACE_Based_Pointer<ACE_MEM_SAP_Node> ACE_MEM_SAP_NODE_PTR;
  51
  52   /// Initialize the node with its capacity.
  53   ACE_MEM_SAP_Node (size_t cap);
  54
  55   /// Get the size of the data we hold.
  56   size_t size (void) const;
  57
  58   /// Get the capacity of this block of data.
  59   size_t capacity (void) const;
  60
  61   /// Get the pointer to the block of data we hold.
  62   void *data (void);
  63
  64   /// The maximum size of this memory block.
  65   size_t capacity_;
  66
  67   /// The actualy size used.
  68   size_t size_;
  69
  70   ACE_MEM_SAP_NODE_PTR next_;
  71 };
  72
  73 /**
  74  * @class ACE_MEM_SAP
  75  *
  76  * @brief Defines the methods of shared memory management for
  77  * shared memory transport.
  78  */
  79 class ACE_Export ACE_MEM_SAP
  80 {
  81 public:
  82   // = Initialization and termination methods.
  83
  84   typedef ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block> MALLOC_TYPE;
  85   typedef ACE_MMAP_Memory_Pool_Options MALLOC_OPTIONS;
  86
  87   /// Destructor.
  88   virtual ~ACE_MEM_SAP (void);
  89
  90   /**
  91    * Initialize the MEM_SAP object.
  92    */
  93   virtual int init (ACE_HANDLE handle,
  94                     const ACE_TCHAR *name,
  95                     MALLOC_OPTIONS *options) = 0;
  96
  97   /**
  98    * Finalizing the MEM_SAP object.  This method doesn't invoke
  99    * the <remove> method.
 100    */
 101   virtual int fini ();
 102
 103   /**
 104    * Fetch location of next available data into <recv_buffer_>.
 105    * As this operation read the address of the data off the socket
 106    * using ACE::recv, @a timeout only applies to ACE::recv.
 107    */
 108   virtual ssize_t recv_buf (ACE_MEM_SAP_Node *&buf,
 109                             int flags,
 110                             const ACE_Time_Value *timeout) = 0;
 111
 112   /**
 113    * Wait to to @a timeout amount of time to send @a buf.  If <send>
 114    * times out a -1 is returned with @c errno == ETIME.  If it succeeds
 115    * the number of bytes sent is returned.  */
 116   virtual ssize_t send_buf (ACE_MEM_SAP_Node *buf,
 117                             int flags,
 118                             const ACE_Time_Value *timeout) = 0;
 119
 120   /// request a buffer of size @a size.  Return 0 if the <shm_malloc_> is
 121   /// not initialized.
 122   ACE_MEM_SAP_Node *acquire_buffer (const ssize_t size);
 123
 124   /// release a buffer pointed by @a buf.  Return -1 if the <shm_malloc_>
 125   /// is not initialized.
 126   int release_buffer (ACE_MEM_SAP_Node *buf);
 127
 128   /// Dump the state of an object.
 129   void dump (void) const;
 130
 131   /// Declare the dynamic allocation hooks.
 132   ACE_ALLOC_HOOK_DECLARE;
 133
 134 protected:
 135   // = Class initializing methods to create/connect to a shared memory pool.
 136
 137   /**
 138    * Create a new shm_malloc object.  Return 0 if succeed and -1
 139    * otherwise.  This method should only be called from an acceptor
 140    * class that wants to create a new memory pool for inter process
 141    * communication.
 142    */
 143   int create_shm_malloc (const ACE_TCHAR *name,
 144                          MALLOC_OPTIONS *options);
 145
 146   /// Close down the share memory pool.  Clean up the
 147   /// mmap file if we are the last one using it.
 148   int close_shm_malloc (void);
 149
 150   ACE_HANDLE handle_;
 151
 152   /// Data exchange channel.
 153   MALLOC_TYPE *shm_malloc_;
 154
 155   /// Constructor.  Prevent this class from being instantiated.
 156   ACE_MEM_SAP (void);
 157 };
 158
 159 ACE_END_VERSIONED_NAMESPACE_DECL
 160
 161 #if defined (__ACE_INLINE__)
 162 #include "ace/MEM_SAP.inl"
 163 #endif /* __ACE_INLINE__ */
 164
 165 #endif /* ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1 */
 166
 167 #include /**/ "ace/post.h"
 168
 169 #endif /* ACE_SOCK_IO_H */