Macros | Functions
omAllocSystem.c File Reference
#include <unistd.h>
#include <mylimits.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 65 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 143 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 23 of file omAllocSystem.c.

§ OM_MALLOC_FROM_SYSTEM

#define OM_MALLOC_FROM_SYSTEM   OM_MALLOC_MALLOC

Definition at line 21 of file omAllocSystem.c.

§ OM_REALLOC_FROM_SYSTEM

#define OM_REALLOC_FROM_SYSTEM   OM_MALLOC_REALLOC

Definition at line 22 of file omAllocSystem.c.

§ OM_VALLOC_FROM_SYSTEM

#define OM_VALLOC_FROM_SYSTEM   omEmulateValloc

Definition at line 140 of file omAllocSystem.c.

§ OM_VFREE_TO_SYSTEM

#define OM_VFREE_TO_SYSTEM   omEmulateVfree

Definition at line 141 of file omAllocSystem.c.

Function Documentation

§ _omVallocFromSystem()

void* _omVallocFromSystem ( size_t  size,
int  fail 
)

Definition at line 298 of file omAllocSystem.c.

299 {
300  void* page = OM_VALLOC_FROM_SYSTEM(size);
301  if (page == NULL)
302  {
303  OM_MEMORY_LOW_HOOK();
304  page = OM_VALLOC_FROM_SYSTEM(size);
305  if (page == NULL)
306  {
307  if (fail) return NULL;
308  else
309  {
310  OM_OUT_OF_MEMORY_HOOK();
311  /* should never get here */
312  omAssume(0);
313  exit(1);
314  }
315  }
316  }
317 
318 #ifndef OM_NDEBUG
319  if (((unsigned long) page) + size > om_MaxAddr)
320  om_MaxAddr = ((unsigned long) page) + size;
321  if (((unsigned long) page) < om_MinAddr)
322  om_MinAddr = ((unsigned long) page);
323 #endif
324 
326  om_Info.CurrentBytesFromValloc += size;
327  if (om_Info.CurrentBytesFromValloc > om_Info.MaxBytesFromValloc)
328  {
329  om_Info.MaxBytesFromValloc = om_Info.CurrentBytesFromValloc;
330 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
331  if (om_Info.MaxBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
332  om_Info.MaxBytesSystem = om_Info.MaxBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
333 #endif
334 #if defined(HAVE_SBRK) && !defined(OM_HAVE_VALLOC_MMAP) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
335  if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
336  if (om_Info.CurrentBytesFromMalloc + om_Info.CurrentBytesFromValloc > om_Info.MaxBytesSbrk)
337  {
338  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
339  omAssume(om_Info.MaxBytesSbrk >= om_Info.CurrentBytesFromMalloc
340  + om_Info.CurrentBytesFromValloc);
341  }
342 #endif
343  }
344  OM_VALLOC_HOOK(size);
345  return page;
346 }
unsigned long om_SbrkInit
Definition: omStats.c:15
#define OM_VALLOC_FROM_SYSTEM
omInfo_t om_Info
Definition: omStats.c:13
#define omAssume(x)
Definition: omError.h:85
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define NULL
Definition: omList.c:10
unsigned long om_MinAddr
Definition: omDebugCheck.c:20
unsigned long om_MaxAddr
Definition: omDebugCheck.c:19
#define omIsAddrPageAligned(addr)
Definition: omBinPage.h:16

§ omAlloc0Large()

void* omAlloc0Large ( size_t  size)

Definition at line 68 of file omAllocSystem.c.

69 {
70  void* addr = omAllocLarge(size);
71  size = omSizeOfLargeAddr(addr);
72  memset(addr, 0, size);
73  return addr;
74 }
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:92
void * omAllocLarge(size_t size)
Definition: omAllocSystem.c:34
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600

§ omAllocFromSystem()

void* omAllocFromSystem ( size_t  size)

Definition at line 180 of file omAllocSystem.c.

181 {
182  void* ptr;
183 
185  if (ptr == NULL)
186  {
187  OM_MEMORY_LOW_HOOK();
189  if (ptr == NULL)
190  {
191  OM_OUT_OF_MEMORY_HOOK();
192  exit(1);
193  }
194  }
195 
196 #ifndef OM_NDEBUG
197  if (((unsigned long) ptr) + size > om_MaxAddr)
198  om_MaxAddr = ((unsigned long) ptr) + size;
199  if (((unsigned long) ptr) < om_MinAddr)
200  om_MinAddr = ((unsigned long) ptr);
201 #endif
202 
203  om_Info.CurrentBytesFromMalloc += size;
204  if (om_Info.CurrentBytesFromMalloc > om_Info.MaxBytesFromMalloc)
205  {
206  om_Info.MaxBytesFromMalloc = om_Info.CurrentBytesFromMalloc;
207 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
208  if (om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
209  om_Info.MaxBytesSystem = om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
210 #endif
211 #if defined(HAVE_SBRK) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
212  if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
213  if (om_Info.MaxBytesFromMalloc
214 #ifndef OM_HAVE_VALLOC_MMAP
215  + om_Info.CurrentBytesFromValloc
216 #endif
217  > om_Info.MaxBytesSbrk)
218  {
219  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
220  }
221 #endif
222  }
223  OM_MALLOC_HOOK(size);
224  return ptr;
225 }
#define OM_MALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:21
unsigned long om_SbrkInit
Definition: omStats.c:15
omInfo_t om_Info
Definition: omStats.c:13
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define NULL
Definition: omList.c:10
unsigned long om_MinAddr
Definition: omDebugCheck.c:20
unsigned long om_MaxAddr
Definition: omDebugCheck.c:19

§ omAllocLarge()

void* omAllocLarge ( size_t  size)

Definition at line 34 of file omAllocSystem.c.

35 {
36  char* addr;
37  size = OM_ALIGN_SIZE(size);
38  addr = omAllocFromSystem(size + SIZEOF_STRICT_ALIGNMENT);
39  *((size_t*) addr) = size;
40  return (void *)(addr + SIZEOF_STRICT_ALIGNMENT);
41 }
void * omAllocFromSystem(size_t size)
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600

§ omEmulateValloc()

void* omEmulateValloc ( size_t  size)

Definition at line 145 of file omAllocSystem.c.

146 {
147  void* addr;
148  size_t padding = SIZEOF_VOIDP;
149  size = OM_ALIGN_SIZE(size);
150  while (1)
151  {
152  addr = OM_MALLOC_FROM_SYSTEM(size + padding);
153  if (addr == NULL) return NULL;
154  if ((OM_ALIGN_PAGE(addr) + SIZEOF_VOIDP) - (long) addr <= padding)
155  {
156  void* ret_addr = (void*) OM_ALIGN_PAGE(addr);
157  *((void**) ((void*) ret_addr + size)) = addr;
158  return ret_addr;
159  }
160  else
161  {
162  OM_FREE_TO_SYSTEM(addr);
163  padding = padding << 1;
164  }
165  }
166 }
#define OM_MALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:21
#define OM_ALIGN_PAGE(addr)
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define NULL
Definition: omList.c:10
#define OM_FREE_TO_SYSTEM
Definition: omAllocSystem.c:23

§ omEmulateVfree()

void omEmulateVfree ( void *  addr,
size_t  size 
)

Definition at line 168 of file omAllocSystem.c.

169 {
170  size = OM_ALIGN_SIZE(size);
171  OM_FREE_TO_SYSTEM( *((void**) ((void*) addr + size)) );
172 }
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define OM_FREE_TO_SYSTEM
Definition: omAllocSystem.c:23

§ omFreeLarge()

void omFreeLarge ( void *  addr)

Definition at line 59 of file omAllocSystem.c.

60 {
61  char* _addr = (char *)addr - SIZEOF_STRICT_ALIGNMENT;
62  omFreeSizeToSystem(_addr, *((size_t*) _addr) + SIZEOF_STRICT_ALIGNMENT);
63 }
void omFreeSizeToSystem(void *addr, size_t size)

§ omFreeSizeToSystem()

void omFreeSizeToSystem ( void *  addr,
size_t  size 
)

Definition at line 291 of file omAllocSystem.c.

292 {
293  OM_FREE_TO_SYSTEM( addr );
294  om_Info.CurrentBytesFromMalloc -= size;
295  OM_FREE_HOOK(size);
296 }
omInfo_t om_Info
Definition: omStats.c:13
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define OM_FREE_TO_SYSTEM
Definition: omAllocSystem.c:23

§ omFreeToSystem()

void omFreeToSystem ( void *  addr)

Definition at line 286 of file omAllocSystem.c.

287 {
288  omFreeSizeToSystem(addr, omSizeOfAddr(addr));
289 }
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:97
void omFreeSizeToSystem(void *addr, size_t size)

§ omRealloc0Large()

void* omRealloc0Large ( void *  old_addr,
size_t  new_size 
)

Definition at line 76 of file omAllocSystem.c.

77 {
78  size_t old_size;
79  char* new_addr;
80 
81  omAssume(!omIsBinPageAddr(old_addr));
82 
83  old_size = omSizeOfLargeAddr(old_addr);
84 
85  new_addr = omReallocLarge(old_addr, new_size);
86  new_size = omSizeOfLargeAddr(new_addr);
87  if (new_size > old_size)
88  memset(new_addr + old_size, 0, new_size - old_size);
89  return (void *)new_addr;
90 }
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:92
void * omReallocLarge(void *old_addr, size_t new_size)
Definition: omAllocSystem.c:43
#define omAssume(x)
Definition: omError.h:85
#define omIsBinPageAddr(addr)
Definition: omBinPage.h:68

§ omReallocFromSystem()

void* omReallocFromSystem ( void *  addr,
size_t  newsize 
)

Definition at line 227 of file omAllocSystem.c.

228 {
229  return omReallocSizeFromSystem(addr, omSizeOfAddr(addr), newsize);
230 }
void * omReallocSizeFromSystem(void *addr, size_t oldsize, size_t newsize)
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:97

§ omReallocLarge()

void* omReallocLarge ( void *  old_addr,
size_t  new_size 
)

Definition at line 43 of file omAllocSystem.c.

44 {
45  char* _old_addr;
46  char* new_addr;
47 
48  omAssume(omIsLargeAddr(old_addr));
49 
50  new_size = OM_ALIGN_SIZE(new_size);
51  _old_addr = (char *)old_addr - SIZEOF_STRICT_ALIGNMENT;
52  new_addr = omReallocSizeFromSystem(_old_addr,
53  *((size_t*) _old_addr) + SIZEOF_STRICT_ALIGNMENT,
54  new_size + SIZEOF_STRICT_ALIGNMENT);
55  *((size_t*) new_addr) = new_size;
56  return (void *)(new_addr + SIZEOF_STRICT_ALIGNMENT);
57 }
void * omReallocSizeFromSystem(void *addr, size_t oldsize, size_t newsize)
#define omAssume(x)
Definition: omError.h:85

§ omReallocSizeFromSystem()

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

Definition at line 232 of file omAllocSystem.c.

233 {
234  void* res;
235 
236  res = OM_REALLOC_FROM_SYSTEM(addr, newsize);
237  if (res == NULL)
238  {
239  OM_MEMORY_LOW_HOOK();
240  /* Can do a realloc again: manpage reads:
241  "If realloc() fails the original block is left untouched -
242  it is not freed or moved." */
243  res = OM_REALLOC_FROM_SYSTEM(addr, newsize);
244  if (res == NULL)
245  {
246  OM_OUT_OF_MEMORY_HOOK();
247  /* should never get here */
248  omAssume(0);
249  exit(1);
250  }
251  }
252 
253 #ifndef OM_NDEBUG
254  if (((unsigned long) res) + newsize > om_MaxAddr)
255  om_MaxAddr = ((unsigned long) res) + newsize;
256  if (((unsigned long) res) < om_MinAddr)
257  om_MinAddr = ((unsigned long) res);
258 #endif
259 
260  om_Info.CurrentBytesFromMalloc += (long) newsize - (long) oldsize;
261 
262 
263  if (om_Info.CurrentBytesFromMalloc > om_Info.MaxBytesFromMalloc)
264  {
265  om_Info.MaxBytesFromMalloc = om_Info.CurrentBytesFromMalloc;
266 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
267  if (om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
268  om_Info.MaxBytesSystem = om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
269 #endif
270 #if defined(HAVE_SBRK) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
271  if (om_Info.MaxBytesFromMalloc
272 #ifndef OM_HAVE_VALLOC_MMAP
273  + om_Info.CurrentBytesFromValloc
274 #endif
275  > om_Info.MaxBytesSbrk)
276  {
277  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
278  }
279 #endif
280  }
281 
282  OM_REALLOC_HOOK(oldsize, newsize);
283  return res;
284 }
unsigned long om_SbrkInit
Definition: omStats.c:15
poly res
Definition: myNF.cc:322
#define OM_REALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:22
omInfo_t om_Info
Definition: omStats.c:13
#define omAssume(x)
Definition: omError.h:85
#define NULL
Definition: omList.c:10
unsigned long om_MinAddr
Definition: omDebugCheck.c:20
unsigned long om_MaxAddr
Definition: omDebugCheck.c:19

§ omSizeOfAddr()

size_t omSizeOfAddr ( const void *  addr)

Definition at line 97 of file omAllocSystem.c.

98 {
99 
100  return (omIsBinPageAddr(addr) ?
101 #ifdef OM_HAVE_TRACK
102  (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr((char *)addr) : omSizeOfBinAddr(addr)) :
103 #else
104  omSizeOfBinAddr(addr) :
105 #endif
106  omSizeOfLargeAddr((char *)addr));
107 }
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:92
#define omIsBinAddrTrackAddr(addr)
Definition: omDebug.h:15
#define omSizeOfBinAddr(addr)
#define omIsBinPageAddr(addr)
Definition: omBinPage.h:68

§ omSizeOfLargeAddr()

size_t omSizeOfLargeAddr ( void *  addr)

Definition at line 92 of file omAllocSystem.c.

93 {
94  return _omSizeOfLargeAddr((char *)addr);
95 }
#define _omSizeOfLargeAddr(addr)
Definition: omAllocSystem.c:65

§ omSizeWOfAddr()

size_t omSizeWOfAddr ( void *  addr)

Definition at line 109 of file omAllocSystem.c.

110 {
111 
112  return (omIsBinPageAddr(addr) ?
113 #ifdef OM_HAVE_TRACK
114  (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr(addr) >> LOG_SIZEOF_LONG : omSizeWOfBinAddr(addr)) :
115 #else
116  omSizeWOfBinAddr(addr) :
117 #endif
118  omSizeOfLargeAddr(addr) >> LOG_SIZEOF_LONG);
119 }
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:92
#define omIsBinAddrTrackAddr(addr)
Definition: omDebug.h:15
#define omSizeWOfBinAddr(addr)
#define omIsBinPageAddr(addr)
Definition: omBinPage.h:68

§ omVfreeToSystem()

void omVfreeToSystem ( void *  page,
size_t  size 
)

Definition at line 348 of file omAllocSystem.c.

349 {
351  OM_VFREE_TO_SYSTEM(page, size);
352  om_Info.CurrentBytesFromValloc -= size;
353  OM_VFREE_HOOK(size);
354 }
omInfo_t om_Info
Definition: omStats.c:13
#define omAssume(x)
Definition: omError.h:85
#define OM_VFREE_TO_SYSTEM
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define omIsAddrPageAligned(addr)
Definition: omBinPage.h:16