My Project  debian-1:4.1.2-p1+ds-2
Macros | Functions
omBin.h File Reference

Go to the source code of this file.

Macros

#define omGetAlignedSpecBin(size)   _omGetSpecBin(size, 1, 0)
 
#define omGetSpecBin(size)   _omGetSpecBin(size, 0, 0)
 
#define omUnGetSpecBin(bin_ptr)   _omUnGetSpecBin(bin_ptr, 0)
 
#define omDeleteSpecBin(bin_ptr)   _omUnGetSpecBin(bin_ptr, 1)
 
#define omIsStickyBin(bin)   (bin->sticky >= SIZEOF_VOIDP)
 
#define omIsStaticNormalBin(bin)
 
#define omIsNormalBin(bin)   omIsStaticNormalBin(bin) || omFindInGList(om_SpecBin, next, bin, bin) || omIsStickyBin(bin)
 
#define omIsSpecBin(bin)   (!omIsStaticNormalBin(bin) && !omIsStickyBin(bin))
 
#define omIsKnownTopBin(bin, normal_bin)   1
 
#define omIsStaticTrackBin(bin)   0
 
#define omIsTrackBin(bin)   0
 
#define omIsStaticBin(bin)   omIsStaticNormalBin(bin) || omIsStaticTrackBin(bin)
 

Functions

omBin _omGetSpecBin (size_t size, int align, int track)
 
void _omUnGetSpecBin (omBin *bin, int force)
 
long omGetUsedBinBytes ()
 
omBin omGetStickyBinOfBin (omBin bin)
 
void omMergeStickyBinIntoBin (omBin sticky_bin, omBin into_bin)
 
unsigned long omGetNewStickyBinTag (omBin bin)
 
void omSetStickyBinTag (omBin bin, unsigned long sticky)
 
void omUnSetStickyBinTag (omBin bin, unsigned long sticky)
 
void omDeleteStickyBinTag (omBin bin, unsigned long sticky)
 
unsigned long omGetNewStickyAllBinTag ()
 
void omSetStickyAllBinTag (unsigned long sticky)
 
void omUnSetStickyAllBinTag (unsigned long sticky)
 
void omDeleteStickyAllBinTag (unsigned long sticky)
 
void omPrintBinStats (FILE *fd)
 
int omIsKnownTopBin (omBin bin, int normal_bin)
 

Macro Definition Documentation

◆ omDeleteSpecBin

#define omDeleteSpecBin (   bin_ptr)    _omUnGetSpecBin(bin_ptr, 1)

Definition at line 14 of file omBin.h.

◆ omGetAlignedSpecBin

#define omGetAlignedSpecBin (   size)    _omGetSpecBin(size, 1, 0)

Definition at line 9 of file omBin.h.

◆ omGetSpecBin

#define omGetSpecBin (   size)    _omGetSpecBin(size, 0, 0)

Definition at line 10 of file omBin.h.

◆ omIsKnownTopBin

#define omIsKnownTopBin (   bin,
  normal_bin 
)    1

Definition at line 54 of file omBin.h.

◆ omIsNormalBin

#define omIsNormalBin (   bin)    omIsStaticNormalBin(bin) || omFindInGList(om_SpecBin, next, bin, bin) || omIsStickyBin(bin)

Definition at line 45 of file omBin.h.

◆ omIsSpecBin

#define omIsSpecBin (   bin)    (!omIsStaticNormalBin(bin) && !omIsStickyBin(bin))

Definition at line 46 of file omBin.h.

◆ omIsStaticBin

#define omIsStaticBin (   bin)    omIsStaticNormalBin(bin) || omIsStaticTrackBin(bin)

Definition at line 58 of file omBin.h.

◆ omIsStaticNormalBin

#define omIsStaticNormalBin (   bin)
Value:
((unsigned long) bin >= ((unsigned long) &om_StaticBin[0]) && \
(unsigned long) bin <= ((unsigned long) &om_StaticBin[OM_MAX_BIN_INDEX]))

Definition at line 42 of file omBin.h.

◆ omIsStaticTrackBin

#define omIsStaticTrackBin (   bin)    0

Definition at line 55 of file omBin.h.

◆ omIsStickyBin

#define omIsStickyBin (   bin)    (bin->sticky >= SIZEOF_VOIDP)

Definition at line 32 of file omBin.h.

◆ omIsTrackBin

#define omIsTrackBin (   bin)    0

Definition at line 56 of file omBin.h.

◆ omUnGetSpecBin

#define omUnGetSpecBin (   bin_ptr)    _omUnGetSpecBin(bin_ptr, 0)

Definition at line 13 of file omBin.h.

Function Documentation

◆ _omGetSpecBin()

omBin _omGetSpecBin ( size_t  size,
int  align,
int  track 
)

Definition at line 24 of file omBin.c.

28 {
29  omBin om_new_specBin;
30  long max_blocks;
31  long sizeW;
32 
33 
34  size = OM_ALIGN_SIZE(size);
35 #ifdef OM_ALIGNMENT_NEEDS_WORK
37  {
38  align = 1;
39  size = OM_STRICT_ALIGN_SIZE(size);
40  }
41 #else
42  align = 0;
43 #endif
44 
46  {
47  /* need page header */
48  max_blocks = - (long)
49  ((size+(SIZEOF_SYSTEM_PAGE-SIZEOF_OM_BIN_PAGE))+SIZEOF_SYSTEM_PAGE-1)
50  / SIZEOF_SYSTEM_PAGE;
51  sizeW = ((-max_blocks*SIZEOF_SYSTEM_PAGE) -
52  (SIZEOF_SYSTEM_PAGE - SIZEOF_OM_BIN_PAGE)) / SIZEOF_LONG;
53  om_new_specBin = om_LargeBin;
54  }
55  else
56  {
57  /* SIZEOF_OM_BIN_PAGE == max_blocks*size + r1; r1 < size */
58  /* r1 = max_blocks*(size_padding) + r2; r2 < max_blocks */
59  max_blocks = SIZEOF_OM_BIN_PAGE / size;
60  sizeW = (SIZEOF_OM_BIN_PAGE % size) / max_blocks;
61 #ifdef OM_ALIGNMENT_NEEDS_WORK
62  if (align)
63  sizeW = ((size + sizeW) & ~ (SIZEOF_STRICT_ALIGNMENT - 1));
64  else
65 #endif
66  sizeW = ((size + sizeW) & ~ (SIZEOF_OM_ALIGNMENT - 1));
67 
68  omAssume(sizeW >= size);
69  omAssume(max_blocks*sizeW <= SIZEOF_OM_BIN_PAGE);
70  omAssume((max_blocks+1)*sizeW > SIZEOF_OM_BIN_PAGE ||
71  max_blocks*(sizeW + SIZEOF_STRICT_ALIGNMENT) > SIZEOF_OM_BIN_PAGE);
72 
73  sizeW = sizeW >> LOG_SIZEOF_LONG;
74  if (size > OM_MAX_BLOCK_SIZE)
75  {
76  om_new_specBin = om_LargeBin;
77  }
78 #ifdef OM_ALIGNMENT_NEEDS_WORK
79  else if (align)
80  {
81  om_new_specBin = omSmallSize2AlignedBin( size );
82  }
83 #endif
84 #ifdef OM_HAVE_TRACK
85  else if (track)
86  {
87  om_new_specBin = omSmallSize2TrackBin( size );
88  }
89 #endif
90  else
91  {
92  om_new_specBin = omSmallSize2Bin( size );
93  }
94  }
95 
96  if (om_new_specBin == om_LargeBin ||
97  om_new_specBin->max_blocks < max_blocks)
98  {
99  omSpecBin s_bin;
100 #ifdef OM_HAVE_TRACK
101  if (track)
102  s_bin = omFindInSortedGList(om_SpecTrackBin, next, max_blocks, max_blocks);
103  else
104 #endif
105  s_bin = omFindInSortedGList(om_SpecBin, next, max_blocks, max_blocks);
106 
107  if (s_bin != NULL)
108  {
109  (s_bin->ref)++;
110  omAssume(s_bin->bin != NULL &&
111  s_bin->bin->max_blocks == s_bin->max_blocks &&
112  s_bin->bin->sizeW == sizeW);
113  return s_bin->bin;
114  }
115  s_bin = (omSpecBin) omAlloc(sizeof(omSpecBin_t));
116  s_bin->ref = 1;
117  s_bin->next = NULL;
118  s_bin->max_blocks = max_blocks;
119  s_bin->bin = (omBin) omAlloc(sizeof(omBin_t));
120  s_bin->bin->current_page = om_ZeroPage;
121  s_bin->bin->last_page = NULL;
122  s_bin->bin->next = NULL;
123  s_bin->bin->sizeW = sizeW;
124  s_bin->bin->max_blocks = max_blocks;
125  s_bin->bin->sticky = 0;
126 #ifdef OM_HAVE_TRACK
127  if (track)
128  {
129  om_SpecTrackBin = omInsertInSortedGList(om_SpecTrackBin, next, max_blocks, s_bin);
130  }
131  else
132 #endif
133  om_SpecBin = omInsertInSortedGList(om_SpecBin, next, max_blocks, s_bin);
134  return s_bin->bin;
135  }
136  else
137  {
138  return om_new_specBin;

◆ _omUnGetSpecBin()

void _omUnGetSpecBin ( omBin bin,
int  force 
)

Definition at line 140 of file omBin.c.

143 {
144  omBin bin = *bin_p;
145  if (! omIsStaticBin(bin))
146  {
147 #ifdef OM_HAVE_TRACK
148  int track_bin = 0;
149 #endif
150  omSpecBin s_bin;
151 
152 #ifdef OM_HAVE_TRACK
153  s_bin = omFindInGList(om_SpecTrackBin, next, bin, bin);
154  if (s_bin != NULL)
155  track_bin = 1;
156  else
157 #endif
158  s_bin = omFindInSortedGList(om_SpecBin, next, max_blocks, bin->max_blocks);
159 
160  omAssume(s_bin != NULL && bin == s_bin->bin);
161  if (s_bin != NULL)
162  {
163  (s_bin->ref)--;
164  if (s_bin->ref == 0 || force)
165  {
166 #ifdef OM_HAVE_TRACK
167  if (! track_bin)
168 #endif
169  omFreeKeptAddrFromBin(s_bin->bin);
170  if(s_bin->bin->last_page == NULL || force)
171  {
172 #ifdef OM_HAVE_TRACK
173  if (track_bin)
174  om_SpecTrackBin = omRemoveFromSortedGList(om_SpecTrackBin, next, max_blocks, s_bin);
175  else
176 #endif
177  om_SpecBin = omRemoveFromSortedGList(om_SpecBin, next, max_blocks, s_bin);
178  omFreeSize(s_bin->bin, sizeof(omBin_t));
179  omFreeSize(s_bin, sizeof(omSpecBin_t));
180  }
181  }
182  }
183  }

◆ omDeleteStickyAllBinTag()

void omDeleteStickyAllBinTag ( unsigned long  sticky)

Definition at line 565 of file omBin.c.

571 {
572  omSpecBin s_bin = om_SpecBin;
573  int i;
574  for (i=0; i<=OM_MAX_BIN_INDEX; i++)
575  {
576  omDeleteStickyBinTag(&(om_StaticBin[i]), sticky);
577  }
578  while (s_bin != NULL)

◆ omDeleteStickyBinTag()

void omDeleteStickyBinTag ( omBin  bin,
unsigned long  sticky 
)

Definition at line 336 of file omBin.c.

340 {
341  omBin no_sticky_bin = NULL;
342  omBin sticky_bin = NULL;
343 
344  if (sticky == 0)
345  {
346  omAssume(0);
347  return;
348  }
349 
350  sticky_bin = omGetStickyBin(bin, sticky);
351  if (sticky_bin != NULL)
352  {
353  no_sticky_bin = omGetStickyBin(bin, 0);
354  omAssume(no_sticky_bin != NULL && sticky_bin != no_sticky_bin);
355 
356  omMergeStickyPages(no_sticky_bin, sticky_bin);
357 
358  if (bin == sticky_bin)
359  {
360  sticky_bin = no_sticky_bin;
361  omSetStickyBinTag(bin, 0);
362  }
363  bin->next = omRemoveFromGList(bin->next, next, sticky_bin);

◆ omGetNewStickyAllBinTag()

unsigned long omGetNewStickyAllBinTag ( )

Definition at line 481 of file omBin.c.

487 {
488  unsigned long sticky = 0, new_sticky;
489  int i;
490  omSpecBin s_bin;
491  // first, find new sticky tag
492  for (i=0; i<=OM_MAX_BIN_INDEX; i++)
493  {
494  new_sticky = omGetMaxStickyBinTag(&(om_StaticBin[i]));
495  if (new_sticky > sticky) sticky = new_sticky;
496  }
497  s_bin = om_SpecBin;
498  while (s_bin != NULL)
499  {
500  new_sticky = omGetMaxStickyBinTag(s_bin->bin);
501  if (new_sticky > sticky) sticky = new_sticky;
502  s_bin = s_bin->next;
503  }
504  if (sticky < BIT_SIZEOF_LONG - 2)
505  {
506  sticky++;
507  for (i=0; i<=OM_MAX_BIN_INDEX; i++)
508  {
509  omCreateStickyBin(&(om_StaticBin[i]), sticky);
510  }
511  s_bin = om_SpecBin;
512  while (s_bin != NULL)
513  {
514  omCreateStickyBin(s_bin->bin, sticky);
515  s_bin = s_bin->next;
516  }
517  return sticky;
518  }
519  else
520  {
521  omBin bin;
522  omAssume(sticky == BIT_SIZEOF_LONG - 1);
523  for (i=0; i<=OM_MAX_BIN_INDEX; i++)
524  {
525  bin = &om_StaticBin[i];
526  if (omGetStickyBin(bin, BIT_SIZEOF_LONG -1) == NULL)
528  }
529  s_bin = om_SpecBin;
530  while (s_bin != NULL)
531  {
532  if (omGetStickyBin(s_bin->bin, BIT_SIZEOF_LONG -1) == NULL)
533  omCreateStickyBin(s_bin->bin, BIT_SIZEOF_LONG -1);

◆ omGetNewStickyBinTag()

unsigned long omGetNewStickyBinTag ( omBin  bin)

Definition at line 218 of file omBin.c.

222 {
223  unsigned long sticky = omGetMaxStickyBinTag(bin);
224  if (sticky < BIT_SIZEOF_LONG - 2)
225  {
226  sticky++;
227  omCreateStickyBin(bin, sticky);
228  return sticky;
229  }
230  else
231  {
232  omAssume(sticky == BIT_SIZEOF_LONG - 1);

◆ omGetStickyBinOfBin()

omBin omGetStickyBinOfBin ( omBin  bin)

Definition at line 371 of file omBin.c.

376 {
377  omBin new_bin = omAlloc(sizeof(omBin_t));
378  omAssume(omIsKnownTopBin(bin, 1) && ! omIsStickyBin(bin));
379  new_bin->sticky = SIZEOF_VOIDP;
380  new_bin->max_blocks = bin->max_blocks;
381  new_bin->sizeW = bin->sizeW;
382  new_bin->next = om_StickyBins;
383  om_StickyBins = new_bin;
384  new_bin->last_page = NULL;
385  new_bin->current_page = om_ZeroPage;
386 #if 0
387  if (omIsSpecBin(bin))
388  {
389  omSpecBin s_bin = omFindInSortedGList(om_SpecBin, next, max_blocks, bin->max_blocks);
390  omAssume(s_bin != NULL);
391  if (s_bin != NULL)
392  s_bin->ref++;

◆ omGetUsedBinBytes()

long omGetUsedBinBytes ( )

Definition at line 757 of file omBin.c.

757 {
758  long pages = 0, used_blocks = 0, free_blocks = 0;
759  omGetTotalBinStat(bin, &pages, &used_blocks, &free_blocks);
760  return (used_blocks)*((long)bin->sizeW)*SIZEOF_LONG;
761 }
762 
763 long omGetUsedBinBytes()
764 {
765  int i = OM_MAX_BIN_INDEX;
766  omSpecBin s_bin = om_SpecBin;
767  long used = 0;
768  omBin sticky;
769 
770  for (; i>=0; i--)
771  {
773  }
774  while (s_bin != NULL)
775  {
776  used += omGetUsedBytesOfBin(s_bin->bin);
777  s_bin = s_bin->next;
778  }
779 #ifdef OM_HAVE_TRACK
780  for (i=OM_MAX_BIN_INDEX; i>=0; i--)
781  {
782  used += omGetUsedBytesOfBin(&om_StaticTrackBin[i]);
783  }
784  s_bin = om_SpecTrackBin;
785  while (s_bin != NULL)
786  {
787  used += omGetUsedBytesOfBin(s_bin->bin);
788  s_bin = s_bin->next;
789  }
790 #endif
791 
792  sticky = om_StickyBins;
793  while (sticky != NULL)

◆ omIsKnownTopBin()

int omIsKnownTopBin ( omBin  bin,
int  normal_bin 
)

Definition at line 437 of file omBin.c.

443 {
444  omBin to_check;
445  omSpecBin s_bin;
446  int i;
447 
448  omAssume(normal_bin == 1 || normal_bin == 0);
449 
450 #ifdef OM_HAVE_TRACK
451  if (! normal_bin)
452  {
453  to_check = om_StaticTrackBin;
454  s_bin = om_SpecTrackBin;
455  }
456  else
457 #endif
458  {
459  omAssume(normal_bin);
460  to_check = om_StaticBin;
461  s_bin = om_SpecBin;
462  }
463 
464  for (i=0; i<= OM_MAX_BIN_INDEX; i++)
465  {
466  if (bin == &(to_check[i]))
467  return 1;
468  }
469 
470  while (s_bin != NULL)
471  {
472  if (bin == s_bin->bin) return 1;
473  s_bin = s_bin->next;
474  }
475  to_check = om_StickyBins;
476 
477  while (to_check != NULL)
478  {

◆ omMergeStickyBinIntoBin()

void omMergeStickyBinIntoBin ( omBin  sticky_bin,
omBin  into_bin 
)

Definition at line 394 of file omBin.c.

399 {
400  if (! omIsOnGList(om_StickyBins, next, sticky_bin) ||
401  !sticky_bin->sticky ||
402  sticky_bin->max_blocks != into_bin->max_blocks ||
403  sticky_bin == into_bin ||
404  !omIsKnownTopBin(into_bin, 1) ||
405  omIsStickyBin(into_bin))
406  {
407 #ifndef OM_NDEBUG
409  (! omIsOnGList(om_StickyBins, next, sticky_bin) ? "unknown sticky_bin" :
410  (!sticky_bin->sticky ? "sticky_bin is not sticky" :
411  (sticky_bin->max_blocks != into_bin->max_blocks ? "sticky_bin and into_bin have different block sizes" :
412  (sticky_bin == into_bin ? "sticky_bin == into_bin" :
413  (!omIsKnownTopBin(into_bin, 1) ? "unknown into_bin" :
414  (omIsStickyBin(into_bin) ? "into_bin is sticky" :
415  "unknown sticky_bin error")))))));
416 #endif
417  return;
418  }
419  omFreeKeptAddrFromBin(sticky_bin);
421  omMergeStickyPages(into_bin, sticky_bin);
422 
423 #if 0
424  if (! omIsStaticBin(into_bin))
425  {
426  omBin _ibin = into_bin;
427  omUnGetSpecBin(&_ibin);
428  }
429 #endif
430  omFreeSize(sticky_bin, sizeof(omBin_t));

◆ omPrintBinStats()

void omPrintBinStats ( FILE *  fd)

Definition at line 688 of file omBin.c.

695 {
696  int i = OM_MAX_BIN_INDEX;
697  long pages=0, used_blocks=0, free_blocks=0;
698  long pages_p, used_blocks_p, free_blocks_p;
699  omSpecBin s_bin = om_SpecBin;
700  omBin sticky;
701 
702  fputs(" SizeW\tBlocks\tUPages\tFBlocks\tUBlocks\tSticky\n",fd);
703  fflush(fd);
704  while (s_bin != NULL || i >= 0)
705  {
706  if (s_bin == NULL || (i >= 0 && (unsigned long) om_StaticBin[i].max_blocks < (unsigned long) s_bin->bin->max_blocks))
707  {
708  omPrintBinStat(fd, &om_StaticBin[i], 0, &pages_p, &used_blocks_p, &free_blocks_p);
709  pages += pages_p;
710  used_blocks += used_blocks_p;
711  free_blocks += free_blocks_p;
712 #ifdef OM_HAVE_TRACK
713  if (om_StaticTrackBin[i].current_page != om_ZeroPage)
714  {
715  omPrintBinStat(fd, &om_StaticTrackBin[i], 1, &pages_p, &used_blocks_p, &free_blocks_p);
716  pages += pages_p;
717  used_blocks += used_blocks_p;
718  free_blocks += free_blocks_p;
719  }
720 #endif
721  i--;
722  }
723  else
724  {
725  omPrintBinStat(fd, s_bin->bin,0, &pages_p, &used_blocks_p, &free_blocks_p);
726  pages += pages_p;
727  used_blocks += used_blocks_p;
728  free_blocks += free_blocks_p;
729  s_bin = s_bin->next;
730  }
731  }
732 #ifdef OM_HAVE_TRACK
733  s_bin = om_SpecTrackBin;
734  while (s_bin != NULL)
735  {
736  omPrintBinStat(fd, s_bin->bin, 0, &pages_p, &used_blocks_p, &free_blocks_p);
737  s_bin = s_bin->next;
738  pages += pages_p;
739  used_blocks += used_blocks_p;
740  free_blocks += free_blocks_p;
741  }
742 #endif
743  sticky = om_StickyBins;
744  while (sticky != NULL)
745  {
746  omPrintBinStat(fd, sticky, 0, &pages_p, &used_blocks_p, &free_blocks_p);
747  sticky = sticky->next;
748  pages += pages_p;

◆ omSetStickyAllBinTag()

void omSetStickyAllBinTag ( unsigned long  sticky)

Definition at line 535 of file omBin.c.

541 {
542  omSpecBin s_bin = om_SpecBin;
543  int i;
544  for (i=0; i<=OM_MAX_BIN_INDEX; i++)
545  {
546  omSetStickyBinTag(&(om_StaticBin[i]), sticky);
547  }
548  while (s_bin != NULL)

◆ omSetStickyBinTag()

void omSetStickyBinTag ( omBin  bin,
unsigned long  sticky 
)

Definition at line 234 of file omBin.c.

238 {
239  omBin s_bin;
240  s_bin = omGetStickyBin(bin, sticky_tag);
241 
242  if (s_bin != bin)
243  {
244  omBinPage tc, tl;
245  unsigned long ts;
246 
247  if (s_bin == NULL) s_bin = omCreateStickyBin(bin, sticky_tag);
248  ts = bin->sticky;
249  tl = bin->last_page;
250  tc = bin->current_page;
251  bin->sticky = s_bin->sticky;
252  bin->current_page = s_bin->current_page;
253  bin->last_page = s_bin->last_page;
254  s_bin->sticky = ts;
255  s_bin->last_page = tl;

◆ omUnSetStickyAllBinTag()

void omUnSetStickyAllBinTag ( unsigned long  sticky)

Definition at line 550 of file omBin.c.

556 {
557  omSpecBin s_bin = om_SpecBin;
558  int i;
559  for (i=0; i<=OM_MAX_BIN_INDEX; i++)
560  {
561  omUnSetStickyBinTag(&(om_StaticBin[i]), sticky);
562  }
563  while (s_bin != NULL)

◆ omUnSetStickyBinTag()

void omUnSetStickyBinTag ( omBin  bin,
unsigned long  sticky 
)

Definition at line 257 of file omBin.c.

261 {
262  omAssume(omGetStickyBin(bin, 0) != NULL);
BIT_SIZEOF_LONG
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:80
omFreeKeptAddrFromBin
void omFreeKeptAddrFromBin(omBin bin)
Definition: omDebug.c:538
om_StickyBins
omBin om_StickyBins
Definition: omBin.c:370
omDeleteStickyBinTag
void omDeleteStickyBinTag(omBin bin, unsigned long sticky)
Definition: omBin.c:336
omPrintBinStat
static void omPrintBinStat(FILE *fd, omBin bin, int track, long *pages, long *used_blocks, long *free_blocks)
Definition: omBin.c:657
omIsOnGList
#define omIsOnGList(ptr, next, addr)
Definition: omList.h:96
omIsStaticBin
#define omIsStaticBin(bin)
Definition: omBin.h:58
omReportError
omError_t omReportError(omError_t error, omError_t report_error, OM_FLR_DECL, const char *fmt,...)
Definition: omError.c:79
omRemoveFromGList
#define omRemoveFromGList(ptr, next, addr)
Definition: omList.h:98
omIsSpecBin
#define omIsSpecBin(bin)
Definition: omBin.h:46
omSmallSize2AlignedBin
#define omSmallSize2AlignedBin
Definition: omtTestAlloc.c:28
omMergeStickyPages
static void omMergeStickyPages(omBin to_bin, omBin from_bin)
Definition: omBin.c:264
omInsertInSortedGList
#define omInsertInSortedGList(ptr, next, what, addr)
Definition: omList.h:102
next
ListNode * next
Definition: janet.h:31
omAssume
#define omAssume(x)
Definition: omError.h:82
i
int i
Definition: cfEzgcd.cc:125
omGetStickyBin
#define omGetStickyBin(bin, sticky_tag)
Definition: omBin.c:190
OM_MAX_BLOCK_SIZE
#define OM_MAX_BLOCK_SIZE
Definition: omTables.c:30
omSpecBin
omSpecBin_t * omSpecBin
Definition: omStructs.h:29
omFindInSortedGList
#define omFindInSortedGList(ptr, next, what, value)
Definition: omList.h:104
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
omGetUsedBytesOfBin
static long omGetUsedBytesOfBin(omBin bin)
Definition: omBin.c:750
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
omError_NoError
Definition: omError.h:23
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
omSmallSize2Bin
#define omSmallSize2Bin(size)
Definition: omAllocPrivate.h:206
OM_SIZEOF_UNIQUE_MAX_BLOCK_THRESHOLD
#define OM_SIZEOF_UNIQUE_MAX_BLOCK_THRESHOLD
Definition: omTables.h:5
omGetMaxStickyBinTag
unsigned long omGetMaxStickyBinTag(omBin bin)
Definition: omBin.c:206
om_LargeBin
#define om_LargeBin
Definition: omBin.c:23
omBin
omBin_t * omBin
Definition: omStructs.h:11
omGetUsedBinBytes
long omGetUsedBinBytes()
Definition: omBin.c:757
om_SpecBin
omSpecBin om_SpecBin
Definition: om_Alloc.c:19
om_ZeroPage
omBinPage_t om_ZeroPage[]
Definition: om_Alloc.c:18
omUnGetSpecBin
#define omUnGetSpecBin(bin_ptr)
Definition: omBin.h:13
OM_MAX_BIN_INDEX
#define OM_MAX_BIN_INDEX
Definition: omTables.h:4
NULL
#define NULL
Definition: omList.c:11
omError_StickyBin
Definition: omError.h:46
SIZEOF_OM_BIN_PAGE
#define SIZEOF_OM_BIN_PAGE
Definition: omAllocPrivate.h:30
omRemoveFromSortedGList
#define omRemoveFromSortedGList(ptr, next, what, addr)
Definition: omList.h:106
omFindInGList
#define omFindInGList(ptr, next, what, value)
Definition: omList.h:100
omSetStickyBinTag
void omSetStickyBinTag(omBin bin, unsigned long sticky_tag)
Definition: omBin.c:234
fd
int status int fd
Definition: si_signals.h:58
omCreateStickyBin
static omBin omCreateStickyBin(omBin bin, unsigned long sticky)
Definition: omBin.c:193
om_StaticBin
omBin_t om_StaticBin[]
omIsKnownTopBin
int omIsKnownTopBin(omBin bin, int normal_bin)
Definition: omBin.c:437
omGetTotalBinStat
static void omGetTotalBinStat(omBin bin, long *pages_p, long *used_blocks_p, long *free_blocks_p)
Definition: omBin.c:635
omUnSetStickyBinTag
void omUnSetStickyBinTag(omBin bin, unsigned long sticky)
Definition: omBin.c:257
omBinPage
omBinPage_t * omBinPage
Definition: omStructs.h:15
omIsStickyBin
#define omIsStickyBin(bin)
Definition: omBin.h:32