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
341 omAssume(omIsAddrPageAligned(page));
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}
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
OM_VALLOC_FROM_SYSTEM
#define OM_VALLOC_FROM_SYSTEM
Definition: omAllocSystem.c:150
omIsAddrPageAligned
#define omIsAddrPageAligned(addr)
Definition: omBinPage.h:16
om_MaxAddr
unsigned long om_MaxAddr
Definition: omDebugCheck.c:19
om_MinAddr
unsigned long om_MinAddr
Definition: omDebugCheck.c:20
omAssume
#define omAssume(x)
Definition: omError.h:85
NULL
#define NULL
Definition: omList.c:12
om_SbrkInit
unsigned long om_SbrkInit
Definition: omStats.c:18
om_Info
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}
omAllocLarge
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
194 ptr = OM_MALLOC_FROM_SYSTEM(size);
195 if (ptr == NULL)
196 {
197 OM_MEMORY_LOW_HOOK();
198 ptr = OM_MALLOC_FROM_SYSTEM(size);
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)
206 size=_omSizeOfLargeAddr(ptr);
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}
omSizeOfAddr
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:106
_omSizeOfLargeAddr
#define _omSizeOfLargeAddr(addr)
Definition: omAllocSystem.c:75
OM_MALLOC_FROM_SYSTEM
#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}
omAllocFromSystem
void * omAllocFromSystem(size_t size)
Definition: omAllocSystem.c:190

◆ 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}
OM_ALIGN_PAGE
#define OM_ALIGN_PAGE(addr)
Definition: omAllocSystem.c:153
OM_FREE_TO_SYSTEM
#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}
omFreeSizeToSystem
void omFreeSizeToSystem(void *addr, size_t size)
Definition: omAllocSystem.c:307

◆ 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}
omSizeOfLargeAddr
size_t omSizeOfLargeAddr(void *addr)
Definition: omAllocSystem.c:101
omReallocLarge
void * omReallocLarge(void *old_addr, size_t new_size)
Definition: omAllocSystem.c:53
omIsBinPageAddr
#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}
omReallocSizeFromSystem
void * omReallocSizeFromSystem(void *addr, size_t oldsize, size_t newsize)
Definition: omAllocSystem.c:246

◆ 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}
res
CanonicalForm res
Definition: facAbsFact.cc:60
OM_REALLOC_FROM_SYSTEM
#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}
omSizeOfBinAddr
#define omSizeOfBinAddr(addr)
Definition: omAllocPrivate.h:97
omIsBinAddrTrackAddr
#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}
omSizeWOfBinAddr
#define omSizeWOfBinAddr(addr)
Definition: omAllocPrivate.h:103

◆ omVfreeToSystem()

void omVfreeToSystem ( void *  page,
size_t  size 
)

Definition at line 364 of file omAllocSystem.c.

365{
366 omAssume(omIsAddrPageAligned(page));
367 OM_VFREE_TO_SYSTEM(page, size);
368 om_Info.CurrentBytesFromValloc -= size;
369 OM_VFREE_HOOK(size);
370}
OM_VFREE_TO_SYSTEM
#define OM_VFREE_TO_SYSTEM
Definition: omAllocSystem.c:151
Generated on Sun Apr 17 2022 10:44:00 for My Project by   doxygen 1.9.3 for Singular