My Project
Data Structures | Macros | Typedefs | Functions | Variables
omtTest.h File Reference
#include <time.h>
#include <string.h>
#include <limits.h>
#include "omConfig.h"
#include "omStructs.h"

Go to the source code of this file.

Data Structures

struct  omMemCell_t
 

Macros

#define TRACK_LEVEL   1
 
#define CHECK_LEVEL   1
 
#define KEEP_LEVEL   20
 
#define MAX_CELLS   100000
 
#define KEEP_ADDR   100
 
#define END_CHECK_LEVEL   5
 
#define myprintf(format, args...)   do {} while (0)
 
#define myfflush(what)   do {} while (0)
 
#define IS_STICKY_BIN(spec)   (spec & 1)
 
#define GET_SIZE(spec)   OM_ALIGN_SIZE((spec & ((((unsigned long) 1) << 14) -1)))
 
#define SET_SIZE(spec, size)   spec = ((spec & ~((((unsigned long) 1) << 14) -1)) | (size))
 
#define IS_ALIGNED(spec)   (spec & (((unsigned long) 1) << 15))
 
#define IS_ZERO(spec)   (spec & (((unsigned long) 1) << 16))
 
#define IS_BIN(spec)   (spec & (((unsigned long) 1) << 17))
 
#define IS_SPEC_BIN(spec)   (spec & (((unsigned long) 1) << 18))
 
#define IS_INLINE(spec)   (spec & (((unsigned long) 1) << 19))
 
#define DO_FREE(spec)   (!(spec & (((unsigned long) 1) << 20)) && !(spec & (((unsigned long) 1) << 21)))
 
#define DO_REALLOC(spec)   ((spec & (((unsigned long) 1) << 20)) && (spec & (((unsigned long) 1) << 21)))
 
#define DO_DUP(spec)   ((spec & (((unsigned long) 1) << 20)) && ! (spec & (((unsigned long) 1) << 21)))
 
#define DO_CHECK(spec)   (spec & (((unsigned long) 1) << 22))
 
#define DO_FREE_CHECK(spec)   (spec & (((unsigned long) 1) << 23))
 
#define DO_TRACK(spec)   (spec & (((unsigned long) 1) << 24))
 
#define GET_TRACK(spec)   (((spec & ((((unsigned long) 1) << 27) | (((unsigned long) 1) << 26) | (((unsigned long) 1) << 25))) >> 25) % 5) + TRACK_LEVEL
 
#define DO_KEEP(spec)   (DO_CHECK(spec) && (spec % KEEP_LEVEL == 0))
 
#define DO_FREE_KEEP(spec)   (DO_FREE_CHECK(spec) && (spec % KEEP_LEVEL == 0))
 
#define IS_FREE_SIZE(spec)   (spec & (((unsigned long) 1) << 28))
 
#define IS_FREE_BIN(spec)   (spec & (((unsigned long) 1) << 29))
 
#define IS_SLOPPY(spec)   (spec & (((unsigned long) 1) << 30))
 
#define IS_FREE_BINADDR(spec)   (spec & (((unsigned long) 1) << 31))
 
#define SPEC_MAX   ULONG_MAX
 
#define SIZE_MAX   ((((unsigned long) 1) << 14) -1)
 
#define RANGE_MIN   (((unsigned long) 1) << 6)
 
#define RANGE_MAX   (((unsigned long) 1) << 14)
 
#define PAGES_PER_REGION   128
 

Typedefs

typedef omMemCell_t * omMemCell
 

Functions

void TestAlloc (omMemCell cell, unsigned long spec)
 
void TestRealloc (omMemCell cell, unsigned long spec)
 
void TestFree (omMemCell cell)
 
void omtTestAlloc (omMemCell cell, unsigned long spec)
 
void omtTestRealloc (omMemCell cell, unsigned long spec)
 
void omtTestDup (omMemCell cell, unsigned long spec)
 
void omtTestFree (omMemCell cell)
 
void omtTestAllocDebug (omMemCell cell, unsigned long spec)
 
void omtTestReallocDebug (omMemCell cell, unsigned long spec)
 
void omtTestDupDebug (omMemCell cell, unsigned long spec)
 
void omtTestFreeDebug (omMemCell cell)
 
void omtTestAllocKeep (omMemCell cell, unsigned long spec)
 
void omtTestReallocKeep (omMemCell cell, unsigned long spec)
 
void omtTestDupKeep (omMemCell cell, unsigned long spec)
 
void omtTestFreeKeep (omMemCell cell)
 
void InitCellAddrContent (omMemCell cell)
 
int omtTestErrors ()
 
omBin omtGetStickyBin (omBin bin)
 
void omtTestDebug (omMemCell cell)
 
void TestAddrContent (void *addr, unsigned long value, size_t size)
 
void TestAddrContentEqual (void *s1, void *s2, size_t size)
 

Variables

omMemCell_t cells []
 

Data Structure Documentation

◆ omMemCell_s

struct omMemCell_s

Definition at line 24 of file omtTest.h.

Data Fields
void * addr
omBin bin
omBin orig_bin
unsigned long spec

Macro Definition Documentation

◆ CHECK_LEVEL

#define CHECK_LEVEL   1

Definition at line 10 of file omtTest.h.

◆ DO_CHECK

#define DO_CHECK (   spec)    (spec & (((unsigned long) 1) << 22))

Definition at line 63 of file omtTest.h.

◆ DO_DUP

#define DO_DUP (   spec)    ((spec & (((unsigned long) 1) << 20)) && ! (spec & (((unsigned long) 1) << 21)))

Definition at line 60 of file omtTest.h.

◆ DO_FREE

#define DO_FREE (   spec)    (!(spec & (((unsigned long) 1) << 20)) && !(spec & (((unsigned long) 1) << 21)))

Definition at line 58 of file omtTest.h.

◆ DO_FREE_CHECK

#define DO_FREE_CHECK (   spec)    (spec & (((unsigned long) 1) << 23))

Definition at line 64 of file omtTest.h.

◆ DO_FREE_KEEP

#define DO_FREE_KEEP (   spec)    (DO_FREE_CHECK(spec) && (spec % KEEP_LEVEL == 0))

Definition at line 80 of file omtTest.h.

◆ DO_KEEP

#define DO_KEEP (   spec)    (DO_CHECK(spec) && (spec % KEEP_LEVEL == 0))

Definition at line 79 of file omtTest.h.

◆ DO_REALLOC

#define DO_REALLOC (   spec)    ((spec & (((unsigned long) 1) << 20)) && (spec & (((unsigned long) 1) << 21)))

Definition at line 59 of file omtTest.h.

◆ DO_TRACK

#define DO_TRACK (   spec)    (spec & (((unsigned long) 1) << 24))

Definition at line 70 of file omtTest.h.

◆ END_CHECK_LEVEL

#define END_CHECK_LEVEL   5

Definition at line 20 of file omtTest.h.

◆ GET_SIZE

#define GET_SIZE (   spec)    OM_ALIGN_SIZE((spec & ((((unsigned long) 1) << 14) -1)))

Definition at line 51 of file omtTest.h.

◆ GET_TRACK

#define GET_TRACK (   spec)    (((spec & ((((unsigned long) 1) << 27) | (((unsigned long) 1) << 26) | (((unsigned long) 1) << 25))) >> 25) % 5) + TRACK_LEVEL

Definition at line 71 of file omtTest.h.

◆ IS_ALIGNED

#define IS_ALIGNED (   spec)    (spec & (((unsigned long) 1) << 15))

Definition at line 53 of file omtTest.h.

◆ IS_BIN

#define IS_BIN (   spec)    (spec & (((unsigned long) 1) << 17))

Definition at line 55 of file omtTest.h.

◆ IS_FREE_BIN

#define IS_FREE_BIN (   spec)    (spec & (((unsigned long) 1) << 29))

Definition at line 87 of file omtTest.h.

◆ IS_FREE_BINADDR

#define IS_FREE_BINADDR (   spec)    (spec & (((unsigned long) 1) << 31))

Definition at line 89 of file omtTest.h.

◆ IS_FREE_SIZE

#define IS_FREE_SIZE (   spec)    (spec & (((unsigned long) 1) << 28))

Definition at line 86 of file omtTest.h.

◆ IS_INLINE

#define IS_INLINE (   spec)    (spec & (((unsigned long) 1) << 19))

Definition at line 57 of file omtTest.h.

◆ IS_SLOPPY

#define IS_SLOPPY (   spec)    (spec & (((unsigned long) 1) << 30))

Definition at line 88 of file omtTest.h.

◆ IS_SPEC_BIN

#define IS_SPEC_BIN (   spec)    (spec & (((unsigned long) 1) << 18))

Definition at line 56 of file omtTest.h.

◆ IS_STICKY_BIN

#define IS_STICKY_BIN (   spec)    (spec & 1)

Definition at line 49 of file omtTest.h.

◆ IS_ZERO

#define IS_ZERO (   spec)    (spec & (((unsigned long) 1) << 16))

Definition at line 54 of file omtTest.h.

◆ KEEP_ADDR

#define KEEP_ADDR   100

Definition at line 18 of file omtTest.h.

◆ KEEP_LEVEL

#define KEEP_LEVEL   20

Definition at line 12 of file omtTest.h.

◆ MAX_CELLS

#define MAX_CELLS   100000

Definition at line 17 of file omtTest.h.

◆ myfflush

#define myfflush (   what)    do {} while (0)

Definition at line 46 of file omtTest.h.

◆ myprintf

#define myprintf (   format,
  args... 
)    do {} while (0)

Definition at line 45 of file omtTest.h.

◆ PAGES_PER_REGION

#define PAGES_PER_REGION   128

Definition at line 97 of file omtTest.h.

◆ RANGE_MAX

#define RANGE_MAX   (((unsigned long) 1) << 14)

Definition at line 95 of file omtTest.h.

◆ RANGE_MIN

#define RANGE_MIN   (((unsigned long) 1) << 6)

Definition at line 94 of file omtTest.h.

◆ SET_SIZE

#define SET_SIZE (   spec,
  size 
)    spec = ((spec & ~((((unsigned long) 1) << 14) -1)) | (size))

Definition at line 52 of file omtTest.h.

◆ SIZE_MAX

#define SIZE_MAX   ((((unsigned long) 1) << 14) -1)

Definition at line 93 of file omtTest.h.

◆ SPEC_MAX

#define SPEC_MAX   ULONG_MAX

Definition at line 92 of file omtTest.h.

◆ TRACK_LEVEL

#define TRACK_LEVEL   1

Definition at line 9 of file omtTest.h.

Typedef Documentation

◆ omMemCell

typedef omMemCell_t* omMemCell

Definition at line 33 of file omtTest.h.

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

◆ 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 NULL
Definition: omList.c:12
#define omFindInGList(ptr, next, what, value)
Definition: omList.h:104
omBin_t * omBin
Definition: omStructs.h:12
#define omGetStickyBinOfBin(B)
Definition: xalloc.h:247

◆ omtTestAlloc()

void omtTestAlloc ( omMemCell  cell,
unsigned long  spec 
)

Definition at line 33 of file omtTestAlloc.c.

34 {
35  size_t size = GET_SIZE(spec);
36  void* addr;
37  omBin bin = NULL;
38  omBin orig_bin = NULL;
39 
40  if (IS_BIN(spec) && (size <= OM_MAX_BLOCK_SIZE || IS_SPEC_BIN(spec)))
41  {
42  if (IS_SPEC_BIN(spec))
43  {
44  if (IS_ALIGNED(spec))
46  else
47  bin = omGetSpecBin(size);
48  }
49  else
50  {
51  if (IS_ALIGNED(spec))
53  else
54  bin = omSmallSize2Bin(size);
55  }
56 
57  if (IS_STICKY_BIN(spec))
58  {
59  orig_bin = bin;
60  bin = omtGetStickyBin(bin);
61  }
62 
63  if (IS_INLINE(spec))
64  {
65  if (IS_ZERO(spec))
66  addr = omAlloc0Bin(bin);
67  else
68  addr = omAllocBin(bin);
69  }
70  else
71  {
72  if (IS_ZERO(spec))
73  omTypeAlloc0Bin(void*, addr, bin);
74  else
75  omTypeAllocBin(void*, addr, bin);
76  }
77  }
78  else
79  {
80  if (IS_INLINE(spec))
81  {
82  if (IS_ZERO(spec))
83  {
84  if (IS_ALIGNED(spec))
85  {
86  if (IS_SLOPPY(spec))
87  addr = omalloc0(size);
88  else
89  addr = omAlloc0Aligned(size);
90  }
91  else
92  addr = omAlloc0(size);
93  }
94  else
95  {
96  if (IS_ALIGNED(spec))
97  {
98  if (IS_SLOPPY(spec))
99  addr = omalloc(size);
100  else
101  addr = omAllocAligned(size);
102  }
103  else
104  addr = omAlloc(size);
105  }
106  }
107  else
108  {
109  if (IS_ZERO(spec))
110  {
111  if (IS_ALIGNED(spec))
112  omTypeAlloc0Aligned(void*, addr, size);
113  else
114  omTypeAlloc0(void*, addr, size);
115  }
116  else
117  {
118  if (IS_ALIGNED(spec))
119  omTypeAllocAligned(void*, addr, size);
120  else
121  omTypeAlloc(void*, addr, size);
122  }
123  }
124  }
125  cell->addr = addr;
126  cell->bin = bin;
127  cell->orig_bin = orig_bin;
128  cell->spec = spec;
129 
130  InitCellAddrContent(cell);
131 
132  omtTestDebug(cell);
133 }
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define omTypeAlloc0Bin(type, addr, bin)
Definition: omAllocDecl.h:204
#define omAlloc0Aligned
Definition: omAllocDecl.h:274
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omTypeAllocBin(type, addr, bin)
Definition: omAllocDecl.h:203
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define omTypeAlloc0(type, addr, size)
Definition: omAllocDecl.h:209
#define omalloc0(size)
Definition: omAllocDecl.h:229
#define omalloc(size)
Definition: omAllocDecl.h:228
#define omTypeAlloc0Aligned
Definition: omAllocDecl.h:272
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#define omTypeAlloc(type, addr, size)
Definition: omAllocDecl.h:208
#define omTypeAllocAligned
Definition: omAllocDecl.h:271
#define omAllocAligned
Definition: omAllocDecl.h:273
#define omSmallSize2Bin(size)
#define omGetSpecBin(size)
Definition: omBin.h:11
#define omGetAlignedSpecBin(size)
Definition: omBin.h:10
#define OM_MAX_BLOCK_SIZE
Definition: omTables.c:31
#define omSmallSize2AlignedBin
Definition: omtTestAlloc.c:29
omBin omtGetStickyBin(omBin bin)
Definition: omtTest.c:275
void omtTestDebug(omMemCell cell)
Definition: omtTest.c:36
void InitCellAddrContent(omMemCell cell)
Definition: omtTest.c:130
#define IS_SPEC_BIN(spec)
Definition: omtTest.h:56
#define IS_STICKY_BIN(spec)
Definition: omtTest.h:49
#define IS_ALIGNED(spec)
Definition: omtTest.h:53
#define IS_BIN(spec)
Definition: omtTest.h:55
#define IS_SLOPPY(spec)
Definition: omtTest.h:88
#define IS_INLINE(spec)
Definition: omtTest.h:57
#define GET_SIZE(spec)
Definition: omtTest.h:51

◆ omtTestAllocDebug()

void omtTestAllocDebug ( omMemCell  cell,
unsigned long  spec 
)

◆ omtTestAllocKeep()

void omtTestAllocKeep ( omMemCell  cell,
unsigned long  spec 
)

◆ 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 }
#define omDebugAddrAlignedBin
Definition: omAllocDecl.h:291
#define omDebugAddrAlignedSize
Definition: omAllocDecl.h:292
#define omDebugAddrSize(addr, size)
Definition: omAllocDecl.h:313
#define omDebugAddrBin(addr, bin)
Definition: omAllocDecl.h:311
size_t omSizeOfAddr(const void *addr)
omError_t om_ErrorStatus
Definition: omError.c:13
omError_t omReportError(omError_t error, omError_t report_error, OM_FLR_DECL, const char *fmt,...)
Definition: omError.c:80
@ omError_NoError
Definition: omError.h:18
@ omError_Unknown
Definition: omError.h:19
void TestAddrContent(void *addr, unsigned long value, size_t size)
Definition: omtTest.c:106

◆ omtTestDup()

void omtTestDup ( omMemCell  cell,
unsigned long  spec 
)

Definition at line 348 of file omtTestAlloc.c.

349 {
350  omtTestDebug(cell);
351 
352  if (DO_STRDUP(spec))
353  {
354  size_t size = omSizeOfAddr(cell->addr);
355  void* new_addr;
356  memset(cell->addr, 'a', size - 1);
357  ((char*) cell->addr)[size-1] = '\0';
358  new_addr = omStrDup(cell->addr);
359  TestAddrContentEqual(new_addr, cell->addr, size);
360  omFree(new_addr);
361  InitCellAddrContent(cell);
362  }
363  else
364  {
365  void* new_addr = omMemDup(cell->addr);
366  TestAddrContentEqual(new_addr, cell->addr, omSizeOfAddr(cell->addr));
367  omFree(new_addr);
368  new_addr = omMemDupAligned(cell->addr);
369  TestAddrContentEqual(new_addr, cell->addr, omSizeOfAddr(cell->addr));
370  omDebugAddrAlignedSize(new_addr, omSizeOfAddr(cell->addr));
371  omFree(new_addr);
372  }
373 }
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omMemDup(s)
Definition: omAllocDecl.h:264
#define omMemDupAligned
Definition: omAllocDecl.h:286
#define DO_STRDUP(l)
Definition: omtTestAlloc.c:347
void TestAddrContentEqual(void *s1, void *s2, size_t size)
Definition: omtTest.c:90

◆ omtTestDupDebug()

void omtTestDupDebug ( omMemCell  cell,
unsigned long  spec 
)

◆ omtTestDupKeep()

void omtTestDupKeep ( omMemCell  cell,
unsigned long  spec 
)

◆ omtTestErrors()

int omtTestErrors ( )

Definition at line 37 of file omtTestError.c.

38 {
39 #ifndef OM_NDEBUG
40  int level = om_Opts.MinCheck;
42  struct LongSpec spec;
43  int missed = 0, alloc;
44  omMemCell cell = NULL;
45 
46  printf("omtTestErrors: Start\n");
47  om_Opts.MinCheck = 2;
49  {
52  printf("!!!expect %s\n", omError2Serror(error));
53  memset(&spec, 0, sizeof(struct LongSpec));
54  cell = NULL;
55  alloc = 0;
56  switch (error)
57  {
59  {
60  spec.MaxSize = OM_MAX_BLOCK_SIZE;
61  cell = omFindCell(spec);
62  if (cell != NULL)
63  {
64  omBin bin = omGetTopBinOfAddr(cell->addr);
65  omBinPage last_page = bin->last_page;
66  omAssume(last_page != NULL);
67  bin->last_page = NULL;
68  omDebugBin(cell->bin);
69  bin->last_page = last_page;
70  }
71  else printf("cell not found\n");
72  break;
73  }
74 
75  case omError_NullAddr:
76  {
78  break;
79  }
80 
82  {
83  omDebugAddr((void*) om_MaxAddr);
84  break;
85  }
86 
87  case omError_FalseAddr:
88  {
89  spec.MinSize = 8;
90  spec.MaxSize = OM_MAX_BLOCK_SIZE;
91  spec.NoTrack = 1;
92  cell = omFindCell(spec);
93  if (cell != NULL)
94  {
95  omDebugAddr(cell->addr + SIZEOF_VOIDP);
96  }
97  else printf("cell not found\n");
98  break;
99  }
100 
102  {
103  spec.MinSize = 8;
104  spec.MinTrack = 3;
105  cell = omFindCell(spec);
106  if (cell != NULL)
107  {
108  omDebugAddr(cell->addr + SIZEOF_VOIDP);
109  }
110  else printf("cell not found\n");
111  break;
112  }
113 
114  case omError_WrongSize:
115  {
116  spec.MaxSize = OM_MAX_BLOCK_SIZE;
117  cell = omFindCell(spec);
118  if (cell != NULL)
119  {
120  omDebugAddrSize(cell->addr, OM_MAX_BLOCK_SIZE + 1);
122  {
124  spec.MaxSize = 0;
125  spec.MinTrack = 3;
126  spec.NotIsBin = 1;
127  spec.MinSize = 2;
128  cell = omFindCell(spec);
129  if (cell != NULL)
130  {
131  omDebugAddrSize(cell->addr, GET_SIZE(cell->spec) + SIZEOF_OM_ALIGNMENT);
133  {
135  spec.MaxSize = OM_MAX_BLOCK_SIZE;
136  spec.MinTrack = 0;
137  spec.NotIsBin = 0;
138  cell = omFindCell(spec);
139  if (cell != NULL)
140  omDebugBinAddrSize(cell->addr, GET_SIZE(cell->spec) - 1);
141  else printf("cell not found");
142  }
143  }
144  else printf("cell not found\n");
145  }
146  }
147  else printf("cell not found\n");
148  break;
149  }
150 
151  case omError_FreedAddr:
152  {
153 #if KEEP_LEVEL > 0
154  void* addr = om_AlwaysKeptAddrs;
155  while (addr != NULL && omIsTrackAddr(addr))
156  {
157  addr = *((void**) addr);
158  }
159  if (addr != NULL)
160  {
161  omFree(addr);
163  {
165  addr = om_AlwaysKeptAddrs;
166  while (addr != NULL && ! omIsTrackAddr(addr))
167  {
168  addr = *((void**) addr);
169  }
170  if (addr != NULL)
171  {
172  addr = omAddr_2_OutAddr(addr);
173  omFree(addr);
174  }
175  }
176  }
177  if (addr == NULL)
178  {
179  printf("addr not found\n");
180  break;
181  }
183  break;
184 #endif
185  spec.MinTrack = 5;
186  spec.NotIsBin = 1;
187  cell = omFindCell(spec);
188  if (cell != NULL)
189  {
190  omFree(cell->addr);
191  omFree(cell->addr);
192  alloc = 1;
193  cell->addr=NULL;
194  }
195  else printf("cell not found\n");
196  break;
197  }
198 
200  {
201  spec.MaxSize = OM_MAX_BLOCK_SIZE;
202  spec.NoTrack = 1;
203  cell = omFindCell(spec);
204  if (cell != NULL)
205  {
206  omBinPage page = omGetBinPageOfAddr(cell->addr);
207  omBinPageRegion region = page->region;
208  page->region = NULL;
209  om_Opts.MinCheck = 1;
210  omDebugAddr(cell->addr);
211  om_Opts.MinCheck = 2;
212  page->region = region;
213  }
214  else printf("cell not found\n");
215  break;
216  }
217 
218  case omError_WrongBin:
219  {
220  spec.MaxSize = 32;
221  spec.NoTrack = 1;
222  cell = omFindCell(spec);
223  if (cell != NULL)
224  {
226  }
227  else printf("cell not found\n");
228  break;
229  }
230 
231  case omError_UnknownBin:
232  {
233  spec.MaxSize = OM_MAX_BLOCK_SIZE;
234  cell = omFindCell(spec);
235  if (cell != NULL)
236  {
237  omDebugAddrBin(cell->addr, (void*) omGetTopBinOfAddr(cell->addr) + SIZEOF_VOIDP);
238  }
239  else printf("cell not found\n");
240  break;
241  }
242 
243  case omError_NotBinAddr:
244  {
245  spec.NotIsBin = 1;
246  spec.MinSize = OM_MAX_BLOCK_SIZE + 1;
247  cell = omFindCell(spec);
248  if (cell != NULL)
249  {
250  omDebugBinAddr(cell->addr);
251  }
252  else printf("cell not found");
253  break;
254  }
255 
257  {
258  cell = omFindCell(spec);
259  if (cell != NULL)
260  {
261  omDebugAddr(cell->addr + 1);
262  }
263  else printf("cell not found\n");
264  break;
265  }
266 
268  {
269  void* addr = omAlloc(0);
270  addr = omRealloc(addr, 0);
271  omFree(addr);
272  break;
273  }
274 
276  {
277  void* last = omListLast(om_SpecBin);
278  if (last != NULL)
279  {
280  *((void**)last) = om_SpecBin;
282  *((void**)last) = NULL;
283  } else printf("last == NULL\n");
284  break;
285  }
286 
288  {
289  if (om_SpecBin != NULL && om_SpecBin->next != NULL)
290  {
291  int max_blocks = om_SpecBin->max_blocks;
292  om_SpecBin->max_blocks = om_SpecBin->next->max_blocks + 1;
293  omCheckSortedList(om_SpecBin, max_blocks, 5, omError_NoError, OM_FLR);
294  om_SpecBin->max_blocks = max_blocks;
295  } else printf("om_SpecBin->next == NULL\n");
296  break;
297  }
298 
300  {
301  if (om_KeptAddr != NULL)
302  {
303  void* last = omListLast(om_KeptAddr);
304  *((void**)last) = om_KeptAddr;
305  om_Opts.MinCheck = 5;
306  omDebugMemory();
307  om_Opts.MinCheck = 2;
308  *((void**)last) = NULL;
309  }
310  else printf("om_KeptAddr == NULL\n");
311  break;
312  }
313 
314  case omError_FreePattern:
315  {
316  if (om_Opts.Keep > 0)
317  {
318  spec.MinTrack=3;
319  spec.NotIsBin = 1;
320  cell = omFindCell(spec);
321  if (cell != NULL)
322  {
323  void* value;
324  omFree(cell->addr);
325  value = *((void**) cell->addr);
326  *((void**) cell->addr) = value -1;
327  omDebugMemory();
328  *((void**) cell->addr) = value;
329  alloc = 1;
330  cell->addr = NULL;
331  }
332  else printf("cell not found\n");
333  }
334  else printf("om_Opts.Keep == 0");
335  break;
336  }
337 
338  case omError_BackPattern:
339  {
340  spec.MinTrack = 3;
341  spec.NotIsBin = 1;
342  cell = omFindCell(spec);
343  if (cell != NULL)
344  {
345  void* addr = cell->addr + omSizeOfAddr(cell->addr);
346  void* value = *((void**) addr);
347  *((void**) addr) = value -1;
348  omDebugAddr(cell->addr);
349  *((void**) addr) = value;
350  }
351  else printf("cell not found\n");
352  break;
353  }
354 
356  {
357  spec.MinTrack=3;
358  cell = omFindCell(spec);
359  if (cell != NULL)
360  {
361  void* addr = cell->addr - SIZEOF_VOIDP;
362  void* value = *((void**) addr);
363  *((void**) addr) = value -1;
364  omDebugAddr(cell->addr);
365  *((void**) addr) = value;
366  }
367  else printf("cell not found\n");
368  break;
369  }
370 
371  case omError_NotString:
372  {
373 /* can only test for NULL string */
374 #if 0
375  spec.MaxSize = OM_MAX_BLOCK_SIZE;
376  cell = omFindCell(spec);
377  if (cell != NULL)
378  {
379  char* addr = (char*) cell->addr;
380  char* s;
381  memset(cell->addr, 1, omSizeOfAddr(cell->addr));
382  omDebugAddr(cell->addr);
383  s = omStrDup(addr);
384  omFree(s);
385  InitCellAddrContent(cell);
386  }
387  else printf("cell not found\n");
388  break;
389 #endif
390  omStrDup(NULL);
391  break;
392  }
393 
394  case omError_StickyBin:
395  {
397  break;
398  }
399 
400  default:
401  printf("No Error test implemented\n");
402  }
403 
404  if (om_ErrorStatus != error)
405  {
406  printf("---missed %s\n", omError2Serror(error));
407  missed++;
408  }
409  else
410  {
411  printf("+++ok %s\n", omError2Serror(error));
412  }
413 
415  if (cell != NULL)
416  {
417  if (alloc) TestAlloc(cell, cell->spec);
418  omtTestDebug(cell);
419  }
420  else
421  {
422  omDebugMemory();
423  }
425  {
426  printf("omtTest panik: memory corrupted\n\n");
427  return -1;
428  }
429  printf("\n");
430  }
431  printf("omtTestErrors: Summary: missed = %d\n\n", missed);
432  om_Opts.MinCheck = level;
433  return missed;
434 #else
435  return 0;
436 #endif
437 }
int level(const CanonicalForm &f)
void error(const char *fmt,...)
Definition: emacs.cc:55
const CanonicalForm int s
Definition: facAbsFact.cc:51
STATIC_VAR poly last
Definition: hdegree.cc:1151
#define omDebugMemory()
Definition: omAllocDecl.h:318
#define omDebugBinAddrSize(addr, size)
Definition: omAllocDecl.h:312
#define omDebugAddr(addr)
Definition: omAllocDecl.h:314
#define omDebugBinAddr(addr)
Definition: omAllocDecl.h:310
#define omRealloc(addr, size)
Definition: omAllocDecl.h:225
#define omDebugBin(bin)
Definition: omAllocDecl.h:317
#define omGetTopBinOfAddr(addr)
omBin_t om_StaticBin[]
#define omGetBinPageOfAddr(addr)
Definition: omBinPage.h:22
void * om_AlwaysKeptAddrs
Definition: omDebug.c:31
void * om_KeptAddr
Definition: omDebug.c:28
unsigned long om_MaxAddr
Definition: omDebugCheck.c:19
void * omAddr_2_OutAddr(void *addr)
#define omIsTrackAddr(addr)
Definition: omDebug.h:12
const char * omError2Serror(omError_t error)
Definition: omError.c:65
omError_t om_InternalErrorStatus
Definition: omError.c:14
#define omAssume(x)
Definition: omError.h:85
@ omError_WrongSize
Definition: omError.h:26
@ omError_ListCycleError
Definition: omError.h:34
@ omError_BackPattern
Definition: omError.h:38
@ omError_NullAddr
Definition: omError.h:22
@ omError_NullSizeAlloc
Definition: omError.h:33
@ omError_MaxError
Definition: omError.h:42
@ omError_FrontPattern
Definition: omError.h:39
@ omError_UnalignedAddr
Definition: omError.h:32
@ omError_MemoryCorrupted
Definition: omError.h:21
@ omError_FreedAddr
Definition: omError.h:27
@ omError_UnknownBin
Definition: omError.h:30
@ omError_FreedAddrOrMemoryCorrupted
Definition: omError.h:28
@ omError_NotString
Definition: omError.h:40
@ omError_SortedListError
Definition: omError.h:35
@ omError_KeptAddrListCorrupted
Definition: omError.h:36
@ omError_NotBinAddr
Definition: omError.h:31
@ omError_InvalidRangeAddr
Definition: omError.h:23
@ omError_FalseAddr
Definition: omError.h:24
@ omError_WrongBin
Definition: omError.h:29
@ omError_StickyBin
Definition: omError.h:41
@ omError_FreePattern
Definition: omError.h:37
@ omError_FalseAddrOrMemoryCorrupted
Definition: omError.h:25
enum omError_e omError_t
Definition: omError.h:44
#define omCheckSortedList(ptr, what, level, report, OM_FLR_VAL)
Definition: omList.h:85
#define omListLast(ptr)
Definition: omList.h:64
#define omCheckList(ptr, level, report, OM_FLR_VAL)
Definition: omList.h:83
omOpts_t om_Opts
Definition: omOpts.c:13
omBinPage_t * omBinPage
Definition: omStructs.h:16
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
#define OM_MAX_BIN_INDEX
Definition: omTables.h:4
omSpecBin om_SpecBin
Definition: om_Alloc.c:20
omMemCell omFindCell(struct LongSpec spec)
Definition: omtTestError.c:16
void TestAlloc(omMemCell cell, unsigned long spec)
Definition: omtTest.c:182
omMemCell_t * omMemCell
Definition: omtTest.h:33
#define omMergeStickyBinIntoBin(A, B)
Definition: xalloc.h:275

◆ omtTestFree()

void omtTestFree ( omMemCell  cell)

Definition at line 135 of file omtTestAlloc.c.

136 {
137  void* addr = cell->addr;
138  unsigned long spec = cell->spec;
139  omBin bin = cell->bin;
140  omBin orig_bin = cell->orig_bin;
141  size_t size = GET_SIZE(spec);
142 
143  omtTestDebug(cell);
144 
145  if (IS_FREE_SIZE(spec))
146  {
147  if (IS_SLOPPY(spec))
148  omfreeSize(addr, size);
149  else
150  omFreeSize(addr, size);
151  }
152  else if (bin != NULL && IS_FREE_BIN(spec))
153  omFreeBin(addr, bin);
154  else if (IS_FREE_BINADDR(spec) && (bin != NULL) && (size <= OM_MAX_BLOCK_SIZE))
155  {
156  omFreeBinAddr(addr);
157  }
158  else
159  {
160  if (IS_SLOPPY(spec))
161  omfree(addr);
162  else
163  omFree(addr);
164  }
165 
166  if (bin != NULL && IS_SPEC_BIN(spec))
167  {
168  if (orig_bin != NULL)
169  omUnGetSpecBin(&orig_bin);
170  else
171  omUnGetSpecBin(&bin);
172  }
173 
174  cell->addr = NULL;
175  cell->spec = 0;
176  cell->bin = NULL;
177  cell->orig_bin = NULL;
178 }
#define omfree(addr)
Definition: omAllocDecl.h:237
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
#define omfreeSize(addr, size)
Definition: omAllocDecl.h:236
#define omUnGetSpecBin(bin_ptr)
Definition: omBin.h:14
#define IS_FREE_BINADDR(spec)
Definition: omtTest.h:89
#define IS_FREE_SIZE(spec)
Definition: omtTest.h:86
#define IS_FREE_BIN(spec)
Definition: omtTest.h:87

◆ omtTestFreeDebug()

void omtTestFreeDebug ( omMemCell  cell)

◆ omtTestFreeKeep()

void omtTestFreeKeep ( omMemCell  cell)

◆ omtTestRealloc()

void omtTestRealloc ( omMemCell  cell,
unsigned long  spec 
)

Definition at line 180 of file omtTestAlloc.c.

181 {
182  void* old_addr = cell->addr;
183  unsigned long old_spec = cell->spec;
184  omBin old_bin = cell->bin;
185  omBin old_orig_bin = cell->orig_bin;
186  size_t old_size = GET_SIZE(old_spec);
187  void* new_addr;
188  omBin new_bin = NULL;
189  omBin new_orig_bin = NULL;
190  size_t new_size = GET_SIZE(new_spec);
191  size_t real_old_size = omSizeOfAddr(old_addr);
192  size_t min_size;
193 
194  omtTestDebug(cell);
195 
196  if (old_bin != NULL && IS_FREE_BIN(old_spec) &&
197  IS_BIN(new_spec) && ((new_size <= OM_MAX_BLOCK_SIZE) || IS_SPEC_BIN(new_spec)))
198  {
199  if (IS_SPEC_BIN(new_spec))
200  {
201  if (IS_ALIGNED(new_spec))
202  new_bin = omGetAlignedSpecBin(new_size);
203  else
204  new_bin = omGetSpecBin(new_size);
205  }
206  else
207  {
208  if (IS_ALIGNED(new_spec))
209  new_bin = omSmallSize2AlignedBin(new_size);
210  else
211  new_bin = omSmallSize2Bin(new_size);
212  }
213 
214  if (IS_STICKY_BIN(new_spec))
215  {
216  new_orig_bin = new_bin;
217  new_bin = omtGetStickyBin(new_bin);
218  }
219 
220  if (IS_INLINE(new_spec))
221  {
222  if (IS_ZERO(new_spec)) new_addr = omRealloc0Bin(old_addr, old_bin, new_bin);
223  else new_addr = omReallocBin(old_addr, old_bin, new_bin);
224  }
225  else
226  {
227  if (IS_ZERO(new_spec)) omTypeRealloc0Bin(old_addr, old_bin, void*, new_addr, new_bin);
228  else omTypeReallocBin(old_addr, old_bin, void*, new_addr, new_bin);
229  }
230  }
231  else
232  {
233  if (IS_FREE_SIZE(old_spec))
234  {
235  if (IS_INLINE(new_spec))
236  {
237  if (IS_ZERO(new_spec))
238  {
239  if (IS_ALIGNED(new_spec))
240  {
241  if (IS_SLOPPY(new_spec))
242  new_addr = omrealloc0Size(old_addr, old_size, new_size);
243  else
244  new_addr = omRealloc0AlignedSize(old_addr, old_size, new_size);
245  }
246  else
247  new_addr = omRealloc0Size(old_addr, old_size, new_size);
248  }
249  else
250  {
251  if (IS_ALIGNED(new_spec))
252  {
253  if (IS_SLOPPY(new_spec))
254  new_addr = omreallocSize(old_addr, old_size, new_size);
255  else
256  new_addr = omReallocAlignedSize(old_addr, old_size, new_size);
257  }
258  else new_addr = omReallocSize(old_addr, old_size, new_size);
259  }
260  }
261  else
262  {
263  if (IS_ZERO(new_spec))
264  {
265  if (IS_ALIGNED(new_spec)) omTypeRealloc0AlignedSize(old_addr, old_size, void*, new_addr, new_size);
266  else omTypeRealloc0Size(old_addr, old_size, void*, new_addr, new_size);
267  }
268  else
269  {
270  if (IS_ALIGNED(new_spec)) omTypeReallocAlignedSize(old_addr, old_size, void*, new_addr, new_size);
271  else omTypeReallocSize(old_addr, old_size, void*, new_addr, new_size);
272  }
273  }
274  }
275  else
276  {
277  if (IS_INLINE(new_spec))
278  {
279  if (IS_ZERO(new_spec))
280  {
281  if (IS_ALIGNED(new_spec))
282  {
283  if (IS_SLOPPY(new_spec))
284  new_addr = omrealloc0(old_addr, new_size);
285  else
286  new_addr = omRealloc0Aligned(old_addr, new_size);
287  }
288  else new_addr = omRealloc0(old_addr, new_size);
289  }
290  else
291  {
292  if (IS_ALIGNED(new_spec))
293  {
294  if (IS_SLOPPY(new_spec))
295  new_addr = omrealloc(old_addr, new_size);
296  else
297  new_addr = omReallocAligned(old_addr, new_size);
298  }
299  else new_addr = omRealloc(old_addr, new_size);
300  }
301  }
302  else
303  {
304  if (IS_ZERO(new_spec))
305  {
306  if (IS_ALIGNED(new_spec)) omTypeRealloc0Aligned(old_addr, void*, new_addr, new_size);
307  else omTypeRealloc0(old_addr, void*, new_addr, new_size);
308  }
309  else
310  {
311  if (IS_ALIGNED(new_spec)) omTypeReallocAligned(old_addr, void*, new_addr, new_size);
312  else omTypeRealloc(old_addr, void*, new_addr, new_size);
313  }
314  }
315  }
316  }
317 
318  if (old_bin != NULL && IS_SPEC_BIN(old_spec))
319  {
320  if (old_orig_bin != NULL)
321  omUnGetSpecBin(&old_orig_bin);
322  else
323  omUnGetSpecBin(&old_bin);
324  }
325 
326  new_size = omSizeOfAddr(new_addr);
327  old_size = real_old_size;
328  min_size = (new_size < old_size ? new_size : old_size);
329 
330  if (IS_ZERO(old_spec) && IS_ZERO(new_spec))
331  TestAddrContent(new_addr, 0, new_size);
332  else
333  {
334  TestAddrContent(new_addr, (IS_ZERO(old_spec) ? 0 : old_spec), min_size);
335  if (IS_ZERO(new_spec) && old_size < new_size)
336  TestAddrContent((char *)new_addr + old_size, 0, new_size - old_size);
337  }
338 
339  cell->addr = new_addr;
340  cell->spec = new_spec;
341  cell->bin = new_bin;
342  cell->orig_bin = new_orig_bin;
343  InitCellAddrContent(cell);
344  omtTestDebug(cell);
345 }
#define omrealloc(addr, size)
Definition: omAllocDecl.h:233
#define omTypeReallocAlignedSize
Definition: omAllocDecl.h:276
#define omTypeRealloc0(o_addr, type, addr, size)
Definition: omAllocDecl.h:224
#define omTypeRealloc0Size(o_addr, o_size, type, addr, size)
Definition: omAllocDecl.h:219
#define omRealloc0AlignedSize
Definition: omAllocDecl.h:279
#define omrealloc0Size(addr, o_size, size)
Definition: omAllocDecl.h:232
#define omRealloc0Aligned
Definition: omAllocDecl.h:284
#define omreallocSize(addr, o_size, size)
Definition: omAllocDecl.h:231
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220
#define omReallocAligned
Definition: omAllocDecl.h:283
#define omTypeRealloc0AlignedSize
Definition: omAllocDecl.h:277
#define omrealloc0(addr, size)
Definition: omAllocDecl.h:234
#define omRealloc0Bin(o_addr, o_bin, bin)
Definition: omAllocDecl.h:216
#define omTypeRealloc0Bin(o_addr, o_bin, type, addr, bin)
Definition: omAllocDecl.h:214
#define omReallocAlignedSize
Definition: omAllocDecl.h:278
#define omTypeRealloc0Aligned
Definition: omAllocDecl.h:282
#define omReallocBin(o_addr, o_bin, bin)
Definition: omAllocDecl.h:215
#define omRealloc0Size(addr, o_size, size)
Definition: omAllocDecl.h:221
#define omTypeReallocAligned
Definition: omAllocDecl.h:281
#define omRealloc0(addr, size)
Definition: omAllocDecl.h:226
#define omTypeReallocSize(o_addr, o_size, type, addr, size)
Definition: omAllocDecl.h:218
#define omTypeReallocBin(o_addr, o_bin, type, addr, bin)
Definition: omAllocDecl.h:213
#define omTypeRealloc(o_addr, type, addr, size)
Definition: omAllocDecl.h:223

◆ omtTestReallocDebug()

void omtTestReallocDebug ( omMemCell  cell,
unsigned long  spec 
)

◆ omtTestReallocKeep()

void omtTestReallocKeep ( omMemCell  cell,
unsigned long  spec 
)

◆ 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 }
int i
Definition: cfEzgcd.cc:132

◆ 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 }
int errors
Definition: omtTest.c:12
#define DO_KEEP(spec)
Definition: omtTest.h:79
void omtTestAlloc(omMemCell cell, unsigned long spec)
Definition: omtTestAlloc.c:33
#define GET_TRACK(spec)
Definition: omtTest.h:71
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

◆ 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)
Definition: omtTestAlloc.c:135
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)
Definition: omtTestAlloc.c:180

Variable Documentation

◆ cells

omMemCell_t cells[]
extern

Definition at line 11 of file omtTest.c.