My Project  debian-1:4.1.1-p2+ds-4build2
Data Structures | Macros | Functions | Variables
omAllocPrivate.h File Reference
#include "omalloc/omAllocSystem.h"

Go to the source code of this file.

Data Structures

struct  omBinPage_t
 
struct  omBin_t
 
struct  omSpecBin_t
 

Macros

#define SIZEOF_OM_BIN_PAGE_HEADER   (5*SIZEOF_VOIDP + SIZEOF_LONG)
 
#define SIZEOF_OM_BIN_PAGE   (SIZEOF_SYSTEM_PAGE - SIZEOF_OM_BIN_PAGE_HEADER)
 
#define omGetTopBinOfPage(page)   ((omBin) ( ((unsigned long) ((page)->bin_sticky)) & ~((unsigned long)SIZEOF_VOIDP - 1)))
 
#define omGetStickyOfPage(page)   (((unsigned long) ((page)->bin_sticky)) & ((unsigned long)SIZEOF_VOIDP-1))
 
#define omSetTopBinOfPage(page, bin)   (page)->bin_sticky= (void*)((unsigned long)bin + omGetStickyOfPage(page))
 
#define omSetStickyOfPage(page, sticky)
 
#define omSetTopBinAndStickyOfPage(page, bin, sticky)
 
#define omGetTopBinOfAddr(addr)   omGetTopBinOfPage(((omBinPage) omGetPageOfAddr(addr)))
 
#define omGetBinOfAddr(addr)   omGetBinOfPage(omGetBinPageOfAddr(addr))
 
#define omSizeOfBinAddr(addr)   _omSizeOfBinAddr(addr)
 
#define omSizeWOfBin(bin_ptr)   ((bin_ptr)->sizeW)
 
#define _omSizeOfBinAddr(addr)   ((omSizeWOfBinAddr(addr)) << LOG_SIZEOF_LONG)
 
#define omSizeWOfBinAddr(addr)   ((omGetTopBinOfAddr(addr))->sizeW)
 
#define __omTypeAllocFromNonEmptyPage(type, addr, page)
 
#define __omFreeToPage(addr, page)
 
#define __omTypeAllocBin(type, addr, bin)
 
#define __omTypeAlloc0Bin(type, addr, bin)
 
#define __omFreeBinAddr(addr)
 
#define __omTypeReallocBin(old_addr, old_bin, new_type, new_addr, new_bin)
 
#define __omTypeRealloc0Bin(old_addr, old_bin, new_type, new_addr, new_bin)
 
#define omSmallSize2Bin(size)   om_Size2Bin[((size) -1)>>LOG_SIZEOF_OM_ALIGNMENT]
 
#define __omTypeAlloc(type, addr, size)
 
#define __omTypeAlloc0(type, addr, size)
 
#define __omTypeAllocAligned   __omTypeAlloc
 
#define __omTypeAlloc0Aligned   __omTypeAlloc0
 
#define __omFreeSize(addr, size)
 
#define __omFree(addr)
 
#define ___omTypeRealloc(old_addr, new_type, new_addr, new_size, SIZE_2_BIN, REALLOC_BIN, flags)
 
#define ___omTypeReallocSize(old_addr, old_size, new_type, new_addr, new_size, SIZE_2_BIN, REALLOC_BIN, flags)
 
#define __omTypeRealloc(old_addr, new_type, new_addr, new_size)   ___omTypeRealloc(old_addr, new_type, new_addr, new_size, omSmallSize2Bin, __omTypeReallocBin, 0)
 
#define __omTypeRealloc0(old_addr, new_type, new_addr, new_size)   ___omTypeRealloc(old_addr, new_type, new_addr, new_size, omSmallSize2Bin, __omTypeRealloc0Bin, 1)
 
#define __omTypeReallocSize(old_addr, old_size, new_type, new_addr, new_size)   ___omTypeReallocSize(old_addr, old_size, new_type, new_addr, new_size, omSmallSize2Bin, __omTypeReallocBin, 0)
 
#define __omTypeRealloc0Size(old_addr, old_size, new_type, new_addr, new_size)   ___omTypeReallocSize(old_addr, old_size, new_type, new_addr, new_size, omSmallSize2Bin, __omTypeRealloc0Bin, 1)
 
#define __omTypeReallocAligned   __omTypeRealloc
 
#define __omTypeRealloc0Aligned   __omTypeRealloc0
 
#define __omTypeReallocAlignedSize   __omTypeReallocSize
 
#define __omTypeRealloc0AlignedSize   __omTypeRealloc0Size
 

Functions

void * omAllocBinFromFullPage (omBin bin)
 
void omFreeToPageFault (omBinPage page, void *addr)
 
void * omDoRealloc (void *old_addr, size_t new_size, int flags)
 

Variables

omSpecBin om_SpecBin
 
omBin om_StickyBins
 
omBinPage_t om_ZeroPage []
 
omBin om_Size2Bin []
 
omBin_t om_StaticBin []
 

Data Structure Documentation

◆ omBinPage_s

struct omBinPage_s

Definition at line 18 of file omAllocPrivate.h.

Data Fields
void * bin_sticky
void * current
omBinPage next
omBinPage prev
omBinPageRegion region
long used_blocks

◆ omBin_s

struct omBin_s

Definition at line 36 of file omAllocPrivate.h.

Data Fields
omBinPage current_page
omBinPage last_page
long max_blocks
omBin next
size_t sizeW
unsigned long sticky

◆ omSpecBin_s

struct omSpecBin_s

Definition at line 47 of file omAllocPrivate.h.

Data Fields
omBin bin
long max_blocks
omSpecBin next
long ref

Macro Definition Documentation

◆ ___omTypeRealloc

#define ___omTypeRealloc (   old_addr,
  new_type,
  new_addr,
  new_size,
  SIZE_2_BIN,
  REALLOC_BIN,
  flags 
)
Value:
do \
{ \
size_t __new_size = new_size; \
if (__new_size <= OM_MAX_BLOCK_SIZE && omIsBinPageAddr(old_addr)) \
{ \
omBin __old_bin = omGetBinOfAddr(old_addr); \
omBin __new_bin = SIZE_2_BIN(__new_size); \
REALLOC_BIN(old_addr, __old_bin, new_type, new_addr, __new_bin); \
} \
else \
{ \
new_addr = (new_type) omDoRealloc(old_addr, __new_size, flags); \
} \
} \
while (0)

Definition at line 314 of file omAllocPrivate.h.

◆ ___omTypeReallocSize

#define ___omTypeReallocSize (   old_addr,
  old_size,
  new_type,
  new_addr,
  new_size,
  SIZE_2_BIN,
  REALLOC_BIN,
  flags 
)
Value:
do \
{ \
size_t __new_size = new_size; \
if (__new_size <= OM_MAX_BLOCK_SIZE && old_size <= OM_MAX_BLOCK_SIZE) \
{ \
omBin __old_bin = omGetBinOfAddr(old_addr); \
omBin __new_bin = SIZE_2_BIN(__new_size); \
REALLOC_BIN(old_addr, __old_bin, new_type, new_addr, __new_bin); \
} \
else \
{ \
new_addr = (new_type) omDoRealloc(old_addr, __new_size, flags); \
} \
} \
while (0)

Definition at line 331 of file omAllocPrivate.h.

◆ __omFree

#define __omFree (   addr)
Value:
do \
{ \
if (omIsBinPageAddr(addr)) \
{ \
__omFreeBinAddr(addr); \
} \
else \
{ \
omFreeLarge(addr); \
} \
} \
while (0)

Definition at line 298 of file omAllocPrivate.h.

◆ __omFreeBinAddr

#define __omFreeBinAddr (   addr)
Value:
do \
{ \
REGISTER void* __om_addr = (void*) (addr); \
REGISTER omBinPage __om_page = omGetBinPageOfAddr(__om_addr); \
__omFreeToPage(__om_addr, __om_page); \
} \
while (0)

Definition at line 163 of file omAllocPrivate.h.

◆ __omFreeSize

#define __omFreeSize (   addr,
  size 
)
Value:
do \
{ \
if ((size <= OM_MAX_BLOCK_SIZE) || omIsBinPageAddr(addr)) \
{ \
__omFreeBinAddr(addr); \
} \
else \
{ \
omFreeLarge(addr); \
} \
} \
while (0)

Definition at line 284 of file omAllocPrivate.h.

◆ __omFreeToPage

#define __omFreeToPage (   addr,
  page 
)
Value:
do \
{ \
if ((page)->used_blocks > 0L) \
{ \
*((void**) (addr)) = (page)->current; \
((page)->used_blocks)--; \
(page)->current = (addr); \
} \
else \
{ \
omFreeToPageFault(page, addr); \
} \
} \
while (0)

Definition at line 124 of file omAllocPrivate.h.

◆ __omTypeAlloc

#define __omTypeAlloc (   type,
  addr,
  size 
)
Value:
do \
{ \
size_t __size = size; \
if (__size <= OM_MAX_BLOCK_SIZE) \
{ \
omBin __om_bin = omSmallSize2Bin(__size); \
__omTypeAllocBin(type, addr, __om_bin); \
} \
else \
{ \
addr = (type) omAllocLarge(__size); \
} \
} \
while(0)

Definition at line 213 of file omAllocPrivate.h.

◆ __omTypeAlloc0

#define __omTypeAlloc0 (   type,
  addr,
  size 
)
Value:
do \
{ \
size_t __size = size; \
if (__size <= OM_MAX_BLOCK_SIZE) \
{ \
omBin __om_bin = omSmallSize2Bin(__size); \
__omTypeAlloc0Bin(type, addr, __om_bin); \
} \
else \
{ \
addr = (type) omAlloc0Large(__size); \
} \
} \
while (0)

Definition at line 229 of file omAllocPrivate.h.

◆ __omTypeAlloc0Aligned

#define __omTypeAlloc0Aligned   __omTypeAlloc0

Definition at line 281 of file omAllocPrivate.h.

◆ __omTypeAlloc0Bin

#define __omTypeAlloc0Bin (   type,
  addr,
  bin 
)
Value:
do \
{ \
__omTypeAllocBin(type, addr, bin); \
omMemsetW(addr, 0, (bin)->sizeW); \
} \
while (0)

Definition at line 154 of file omAllocPrivate.h.

◆ __omTypeAllocAligned

#define __omTypeAllocAligned   __omTypeAlloc

Definition at line 280 of file omAllocPrivate.h.

◆ __omTypeAllocBin

#define __omTypeAllocBin (   type,
  addr,
  bin 
)
Value:
do \
{ \
REGISTER omBinPage __om_page = (bin)->current_page; \
if (__om_page->current != NULL) \
__omTypeAllocFromNonEmptyPage(type, addr, __om_page); \
else \
addr = (type) omAllocBinFromFullPage(bin); \
} \
while (0)

Definition at line 143 of file omAllocPrivate.h.

◆ __omTypeAllocFromNonEmptyPage

#define __omTypeAllocFromNonEmptyPage (   type,
  addr,
  page 
)
Value:
do \
{ \
((page)->used_blocks)++; \
addr = (type)((page)->current); \
(page)->current = *((void**) (page)->current); \
} \
while (0)

Definition at line 115 of file omAllocPrivate.h.

◆ __omTypeRealloc

#define __omTypeRealloc (   old_addr,
  new_type,
  new_addr,
  new_size 
)    ___omTypeRealloc(old_addr, new_type, new_addr, new_size, omSmallSize2Bin, __omTypeReallocBin, 0)

Definition at line 348 of file omAllocPrivate.h.

◆ __omTypeRealloc0

#define __omTypeRealloc0 (   old_addr,
  new_type,
  new_addr,
  new_size 
)    ___omTypeRealloc(old_addr, new_type, new_addr, new_size, omSmallSize2Bin, __omTypeRealloc0Bin, 1)

Definition at line 350 of file omAllocPrivate.h.

◆ __omTypeRealloc0Aligned

#define __omTypeRealloc0Aligned   __omTypeRealloc0

Definition at line 368 of file omAllocPrivate.h.

◆ __omTypeRealloc0AlignedSize

#define __omTypeRealloc0AlignedSize   __omTypeRealloc0Size

Definition at line 370 of file omAllocPrivate.h.

◆ __omTypeRealloc0Bin

#define __omTypeRealloc0Bin (   old_addr,
  old_bin,
  new_type,
  new_addr,
  new_bin 
)
Value:
do \
{ \
if (old_bin != new_bin) \
{ \
size_t old_sizeW = (omIsNormalBinPageAddr(old_addr) ? old_bin->sizeW : omSizeWOfAddr(old_addr)); \
__omTypeAllocBin(new_type, new_addr, new_bin); \
omMemcpyW(new_addr, old_addr, (new_bin->sizeW > old_sizeW ? old_sizeW : new_bin->sizeW)); \
if (new_bin->sizeW > old_sizeW) \
omMemsetW((void**)new_addr + old_sizeW, 0, new_bin->sizeW - old_sizeW); \
__omFreeBinAddr(old_addr); \
} \
else \
{ \
new_addr = (new_type) old_addr; \
} \
} \
while (0)

Definition at line 190 of file omAllocPrivate.h.

◆ __omTypeRealloc0Size

#define __omTypeRealloc0Size (   old_addr,
  old_size,
  new_type,
  new_addr,
  new_size 
)    ___omTypeReallocSize(old_addr, old_size, new_type, new_addr, new_size, omSmallSize2Bin, __omTypeRealloc0Bin, 1)

Definition at line 354 of file omAllocPrivate.h.

◆ __omTypeReallocAligned

#define __omTypeReallocAligned   __omTypeRealloc

Definition at line 367 of file omAllocPrivate.h.

◆ __omTypeReallocAlignedSize

#define __omTypeReallocAlignedSize   __omTypeReallocSize

Definition at line 369 of file omAllocPrivate.h.

◆ __omTypeReallocBin

#define __omTypeReallocBin (   old_addr,
  old_bin,
  new_type,
  new_addr,
  new_bin 
)
Value:
do \
{ \
if (old_bin != new_bin) \
{ \
size_t old_sizeW = (omIsNormalBinPageAddr(old_addr) ? old_bin->sizeW : omSizeWOfAddr(old_addr)); \
__omTypeAllocBin(new_type, new_addr, new_bin); \
omMemcpyW(new_addr, old_addr, (new_bin->sizeW > old_sizeW ? old_sizeW : new_bin->sizeW)); \
__omFreeBinAddr(old_addr); \
} \
else \
{ \
new_addr = (new_type) old_addr; \
} \
} \
while (0)

Definition at line 172 of file omAllocPrivate.h.

◆ __omTypeReallocSize

#define __omTypeReallocSize (   old_addr,
  old_size,
  new_type,
  new_addr,
  new_size 
)    ___omTypeReallocSize(old_addr, old_size, new_type, new_addr, new_size, omSmallSize2Bin, __omTypeReallocBin, 0)

Definition at line 352 of file omAllocPrivate.h.

◆ _omSizeOfBinAddr

#define _omSizeOfBinAddr (   addr)    ((omSizeWOfBinAddr(addr)) << LOG_SIZEOF_LONG)

Definition at line 102 of file omAllocPrivate.h.

◆ omGetBinOfAddr

#define omGetBinOfAddr (   addr)    omGetBinOfPage(omGetBinPageOfAddr(addr))

Definition at line 80 of file omAllocPrivate.h.

◆ omGetStickyOfPage

#define omGetStickyOfPage (   page)    (((unsigned long) ((page)->bin_sticky)) & ((unsigned long)SIZEOF_VOIDP-1))

Definition at line 67 of file omAllocPrivate.h.

◆ omGetTopBinOfAddr

#define omGetTopBinOfAddr (   addr)    omGetTopBinOfPage(((omBinPage) omGetPageOfAddr(addr)))

Definition at line 78 of file omAllocPrivate.h.

◆ omGetTopBinOfPage

#define omGetTopBinOfPage (   page)    ((omBin) ( ((unsigned long) ((page)->bin_sticky)) & ~((unsigned long)SIZEOF_VOIDP - 1)))

Definition at line 65 of file omAllocPrivate.h.

◆ omSetStickyOfPage

#define omSetStickyOfPage (   page,
  sticky 
)
Value:
(page)->bin_sticky = (void*)(((unsigned long)sticky & ((unsigned long)SIZEOF_VOIDP-1)) + \
(unsigned long)omGetTopBinOfPage(page))

Definition at line 71 of file omAllocPrivate.h.

◆ omSetTopBinAndStickyOfPage

#define omSetTopBinAndStickyOfPage (   page,
  bin,
  sticky 
)
Value:
(page)->bin_sticky= (void*)(((unsigned long)sticky & (SIZEOF_VOIDP-1)) \
+ (unsigned long)bin)

Definition at line 74 of file omAllocPrivate.h.

◆ omSetTopBinOfPage

#define omSetTopBinOfPage (   page,
  bin 
)    (page)->bin_sticky= (void*)((unsigned long)bin + omGetStickyOfPage(page))

Definition at line 69 of file omAllocPrivate.h.

◆ omSizeOfBinAddr

#define omSizeOfBinAddr (   addr)    _omSizeOfBinAddr(addr)

Definition at line 97 of file omAllocPrivate.h.

◆ omSizeWOfBin

#define omSizeWOfBin (   bin_ptr)    ((bin_ptr)->sizeW)

Definition at line 100 of file omAllocPrivate.h.

◆ omSizeWOfBinAddr

#define omSizeWOfBinAddr (   addr)    ((omGetTopBinOfAddr(addr))->sizeW)

Definition at line 103 of file omAllocPrivate.h.

◆ omSmallSize2Bin

#define omSmallSize2Bin (   size)    om_Size2Bin[((size) -1)>>LOG_SIZEOF_OM_ALIGNMENT]

Definition at line 211 of file omAllocPrivate.h.

◆ SIZEOF_OM_BIN_PAGE

#define SIZEOF_OM_BIN_PAGE   (SIZEOF_SYSTEM_PAGE - SIZEOF_OM_BIN_PAGE_HEADER)

Definition at line 32 of file omAllocPrivate.h.

◆ SIZEOF_OM_BIN_PAGE_HEADER

#define SIZEOF_OM_BIN_PAGE_HEADER   (5*SIZEOF_VOIDP + SIZEOF_LONG)

Definition at line 31 of file omAllocPrivate.h.

Function Documentation

◆ omAllocBinFromFullPage()

void* omAllocBinFromFullPage ( omBin  bin)

Definition at line 117 of file om_Alloc.c.

118 {
119  void* addr;
120  omBinPage newpage;
121  omAssume(bin->current_page->current == NULL);
122 
123  if (bin->current_page != om_ZeroPage)
124  {
125  omAssume(bin->last_page != NULL);
126  /* Set this to zero, but preserve the first bit,
127  so that tracking works */
128 #ifdef OM_HAVE_TRACK
129  bin->current_page->used_blocks &= (((unsigned long) 1) << (BIT_SIZEOF_LONG -1));
130 #else
131  bin->current_page->used_blocks = 0;
132 #endif
133  }
134 
135  if (!bin->sticky && bin->current_page->next != NULL)
136  {
137  omAssume(bin->current_page->next->current != NULL);
138  newpage = bin->current_page->next;
139  }
140  else
141  {
142  // need to Allocate new page
143  newpage = omAllocNewBinPage(bin);
144  omInsertBinPage(bin->current_page, newpage, bin);
145  }
146 
147  bin->current_page = newpage;
148  omAssume(newpage != NULL && newpage != om_ZeroPage &&
149  newpage->current != NULL);
150  __omTypeAllocFromNonEmptyPage(void*, addr, newpage);
151  return addr;
152 }

◆ omDoRealloc()

void* omDoRealloc ( void *  old_addr,
size_t  new_size,
int  flags 
)

Definition at line 227 of file om_Alloc.c.

228 {
229  void* new_addr;
230 
231  if (!omIsBinPageAddr(old_addr) && new_size > OM_MAX_BLOCK_SIZE)
232  {
233  if (DO_ZERO(flag))
234  return omRealloc0Large(old_addr, new_size);
235  else
236  return omReallocLarge(old_addr, new_size);
237  }
238  else
239  {
240  size_t old_size = omSizeOfAddr(old_addr);
241  size_t min_size;
242 
243  omAssume(OM_IS_ALIGNED(old_addr));
244 
245 #ifdef OM_ALIGNMENT_NEEDS_WORK
246  if (flag & 2)
247  __omTypeAllocAligned(void*, new_addr, new_size);
248  else
249 #endif
250  __omTypeAlloc(void*, new_addr, new_size);
251 
252  new_size = omSizeOfAddr(new_addr);
253  min_size = (old_size < new_size ? old_size : new_size);
254  omMemcpyW(new_addr, old_addr, min_size >> LOG_SIZEOF_LONG);
255 
256  if (DO_ZERO(flag) && (new_size > old_size))
257  omMemsetW((char*) new_addr + min_size, 0, (new_size - old_size) >> LOG_SIZEOF_LONG);
258 
259  __omFreeSize(old_addr, old_size);
260 
261  return new_addr;
262  }
263 }

◆ omFreeToPageFault()

void omFreeToPageFault ( omBinPage  page,
void *  addr 
)

Definition at line 165 of file om_Alloc.c.

166 {
167  omBin bin;
168  omAssume(page->used_blocks <= 0L);
169 
170 #ifdef OM_HAVE_TRACK
171  if (page->used_blocks < 0L)
172  {
173  omFreeTrackAddr(addr);
174  return;
175  }
176 #endif
177 
178  bin = omGetBinOfPage(page);
179  if ((page->current != NULL) || (bin->max_blocks <= 1))
180  {
181  // all blocks of page are now collected
182  omTakeOutBinPage(page, bin);
183  // page can be freed
184  if (bin->max_blocks > 0)
185  omFreeBinPage(page);
186  else
187  omFreeBinPages(page, - bin->max_blocks);
188 #ifdef OM_HAVE_TRACK
189  om_JustFreedPage = page;
190 #endif
191  }
192  else
193  {
194  // page was full
195  page->current = addr;
196  page->used_blocks = bin->max_blocks - 2;
197  *((void**)addr) = NULL;
198 
199  omTakeOutBinPage(page, bin);
200 #if defined(PAGE_BEFORE_CURRENT)
201  if (bin->current_page->prev != NULL)
202  omInsertBinPage(bin->current_page->prev, page);
203  else
204  omInsertBinPage(bin->current_page, page, bin);
205  bin->current_page = page;
206 #else
207 # if defined(PAGE_AFTER_CURRENT)
208  omInsertBinPage(bin->current_page, page, bin);
209 # else
210  omInsertBinPage(bin->last_page, page, bin);
211 # endif
212 #endif
213  }
214 }

Variable Documentation

◆ om_Size2Bin

omBin om_Size2Bin

Definition at line 84 of file omAllocPrivate.h.

◆ om_SpecBin

omSpecBin om_SpecBin

Definition at line 18 of file om_Alloc.c.

◆ om_StaticBin

omBin_t om_StaticBin[]

◆ om_StickyBins

omBin om_StickyBins

Definition at line 372 of file omBin.c.

◆ om_ZeroPage

omBinPage_t om_ZeroPage[]

Definition at line 17 of file om_Alloc.c.

BIT_SIZEOF_LONG
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:78
omMemsetW
#define omMemsetW(P1, W, L)
Definition: omMemOps.h:161
omFreeBinPage
#define omFreeBinPage(addr)
Definition: omBinPage.h:88
omSizeOfAddr
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:100
omIsNormalBinPageAddr
#define omIsNormalBinPageAddr(addr)
Definition: omDebug.h:14
__omTypeAllocAligned
#define __omTypeAllocAligned
Definition: omAllocPrivate.h:280
omGetBinOfAddr
#define omGetBinOfAddr(addr)
Definition: omAllocPrivate.h:80
__omFreeSize
#define __omFreeSize(addr, size)
Definition: omAllocPrivate.h:284
omAllocLarge
void * omAllocLarge(size_t size)
Definition: omAllocSystem.c:38
flags
int status int void size_t count int const void size_t count const char int flags
Definition: si_signals.h:73
omTakeOutBinPage
OM_INLINE_LOCAL void omTakeOutBinPage(omBinPage page, omBin bin)
Definition: om_Alloc.c:57
DO_ZERO
#define DO_ZERO(flag)
Definition: om_Alloc.c:224
omFreeBinPages
void omFreeBinPages(omBinPage bin_page, int how_many)
Definition: omBinPage.c:204
__omTypeAlloc
#define __omTypeAlloc(type, addr, size)
Definition: omAllocPrivate.h:213
omAssume
#define omAssume(x)
Definition: omError.h:85
omIsBinPageAddr
#define omIsBinPageAddr(addr)
Definition: omBinPage.h:68
OM_MAX_BLOCK_SIZE
#define OM_MAX_BLOCK_SIZE
Definition: omTables.c:31
omGetBinOfPage
OM_INLINE_DECL omBin omGetBinOfPage(omBinPage page)
omSizeWOfAddr
size_t omSizeWOfAddr(void *addr)
Definition: omAllocSystem.c:113
omMemcpyW
#define omMemcpyW(p1, p2, l)
Definition: omMemOps.h:29
omInsertBinPage
OM_INLINE_LOCAL void omInsertBinPage(omBinPage after, omBinPage page, omBin bin)
Definition: om_Alloc.c:88
__omTypeAllocFromNonEmptyPage
#define __omTypeAllocFromNonEmptyPage(type, addr, page)
Definition: omAllocPrivate.h:115
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:47
omSmallSize2Bin
#define omSmallSize2Bin(size)
Definition: omAllocPrivate.h:211
omGetBinPageOfAddr
#define omGetBinPageOfAddr(addr)
Definition: omBinPage.h:22
omRealloc0Large
void * omRealloc0Large(void *old_addr, size_t new_size)
Definition: omAllocSystem.c:79
omAllocNewBinPage
static omBinPage omAllocNewBinPage(omBin bin)
Definition: om_Alloc.c:30
omAlloc0Large
void * omAlloc0Large(size_t size)
Definition: omAllocSystem.c:72
omGetTopBinOfPage
#define omGetTopBinOfPage(page)
Definition: omAllocPrivate.h:65
omBin
omBin_t * omBin
Definition: omStructs.h:12
om_ZeroPage
omBinPage_t om_ZeroPage[]
Definition: om_Alloc.c:17
omAllocBinFromFullPage
void * omAllocBinFromFullPage(omBin bin)
Definition: om_Alloc.c:117
NULL
#define NULL
Definition: omList.c:10
omDoRealloc
void * omDoRealloc(void *old_addr, size_t new_size, int flags)
Definition: om_Alloc.c:227
omBinPage
omBinPage_t * omBinPage
Definition: omStructs.h:16