ACE/ace/Sbrk_Memory_Pool.cpp

   1 #include "ace/OS_NS_unistd.h"
   2 #include "ace/Sbrk_Memory_Pool.h"
   3 #include "ace/Log_Category.h"
   4 #include "ace/Malloc_Base.h"
   5
   6
   7 #if !defined (ACE_LACKS_SBRK)
   8
   9 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  10
  11 ACE_ALLOC_HOOK_DEFINE(ACE_Sbrk_Memory_Pool)
  12
  13 // Ask system for more local memory via sbrk(2).
  14
  15 void *
  16 ACE_Sbrk_Memory_Pool::acquire (size_t nbytes,
  17                                size_t &rounded_bytes)
  18 {
  19   ACE_TRACE ("ACE_Sbrk_Memory_Pool::acquire");
  20   rounded_bytes = this->round_up (nbytes);
  21   // ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("(%P|%t) acquiring more chunks, nbytes = %d, rounded_bytes = %d\n"), nbytes, rounded_bytes));
  22   void *cp = ACE_OS::sbrk (rounded_bytes);
  23
  24   if (cp == MAP_FAILED)
  25     ACELIB_ERROR_RETURN ((LM_ERROR,
  26                        "(%P|%t) cp = %u\n",
  27                        cp),
  28                       0);
  29   else
  30     // ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("(%P|%t) acquired more chunks, nbytes = %d, rounded_bytes = %d, new break = %u\n"), nbytes, rounded_bytes, cp));
  31   return cp;
  32 }
  33
  34 /* No-op for now... */
  35
  36 int
  37 ACE_Sbrk_Memory_Pool::release (int)
  38 {
  39   ACE_TRACE ("ACE_Sbrk_Memory_Pool::release");
  40   return 0;
  41 }
  42
  43 int
  44 ACE_Sbrk_Memory_Pool::sync (ssize_t, int)
  45 {
  46   ACE_TRACE ("ACE_Sbrk_Memory_Pool::sync");
  47   return 0;
  48 }
  49
  50 int
  51 ACE_Sbrk_Memory_Pool::sync (void *, size_t, int)
  52 {
  53   ACE_TRACE ("ACE_Sbrk_Memory_Pool::sync");
  54   return 0;
  55 }
  56
  57 int
  58 ACE_Sbrk_Memory_Pool::protect (ssize_t, int)
  59 {
  60   ACE_TRACE ("ACE_Sbrk_Memory_Pool::protect");
  61   return 0;
  62 }
  63
  64 int
  65 ACE_Sbrk_Memory_Pool::protect (void *, size_t, int)
  66 {
  67   ACE_TRACE ("ACE_Sbrk_Memory_Pool::protect");
  68   return 0;
  69 }
  70
  71 // Ask system for initial chunk of local memory.
  72
  73 void *
  74 ACE_Sbrk_Memory_Pool::init_acquire (size_t nbytes,
  75                                     size_t &rounded_bytes,
  76                                     int &first_time)
  77 {
  78   ACE_TRACE ("ACE_Sbrk_Memory_Pool::init_acquire");
  79   // Note that we assume that when ACE_Sbrk_Memory_Pool is used,
  80   // ACE_Malloc's constructor will only get called once.  If this
  81   // assumption doesn't hold, we are in deep trouble!
  82
  83   first_time = 1;
  84   return this->acquire (nbytes, rounded_bytes);
  85 }
  86
  87 void
  88 ACE_Sbrk_Memory_Pool::dump (void) const
  89 {
  90 #if defined (ACE_HAS_DUMP)
  91   ACE_TRACE ("ACE_Sbrk_Memory_Pool::dump");
  92 #endif /* ACE_HAS_DUMP */
  93 }
  94
  95 ACE_Sbrk_Memory_Pool::ACE_Sbrk_Memory_Pool (const ACE_TCHAR *,
  96                                             const OPTIONS *)
  97 {
  98   ACE_TRACE ("ACE_Sbrk_Memory_Pool::ACE_Sbrk_Memory_Pool");
  99 }
 100
 101 ACE_Sbrk_Memory_Pool::~ACE_Sbrk_Memory_Pool (void)
 102 {
 103 }
 104
 105 void *
 106 ACE_Sbrk_Memory_Pool::base_addr (void) const
 107 {
 108   return 0;
 109 }
 110
 111 // Round up the request to a multiple of the page size.
 112
 113 size_t
 114 ACE_Sbrk_Memory_Pool::round_up (size_t nbytes)
 115 {
 116   ACE_TRACE ("ACE_Sbrk_Memory_Pool::round_up");
 117   return ACE::round_to_pagesize (nbytes);
 118 }
 119
 120 ACE_END_VERSIONED_NAMESPACE_DECL
 121
 122 #endif /* !ACE_LACKS_SBRK */