My Project  debian-1:4.1.1-p2+ds-4build1
Macros | Functions
omAllocSystem.h File Reference
#include "omalloc/omConfig.h"

Go to the source code of this file.

Macros

#define omSizeWOfLargeAddr(addr)   (omSizeOfLargeAddr(addr) >> LOG_SIZEOF_LONG)
 
#define omVallocFromSystem(size)   _omVallocFromSystem(size, 0)
 

Functions

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

Macro Definition Documentation

◆ omSizeWOfLargeAddr

#define omSizeWOfLargeAddr (   addr)    (omSizeOfLargeAddr(addr) >> LOG_SIZEOF_LONG)

Definition at line 18 of file omAllocSystem.h.

◆ omVallocFromSystem

#define omVallocFromSystem (   size)    _omVallocFromSystem(size, 0)

Definition at line 27 of file omAllocSystem.h.

Function Documentation

◆ _omVallocFromSystem()

void* _omVallocFromSystem ( size_t  size,
int  fail 
)

Definition at line 304 of file omAllocSystem.c.

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

◆ omAlloc0Large()

void* omAlloc0Large ( size_t  size)

Definition at line 70 of file omAllocSystem.c.

73 {
74  void* addr = omAllocLarge(size);
75  memset(addr, 0, size);

◆ omAllocFromSystem()

void* omAllocFromSystem ( size_t  size)

Definition at line 180 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 #if defined(HAVE_MALLOC_SIZE) || defined(HAVE_MALLOC_USABLE_SIZE)
201 #else
202  size=omSizeOfAddr(ptr);
203 #endif
204 #ifndef OM_NDEBUG
205  if (((unsigned long) ptr) + size > om_MaxAddr)
206  om_MaxAddr = ((unsigned long) ptr) + size;
207  if (((unsigned long) ptr) < om_MinAddr)
208  om_MinAddr = ((unsigned long) ptr);
209 #endif
210 
211  om_Info.CurrentBytesFromMalloc += size;
212  if (om_Info.CurrentBytesFromMalloc > om_Info.MaxBytesFromMalloc)
213  {
214  om_Info.MaxBytesFromMalloc = om_Info.CurrentBytesFromMalloc;
215 #if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
216  if (om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
217  om_Info.MaxBytesSystem = om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
218 #endif
219 #if defined(HAVE_SBRK) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
220  if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
221  if (om_Info.MaxBytesFromMalloc
222 #ifndef OM_HAVE_VALLOC_MMAP
223  + om_Info.CurrentBytesFromValloc
224 #endif
225  > om_Info.MaxBytesSbrk)
226  {
227  om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
228  }
229 #endif

◆ omAllocLarge()

void* omAllocLarge ( size_t  size)

Definition at line 36 of file omAllocSystem.c.

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

◆ omFreeLarge()

void omFreeLarge ( void *  addr)

Definition at line 61 of file omAllocSystem.c.

64 {
65  char* _addr = (char *)addr - SIZEOF_STRICT_ALIGNMENT;

◆ omFreeSizeToSystem()

void omFreeSizeToSystem ( void *  addr,
size_t  size 
)

Definition at line 297 of file omAllocSystem.c.

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

◆ omFreeToSystem()

void omFreeToSystem ( void *  addr)

Definition at line 292 of file omAllocSystem.c.

297 {

◆ omRealloc0Large()

void* omRealloc0Large ( void *  old_addr,
size_t  new_size 
)

Definition at line 77 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);

◆ omReallocFromSystem()

void* omReallocFromSystem ( void *  addr,
size_t  newsize 
)

Definition at line 231 of file omAllocSystem.c.

236 {

◆ omReallocLarge()

void* omReallocLarge ( void *  old_addr,
size_t  new_size 
)

Definition at line 45 of file omAllocSystem.c.

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

◆ omReallocSizeFromSystem()

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

Definition at line 236 of file omAllocSystem.c.

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

◆ omSizeOfAddr()

size_t omSizeOfAddr ( const void *  addr)

Definition at line 98 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

◆ omSizeOfLargeAddr()

size_t omSizeOfLargeAddr ( void *  addr)

Definition at line 93 of file omAllocSystem.c.

96 {

◆ omSizeWOfAddr()

size_t omSizeWOfAddr ( void *  addr)

Definition at line 111 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

◆ omVfreeToSystem()

void omVfreeToSystem ( void *  page,
size_t  size 
)

Definition at line 354 of file omAllocSystem.c.

359 {
omAllocFromSystem
void * omAllocFromSystem(size_t size)
Definition: omAllocSystem.c:180
om_SbrkInit
unsigned long om_SbrkInit
Definition: omStats.c:14
omReallocSizeFromSystem
void * omReallocSizeFromSystem(void *addr, size_t oldsize, size_t newsize)
Definition: omAllocSystem.c:236
omSizeOfAddr
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:98
omSizeWOfBinAddr
#define omSizeWOfBinAddr(addr)
Definition: omAllocPrivate.h:99
OM_MALLOC_FROM_SYSTEM
#define OM_MALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:20
OM_VALLOC_FROM_SYSTEM
#define OM_VALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:141
omSizeOfLargeAddr
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:93
_omSizeOfLargeAddr
#define _omSizeOfLargeAddr(addr)
Definition: omAllocSystem.c:67
omAllocLarge
void * omAllocLarge(size_t size)
Definition: omAllocSystem.c:36
OM_REALLOC_FROM_SYSTEM
#define OM_REALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:21
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:12
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:45
omFreeSizeToSystem
void omFreeSizeToSystem(void *addr, size_t size)
Definition: omAllocSystem.c:297
omIsBinAddrTrackAddr
#define omIsBinAddrTrackAddr(addr)
Definition: omDebug.h:14
NULL
#define NULL
Definition: omList.c:9
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