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 68 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 147 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 144 of file omAllocSystem.c.

◆ OM_VFREE_TO_SYSTEM

#define OM_VFREE_TO_SYSTEM   omEmulateVfree

Definition at line 145 of file omAllocSystem.c.

Function Documentation

◆ _omVallocFromSystem()

void* _omVallocFromSystem ( size_t  size,
int  fail 
)

Definition at line 305 of file omAllocSystem.c.

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

72 {
73  void* addr = omAllocLarge(size);
74  size = omSizeOfLargeAddr(addr);
75  memset(addr, 0, size);
76  return addr;
77 }
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:95
void * omAllocLarge(size_t size)
Definition: omAllocSystem.c:37
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 184 of file omAllocSystem.c.

185 {
186  void* ptr;
187 
189  if (ptr == NULL)
190  {
191  OM_MEMORY_LOW_HOOK();
193  if (ptr == NULL)
194  {
195  OM_OUT_OF_MEMORY_HOOK();
196  exit(1);
197  }
198  }
199 
200  size=omSizeOfAddr(ptr);
201 #ifndef OM_NDEBUG
202  if (((unsigned long) ptr) + size > om_MaxAddr)
203  om_MaxAddr = ((unsigned long) ptr) + size;
204  if (((unsigned long) ptr) < om_MinAddr)
205  om_MinAddr = ((unsigned long) ptr);
206 #endif
207 
208  om_Info.CurrentBytesFromMalloc += size;
209  if (om_Info.CurrentBytesFromMalloc > om_Info.MaxBytesFromMalloc)
210  {
211  om_Info.MaxBytesFromMalloc = om_Info.CurrentBytesFromMalloc;
212 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
213  if (om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
214  om_Info.MaxBytesSystem = om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
215 #endif
216 #if defined(HAVE_SBRK) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
217  if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
218  if (om_Info.MaxBytesFromMalloc
219 #ifndef OM_HAVE_VALLOC_MMAP
220  + om_Info.CurrentBytesFromValloc
221 #endif
222  > om_Info.MaxBytesSbrk)
223  {
224  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
225  }
226 #endif
227  }
228  OM_MALLOC_HOOK(size);
229  return ptr;
230 }
#define OM_MALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:21
unsigned long om_SbrkInit
Definition: omStats.c:15
size_t omSizeOfAddr(const void *addr)
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 37 of file omAllocSystem.c.

38 {
39  char* addr;
40  size = OM_ALIGN_SIZE(size);
41  addr = omAllocFromSystem(size + SIZEOF_STRICT_ALIGNMENT);
42  *((size_t*) addr) = size;
43  return (void *)(addr + SIZEOF_STRICT_ALIGNMENT);
44 }
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 149 of file omAllocSystem.c.

150 {
151  void* addr;
152  size_t padding = SIZEOF_VOIDP;
153  size = OM_ALIGN_SIZE(size);
154  while (1)
155  {
156  addr = OM_MALLOC_FROM_SYSTEM(size + padding);
157  if (addr == NULL) return NULL;
158  if ((OM_ALIGN_PAGE(addr) + SIZEOF_VOIDP) - (long) addr <= padding)
159  {
160  void* ret_addr = (void*) OM_ALIGN_PAGE(addr);
161  *((void**) ((void*) ret_addr + size)) = addr;
162  return ret_addr;
163  }
164  else
165  {
166  OM_FREE_TO_SYSTEM(addr);
167  padding = padding << 1;
168  }
169  }
170 }
#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 172 of file omAllocSystem.c.

173 {
174  size = OM_ALIGN_SIZE(size);
175  OM_FREE_TO_SYSTEM( *((void**) ((void*) addr + size)) );
176 }
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 62 of file omAllocSystem.c.

63 {
64  char* _addr = (char *)addr - SIZEOF_STRICT_ALIGNMENT;
65  omFreeSizeToSystem(_addr, *((size_t*) _addr) + SIZEOF_STRICT_ALIGNMENT);
66 }
void omFreeSizeToSystem(void *addr, size_t size)

◆ omFreeSizeToSystem()

void omFreeSizeToSystem ( void *  addr,
size_t  size 
)

Definition at line 298 of file omAllocSystem.c.

299 {
300  OM_FREE_TO_SYSTEM( addr );
301  om_Info.CurrentBytesFromMalloc -= size;
302  OM_FREE_HOOK(size);
303 }
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 293 of file omAllocSystem.c.

294 {
295  omFreeSizeToSystem(addr, omSizeOfAddr(addr));
296 }
size_t omSizeOfAddr(const void *addr)
void omFreeSizeToSystem(void *addr, size_t size)

◆ omRealloc0Large()

void* omRealloc0Large ( void *  old_addr,
size_t  new_size 
)

Definition at line 79 of file omAllocSystem.c.

80 {
81  size_t old_size;
82  char* new_addr;
83 
84  omAssume(!omIsBinPageAddr(old_addr));
85 
86  old_size = omSizeOfLargeAddr(old_addr);
87 
88  new_addr = omReallocLarge(old_addr, new_size);
89  new_size = omSizeOfLargeAddr(new_addr);
90  if (new_size > old_size)
91  memset(new_addr + old_size, 0, new_size - old_size);
92  return (void *)new_addr;
93 }
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:95
void * omReallocLarge(void *old_addr, size_t new_size)
Definition: omAllocSystem.c:46
#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 232 of file omAllocSystem.c.

233 {
234  return omReallocSizeFromSystem(addr, omSizeOfAddr(addr), newsize);
235 }
void * omReallocSizeFromSystem(void *addr, size_t oldsize, size_t newsize)
size_t omSizeOfAddr(const void *addr)

◆ omReallocLarge()

void* omReallocLarge ( void *  old_addr,
size_t  new_size 
)

Definition at line 46 of file omAllocSystem.c.

47 {
48  char* _old_addr;
49  char* new_addr;
50 
51  omAssume(omIsLargeAddr(old_addr));
52 
53  new_size = OM_ALIGN_SIZE(new_size);
54  _old_addr = (char *)old_addr - SIZEOF_STRICT_ALIGNMENT;
55  new_addr = omReallocSizeFromSystem(_old_addr,
56  *((size_t*) _old_addr) + SIZEOF_STRICT_ALIGNMENT,
57  new_size + SIZEOF_STRICT_ALIGNMENT);
58  *((size_t*) new_addr) = new_size;
59  return (void *)(new_addr + SIZEOF_STRICT_ALIGNMENT);
60 }
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 237 of file omAllocSystem.c.

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

101 {
102  /*if (addr==NULL) return 0; */
103 
104  return (omIsBinPageAddr(addr) ?
105 #ifdef OM_HAVE_TRACK
106  (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr((char *)addr) : omSizeOfBinAddr(addr)) :
107 #else
108  omSizeOfBinAddr(addr) :
109 #endif
110  omSizeOfLargeAddr((char *)addr));
111 }
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:95
#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 95 of file omAllocSystem.c.

96 {
97  return _omSizeOfLargeAddr((char *)addr);
98 }
#define _omSizeOfLargeAddr(addr)
Definition: omAllocSystem.c:68

◆ omSizeWOfAddr()

size_t omSizeWOfAddr ( void *  addr)

Definition at line 113 of file omAllocSystem.c.

114 {
115 
116  return (omIsBinPageAddr(addr) ?
117 #ifdef OM_HAVE_TRACK
118  (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr(addr) >> LOG_SIZEOF_LONG : omSizeWOfBinAddr(addr)) :
119 #else
120  omSizeWOfBinAddr(addr) :
121 #endif
122  omSizeOfLargeAddr(addr) >> LOG_SIZEOF_LONG);
123 }
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:95
#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 355 of file omAllocSystem.c.

356 {
358  OM_VFREE_TO_SYSTEM(page, size);
359  om_Info.CurrentBytesFromValloc -= size;
360  OM_VFREE_HOOK(size);
361 }
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