My Project
Loading...
Searching...
No Matches
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 4 of file omtTest.c.

Function Documentation

◆ InitCellAddrContent()

void InitCellAddrContent ( omMemCell cell)

Definition at line 130 of file omtTest.c.

131{
132 size_t sizeW = omSizeWOfAddr(cell->addr);
133 omMemsetW(cell->addr, (IS_ZERO(cell->spec) ? 0 : cell->spec), sizeW);
134}
#define omMemsetW(P1, W, L)
Definition omMemOps.h:161
#define IS_ZERO(spec)
Definition omtTest.h:54
#define omSizeWOfAddr(P)
Definition xalloc.h:223

◆ main()

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

Definition at line 336 of file omtTest.c.

337{
338 int i=0, error_test = 1;
339 unsigned long spec, j;
340 int n = 1;
341 int n_cells = MAX_CELLS;
342 int decr = 2;
343 int last_kept_freed = 0;
344 om_Opts.MinCheck = CHECK_LEVEL;
345 om_Opts.Keep = KEEP_ADDR;
346 om_Opts.HowToReportErrors = 3;
347
348 seed = time(NULL);
349
350 omInitRet_2_Info(argv[0]);
352 omInitInfo();
353 om_Opts.PagesPerRegion = PAGES_PER_REGION;
354
355 if (argc > 1) sscanf(argv[1], "%d", &error_test);
356 if (argc > 2) sscanf(argv[2], "%d", &seed);
357 srandom(seed);
358
359 if (argc > 3) sscanf(argv[3], "%d", &n);
360 if (argc > 4) sscanf(argv[4], "%d", &decr);
361
362 if (decr < 2) decr = 2;
363 printf("seed == %d\n", seed);
364 fflush(stdout);
365 while (1)
366 {
367 if (i == n_cells)
368 {
369 i = 0;
370 printf("\nCells: %d KeptAddr:%d AlwaysKeptAddr:%d\n", n_cells,
371#ifndef OM_NDEBUG
373#else
374 0, 0
375#endif
376 );
377
378 printf("Checking Memory and all cells ");
379 fflush(stdout);
381 printf("\n");
382 omPrintStats(stdout);
383 omPrintInfo(stdout);
384 if (om_Info.CurrentRegionsAlloc > 0) omPrintBinStats(stdout);
385 fflush(stdout);
386#if CHECK_LEVEL > 0 && TRACK_LEVEL > 0
387 if (error_test && errors == 0)
388 {
390 if (missed_errors < 0)
391 {
392 my_exit();
393 }
394 }
395#endif
396 omtMergeStickyBins(cells, n_cells);
397 while (i< n_cells)
398 {
399 TestFree(&cells[i]);
400 i++;
401 }
404 omPrintStats(stdout);
405 omPrintInfo(stdout);
406 if (om_Info.CurrentRegionsAlloc > 0)
407 {
408 omPrintBinStats(stdout);
409 used_regions += om_Info.CurrentRegionsAlloc;
410 }
411 omPrintUsedAddrs(stdout, 5);
412 i=0;
413 n--;
414 if (n <= 0 || n_cells <= 100)
415 {
416 my_exit();
417 }
418 else
419 {
420 n_cells = n_cells / decr;
421 }
422 }
423 spec = MyRandSpec();
424 myprintf("%d:%lu:%ld:%ld", i, spec, GET_SIZE(spec), GET_TRACK(spec));
425 myfflush(stdout);
426 if (DO_FREE(spec))
427 {
428 if (i != 0)
429 {
430 myprintf(" FREE");
431 j = spec % i;
432 myprintf(" %ld ", j);
433 myfflush(stdout);
434 TestFree(&cells[j]);
435 TestAlloc(&cells[j], spec);
436 }
437 }
438 else if (DO_REALLOC(spec))
439 {
440 if (i != 0)
441 {
442 myprintf(" REALLOC");
443 j = spec % i;
444 myprintf(" %ld ", j);
445 myfflush(stdout);
446 TestRealloc(&cells[j], spec);
447 }
448 }
449 else if (DO_DUP(spec))
450 {
451 if (i != 0)
452 {
453 myprintf(" DUP");
454 j = spec % i;
455 myprintf(" %ld ", j);
456 myfflush(stdout);
457 TestDup(&cells[j], spec);
458 }
459 }
460 else
461 {
462 myprintf(" ALLOC");
463 myfflush(stdout);
464 TestAlloc(&cells[i], spec);
465 i++;
466 if (i % 1000 == 0)
467 {
468 printf("%d:", i / 1000);
469 fflush(stdout);
470 }
471 }
472 myprintf("\n");
473 myfflush(stdout);
474 // free kept addresses from time to time
475 if ((i % 10000) == 0 && i != n_cells && i!=last_kept_freed)
476 {
477 printf("F:");
479 last_kept_freed = i;
480 }
481#if 0
482 if (CHECK_LEVEL > 2)
483 {
484 for (j=0; j<i; j++)
485 {
487 }
488 }
489#endif
490 }
491 return 0;
492}
int i
Definition cfEzgcd.cc:132
int j
Definition facHensel.cc:110
void * om_AlwaysKeptAddrs
Definition omDebug.c:31
void omFreeKeptAddr()
Definition omDebug.c:609
void * om_KeptAddr
Definition omDebug.c:28
#define omInitGetBackTrace()
#define NULL
Definition omList.c:12
#define omListLength(ptr)
Definition omList.h:62
omOpts_t om_Opts
Definition omOpts.c:13
omInfo_t om_Info
Definition omStats.c:16
void TestAlloc(omMemCell cell, unsigned long spec)
Definition omtTest.c:182
int seed
Definition omtTest.c:15
omMemCell_t cells[MAX_CELLS]
Definition omtTest.c:11
int used_regions
Definition omtTest.c:14
int errors
Definition omtTest.c:12
void TestFree(omMemCell cell)
Definition omtTest.c:252
void omtMergeStickyBins(omMemCell cell, int n)
Definition omtTest.c:283
void my_exit()
Definition omtTest.c:318
int missed_errors
Definition omtTest.c:13
void TestRealloc(omMemCell cell, unsigned long spec)
Definition omtTest.c:205
void omtTestDebug(omMemCell cell)
Definition omtTest.c:36
void omCheckCells(int n, int level, omMemCell_t *cells)
Definition omtTest.c:136
int MyRandSpec()
Definition omtTest.c:166
void TestDup(omMemCell cell, unsigned long spec)
Definition omtTest.c:228
#define KEEP_ADDR
Definition omtTest.h:18
#define GET_TRACK(spec)
Definition omtTest.h:71
#define myprintf(format, args...)
Definition omtTest.h:45
#define DO_REALLOC(spec)
Definition omtTest.h:59
#define DO_FREE(spec)
Definition omtTest.h:58
#define DO_DUP(spec)
Definition omtTest.h:60
#define PAGES_PER_REGION
Definition omtTest.h:97
int omtTestErrors()
#define GET_SIZE(spec)
Definition omtTest.h:51
#define myfflush(what)
Definition omtTest.h:46
#define CHECK_LEVEL
Definition omtTest.h:10
#define END_CHECK_LEVEL
Definition omtTest.h:20
#define MAX_CELLS
Definition omtTest.h:17
#define omPrintUsedAddrs(F, max)
Definition xalloc.h:268
#define OM_NDEBUG
Definition xalloc.h:10
#define omPrintStats(F)
Definition xalloc.h:231
#define omInitInfo()
Definition xalloc.h:228
#define omPrintInfo(F)
Definition xalloc.h:232
#define omPrintBinStats(F)
Definition xalloc.h:233
#define omInitRet_2_Info(argv0)
Definition xalloc.h:274

◆ my_exit()

void my_exit ( )

Definition at line 318 of file omtTest.c.

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

◆ MyRandSpec()

int MyRandSpec ( )

Definition at line 166 of file omtTest.c.

167{
168 unsigned long spec = random() + 1;
169 if (! size_range_number)
170 {
171 size_range = size_range << 1;
174 }
175 SET_SIZE(spec, GET_SIZE(spec) & (size_range -1));
177 if (GET_SIZE(spec) == 0) spec++;
178 return spec;
179}
int size_range_number
Definition omtTest.c:164
int size_range
Definition omtTest.c:163
#define RANGE_MIN
Definition omtTest.h:94
#define RANGE_MAX
Definition omtTest.h:95
#define SET_SIZE(spec, size)
Definition omtTest.h:52

◆ omCheckCells()

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

Definition at line 136 of file omtTest.c.

137{
138#if END_CHECK_LEVEL > 0
139 int l = om_Opts.MinCheck;
140 int i;
141
143 om_Opts.MinCheck = 1;
144 for (i=0; i<n; i++)
145 {
148 {
149 errors++;
151 }
152 if ((i % 10000) == 0)
153 {
154 printf(".");
155 fflush(stdout);
156 }
157 }
158 om_Opts.MinCheck = l;
159#endif
160}
int level(const CanonicalForm &f)
int l
Definition cfEzgcd.cc:100
omError_t omTestMemory(int check_level)
Definition omDebug.c:94
omError_t om_ErrorStatus
Definition omError.c:13
@ omError_NoError
Definition omError.h:18

◆ omtGetStickyBin()

omBin omtGetStickyBin ( omBin bin)

Definition at line 275 of file omtTest.c.

276{
277 omBin sticky_bin = omFindInGList(om_StickyBins, next, max_blocks, bin->max_blocks);
278 if (sticky_bin == NULL)
279 sticky_bin = omGetStickyBinOfBin(bin);
280 return sticky_bin;
281}
ListNode * next
Definition janet.h:31
omBin om_StickyBins
Definition omBin.c:374
#define omFindInGList(ptr, next, what, value)
Definition omList.h:104
omBin_t * omBin
Definition omStructs.h:12
#define omGetStickyBinOfBin(B)
Definition xalloc.h:247

◆ omtMergeStickyBins()

void omtMergeStickyBins ( omMemCell cell,
int n )

Definition at line 283 of file omtTest.c.

284{
285 int i;
286 omBin bin;
287
288 for (i=0; i<n; i++)
289 {
290 if (cell[i].orig_bin != NULL)
291 {
292 if (omIsOnGList(om_StickyBins, next, cell[i].bin))
293 omMergeStickyBinIntoBin(cell[i].bin, cell[i].orig_bin);
294
295 cell[i].bin = cell[i].orig_bin;
296 cell[i].orig_bin = NULL;
297 }
298 }
299
300 bin = om_StickyBins;
301 while (bin != NULL)
302 {
303 if (bin->current_page == om_ZeroPage)
304 {
305 omBin next_bin = bin->next;
307 __omFreeBinAddr(bin);
308 bin = next_bin;
309 }
310 else
311 {
312 bin = bin->next;
313 }
314 }
315}
#define __omFreeBinAddr(addr)
#define omRemoveFromGList(ptr, next, addr)
Definition omList.h:102
#define omIsOnGList(ptr, next, addr)
Definition omList.h:100
omBinPage_t om_ZeroPage[]
Definition om_Alloc.c:19
#define omMergeStickyBinIntoBin(A, B)
Definition xalloc.h:275

◆ omtTestDebug()

void omtTestDebug ( omMemCell cell)

Definition at line 36 of file omtTest.c.

37{
38 size_t size = GET_SIZE(cell->spec);
39 size_t is_size;
40
41 if (om_ErrorStatus != omError_NoError) return;
42 if (cell->bin != NULL)
43 {
44 if (IS_ALIGNED(cell->spec))
45 omDebugAddrAlignedBin(cell->addr, cell->bin);
46 else
47 omDebugAddrBin(cell->addr, cell->bin);
48 }
49 else
50 {
51 if (IS_ALIGNED(cell->spec))
52 omDebugAddrAlignedSize(cell->addr, size);
53 else
54 omDebugAddrSize(cell->addr, size);
55 }
56 if (om_ErrorStatus != omError_NoError) return;
57
58 if (!OM_IS_ALIGNED(cell->addr))
59 {
61 "addr:%p is unaligned", cell->addr);
62 return;
63 }
64
65 if (IS_ALIGNED(cell->spec) && !OM_IS_STRICT_ALIGNED(cell->addr))
66 {
68 "addr:%p is not strict unaligned", cell->addr);
69 return;
70 }
71
72 is_size = omSizeOfAddr(cell->addr);
73 if (is_size < size)
74 {
76 "is_size==%u < size==%u", is_size, size);
77 return;
78 }
79
80 if (is_size >> LOG_SIZEOF_LONG != omSizeWOfAddr(cell->addr))
81 {
83 "is_sizeW==%u < sizeW==%u", is_size >> LOG_SIZEOF_LONG, omSizeWOfAddr(cell->addr));
84 return;
85 }
86
87 TestAddrContent(cell->addr, (IS_ZERO(cell->spec) ? 0 : cell->spec), is_size);
88}
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition cf_ops.cc:600
#define omDebugAddrAlignedBin
#define omDebugAddrAlignedSize
#define omDebugAddrSize(addr, size)
#define omDebugAddrBin(addr, bin)
size_t omSizeOfAddr(const void *addr)
omError_t omReportError(omError_t error, omError_t report_error, OM_FLR_DECL, const char *fmt,...)
Definition omError.c:80
@ omError_Unknown
Definition omError.h:19
void TestAddrContent(void *addr, unsigned long value, size_t size)
Definition omtTest.c:106
#define IS_ALIGNED(spec)
Definition omtTest.h:53

◆ TestAddrContent()

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

Definition at line 106 of file omtTest.c.

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

◆ TestAddrContentEqual()

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

Definition at line 90 of file omtTest.c.

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

◆ TestAlloc()

void TestAlloc ( omMemCell cell,
unsigned long spec )

Definition at line 182 of file omtTest.c.

183{
184 if (DO_CHECK(spec))
185 {
186 if (DO_TRACK(spec))
187 om_Opts.MinTrack = GET_TRACK(spec);
188 else
189 om_Opts.MinTrack = 0;
190
191 if (DO_KEEP(spec))
192 omtTestAllocKeep(cell, spec);
193 else
194 omtTestAllocDebug(cell, spec);
195 }
196 else
197 omtTestAlloc(cell, spec);
199 {
200 errors++;
202 }
203}
#define DO_KEEP(spec)
Definition omtTest.h:79
void omtTestAlloc(omMemCell cell, unsigned long spec)
void omtTestAllocKeep(omMemCell cell, unsigned long spec)
void omtTestAllocDebug(omMemCell cell, unsigned long spec)
#define DO_CHECK(spec)
Definition omtTest.h:63
#define DO_TRACK(spec)
Definition omtTest.h:70

◆ TestDup()

void TestDup ( omMemCell cell,
unsigned long spec )

Definition at line 228 of file omtTest.c.

229{
230 if (DO_CHECK(spec))
231 {
232 if (DO_TRACK(spec))
233 om_Opts.MinTrack = GET_TRACK(spec);
234 else
235 om_Opts.MinTrack = 0;
236
237 if (DO_KEEP(spec))
238 omtTestDupKeep(cell, spec);
239 else
240 omtTestDupDebug(cell, spec);
241 }
242 else
243 omtTestDup(cell, spec);
244
246 {
247 errors++;
249 }
250}
void omtTestDup(omMemCell cell, unsigned long spec)
void omtTestDupDebug(omMemCell cell, unsigned long spec)
void omtTestDupKeep(omMemCell cell, unsigned long spec)

◆ TestFree()

void TestFree ( omMemCell cell)

Definition at line 252 of file omtTest.c.

253{
254 if (cell->addr != NULL)
255 {
256 if (DO_FREE_CHECK(cell->spec))
257 {
258 if (DO_KEEP(cell->spec))
259 omtTestFreeKeep(cell);
260 else
261 omtTestFreeDebug(cell);
262 }
263 else
264 {
265 omtTestFree(cell);
266 }
268 {
269 errors++;
271 }
272 }
273}
#define DO_FREE_CHECK(spec)
Definition omtTest.h:64
void omtTestFreeDebug(omMemCell cell)
void omtTestFree(omMemCell cell)
void omtTestFreeKeep(omMemCell cell)

◆ TestRealloc()

void TestRealloc ( omMemCell cell,
unsigned long spec )

Definition at line 205 of file omtTest.c.

206{
207 if (DO_CHECK(spec))
208 {
209 if (DO_TRACK(spec))
210 om_Opts.MinTrack = GET_TRACK(spec);
211 else
212 om_Opts.MinTrack = 0;
213
214 if (DO_KEEP(spec))
215 omtTestReallocKeep(cell, spec);
216 else
217 omtTestReallocDebug(cell, spec);
218 }
219 else
220 omtTestRealloc(cell, spec);
222 {
223 errors++;
225 }
226}
void omtTestReallocDebug(omMemCell cell, unsigned long spec)
void omtTestReallocKeep(omMemCell cell, unsigned long spec)
void omtTestRealloc(omMemCell cell, unsigned long spec)

Variable Documentation

◆ cells

omMemCell_t cells[MAX_CELLS]

Definition at line 11 of file omtTest.c.

◆ errors

int errors = 0

Definition at line 12 of file omtTest.c.

◆ missed_errors

int missed_errors = 0

Definition at line 13 of file omtTest.c.

◆ seed

int seed

Definition at line 15 of file omtTest.c.

◆ size_range

int size_range = RANGE_MIN

Definition at line 163 of file omtTest.c.

◆ size_range_number

int size_range_number = RANGE_MAX / RANGE_MIN

Definition at line 164 of file omtTest.c.

◆ used_regions

int used_regions = 0

Definition at line 14 of file omtTest.c.