Data Structures | Macros | Functions | Variables
omBinPage.c File Reference
#include <mylimits.h>
#include "omalloc.h"
#include "omDefaultConfig.h"
#include "omDebug.h"

Go to the source code of this file.

Data Structures

struct  omBinPageRegion_t
 

Macros

#define OM_KEEP_REGIONS_ORDER
 
#define NEXT_PAGE(page)   *((void**) page)
 
#define OM_IS_EMPTY_REGION(region)   ((region)->current == NULL && (region->init_addr == NULL))
 

Functions

static void * omTakeOutConsecutivePages (omBinPageRegion region, int how_many)
 
static omBinPageRegion omAllocNewBinPagesRegion (int min_pages)
 
static void omFreeBinPagesRegion (omBinPageRegion region)
 
static void omBinPageIndexFault (unsigned long low_index, unsigned long high_index)
 
static void omRegisterBinPages (void *low_addr, int pages)
 
static void omUnregisterBinPages (void *low_addr, int pages)
 
OM_INLINE_LOCAL void omTakeOutRegion (omBinPageRegion region)
 
OM_INLINE_LOCAL void omInsertRegionAfter (omBinPageRegion insert, omBinPageRegion after)
 
OM_INLINE_LOCAL void omInsertRegionBefore (omBinPageRegion insert, omBinPageRegion before)
 
omBinPage omAllocBinPage ()
 
omBinPage omAllocBinPages (int how_many)
 
void omFreeBinPages (omBinPage bin_page, int how_many)
 
int omIsKnownMemoryRegion (omBinPageRegion region)
 
omError_t omCheckBinPageRegion (omBinPageRegion region, int level, omError_t report, OM_FLR_DECL)
 
omError_t omCheckBinPageRegions (int level, omError_t report, OM_FLR_DECL)
 
omBinPageRegion omFindRegionOfAddr (void *addr)
 
int omIsAddrOnFreeBinPage (void *addr)
 

Variables

static omBinPageRegion om_CurrentBinPageRegion = NULL
 
unsigned long om_MaxBinPageIndex = 0
 
unsigned long om_MinBinPageIndex = ULONG_MAX
 
unsigned long * om_BinPageIndicies = NULL
 

Data Structure Documentation

struct omBinPageRegion_s

Definition at line 20 of file omBinPage.c.

Data Fields
char * addr
void * current
char * init_addr
int init_pages
omBinPageRegion next
int pages
omBinPageRegion prev
int used_pages

Macro Definition Documentation

#define NEXT_PAGE (   page)    *((void**) page)

Definition at line 93 of file omBinPage.c.

#define OM_IS_EMPTY_REGION (   region)    ((region)->current == NULL && (region->init_addr == NULL))

Definition at line 94 of file omBinPage.c.

#define OM_KEEP_REGIONS_ORDER

Definition at line 18 of file omBinPage.c.

Function Documentation

omBinPage omAllocBinPage ( )

Definition at line 96 of file omBinPage.c.

97 {
98  omBinPage bin_page;
99 
102 
103  while (1)
104  {
105  if (om_CurrentBinPageRegion->current != NULL)
106  {
107  bin_page = om_CurrentBinPageRegion->current;
108  om_CurrentBinPageRegion->current = NEXT_PAGE(bin_page);
109  goto Found;
110  }
111  if (om_CurrentBinPageRegion->init_pages > 0)
112  {
113  bin_page = (omBinPage)om_CurrentBinPageRegion->init_addr;
114  om_CurrentBinPageRegion->init_pages--;
115  if (om_CurrentBinPageRegion->init_pages > 0)
116  om_CurrentBinPageRegion->init_addr += SIZEOF_SYSTEM_PAGE;
117  else
118  om_CurrentBinPageRegion->init_addr = NULL;
119  goto Found;
120  }
121  if (om_CurrentBinPageRegion->next != NULL)
122  {
124  }
125  else
126  {
128  new_region->prev = om_CurrentBinPageRegion;
129  om_CurrentBinPageRegion->next = new_region;
130  om_CurrentBinPageRegion = new_region;
131  }
132  }
133 
134  Found:
135  bin_page->region = om_CurrentBinPageRegion;
136  om_CurrentBinPageRegion->used_pages++;
137 
138  om_Info.UsedPages++;
139  om_Info.AvailPages--;
140  if (om_Info.UsedPages > om_Info.MaxPages)
141  om_Info.MaxPages = om_Info.UsedPages;
142 
143  OM_ALLOC_BINPAGE_HOOK;
144  return bin_page;
145 }
#define NEXT_PAGE(page)
Definition: omBinPage.c:93
static omBinPageRegion om_CurrentBinPageRegion
Definition: omBinPage.c:33
int int kStrategy strat if(h==NULL) return NULL
omInfo_t om_Info
Definition: omStats.c:13
omBinPage_t * omBinPage
Definition: omStructs.h:16
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
#define NULL
Definition: omList.c:10
static omBinPageRegion omAllocNewBinPagesRegion(int min_pages)
Definition: omBinPage.c:292
omBinPage omAllocBinPages ( int  how_many)

Definition at line 147 of file omBinPage.c.

148 {
149  omBinPage bin_page;
150  omBinPageRegion region;
151 
154 
155  region = om_CurrentBinPageRegion;
156  while (1)
157  {
158  if (region->init_pages >= how_many)
159  {
160  bin_page = (omBinPage)region->init_addr;
161  region->init_pages -= how_many;
162  if (region->init_pages)
163  region->init_addr += how_many*SIZEOF_SYSTEM_PAGE;
164  else
165  region->init_addr = NULL;
166  goto Found;
167  }
168  if ((bin_page = omTakeOutConsecutivePages(region, how_many)) != NULL)
169  {
170  goto Found;
171  }
172  if (region->next != NULL)
173  {
174  region = region->next;
175  }
176  else
177  {
178  omBinPageRegion new_region = omAllocNewBinPagesRegion(how_many);
179  region->next = new_region;
180  new_region->prev = region;
181  region = new_region;
182  }
183  }
184  /*while (1) */
185 
186  Found:
187  bin_page->region = region;
188  region->used_pages += how_many;
189 
190  if (region != om_CurrentBinPageRegion && OM_IS_EMPTY_REGION(region))
191  {
192  omTakeOutRegion(region);
194  }
195  om_Info.UsedPages += how_many;
196  om_Info.AvailPages -= how_many;
197  if (om_Info.UsedPages > om_Info.MaxPages)
198  om_Info.MaxPages = om_Info.UsedPages;
199 
200  OM_ALLOC_BINPAGE_HOOK;
201  return bin_page;
202 }
OM_INLINE_LOCAL void omInsertRegionBefore(omBinPageRegion insert, omBinPageRegion before)
Definition: omBinPage.c:77
static void * omTakeOutConsecutivePages(omBinPageRegion region, int how_many)
Definition: omBinPage.c:252
static omBinPageRegion om_CurrentBinPageRegion
Definition: omBinPage.c:33
int int kStrategy strat if(h==NULL) return NULL
omInfo_t om_Info
Definition: omStats.c:13
omBinPage_t * omBinPage
Definition: omStructs.h:16
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
#define NULL
Definition: omList.c:10
#define OM_IS_EMPTY_REGION(region)
Definition: omBinPage.c:94
static omBinPageRegion omAllocNewBinPagesRegion(int min_pages)
Definition: omBinPage.c:292
OM_INLINE_LOCAL void omTakeOutRegion(omBinPageRegion region)
Definition: omBinPage.c:47
static omBinPageRegion omAllocNewBinPagesRegion ( int  min_pages)
static

Definition at line 292 of file omBinPage.c.

293 {
294  omBinPageRegion region = omAllocFromSystem(sizeof(omBinPageRegion_t));
295  void* addr;
296  int pages = (min_pages>om_Opts.PagesPerRegion ? min_pages : om_Opts.PagesPerRegion);
297  size_t size = pages*SIZEOF_SYSTEM_PAGE;
298 
299  addr = _omVallocFromSystem(size, 1);
300  if (addr == NULL)
301  {
302  pages = min_pages;
303  size = min_pages*SIZEOF_SYSTEM_PAGE;
304  addr = omVallocFromSystem(size);
305  }
306 
307  omRegisterBinPages(addr, pages);
308  region->addr = addr;
309  region->pages = pages;
310  region->used_pages = 0;
311  region->init_addr = addr;
312  region->init_pages = pages;
313  region->current = NULL;
314  region->next = NULL;
315  region->prev = NULL;
316 
317  om_Info.AvailPages += pages;
318 
319  om_Info.CurrentRegionsAlloc++;
320  if (om_Info.CurrentRegionsAlloc > om_Info.MaxRegionsAlloc)
321  om_Info.MaxRegionsAlloc = om_Info.CurrentRegionsAlloc;
322 
323  return region;
324 }
void * omAllocFromSystem(size_t size)
static void omRegisterBinPages(void *low_addr, int pages)
Definition: omBinPage.c:382
#define omVallocFromSystem(size)
Definition: omAllocSystem.h:24
void * _omVallocFromSystem(size_t size, int fail)
omOpts_t om_Opts
Definition: omOpts.c:11
omInfo_t om_Info
Definition: omStats.c:13
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
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
static void omBinPageIndexFault ( unsigned long  low_index,
unsigned long  high_index 
)
static

Definition at line 345 of file omBinPage.c.

346 {
347  unsigned long index_diff = high_index - low_index;
348  long i;
349  omAssume(low_index <= high_index &&
350  (high_index > om_MaxBinPageIndex || low_index < om_MinBinPageIndex));
351 
352  if (om_BinPageIndicies == NULL)
353  {
354  om_BinPageIndicies = (unsigned long*) omAllocFromSystem((index_diff + 1)*SIZEOF_LONG);
355  om_MaxBinPageIndex = high_index;
356  om_MinBinPageIndex = low_index;
357  for (i=0; i<=index_diff; i++) om_BinPageIndicies[i] = 0;
358  }
359  else
360  {
361  unsigned long old_length = om_MaxBinPageIndex - om_MinBinPageIndex + 1;
362  unsigned long new_length = (low_index < om_MinBinPageIndex ?
363  om_MaxBinPageIndex - low_index :
364  high_index - om_MinBinPageIndex) + 1;
365  om_BinPageIndicies = (unsigned long*) omReallocSizeFromSystem(om_BinPageIndicies, old_length*SIZEOF_LONG,
366  new_length*SIZEOF_LONG);
367  if (low_index < om_MinBinPageIndex)
368  {
369  unsigned long offset = new_length - old_length;
370  for (i=old_length - 1; i >= 0; i--) om_BinPageIndicies[i+offset] = om_BinPageIndicies[i];
371  for (i=0; i<offset; i++) om_BinPageIndicies[i] = 0;
372  om_MinBinPageIndex = low_index;
373  }
374  else
375  {
376  for (i=old_length; i<new_length; i++) om_BinPageIndicies[i] = 0;
377  om_MaxBinPageIndex = high_index;
378  }
379  }
380 }
void * omAllocFromSystem(size_t size)
unsigned long om_MinBinPageIndex
Definition: omBinPage.c:35
void * omReallocSizeFromSystem(void *addr, size_t oldsize, size_t newsize)
#define omAssume(x)
Definition: omError.h:85
int i
Definition: cfEzgcd.cc:123
unsigned long om_MaxBinPageIndex
Definition: omBinPage.c:34
unsigned long * om_BinPageIndicies
Definition: omBinPage.c:36
#define NULL
Definition: omList.c:10
int offset
Definition: libparse.cc:1091
omError_t omCheckBinPageRegion ( omBinPageRegion  region,
int  level,
omError_t  report,
OM_FLR_DECL   
)

Definition at line 497 of file omBinPage.c.

498 {
499  if (level <= 0) return omError_NoError;
500 
501  omCheckReturn(omCheckPtr(region, report, OM_FLR_VAL));
503  omCheckReturnCorrupted(! omIsAddrPageAligned(region->addr) || ! omIsAddrPageAligned(region->current));
504  omCheckReturnCorrupted(region->used_pages < 0);
505  omCheckReturnCorrupted(region->init_pages < 0 || region->init_pages > region->pages);
506 
507  if (region->init_pages)
508  {
509  omCheckReturnCorrupted(! omIsAddrPageAligned(region->init_addr));
510  omCheckReturnCorrupted(! (region->init_addr >= region->addr
511  && region->init_addr <= region->addr + (region->pages -1)*SIZEOF_SYSTEM_PAGE));
512  omCheckReturnCorrupted(region->init_addr !=
513  region->addr + (region->pages - region->init_pages)*SIZEOF_SYSTEM_PAGE);
514  }
515 
516  omCheckReturn(omCheckList(region->current, level, report, OM_FLR_VAL));
517  omCheckReturnCorrupted(region->current == NULL && region->used_pages + region->init_pages != region->pages);
519  omListLength(region->current)+region->used_pages+region->init_pages != region->pages);
520  return omError_NoError;
521 }
int omIsKnownMemoryRegion(omBinPageRegion region)
Definition: omBinPage.c:481
int level(const CanonicalForm &f)
#define omCheckList(ptr, level, report, OM_FLR_VAL)
Definition: omList.h:83
#define omListLength(ptr)
Definition: omList.h:62
#define omCheckReturnCorrupted(cond)
Definition: omDebug.h:174
#define omCheckReturn(cond)
Definition: omDebug.h:170
omError_t omCheckPtr(const void *ptr, omError_t report, OM_FLR_DECL)
Definition: omDebugCheck.c:136
#define NULL
Definition: omList.c:10
#define omIsAddrPageAligned(addr)
Definition: omBinPage.h:16
omError_t omCheckBinPageRegions ( int  level,
omError_t  report,
OM_FLR_DECL   
)

Definition at line 523 of file omBinPage.c.

524 {
526 
527  if (level <= 0) return omError_NoError;
528  if (iter == NULL) return omError_NoError;
529 
534 
535 
536  if (level > 1)
537  {
540 
541  omCheckReturn(omCheckGList(iter, next, level, report, OM_FLR_VAL));
542  omCheckReturn(omCheckGList(iter, prev, level, report, OM_FLR_VAL));
543 
545  !=
546  omGListLength(next_last, prev));
547 
549 
550  iter = om_CurrentBinPageRegion->next;
551  while (iter)
552  {
554 
555  omCheckReturn(omCheckBinPageRegion(iter, level - 1, report, OM_FLR_VAL));
556  iter = iter->next;
557  }
558 
559  iter = om_CurrentBinPageRegion->prev;
560  while (iter)
561  {
563  omCheckReturn(omCheckBinPageRegion(iter, level - 1, report, OM_FLR_VAL));
564  iter = iter->prev;
565  }
566  }
567  return omError_NoError;
568 }
int level(const CanonicalForm &f)
#define omCheckGList(ptr, next, level, report, OM_FLR_VAL)
Definition: omList.h:115
omError_t omCheckBinPageRegion(omBinPageRegion region, int level, omError_t report, OM_FLR_DECL)
Definition: omBinPage.c:497
CFFListIterator iter
Definition: facAbsBiFact.cc:54
#define omCheckReturnError(cond, error)
Definition: omDebug.h:172
#define omCheckReturnCorrupted(cond)
Definition: omDebug.h:174
static omBinPageRegion om_CurrentBinPageRegion
Definition: omBinPage.c:33
#define omGListLast(ptr, next)
Definition: omList.h:96
#define omCheckReturn(cond)
Definition: omDebug.h:170
#define omGListLength(ptr, next)
Definition: omList.h:94
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
#define NULL
Definition: omList.c:10
#define OM_IS_EMPTY_REGION(region)
Definition: omBinPage.c:94
ListNode * next
Definition: janet.h:31
omBinPageRegion omFindRegionOfAddr ( void *  addr)

Definition at line 570 of file omBinPage.c.

571 {
573 
574  if (region == NULL) return 0;
575  region = omGListLast(region, prev);
576  do
577  {
578  if ((char *)addr >= region->addr
579  && (char *)addr < region->addr + (region->pages)*SIZEOF_SYSTEM_PAGE)
580  return region;
581  region = region->next;
582  }
583  while (region != NULL);
584  return NULL;
585 }
static omBinPageRegion om_CurrentBinPageRegion
Definition: omBinPage.c:33
#define omGListLast(ptr, next)
Definition: omList.h:96
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
#define NULL
Definition: omList.c:10
void omFreeBinPages ( omBinPage  bin_page,
int  how_many 
)

Definition at line 204 of file omBinPage.c.

205 {
206  omBinPageRegion region = bin_page->region;
207 
208  region->used_pages -= how_many;
209  if (region->used_pages == 0)
210  {
211  if (region == om_CurrentBinPageRegion)
212  {
213  if (region->next != NULL)
214  om_CurrentBinPageRegion = region->next;
215  else
216  om_CurrentBinPageRegion = region->prev;
217  }
218  omTakeOutRegion(region);
219  omFreeBinPagesRegion(region);
220  }
221  else
222  {
223  if (region != om_CurrentBinPageRegion && OM_IS_EMPTY_REGION(region))
224  {
225  omTakeOutRegion(region);
227  }
228  if (how_many > 1)
229  {
230  int i = how_many;
231  char* page = (char *)bin_page;
232 
233  while (i > 1)
234  {
235  NEXT_PAGE(page) = page + SIZEOF_SYSTEM_PAGE;
236  page = NEXT_PAGE(page);
237  i--;
238  }
239  NEXT_PAGE(page) = region->current;
240  }
241  else
242  {
243  NEXT_PAGE(bin_page) = region->current;
244  }
245  region->current = (void*) bin_page;
246  }
247  om_Info.AvailPages += how_many;
248  om_Info.UsedPages -= how_many;
249  OM_FREE_BINPAGE_HOOK;
250 }
static void omFreeBinPagesRegion(omBinPageRegion region)
Definition: omBinPage.c:327
#define NEXT_PAGE(page)
Definition: omBinPage.c:93
static omBinPageRegion om_CurrentBinPageRegion
Definition: omBinPage.c:33
omInfo_t om_Info
Definition: omStats.c:13
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
#define OM_IS_EMPTY_REGION(region)
Definition: omBinPage.c:94
OM_INLINE_LOCAL void omInsertRegionAfter(omBinPageRegion insert, omBinPageRegion after)
Definition: omBinPage.c:64
OM_INLINE_LOCAL void omTakeOutRegion(omBinPageRegion region)
Definition: omBinPage.c:47
static void omFreeBinPagesRegion ( omBinPageRegion  region)
static

Definition at line 327 of file omBinPage.c.

328 {
329  omAssume(region != NULL && region->used_pages == 0);
330 
331  om_Info.AvailPages -= region->pages;
332  om_Info.CurrentRegionsAlloc--;
333 
334  omUnregisterBinPages(region->addr, region->pages);
335  omVfreeToSystem(region->addr, region->pages*SIZEOF_SYSTEM_PAGE);
336  omFreeSizeToSystem(region, sizeof(omBinPageRegion_t));
337 }
void omFreeSizeToSystem(void *addr, size_t size)
static void omUnregisterBinPages(void *low_addr, int pages)
Definition: omBinPage.c:429
omInfo_t om_Info
Definition: omStats.c:13
#define omAssume(x)
Definition: omError.h:85
void omVfreeToSystem(void *page, size_t size)
#define NULL
Definition: omList.c:10
OM_INLINE_LOCAL void omInsertRegionAfter ( omBinPageRegion  insert,
omBinPageRegion  after 
)

Definition at line 64 of file omBinPage.c.

65 {
66  omAssume(insert != NULL && after != NULL && insert != after);
67  insert->next = after->next;
68  insert->prev = after;
69  after->next = insert;
70  if (insert->next != NULL)
71  {
72  omAssume(insert->next != insert && insert->next != after);
73  insert->next->prev = insert;
74  }
75 }
#define omAssume(x)
Definition: omError.h:85
result insert(CFAFactor(LcF, 1, 1))
#define NULL
Definition: omList.c:10
OM_INLINE_LOCAL void omInsertRegionBefore ( omBinPageRegion  insert,
omBinPageRegion  before 
)

Definition at line 77 of file omBinPage.c.

78 {
79  omAssume(insert != NULL && before != NULL && insert != before);
80  insert->prev = before->prev;
81  insert->next = before;
82  before->prev = insert;
83  if (insert->prev != NULL)
84  insert->prev->next = insert;
85 }
#define omAssume(x)
Definition: omError.h:85
result insert(CFAFactor(LcF, 1, 1))
#define NULL
Definition: omList.c:10
int omIsAddrOnFreeBinPage ( void *  addr)

Definition at line 587 of file omBinPage.c.

588 {
589  char *c_addr=(char *)addr;
591 
592  if (region == NULL) return 0;
593  do
594  {
595  if (c_addr > region->addr && c_addr < region->addr + (region->pages)*SIZEOF_SYSTEM_PAGE)
596  {
597  if (omIsOnList(region->current, omGetPageOfAddr(addr))) return 1;
598  return 0;
599  }
600  region = region->next;
601  }
602  while (region != NULL);
603  return 0;
604 }
#define omIsOnList(ptr, addr)
Definition: omList.h:68
static omBinPageRegion om_CurrentBinPageRegion
Definition: omBinPage.c:33
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
#define NULL
Definition: omList.c:10
#define omGetPageOfAddr(addr)
Definition: omBinPage.h:19
int omIsKnownMemoryRegion ( omBinPageRegion  region)

Definition at line 481 of file omBinPage.c.

482 {
484 
485  if (region == NULL || iter == NULL) return 0;
486  iter = omGListLast(om_CurrentBinPageRegion, prev);
487  do
488  {
489  if (region == iter) return 1;
490  iter = iter->next;
491  }
492  while (iter != NULL);
493  return 0;
494 }
CFFListIterator iter
Definition: facAbsBiFact.cc:54
static omBinPageRegion om_CurrentBinPageRegion
Definition: omBinPage.c:33
#define omGListLast(ptr, next)
Definition: omList.h:96
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
#define NULL
Definition: omList.c:10
static void omRegisterBinPages ( void *  low_addr,
int  pages 
)
static

Definition at line 382 of file omBinPage.c.

383 {
384  unsigned long low_index = omGetPageIndexOfAddr(low_addr);
385  char* high_addr = (char *)low_addr + (pages-1)*SIZEOF_SYSTEM_PAGE;
386  unsigned long high_index = omGetPageIndexOfAddr(high_addr);
387  unsigned long shift;
388 
389  if (low_index < om_MinBinPageIndex || high_index > om_MaxBinPageIndex)
390  omBinPageIndexFault(low_index, high_index);
391 
392  shift = omGetPageShiftOfAddr(low_addr);
393  if (low_index < high_index)
394  {
395  if (shift == 0)
396  {
397  om_BinPageIndicies[low_index-om_MinBinPageIndex] = ULONG_MAX;
398  }
399  else
400  {
401  om_BinPageIndicies[low_index-om_MinBinPageIndex] |= ~ ((((unsigned long) 1) << shift) - 1);
402  }
403  for (shift = low_index+1; shift < high_index; shift++)
404  {
405  om_BinPageIndicies[shift-om_MinBinPageIndex] = ULONG_MAX;
406  }
407  shift = omGetPageShiftOfAddr(high_addr);
408  if (shift == BIT_SIZEOF_LONG - 1)
409  {
410  om_BinPageIndicies[high_index - om_MinBinPageIndex] = ULONG_MAX;
411  }
412  else
413  {
414  om_BinPageIndicies[high_index-om_MinBinPageIndex] |= ((((unsigned long) 1) << (shift + 1)) - 1);
415  }
416  }
417  else
418  {
419  high_index = omGetPageShiftOfAddr(high_addr);
420  while (high_index > shift)
421  {
422  om_BinPageIndicies[low_index-om_MinBinPageIndex] |= (((unsigned long) 1) << high_index);
423  high_index--;
424  }
425  om_BinPageIndicies[low_index-om_MinBinPageIndex] |= (((unsigned long) 1) << shift);
426  }
427 }
unsigned long om_MinBinPageIndex
Definition: omBinPage.c:35
#define omGetPageIndexOfAddr(addr)
Definition: omBinPage.h:63
unsigned long om_MaxBinPageIndex
Definition: omBinPage.c:34
unsigned long * om_BinPageIndicies
Definition: omBinPage.c:36
static void omBinPageIndexFault(unsigned long low_index, unsigned long high_index)
Definition: omBinPage.c:345
#define omGetPageShiftOfAddr(addr)
Definition: omBinPage.h:60
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:124
static void * omTakeOutConsecutivePages ( omBinPageRegion  region,
int  how_many 
)
static

Definition at line 252 of file omBinPage.c.

253 {
254  void* current;
255  char* iter;
256  void* prev = NULL;
257  void* bin_page;
258  int found;
259  current = region->current;
260  while (current != NULL)
261  {
262  found = 1;
263  iter = current;
264  while (NEXT_PAGE(iter) == (iter + SIZEOF_SYSTEM_PAGE))
265  {
266  iter = NEXT_PAGE(iter);
267  /* handle pathological case that iter + SIZEOF_SYSTEM_PAGE == 0 */
268  if (iter == NULL) return NULL;
269  found++;
270  if (found == pages)
271  {
272  bin_page = current;
273  if (current == region->current)
274  {
275  region->current = NEXT_PAGE(iter);
276  }
277  else
278  {
279  omAssume(prev != NULL);
280  NEXT_PAGE(prev) = NEXT_PAGE(iter);
281  }
282  return bin_page;
283  }
284  }
285  prev = iter;
286  current = NEXT_PAGE(iter);
287  }
288  return NULL;
289 }
#define NEXT_PAGE(page)
Definition: omBinPage.c:93
CFFListIterator iter
Definition: facAbsBiFact.cc:54
bool found
Definition: facFactorize.cc:56
#define omAssume(x)
Definition: omError.h:85
#define NULL
Definition: omList.c:10
OM_INLINE_LOCAL void omTakeOutRegion ( omBinPageRegion  region)

Definition at line 47 of file omBinPage.c.

48 {
49  omAssume(region != NULL);
50 
51  if (region->prev != NULL)
52  {
53  omAssume(region->prev != region && region->prev != region->next);
54  region->prev->next = region->next;
55  }
56 
57  if (region->next != NULL)
58  {
59  omAssume(region->next != region && region->prev != region->next);
60  region->next->prev = region->prev;
61  }
62 }
#define omAssume(x)
Definition: omError.h:85
#define NULL
Definition: omList.c:10
static void omUnregisterBinPages ( void *  low_addr,
int  pages 
)
static

Definition at line 429 of file omBinPage.c.

430 {
431  unsigned long low_index = omGetPageIndexOfAddr(low_addr);
432  char* high_addr = (char *)low_addr + (pages-1)*SIZEOF_SYSTEM_PAGE;
433  unsigned long high_index = omGetPageIndexOfAddr(high_addr);
434  unsigned long shift;
435 
436  shift = omGetPageShiftOfAddr(low_addr);
437  if (low_index < high_index)
438  {
439  if (shift == 0)
440  {
441  om_BinPageIndicies[low_index-om_MinBinPageIndex] = 0;
442  }
443  else
444  {
445  om_BinPageIndicies[low_index-om_MinBinPageIndex] &= ((((unsigned long) 1) << shift) - 1);
446  }
447  for (shift = low_index+1; shift < high_index; shift++)
448  {
450  }
451  shift = omGetPageShiftOfAddr(high_addr);
452  if (shift == BIT_SIZEOF_LONG - 1)
453  {
454  om_BinPageIndicies[high_index - om_MinBinPageIndex] = 0;
455  }
456  else
457  {
458  om_BinPageIndicies[high_index-om_MinBinPageIndex] &= ~ ((((unsigned long) 1) << (shift + 1)) - 1);
459  }
460  }
461  else
462  {
463  high_index = omGetPageShiftOfAddr(high_addr);
464  while (high_index > shift)
465  {
466  om_BinPageIndicies[low_index-om_MinBinPageIndex] &= ~(((unsigned long) 1) << high_index);
467  high_index--;
468  }
469  om_BinPageIndicies[low_index-om_MinBinPageIndex] &= ~(((unsigned long) 1) << shift);
470  }
471 }
unsigned long om_MinBinPageIndex
Definition: omBinPage.c:35
#define omGetPageIndexOfAddr(addr)
Definition: omBinPage.h:63
unsigned long * om_BinPageIndicies
Definition: omBinPage.c:36
#define omGetPageShiftOfAddr(addr)
Definition: omBinPage.h:60
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:124

Variable Documentation

unsigned long* om_BinPageIndicies = NULL

Definition at line 36 of file omBinPage.c.

omBinPageRegion om_CurrentBinPageRegion = NULL
static

Definition at line 33 of file omBinPage.c.

unsigned long om_MaxBinPageIndex = 0

Definition at line 34 of file omBinPage.c.

unsigned long om_MinBinPageIndex = ULONG_MAX

Definition at line 35 of file omBinPage.c.