src/system/libroot/posix/malloc/block.h

   1 ///-*-C++-*-//////////////////////////////////////////////////////////////////
   2 //
   3 // Hoard: A Fast, Scalable, and Memory-Efficient Allocator
   4 //        for Shared-Memory Multiprocessors
   5 // Contact author: Emery Berger, http://www.cs.utexas.edu/users/emery
   6 //
   7 // Copyright (c) 1998-2000, The University of Texas at Austin.
   8 //
   9 // This library is free software; you can redistribute it and/or modify
  10 // it under the terms of the GNU Library General Public License as
  11 // published by the Free Software Foundation, http://www.fsf.org.
  12 //
  13 // This library is distributed in the hope that it will be useful, but
  14 // WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 // Library General Public License for more details.
  17 //
  18 //////////////////////////////////////////////////////////////////////////////
  19
  20 #ifndef _BLOCK_H_
  21 #define _BLOCK_H_
  22
  23 #include "config.h"
  24
  25 //#include <assert.h>
  26
  27 namespace BPrivate {
  28
  29 class superblock;
  30
  31 class block {
  32         public:
  33                 block(superblock * sb)
  34                         :
  35 #if HEAP_DEBUG
  36                         _magic(FREE_BLOCK_MAGIC),
  37 #endif
  38                         _next(NULL), _mySuperblock(sb)
  39                 {
  40                 }
  41
  42                 block &
  43                 operator=(const block & b)
  44                 {
  45 #if HEAP_DEBUG
  46                         _magic = b._magic;
  47 #endif
  48                         _next = b._next;
  49                         _mySuperblock = b._mySuperblock;
  50 #if HEAP_FRAG_STATS
  51                         _requestedSize = b._requestedSize;
  52 #endif
  53                         return *this;
  54                 }
  55
  56                 enum {
  57                         ALLOCATED_BLOCK_MAGIC = 0xcafecafe,
  58                         FREE_BLOCK_MAGIC = 0xbabebabe
  59                 };
  60
  61                 // Mark this block as free.
  62                 inline void markFree(void);
  63
  64                 // Mark this block as allocated.
  65                 inline void markAllocated(void);
  66
  67                 // Is this block valid? (i.e.,
  68                 // does it have the right magic number?)
  69                 inline const int isValid(void) const;
  70
  71                 // Return the block's superblock pointer.
  72                 inline superblock *getSuperblock(void);
  73
  74 #if HEAP_FRAG_STATS
  75                 void
  76                 setRequestedSize(size_t s)
  77                 {
  78                         _requestedSize = s;
  79                 }
  80
  81                 size_t
  82                 getRequestedSize(void)
  83                 {
  84                         return _requestedSize;
  85                 }
  86 #endif
  87
  88 #if USE_PRIVATE_HEAPS
  89                 void
  90                 setActualSize(size_t s)
  91                 {
  92                         _actualSize = s;
  93                 }
  94
  95                 size_t
  96                 getActualSize(void)
  97                 {
  98                         return _actualSize;
  99                 }
 100 #endif
 101                 void
 102                 setNext(block * b)
 103                 {
 104                         _next = b;
 105                 }
 106
 107                 block *
 108                 getNext(void)
 109                 {
 110                         return _next;
 111                 }
 112
 113 #if HEAP_LEAK_CHECK
 114                 void
 115                 setCallStack(int index, void *address)
 116                 {
 117                         _callStack[index] = address;
 118                 }
 119
 120                 void *
 121                 getCallStack(int index)
 122                 {
 123                         return _callStack[index];
 124                 }
 125
 126                 void
 127                 setAllocatedSize(size_t size)
 128                 {
 129                         _allocatedSize = size;
 130                 }
 131
 132                 size_t
 133                 getAllocatedSize()
 134                 {
 135                         return _allocatedSize;
 136                 }
 137 #endif
 138
 139         private:
 140 #if USE_PRIVATE_HEAPS
 141 #if HEAP_DEBUG
 142                 union {
 143                         unsigned long _magic;
 144                         double _d1;                             // For alignment.
 145                 };
 146 #endif
 147
 148                 block *_next;                           // The next block in a linked-list of blocks.
 149                 size_t _actualSize;                     // The actual size of the block.
 150
 151                 union {
 152                         double _d2;                             // For alignment.
 153                         superblock *_mySuperblock;      // A pointer to my superblock.
 154                 };
 155 #else // ! USE_PRIVATE_HEAPS
 156
 157 #if HEAP_DEBUG
 158                 union {
 159                         unsigned long _magic;
 160                         double _d3;                             // For alignment.
 161                 };
 162 #endif
 163
 164                 block *_next;                           // The next block in a linked-list of blocks.
 165                 superblock *_mySuperblock;      // A pointer to my superblock.
 166 #endif // USE_PRIVATE_HEAPS
 167
 168 #if HEAP_LEAK_CHECK
 169                 void *_callStack[HEAP_CALL_STACK_SIZE];
 170                 size_t _allocatedSize;
 171 #endif
 172
 173 #if HEAP_FRAG_STATS
 174                 union {
 175                         double _d4;                             // This is just for alignment purposes.
 176                         size_t _requestedSize;  // The amount of space requested (vs. allocated).
 177                 };
 178 #endif
 179
 180                 // Disable copying.
 181                 block(const block &);
 182 };
 183
 184
 185 superblock *
 186 block::getSuperblock(void)
 187 {
 188 #if HEAP_DEBUG
 189         assert(isValid());
 190 #endif
 191
 192         return _mySuperblock;
 193 }
 194
 195
 196 void
 197 block::markFree(void)
 198 {
 199 #if HEAP_DEBUG
 200         assert(_magic == ALLOCATED_BLOCK_MAGIC);
 201         _magic = FREE_BLOCK_MAGIC;
 202 #endif
 203 }
 204
 205
 206 void
 207 block::markAllocated(void)
 208 {
 209 #if HEAP_DEBUG
 210         assert(_magic == FREE_BLOCK_MAGIC);
 211         _magic = ALLOCATED_BLOCK_MAGIC;
 212 #endif
 213 }
 214
 215
 216 const int
 217 block::isValid(void) const
 218 {
 219 #if HEAP_DEBUG
 220         return _magic == FREE_BLOCK_MAGIC
 221                 || _magic == ALLOCATED_BLOCK_MAGIC;
 222 #else
 223         return 1;
 224 #endif
 225 }
 226
 227 }       // namespace BPrivate
 228
 229 #endif // _BLOCK_H_