My Project  debian-1:4.1.2-p1+ds-2
Macros | Functions
omAllocSystem.c File Reference
#include <unistd.h>
#include <limits.h>
#include "omConfig.h"
#include "omDefaultConfig.h"
#include "omMalloc.h"
#include "omalloc.h"
#include <string.h>

Go to the source code of this file.

Macros

#define OM_ALLOC_SYSTEM_C
 
#define OM_MALLOC_FROM_SYSTEM   OM_MALLOC_MALLOC
 
#define OM_REALLOC_FROM_SYSTEM   OM_MALLOC_REALLOC
 
#define OM_FREE_TO_SYSTEM   OM_MALLOC_FREE
 
#define _omSizeOfLargeAddr(addr)   (*((size_t*) ((char*) addr - SIZEOF_STRICT_ALIGNMENT)))
 
#define OM_VALLOC_FROM_SYSTEM   omEmulateValloc
 
#define OM_VFREE_TO_SYSTEM   omEmulateVfree
 
#define OM_ALIGN_PAGE(addr)   ( ((long)addr + (SIZEOF_SYSTEM_PAGE -1)) & ~(SIZEOF_SYSTEM_PAGE - 1))
 

Functions

void * omAllocLarge (size_t size)
 
void * omReallocLarge (void *old_addr, size_t new_size)
 
void omFreeLarge (void *addr)
 
void * omAlloc0Large (size_t size)
 
void * omRealloc0Large (void *old_addr, size_t new_size)
 
size_t omSizeOfLargeAddr (void *addr)
 
size_t omSizeOfAddr (const void *addr)
 
size_t omSizeWOfAddr (void *addr)
 
void * omEmulateValloc (size_t size)
 
void omEmulateVfree (void *addr, size_t size)
 
void * omAllocFromSystem (size_t size)
 
void * omReallocFromSystem (void *addr, size_t newsize)
 
void * omReallocSizeFromSystem (void *addr, size_t oldsize, size_t newsize)
 
void omFreeToSystem (void *addr)
 
void omFreeSizeToSystem (void *addr, size_t size)
 
void * _omVallocFromSystem (size_t size, int fail)
 
void omVfreeToSystem (void *page, size_t size)
 

Macro Definition Documentation

◆ _omSizeOfLargeAddr

#define _omSizeOfLargeAddr (   addr)    (*((size_t*) ((char*) addr - SIZEOF_STRICT_ALIGNMENT)))

Definition at line 69 of file omAllocSystem.c.

◆ OM_ALIGN_PAGE

#define OM_ALIGN_PAGE (   addr)    ( ((long)addr + (SIZEOF_SYSTEM_PAGE -1)) & ~(SIZEOF_SYSTEM_PAGE - 1))

Definition at line 146 of file omAllocSystem.c.

◆ OM_ALLOC_SYSTEM_C

#define OM_ALLOC_SYSTEM_C

Definition at line 7 of file omAllocSystem.c.

◆ OM_FREE_TO_SYSTEM

#define OM_FREE_TO_SYSTEM   OM_MALLOC_FREE

Definition at line 24 of file omAllocSystem.c.

◆ OM_MALLOC_FROM_SYSTEM

#define OM_MALLOC_FROM_SYSTEM   OM_MALLOC_MALLOC

Definition at line 22 of file omAllocSystem.c.

◆ OM_REALLOC_FROM_SYSTEM

#define OM_REALLOC_FROM_SYSTEM   OM_MALLOC_REALLOC

Definition at line 23 of file omAllocSystem.c.

◆ OM_VALLOC_FROM_SYSTEM

#define OM_VALLOC_FROM_SYSTEM   omEmulateValloc

Definition at line 143 of file omAllocSystem.c.

◆ OM_VFREE_TO_SYSTEM

#define OM_VFREE_TO_SYSTEM   omEmulateVfree

Definition at line 144 of file omAllocSystem.c.

Function Documentation

◆ _omVallocFromSystem()

void* _omVallocFromSystem ( size_t  size,
int  fail 
)

Definition at line 306 of file omAllocSystem.c.

311 {
312  void* page = OM_VALLOC_FROM_SYSTEM(size);
313  if (page == NULL)
314  {
315  OM_MEMORY_LOW_HOOK();
316  page = OM_VALLOC_FROM_SYSTEM(size);
317  if (page == NULL)
318  {
319  if (fail) return NULL;
320  else
321  {
322  OM_OUT_OF_MEMORY_HOOK();
323  /* should never get here */
324  omAssume(0);
325  exit(1);
326  }
327  }
328  }
329 
330 #ifndef OM_NDEBUG
331  if (((unsigned long) page) + size > om_MaxAddr)
332  om_MaxAddr = ((unsigned long) page) + size;
333  if (((unsigned long) page) < om_MinAddr)
334  om_MinAddr = ((unsigned long) page);
335 #endif
336 
338  om_Info.CurrentBytesFromValloc += size;
339  if (om_Info.CurrentBytesFromValloc > om_Info.MaxBytesFromValloc)
340  {
341  om_Info.MaxBytesFromValloc = om_Info.CurrentBytesFromValloc;
342 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
343  if (om_Info.MaxBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
344  om_Info.MaxBytesSystem = om_Info.MaxBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
345 #endif
346 #if defined(HAVE_SBRK) && !defined(OM_HAVE_VALLOC_MMAP) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
347  if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
348  if (om_Info.CurrentBytesFromMalloc + om_Info.CurrentBytesFromValloc > om_Info.MaxBytesSbrk)
349  {
350  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
351  omAssume(om_Info.MaxBytesSbrk >= om_Info.CurrentBytesFromMalloc
352  + om_Info.CurrentBytesFromValloc);
353  }
354 #endif

◆ omAlloc0Large()

void* omAlloc0Large ( size_t  size)

Definition at line 72 of file omAllocSystem.c.

75 {
76  void* addr = omAllocLarge(size);
77  memset(addr, 0, size);

◆ omAllocFromSystem()

void* omAllocFromSystem ( size_t  size)

Definition at line 182 of file omAllocSystem.c.

187 {
188  void* ptr;
189 
191  if (ptr == NULL)
192  {
193  OM_MEMORY_LOW_HOOK();
195  if (ptr == NULL)
196  {
197  OM_OUT_OF_MEMORY_HOOK();
198  exit(1);
199  }
200  }
201 #if defined(HAVE_MALLOC_SIZE) || defined(HAVE_MALLOC_USABLE_SIZE)
203 #else
204  size=omSizeOfAddr(ptr);
205 #endif
206 #ifndef OM_NDEBUG
207  if (((unsigned long) ptr) + size > om_MaxAddr)
208  om_MaxAddr = ((unsigned long) ptr) + size;
209  if (((unsigned long) ptr) < om_MinAddr)
210  om_MinAddr = ((unsigned long) ptr);
211 #endif
212 
213  om_Info.CurrentBytesFromMalloc += size;
214  if (om_Info.CurrentBytesFromMalloc > om_Info.MaxBytesFromMalloc)
215  {
216  om_Info.MaxBytesFromMalloc = om_Info.CurrentBytesFromMalloc;
217 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
218  if (om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
219  om_Info.MaxBytesSystem = om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
220 #endif
221 #if defined(HAVE_SBRK) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
222  if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
223  if (om_Info.MaxBytesFromMalloc
224 #ifndef OM_HAVE_VALLOC_MMAP
225  + om_Info.CurrentBytesFromValloc
226 #endif
227  > om_Info.MaxBytesSbrk)
228  {
229  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
230  }
231 #endif

◆ omAllocLarge()

void* omAllocLarge ( size_t  size)

Definition at line 38 of file omAllocSystem.c.

41 {
42  char* addr;
43  size = OM_ALIGN_SIZE(size);
44  addr = omAllocFromSystem(size + SIZEOF_STRICT_ALIGNMENT);
45  *((size_t*) addr) = size;

◆ omEmulateValloc()

void* omEmulateValloc ( size_t  size)

Definition at line 148 of file omAllocSystem.c.

152 {
153  void* addr;
154  size_t padding = SIZEOF_VOIDP;
155  size = OM_ALIGN_SIZE(size);
156  while (1)
157  {
158  addr = OM_MALLOC_FROM_SYSTEM(size + padding);
159  if (addr == NULL) return NULL;
160  if ((OM_ALIGN_PAGE(addr) + SIZEOF_VOIDP) - (long) addr <= padding)
161  {
162  void* ret_addr = (void*) OM_ALIGN_PAGE(addr);
163  *((void**) ((void*) ret_addr + size)) = addr;
164  return ret_addr;
165  }
166  else
167  {
168  OM_FREE_TO_SYSTEM(addr);
169  padding = padding << 1;

◆ omEmulateVfree()

void omEmulateVfree ( void *  addr,
size_t  size 
)

Definition at line 171 of file omAllocSystem.c.

175 {

◆ omFreeLarge()

void omFreeLarge ( void *  addr)

Definition at line 63 of file omAllocSystem.c.

66 {
67  char* _addr = (char *)addr - SIZEOF_STRICT_ALIGNMENT;

◆ omFreeSizeToSystem()

void omFreeSizeToSystem ( void *  addr,
size_t  size 
)

Definition at line 299 of file omAllocSystem.c.

299 {
300  omFreeSizeToSystem(addr, omSizeOfAddr(addr));
301 }
302 
303 void omFreeSizeToSystem(void* addr, size_t size)
304 {

◆ omFreeToSystem()

void omFreeToSystem ( void *  addr)

Definition at line 294 of file omAllocSystem.c.

299 {

◆ omRealloc0Large()

void* omRealloc0Large ( void *  old_addr,
size_t  new_size 
)

Definition at line 79 of file omAllocSystem.c.

82 {
83  size_t old_size;
84  char* new_addr;
85 
86  omAssume(!omIsBinPageAddr(old_addr));
87 
88  old_size = omSizeOfLargeAddr(old_addr);
89 
90  new_addr = omReallocLarge(old_addr, new_size);
91  new_size = omSizeOfLargeAddr(new_addr);
92  if (new_size > old_size)
93  memset(new_addr + old_size, 0, new_size - old_size);

◆ omReallocFromSystem()

void* omReallocFromSystem ( void *  addr,
size_t  newsize 
)

Definition at line 233 of file omAllocSystem.c.

238 {

◆ omReallocLarge()

void* omReallocLarge ( void *  old_addr,
size_t  new_size 
)

Definition at line 47 of file omAllocSystem.c.

50 {
51  char* _old_addr;
52  char* new_addr;
53 
54  omAssume(omIsLargeAddr(old_addr));
55 
56  new_size = OM_ALIGN_SIZE(new_size);
57  _old_addr = (char *)old_addr - SIZEOF_STRICT_ALIGNMENT;
58  new_addr = omReallocSizeFromSystem(_old_addr,
59  *((size_t*) _old_addr) + SIZEOF_STRICT_ALIGNMENT,
60  new_size + SIZEOF_STRICT_ALIGNMENT);
61  *((size_t*) new_addr) = new_size;

◆ omReallocSizeFromSystem()

void* omReallocSizeFromSystem ( void *  addr,
size_t  oldsize,
size_t  newsize 
)

Definition at line 238 of file omAllocSystem.c.

238 {
239  return omReallocSizeFromSystem(addr, omSizeOfAddr(addr), newsize);
240 }
241 
242 void* omReallocSizeFromSystem(void* addr, size_t oldsize, size_t newsize)
243 {
244  void* res;
245 
246  /*oldsize=omSizeOfLargeAddr(addr);*/
247  res = OM_REALLOC_FROM_SYSTEM(addr, newsize);
248  if (res == NULL)
249  {
250  OM_MEMORY_LOW_HOOK();
251  /* Can do a realloc again: manpage reads:
252  "If realloc() fails the original block is left untouched -
253  it is not freed or moved." */
254  res = OM_REALLOC_FROM_SYSTEM(addr, newsize);
255  if (res == NULL)
256  {
257  OM_OUT_OF_MEMORY_HOOK();
258  /* should never get here */
259  omAssume(0);
260  exit(1);
261  }
262  }
263  /*newsize=omSizeOfAddr(res);*/
264 
265 #ifndef OM_NDEBUG
266  if (((unsigned long) res) + newsize > om_MaxAddr)
267  om_MaxAddr = ((unsigned long) res) + newsize;
268  if (((unsigned long) res) < om_MinAddr)
269  om_MinAddr = ((unsigned long) res);
270 #endif
271 
272  om_Info.CurrentBytesFromMalloc += (long) newsize - (long) oldsize;
273 
274 
275  if (om_Info.CurrentBytesFromMalloc > om_Info.MaxBytesFromMalloc)
276  {
277  om_Info.MaxBytesFromMalloc = om_Info.CurrentBytesFromMalloc;
278 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
279  if (om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
280  om_Info.MaxBytesSystem = om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
281 #endif
282 #if defined(HAVE_SBRK) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
283  if (om_Info.MaxBytesFromMalloc
284 #ifndef OM_HAVE_VALLOC_MMAP
285  + om_Info.CurrentBytesFromValloc
286 #endif
287  > om_Info.MaxBytesSbrk)
288  {
289  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
290  }
291 #endif
292  }

◆ omSizeOfAddr()

size_t omSizeOfAddr ( const void *  addr)

Definition at line 100 of file omAllocSystem.c.

103 {
104  /*if (addr==NULL) return 0; */
105 
106  return (omIsBinPageAddr(addr) ?
107 #ifdef OM_HAVE_TRACK
108  (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr((char *)addr) : omSizeOfBinAddr(addr)) :
109 #else
110  omSizeOfBinAddr(addr) :
111 #endif

◆ omSizeOfLargeAddr()

size_t omSizeOfLargeAddr ( void *  addr)

Definition at line 95 of file omAllocSystem.c.

98 {

◆ omSizeWOfAddr()

size_t omSizeWOfAddr ( void *  addr)

Definition at line 113 of file omAllocSystem.c.

116 {
117 
118  return (omIsBinPageAddr(addr) ?
119 #ifdef OM_HAVE_TRACK
120  (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr(addr) >> LOG_SIZEOF_LONG : omSizeWOfBinAddr(addr)) :
121 #else
122  omSizeWOfBinAddr(addr) :
123 #endif

◆ omVfreeToSystem()

void omVfreeToSystem ( void *  page,
size_t  size 
)

Definition at line 356 of file omAllocSystem.c.

361 {
omAllocFromSystem
void * omAllocFromSystem(size_t size)
Definition: omAllocSystem.c:182
om_SbrkInit
unsigned long om_SbrkInit
Definition: omStats.c:17
OM_ALIGN_PAGE
#define OM_ALIGN_PAGE(addr)
Definition: omAllocSystem.c:146
OM_FREE_TO_SYSTEM
#define OM_FREE_TO_SYSTEM
Definition: omAllocSystem.c:24
omReallocSizeFromSystem
void * omReallocSizeFromSystem(void *addr, size_t oldsize, size_t newsize)
Definition: omAllocSystem.c:238
omSizeOfAddr
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:100
omSizeWOfBinAddr
#define omSizeWOfBinAddr(addr)
Definition: omAllocPrivate.h:99
OM_MALLOC_FROM_SYSTEM
#define OM_MALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:22
OM_VALLOC_FROM_SYSTEM
#define OM_VALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:143
omSizeOfLargeAddr
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:95
_omSizeOfLargeAddr
#define _omSizeOfLargeAddr(addr)
Definition: omAllocSystem.c:69
omAllocLarge
void * omAllocLarge(size_t size)
Definition: omAllocSystem.c:38
OM_REALLOC_FROM_SYSTEM
#define OM_REALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:23
omAssume
#define omAssume(x)
Definition: omError.h:82
omIsBinPageAddr
#define omIsBinPageAddr(addr)
Definition: omBinPage.h:65
res
CanonicalForm res
Definition: facAbsFact.cc:64
om_Info
omInfo_t om_Info
Definition: omStats.c:15
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
omReallocLarge
void * omReallocLarge(void *old_addr, size_t new_size)
Definition: omAllocSystem.c:47
omFreeSizeToSystem
void omFreeSizeToSystem(void *addr, size_t size)
Definition: omAllocSystem.c:299
omIsBinAddrTrackAddr
#define omIsBinAddrTrackAddr(addr)
Definition: omDebug.h:14
NULL
#define NULL
Definition: omList.c:11
om_MaxAddr
unsigned long om_MaxAddr
Definition: omDebugCheck.c:17
omIsAddrPageAligned
#define omIsAddrPageAligned(addr)
Definition: omBinPage.h:14
om_MinAddr
unsigned long om_MinAddr
Definition: omDebugCheck.c:18
omSizeOfBinAddr
#define omSizeOfBinAddr(addr)
Definition: omAllocPrivate.h:93