My Project
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 75 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 153 of file omAllocSystem.c.

◆ OM_ALLOC_SYSTEM_C

#define OM_ALLOC_SYSTEM_C

Definition at line 8 of file omAllocSystem.c.

◆ OM_FREE_TO_SYSTEM

#define OM_FREE_TO_SYSTEM   OM_MALLOC_FREE

Definition at line 25 of file omAllocSystem.c.

◆ OM_MALLOC_FROM_SYSTEM

#define OM_MALLOC_FROM_SYSTEM   OM_MALLOC_MALLOC

Definition at line 23 of file omAllocSystem.c.

◆ OM_REALLOC_FROM_SYSTEM

#define OM_REALLOC_FROM_SYSTEM   OM_MALLOC_REALLOC

Definition at line 24 of file omAllocSystem.c.

◆ OM_VALLOC_FROM_SYSTEM

#define OM_VALLOC_FROM_SYSTEM   omEmulateValloc

Definition at line 150 of file omAllocSystem.c.

◆ OM_VFREE_TO_SYSTEM

#define OM_VFREE_TO_SYSTEM   omEmulateVfree

Definition at line 151 of file omAllocSystem.c.

Function Documentation

◆ _omVallocFromSystem()

void* _omVallocFromSystem ( size_t  size,
int  fail 
)

Definition at line 314 of file omAllocSystem.c.

315 {
316  void* page = OM_VALLOC_FROM_SYSTEM(size);
317  if (page == NULL)
318  {
319  OM_MEMORY_LOW_HOOK();
320  page = OM_VALLOC_FROM_SYSTEM(size);
321  if (page == NULL)
322  {
323  if (fail) return NULL;
324  else
325  {
326  OM_OUT_OF_MEMORY_HOOK();
327  /* should never get here */
328  omAssume(0);
329  exit(1);
330  }
331  }
332  }
333 
334 #ifndef OM_NDEBUG
335  if (((unsigned long) page) + size > om_MaxAddr)
336  om_MaxAddr = ((unsigned long) page) + size;
337  if (((unsigned long) page) < om_MinAddr)
338  om_MinAddr = ((unsigned long) page);
339 #endif
340 
342  om_Info.CurrentBytesFromValloc += size;
343  if (om_Info.CurrentBytesFromValloc > om_Info.MaxBytesFromValloc)
344  {
345  om_Info.MaxBytesFromValloc = om_Info.CurrentBytesFromValloc;
346 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
347  if (om_Info.MaxBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
348  om_Info.MaxBytesSystem = om_Info.MaxBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
349 #endif
350 #if defined(HAVE_SBRK) && !defined(OM_HAVE_VALLOC_MMAP) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
351  if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
352  if (om_Info.CurrentBytesFromMalloc + om_Info.CurrentBytesFromValloc > om_Info.MaxBytesSbrk)
353  {
354  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
355  omAssume(om_Info.MaxBytesSbrk >= om_Info.CurrentBytesFromMalloc
356  + om_Info.CurrentBytesFromValloc);
357  }
358 #endif
359  }
360  OM_VALLOC_HOOK(size);
361  return page;
362 }
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define OM_VALLOC_FROM_SYSTEM
#define omIsAddrPageAligned(addr)
Definition: omBinPage.h:16
unsigned long om_MaxAddr
Definition: omDebugCheck.c:19
unsigned long om_MinAddr
Definition: omDebugCheck.c:20
#define omAssume(x)
Definition: omError.h:85
#define NULL
Definition: omList.c:12
unsigned long om_SbrkInit
Definition: omStats.c:18
omInfo_t om_Info
Definition: omStats.c:16

◆ omAlloc0Large()

void* omAlloc0Large ( size_t  size)

Definition at line 78 of file omAllocSystem.c.

79 {
80  void* addr = omAllocLarge(size);
81  memset(addr, 0, size);
82  return addr;
83 }
void * omAllocLarge(size_t size)
Definition: omAllocSystem.c:44

◆ omAllocFromSystem()

void* omAllocFromSystem ( size_t  size)

Definition at line 190 of file omAllocSystem.c.

191 {
192  void* ptr;
193 
195  if (ptr == NULL)
196  {
197  OM_MEMORY_LOW_HOOK();
199  if (ptr == NULL)
200  {
201  OM_OUT_OF_MEMORY_HOOK();
202  exit(1);
203  }
204  }
205 #if defined(HAVE_MALLOC_SIZE) || defined(HAVE_MALLOC_USABLE_SIZE)
207 #else
208  size=omSizeOfAddr(ptr);
209 #endif
210 #ifndef OM_NDEBUG
211  if (((unsigned long) ptr) + size > om_MaxAddr)
212  om_MaxAddr = ((unsigned long) ptr) + size;
213  if (((unsigned long) ptr) < om_MinAddr)
214  om_MinAddr = ((unsigned long) ptr);
215 #endif
216 
217  om_Info.CurrentBytesFromMalloc += size;
218  if (om_Info.CurrentBytesFromMalloc > om_Info.MaxBytesFromMalloc)
219  {
220  om_Info.MaxBytesFromMalloc = om_Info.CurrentBytesFromMalloc;
221 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
222  if (om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
223  om_Info.MaxBytesSystem = om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
224 #endif
225 #if defined(HAVE_SBRK) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
226  if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
227  if (om_Info.MaxBytesFromMalloc
228 #ifndef OM_HAVE_VALLOC_MMAP
229  + om_Info.CurrentBytesFromValloc
230 #endif
231  > om_Info.MaxBytesSbrk)
232  {
233  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
234  }
235 #endif
236  }
237  OM_MALLOC_HOOK(size);
238  return ptr;
239 }
size_t omSizeOfAddr(const void *addr)
#define _omSizeOfLargeAddr(addr)
Definition: omAllocSystem.c:75
#define OM_MALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:23

◆ omAllocLarge()

void* omAllocLarge ( size_t  size)

Definition at line 44 of file omAllocSystem.c.

45 {
46  char* addr;
47  size = OM_ALIGN_SIZE(size);
48  addr = omAllocFromSystem(size + SIZEOF_STRICT_ALIGNMENT);
49  *((size_t*) addr) = size;
50  return (void *)(addr + SIZEOF_STRICT_ALIGNMENT);
51 }
void * omAllocFromSystem(size_t size)

◆ omEmulateValloc()

void* omEmulateValloc ( size_t  size)

Definition at line 155 of file omAllocSystem.c.

156 {
157  void* addr;
158  size_t padding = SIZEOF_VOIDP;
159  size = OM_ALIGN_SIZE(size);
160  while (1)
161  {
162  addr = OM_MALLOC_FROM_SYSTEM(size + padding);
163  if (addr == NULL) return NULL;
164  if ((OM_ALIGN_PAGE(addr) + SIZEOF_VOIDP) - (long) addr <= padding)
165  {
166  void* ret_addr = (void*) OM_ALIGN_PAGE(addr);
167  *((void**) ((void*) ret_addr + size)) = addr;
168  return ret_addr;
169  }
170  else
171  {
172  OM_FREE_TO_SYSTEM(addr);
173  padding = padding << 1;
174  }
175  }
176 }
#define OM_ALIGN_PAGE(addr)
#define OM_FREE_TO_SYSTEM
Definition: omAllocSystem.c:25

◆ omEmulateVfree()

void omEmulateVfree ( void *  addr,
size_t  size 
)

Definition at line 178 of file omAllocSystem.c.

179 {
180  size = OM_ALIGN_SIZE(size);
181  OM_FREE_TO_SYSTEM( *((void**) ((void*) addr + size)) );
182 }

◆ omFreeLarge()

void omFreeLarge ( void *  addr)

Definition at line 69 of file omAllocSystem.c.

70 {
71  char* _addr = (char *)addr - SIZEOF_STRICT_ALIGNMENT;
72  omFreeSizeToSystem(_addr, *((size_t*) _addr) + SIZEOF_STRICT_ALIGNMENT);
73 }
void omFreeSizeToSystem(void *addr, size_t size)

◆ omFreeSizeToSystem()

void omFreeSizeToSystem ( void *  addr,
size_t  size 
)

Definition at line 307 of file omAllocSystem.c.

308 {
309  OM_FREE_TO_SYSTEM( addr );
310  om_Info.CurrentBytesFromMalloc -= size;
311  OM_FREE_HOOK(size);
312 }

◆ omFreeToSystem()

void omFreeToSystem ( void *  addr)

Definition at line 302 of file omAllocSystem.c.

303 {
304  omFreeSizeToSystem(addr, omSizeOfAddr(addr));
305 }

◆ omRealloc0Large()

void* omRealloc0Large ( void *  old_addr,
size_t  new_size 
)

Definition at line 85 of file omAllocSystem.c.

86 {
87  size_t old_size;
88  char* new_addr;
89 
90  omAssume(!omIsBinPageAddr(old_addr));
91 
92  old_size = omSizeOfLargeAddr(old_addr);
93 
94  new_addr = omReallocLarge(old_addr, new_size);
95  new_size = omSizeOfLargeAddr(new_addr);
96  if (new_size > old_size)
97  memset(new_addr + old_size, 0, new_size - old_size);
98  return (void *)new_addr;
99 }
size_t omSizeOfLargeAddr(void *addr)
void * omReallocLarge(void *old_addr, size_t new_size)
Definition: omAllocSystem.c:53
#define omIsBinPageAddr(addr)
Definition: omBinPage.h:68

◆ omReallocFromSystem()

void* omReallocFromSystem ( void *  addr,
size_t  newsize 
)

Definition at line 241 of file omAllocSystem.c.

242 {
243  return omReallocSizeFromSystem(addr, omSizeOfAddr(addr), newsize);
244 }
void * omReallocSizeFromSystem(void *addr, size_t oldsize, size_t newsize)

◆ omReallocLarge()

void* omReallocLarge ( void *  old_addr,
size_t  new_size 
)

Definition at line 53 of file omAllocSystem.c.

54 {
55  char* _old_addr;
56  char* new_addr;
57 
58  omAssume(omIsLargeAddr(old_addr));
59 
60  new_size = OM_ALIGN_SIZE(new_size);
61  _old_addr = (char *)old_addr - SIZEOF_STRICT_ALIGNMENT;
62  new_addr = omReallocSizeFromSystem(_old_addr,
63  *((size_t*) _old_addr) + SIZEOF_STRICT_ALIGNMENT,
64  new_size + SIZEOF_STRICT_ALIGNMENT);
65  *((size_t*) new_addr) = new_size;
66  return (void *)(new_addr + SIZEOF_STRICT_ALIGNMENT);
67 }

◆ omReallocSizeFromSystem()

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

Definition at line 246 of file omAllocSystem.c.

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

◆ omSizeOfAddr()

size_t omSizeOfAddr ( const void *  addr)

Definition at line 106 of file omAllocSystem.c.

107 {
108  /*if (addr==NULL) return 0; */
109 
110  return (omIsBinPageAddr(addr) ?
111 #ifdef OM_HAVE_TRACK
112  (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr((char *)addr) : omSizeOfBinAddr(addr)) :
113 #else
114  omSizeOfBinAddr(addr) :
115 #endif
116  omSizeOfLargeAddr((char *)addr));
117 }
#define omSizeOfBinAddr(addr)
#define omIsBinAddrTrackAddr(addr)
Definition: omDebug.h:15

◆ omSizeOfLargeAddr()

size_t omSizeOfLargeAddr ( void *  addr)

Definition at line 101 of file omAllocSystem.c.

102 {
103  return _omSizeOfLargeAddr((char *)addr);
104 }

◆ omSizeWOfAddr()

size_t omSizeWOfAddr ( void *  addr)

Definition at line 119 of file omAllocSystem.c.

120 {
121 
122  return (omIsBinPageAddr(addr) ?
123 #ifdef OM_HAVE_TRACK
124  (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr(addr) >> LOG_SIZEOF_LONG : omSizeWOfBinAddr(addr)) :
125 #else
126  omSizeWOfBinAddr(addr) :
127 #endif
128  omSizeOfLargeAddr(addr) >> LOG_SIZEOF_LONG);
129 }
#define omSizeWOfBinAddr(addr)

◆ omVfreeToSystem()

void omVfreeToSystem ( void *  page,
size_t  size 
)

Definition at line 364 of file omAllocSystem.c.

365 {
367  OM_VFREE_TO_SYSTEM(page, size);
368  om_Info.CurrentBytesFromValloc -= size;
369  OM_VFREE_HOOK(size);
370 }
#define OM_VFREE_TO_SYSTEM