My Project  UNKNOWN_GIT_VERSION
Macros | Functions | Variables
omtTest.c File Reference
#include "omtTest.h"
#include "omalloc.h"

Go to the source code of this file.

Macros

#define OM_CHECK   CHECK_LEVEL
 

Functions

void omtTestDebug (omMemCell cell)
 
void TestAddrContentEqual (void *s1, void *s2, size_t size)
 
void TestAddrContent (void *addr, unsigned long value, size_t size)
 
void InitCellAddrContent (omMemCell cell)
 
void omCheckCells (int n, int level, omMemCell_t *cells)
 
int MyRandSpec ()
 
void TestAlloc (omMemCell cell, unsigned long spec)
 
void TestRealloc (omMemCell cell, unsigned long spec)
 
void TestDup (omMemCell cell, unsigned long spec)
 
void TestFree (omMemCell cell)
 
omBin omtGetStickyBin (omBin bin)
 
void omtMergeStickyBins (omMemCell cell, int n)
 
void my_exit ()
 
int main (int argc, char *argv[])
 

Variables

omMemCell_t cells [MAX_CELLS]
 
int errors = 0
 
int missed_errors = 0
 
int used_regions = 0
 
int seed
 
int size_range = RANGE_MIN
 
int size_range_number = RANGE_MAX / RANGE_MIN
 

Macro Definition Documentation

◆ OM_CHECK

#define OM_CHECK   CHECK_LEVEL

Definition at line 5 of file omtTest.c.

Function Documentation

◆ InitCellAddrContent()

void InitCellAddrContent ( omMemCell  cell)

Definition at line 134 of file omtTest.c.

135 {
136  size_t sizeW = omSizeWOfAddr(cell->addr);
137  omMemsetW(cell->addr, (IS_ZERO(cell->spec) ? 0 : cell->spec), sizeW);
138 }

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 340 of file omtTest.c.

341 {
342  int i=0, error_test = 1;
343  unsigned long spec, j;
344  int n = 1;
345  int n_cells = MAX_CELLS;
346  int decr = 2;
347  int last_kept_freed = 0;
348  om_Opts.MinCheck = CHECK_LEVEL;
349  om_Opts.Keep = KEEP_ADDR;
350 
351  seed = time(NULL);
352 
353  omInitRet_2_Info(argv[0]);
355  omInitInfo();
356  om_Opts.PagesPerRegion = PAGES_PER_REGION;
357 
358  if (argc > 1) sscanf(argv[1], "%d", &error_test);
359  if (argc > 2) sscanf(argv[2], "%d", &seed);
360  srandom(seed);
361 
362  if (argc > 3) sscanf(argv[3], "%d", &n);
363  if (argc > 4) sscanf(argv[4], "%d", &decr);
364 
365  if (decr < 2) decr = 2;
366  printf("seed == %d\n", seed);
367  fflush(stdout);
368  while (1)
369  {
370  if (i == n_cells)
371  {
372  i = 0;
373  printf("\nCells: %d KeptAddr:%d AlwaysKeptAddr:%d\n", n_cells,
374 #ifndef OM_NDEBUG
376 #else
377  0, 0
378 #endif
379  );
380 
381  printf("Checking Memory and all cells ");
382  fflush(stdout);
384  printf("\n");
385  omPrintStats(stdout);
386  omPrintInfo(stdout);
387  if (om_Info.CurrentRegionsAlloc > 0) omPrintBinStats(stdout);
388  fflush(stdout);
389 #if CHECK_LEVEL > 0 && TRACK_LEVEL > 0
390  if (error_test && errors == 0)
391  {
393  if (missed_errors < 0)
394  {
395  my_exit();
396  }
397  }
398 #endif
399  omtMergeStickyBins(cells, n_cells);
400  while (i< n_cells)
401  {
402  TestFree(&cells[i]);
403  i++;
404  }
405  omFreeKeptAddr();
407  omPrintStats(stdout);
408  omPrintInfo(stdout);
409  if (om_Info.CurrentRegionsAlloc > 0)
410  {
411  omPrintBinStats(stdout);
412  used_regions += om_Info.CurrentRegionsAlloc;
413  }
414  omPrintUsedAddrs(stdout, 5);
415  i=0;
416  n--;
417  if (n <= 0 || n_cells <= 100)
418  {
419  my_exit();
420  }
421  else
422  {
423  n_cells = n_cells / decr;
424  }
425  }
426  spec = MyRandSpec();
427  myprintf("%d:%lu:%ld:%ld", i, spec, GET_SIZE(spec), GET_TRACK(spec));
428  myfflush(stdout);
429  if (DO_FREE(spec))
430  {
431  if (i != 0)
432  {
433  myprintf(" FREE");
434  j = spec % i;
435  myprintf(" %ld ", j);
436  myfflush(stdout);
437  TestFree(&cells[j]);
438  TestAlloc(&cells[j], spec);
439  }
440  }
441  else if (DO_REALLOC(spec))
442  {
443  if (i != 0)
444  {
445  myprintf(" REALLOC");
446  j = spec % i;
447  myprintf(" %ld ", j);
448  myfflush(stdout);
449  TestRealloc(&cells[j], spec);
450  }
451  }
452  else if (DO_DUP(spec))
453  {
454  if (i != 0)
455  {
456  myprintf(" DUP");
457  j = spec % i;
458  myprintf(" %ld ", j);
459  myfflush(stdout);
460  TestDup(&cells[j], spec);
461  }
462  }
463  else
464  {
465  myprintf(" ALLOC");
466  myfflush(stdout);
467  TestAlloc(&cells[i], spec);
468  i++;
469  if (i % 1000 == 0)
470  {
471  printf("%d:", i / 1000);
472  fflush(stdout);
473  }
474  }
475  myprintf("\n");
476  myfflush(stdout);
477  // free kept addresses from time to time
478  if ((i % 10000) == 0 && i != n_cells && i!=last_kept_freed)
479  {
480  printf("F:");
481  omFreeKeptAddr();
482  last_kept_freed = i;
483  }
484 #if 0
485  if (CHECK_LEVEL > 2)
486  {
487  for (j=0; j<i; j++)
488  {
489  omtTestDebug(&cells[j]);
490  }
491  }
492 #endif
493  }
494  return 0;
495 }

◆ my_exit()

void my_exit ( )

Definition at line 322 of file omtTest.c.

323 {
324  printf("\nomtTest Summary: ");
326  {
327  printf("***FAILED***errors:%d, missed_errors:%d, used_regions:%d, seed=%d\n", errors, missed_errors, used_regions, seed);
328  if (errors) exit(errors);
329  if (missed_errors) exit(missed_errors);
330  if (used_regions) exit(used_regions);
331  }
332  else
333  {
334  printf("OK\n");
335  exit(0);
336  }
337 }

◆ MyRandSpec()

int MyRandSpec ( )

Definition at line 170 of file omtTest.c.

171 {
172  unsigned long spec = random() + 1;
173  if (! size_range_number)
174  {
175  size_range = size_range << 1;
178  }
179  SET_SIZE(spec, GET_SIZE(spec) & (size_range -1));
181  if (GET_SIZE(spec) == 0) spec++;
182  return spec;
183 }

◆ omCheckCells()

void omCheckCells ( int  n,
int  level,
omMemCell_t *  cells 
)

Definition at line 140 of file omtTest.c.

141 {
142 #if END_CHECK_LEVEL > 0
143  int l = om_Opts.MinCheck;
144  int i;
145 
147  om_Opts.MinCheck = 1;
148  for (i=0; i<n; i++)
149  {
150  omtTestDebug(&cells[i]);
152  {
153  errors++;
155  }
156  if ((i % 10000) == 0)
157  {
158  printf(".");
159  fflush(stdout);
160  }
161  }
162  om_Opts.MinCheck = l;
163 #endif
164 }

◆ omtGetStickyBin()

omBin omtGetStickyBin ( omBin  bin)

Definition at line 279 of file omtTest.c.

280 {
281  omBin sticky_bin = omFindInGList(om_StickyBins, next, max_blocks, bin->max_blocks);
282  if (sticky_bin == NULL)
283  sticky_bin = omGetStickyBinOfBin(bin);
284  return sticky_bin;
285 }

◆ omtMergeStickyBins()

void omtMergeStickyBins ( omMemCell  cell,
int  n 
)

Definition at line 287 of file omtTest.c.

288 {
289  int i;
290  omBin bin;
291 
292  for (i=0; i<n; i++)
293  {
294  if (cell[i].orig_bin != NULL)
295  {
296  if (omIsOnGList(om_StickyBins, next, cell[i].bin))
297  omMergeStickyBinIntoBin(cell[i].bin, cell[i].orig_bin);
298 
299  cell[i].bin = cell[i].orig_bin;
300  cell[i].orig_bin = NULL;
301  }
302  }
303 
304  bin = om_StickyBins;
305  while (bin != NULL)
306  {
307  if (bin->current_page == om_ZeroPage)
308  {
309  omBin next_bin = bin->next;
311  __omFreeBinAddr(bin);
312  bin = next_bin;
313  }
314  else
315  {
316  bin = bin->next;
317  }
318  }
319 }

◆ omtTestDebug()

void omtTestDebug ( omMemCell  cell)

Definition at line 34 of file omtTest.c.

35 {
36  size_t size = GET_SIZE(cell->spec);
37  size_t is_size;
38 
39  if (om_ErrorStatus != omError_NoError) return;
40  if (cell->bin != NULL)
41  {
42  if (IS_ALIGNED(cell->spec))
43  omDebugAddrAlignedBin(cell->addr, cell->bin);
44  else
45  omDebugAddrBin(cell->addr, cell->bin);
46  }
47  else
48  {
49  if (IS_ALIGNED(cell->spec))
50  omDebugAddrAlignedSize(cell->addr, size);
51  else
52  omDebugAddrSize(cell->addr, size);
53  }
54  if (om_ErrorStatus != omError_NoError) return;
55 
56  if (!OM_IS_ALIGNED(cell->addr))
57  {
59  "addr:%p is unaligned", cell->addr);
60  return;
61  }
62 
63  if (IS_ALIGNED(cell->spec) && !OM_IS_STRICT_ALIGNED(cell->addr))
64  {
66  "addr:%p is not strict unaligned", cell->addr);
67  return;
68  }
69 
70  is_size = omSizeOfAddr(cell->addr);
71  if (!OM_IS_ALIGNED(is_size))
72  {
74  "is_size == %u is unaligned", is_size);
75  return;
76  }
77  if (is_size < size)
78  {
80  "is_size==%u < size==%u", is_size, size);
81  return;
82  }
83 
84  if (is_size >> LOG_SIZEOF_LONG != omSizeWOfAddr(cell->addr))
85  {
87  "is_sizeW==%u < sizeW==%u", is_size >> LOG_SIZEOF_LONG, omSizeWOfAddr(cell->addr));
88  return;
89  }
90 
91  TestAddrContent(cell->addr, (IS_ZERO(cell->spec) ? 0 : cell->spec), is_size);
92 }

◆ TestAddrContent()

void TestAddrContent ( void *  addr,
unsigned long  value,
size_t  size 
)

Definition at line 110 of file omtTest.c.

111 {
112  size_t sizeW = OM_ALIGN_SIZE(size) >> LOG_SIZEOF_LONG;
113  int i;
114 
115  if (!OM_IS_ALIGNED(addr))
116  {
118  "addr %p unaligned", addr);
119  return;
120  }
121 
122  for (i=0; i<sizeW; i++)
123  {
124  if (((unsigned long*)addr)[i] != value)
125  {
127  "word %d modified: is %u should be %u", i, ((unsigned long*)addr)[i], value);
128  return;
129  }
130  }
131 }

◆ TestAddrContentEqual()

void TestAddrContentEqual ( void *  s1,
void *  s2,
size_t  size 
)

Definition at line 94 of file omtTest.c.

95 {
96  int i;
97  size_t sizeW = OM_ALIGN_SIZE(size) >> LOG_SIZEOF_LONG;
98 
99  for (i=0; i<sizeW; i++)
100  {
101  if (((unsigned long*)s1)[i] != ((unsigned long*)s2)[i])
102  {
104  "s1[%u]==%d != s2[%u]==%d", i, ((unsigned long*)s1)[i], i, ((unsigned long*)s2)[i]);
105  return;
106  }
107  }
108 }

◆ TestAlloc()

void TestAlloc ( omMemCell  cell,
unsigned long  spec 
)

Definition at line 186 of file omtTest.c.

187 {
188  if (DO_CHECK(spec))
189  {
190  if (DO_TRACK(spec))
191  om_Opts.MinTrack = GET_TRACK(spec);
192  else
193  om_Opts.MinTrack = 0;
194 
195  if (DO_KEEP(spec))
196  omtTestAllocKeep(cell, spec);
197  else
198  omtTestAllocDebug(cell, spec);
199  }
200  else
201  omtTestAlloc(cell, spec);
203  {
204  errors++;
206  }
207 }

◆ TestDup()

void TestDup ( omMemCell  cell,
unsigned long  spec 
)

Definition at line 232 of file omtTest.c.

233 {
234  if (DO_CHECK(spec))
235  {
236  if (DO_TRACK(spec))
237  om_Opts.MinTrack = GET_TRACK(spec);
238  else
239  om_Opts.MinTrack = 0;
240 
241  if (DO_KEEP(spec))
242  omtTestDupKeep(cell, spec);
243  else
244  omtTestDupDebug(cell, spec);
245  }
246  else
247  omtTestDup(cell, spec);
248 
250  {
251  errors++;
253  }
254 }

◆ TestFree()

void TestFree ( omMemCell  cell)

Definition at line 256 of file omtTest.c.

257 {
258  if (cell->addr != NULL)
259  {
260  if (DO_FREE_CHECK(cell->spec))
261  {
262  if (DO_KEEP(cell->spec))
263  omtTestFreeKeep(cell);
264  else
265  omtTestFreeDebug(cell);
266  }
267  else
268  {
269  omtTestFree(cell);
270  }
272  {
273  errors++;
275  }
276  }
277 }

◆ TestRealloc()

void TestRealloc ( omMemCell  cell,
unsigned long  spec 
)

Definition at line 209 of file omtTest.c.

210 {
211  if (DO_CHECK(spec))
212  {
213  if (DO_TRACK(spec))
214  om_Opts.MinTrack = GET_TRACK(spec);
215  else
216  om_Opts.MinTrack = 0;
217 
218  if (DO_KEEP(spec))
219  omtTestReallocKeep(cell, spec);
220  else
221  omtTestReallocDebug(cell, spec);
222  }
223  else
224  omtTestRealloc(cell, spec);
226  {
227  errors++;
229  }
230 }

Variable Documentation

◆ cells

omMemCell_t cells[MAX_CELLS]

Definition at line 9 of file omtTest.c.

◆ errors

int errors = 0

Definition at line 10 of file omtTest.c.

◆ missed_errors

int missed_errors = 0

Definition at line 11 of file omtTest.c.

◆ seed

int seed

Definition at line 13 of file omtTest.c.

◆ size_range

int size_range = RANGE_MIN

Definition at line 167 of file omtTest.c.

◆ size_range_number

int size_range_number = RANGE_MAX / RANGE_MIN

Definition at line 168 of file omtTest.c.

◆ used_regions

int used_regions = 0

Definition at line 12 of file omtTest.c.

om_AlwaysKeptAddrs
void * om_AlwaysKeptAddrs
Definition: omDebug.c:31
DO_CHECK
#define DO_CHECK(spec)
Definition: omtTest.h:64
omPrintUsedAddrs
void omPrintUsedAddrs(FILE *fd, int max_frames)
Definition: omDebugCheck.c:565
omtTestFree
void omtTestFree(omMemCell cell)
Definition: omtTestAlloc.c:134
IS_ZERO
#define IS_ZERO(spec)
Definition: omtTest.h:55
omtTestAllocKeep
void omtTestAllocKeep(omMemCell cell, unsigned long spec)
omMemsetW
#define omMemsetW(P1, W, L)
Definition: omMemOps.h:161
j
int j
Definition: facHensel.cc:105
omSizeOfAddr
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:100
TestDup
void TestDup(omMemCell cell, unsigned long spec)
Definition: omtTest.c:232
omInitGetBackTrace
#define omInitGetBackTrace()
Definition: omGetBackTrace.h:14
omIsOnGList
#define omIsOnGList(ptr, next, addr)
Definition: omList.h:100
size_range_number
int size_range_number
Definition: omtTest.c:168
PAGES_PER_REGION
#define PAGES_PER_REGION
Definition: omtTest.h:98
cells
omMemCell_t cells[MAX_CELLS]
Definition: omtTest.c:9
OM_NDEBUG
#define OM_NDEBUG
Definition: factoryconf.h:219
omtTestDupDebug
void omtTestDupDebug(omMemCell cell, unsigned long spec)
__omFreeBinAddr
#define __omFreeBinAddr(addr)
Definition: omAllocPrivate.h:163
DO_FREE_CHECK
#define DO_FREE_CHECK(spec)
Definition: omtTest.h:65
omReportError
omError_t omReportError(omError_t error, omError_t report_error, OM_FLR_DECL, const char *fmt,...)
Definition: omError.c:78
omRemoveFromGList
#define omRemoveFromGList(ptr, next, addr)
Definition: omList.h:102
omPrintInfo
void omPrintInfo(FILE *fd)
Definition: omStats.c:129
missed_errors
int missed_errors
Definition: omtTest.c:11
level
int level(const CanonicalForm &f)
Definition: canonicalform.h:324
TestRealloc
void TestRealloc(omMemCell cell, unsigned long spec)
Definition: omtTest.c:209
omtTestAllocDebug
void omtTestAllocDebug(omMemCell cell, unsigned long spec)
omDebugAddrAlignedBin
#define omDebugAddrAlignedBin
Definition: omAllocDecl.h:291
DO_TRACK
#define DO_TRACK(spec)
Definition: omtTest.h:71
omInitInfo
void omInitInfo()
Definition: omStats.c:17
size_range
int size_range
Definition: omtTest.c:167
DO_REALLOC
#define DO_REALLOC(spec)
Definition: omtTest.h:60
GET_SIZE
#define GET_SIZE(spec)
Definition: omtTest.h:52
TestFree
void TestFree(omMemCell cell)
Definition: omtTest.c:256
next
ListNode * next
Definition: janet.h:31
IS_ALIGNED
#define IS_ALIGNED(spec)
Definition: omtTest.h:54
i
int i
Definition: cfEzgcd.cc:125
omCheckCells
void omCheckCells(int n, int level, omMemCell_t *cells)
Definition: omtTest.c:140
KEEP_ADDR
#define KEEP_ADDR
Definition: omtTest.h:14
om_Info
omInfo_t om_Info
Definition: omStats.c:13
omSizeWOfAddr
size_t omSizeWOfAddr(void *addr)
Definition: omAllocSystem.c:113
omtTestFreeDebug
void omtTestFreeDebug(omMemCell cell)
myprintf
#define myprintf(format, args...)
Definition: omtTest.h:46
om_ErrorStatus
omError_t om_ErrorStatus
Definition: omError.c:11
omPrintBinStats
void omPrintBinStats(FILE *fd)
Definition: omBin.c:692
omPrintStats
void omPrintStats(FILE *fd)
Definition: omStats.c:115
omtTestDupKeep
void omtTestDupKeep(omMemCell cell, unsigned long spec)
omtTestDebug
void omtTestDebug(omMemCell cell)
Definition: omtTest.c:34
my_exit
void my_exit()
Definition: omtTest.c:322
GET_TRACK
#define GET_TRACK(spec)
Definition: omtTest.h:72
omInitRet_2_Info
void omInitRet_2_Info(const char *argv0)
Definition: omRet2Info.c:34
seed
int seed
Definition: omtTest.c:13
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
END_CHECK_LEVEL
#define END_CHECK_LEVEL
Definition: omtTest.h:16
omError_NoError
@ omError_NoError
Definition: omError.h:27
omError_Unknown
@ omError_Unknown
Definition: omError.h:28
errors
int errors
Definition: omtTest.c:10
RANGE_MIN
#define RANGE_MIN
Definition: omtTest.h:95
used_regions
int used_regions
Definition: omtTest.c:12
TestAddrContent
void TestAddrContent(void *addr, unsigned long value, size_t size)
Definition: omtTest.c:110
SET_SIZE
#define SET_SIZE(spec, size)
Definition: omtTest.h:53
omtTestRealloc
void omtTestRealloc(omMemCell cell, unsigned long spec)
Definition: omtTestAlloc.c:179
DO_FREE
#define DO_FREE(spec)
Definition: omtTest.h:59
omtMergeStickyBins
void omtMergeStickyBins(omMemCell cell, int n)
Definition: omtTest.c:287
omBin
omBin_t * omBin
Definition: omStructs.h:12
omDebugAddrSize
#define omDebugAddrSize(addr, size)
Definition: omAllocDecl.h:313
om_ZeroPage
omBinPage_t om_ZeroPage[]
Definition: om_Alloc.c:17
om_StickyBins
omBin om_StickyBins
Definition: omBin.c:372
DO_DUP
#define DO_DUP(spec)
Definition: omtTest.h:61
om_Opts
omOpts_t om_Opts
Definition: omOpts.c:11
omMergeStickyBinIntoBin
void omMergeStickyBinIntoBin(omBin sticky_bin, omBin into_bin)
Definition: omBin.c:396
omDebugAddrAlignedSize
#define omDebugAddrAlignedSize
Definition: omAllocDecl.h:292
CHECK_LEVEL
#define CHECK_LEVEL
Definition: omtTest.h:6
NULL
#define NULL
Definition: omList.c:10
l
int l
Definition: cfEzgcd.cc:93
omtTestDup
void omtTestDup(omMemCell cell, unsigned long spec)
Definition: omtTestAlloc.c:347
om_KeptAddr
void * om_KeptAddr
Definition: omDebug.c:28
myfflush
#define myfflush(what)
Definition: omtTest.h:47
omtTestFreeKeep
void omtTestFreeKeep(omMemCell cell)
DO_KEEP
#define DO_KEEP(spec)
Definition: omtTest.h:80
omtTestReallocKeep
void omtTestReallocKeep(omMemCell cell, unsigned long spec)
omFindInGList
#define omFindInGList(ptr, next, what, value)
Definition: omList.h:104
RANGE_MAX
#define RANGE_MAX
Definition: omtTest.h:96
MAX_CELLS
#define MAX_CELLS
Definition: omtTest.h:13
omGetStickyBinOfBin
omBin omGetStickyBinOfBin(omBin bin)
Definition: omBin.c:373
omListLength
#define omListLength(ptr)
Definition: omList.h:62
omtTestAlloc
void omtTestAlloc(omMemCell cell, unsigned long spec)
Definition: omtTestAlloc.c:32
omFreeKeptAddr
void omFreeKeptAddr()
Definition: omDebug.c:609
omtTestReallocDebug
void omtTestReallocDebug(omMemCell cell, unsigned long spec)
omDebugAddrBin
#define omDebugAddrBin(addr, bin)
Definition: omAllocDecl.h:311
MyRandSpec
int MyRandSpec()
Definition: omtTest.c:170
omtTestErrors
int omtTestErrors()
Definition: omtTestError.c:36
omTestMemory
omError_t omTestMemory(int check_level)
Definition: omDebug.c:94
TestAlloc
void TestAlloc(omMemCell cell, unsigned long spec)
Definition: omtTest.c:186