My Project  UNKNOWN_GIT_VERSION
omtTestAlloc.c
Go to the documentation of this file.
1 /*******************************************************************
2  * File: omtTestAlloc.c
3  * Purpose: alloc function to be included in omMain.c
4  * Author: obachman@mathematik.uni-kl.de (Olaf Bachmann)
5  * Created: 11/99
6  *******************************************************************/
7 #include "omtTest.h"
8 
9 #ifdef TEST_CHECK
10 #define OM_CHECK CHECK_LEVEL
11 #define omtTestAlloc omtTestAllocDebug
12 #define omtTestRealloc omtTestReallocDebug
13 #define omtTestFree omtTestFreeDebug
14 #define omtTestDup omtTestDupDebug
15 #endif
16 
17 #ifdef TEST_KEEP
18 #define OM_CHECK CHECK_LEVEL
19 #define OM_KEEP 1
20 #define omtTestAlloc omtTestAllocKeep
21 #define omtTestRealloc omtTestReallocKeep
22 #define omtTestFree omtTestFreeKeep
23 #define omtTestDup omtTestDupKeep
24 #endif
25 
26 #include "omalloc.h"
27 
28 #ifndef OM_ALIGNMENT_NEEDS_WORK
29 #define omSmallSize2AlignedBin omSmallSize2Bin
30 #endif
31 
32 void omtTestAlloc(omMemCell cell, unsigned long spec)
33 {
34  size_t size = GET_SIZE(spec);
35  void* addr;
36  omBin bin = NULL;
38 
40  {
41  if (IS_SPEC_BIN(spec))
42  {
43  if (IS_ALIGNED(spec))
45  else
47  }
48  else
49  {
50  if (IS_ALIGNED(spec))
52  else
54  }
55 
56  if (IS_STICKY_BIN(spec))
57  {
58  orig_bin = bin;
60  }
61 
62  if (IS_INLINE(spec))
63  {
64  if (IS_ZERO(spec))
65  addr = omAlloc0Bin(bin);
66  else
67  addr = omAllocBin(bin);
68  }
69  else
70  {
71  if (IS_ZERO(spec))
72  omTypeAlloc0Bin(void*, addr, bin);
73  else
74  omTypeAllocBin(void*, addr, bin);
75  }
76  }
77  else
78  {
79  if (IS_INLINE(spec))
80  {
81  if (IS_ZERO(spec))
82  {
83  if (IS_ALIGNED(spec))
84  {
85  if (IS_SLOPPY(spec))
86  addr = omalloc0(size);
87  else
89  }
90  else
91  addr = omAlloc0(size);
92  }
93  else
94  {
95  if (IS_ALIGNED(spec))
96  {
97  if (IS_SLOPPY(spec))
98  addr = omalloc(size);
99  else
101  }
102  else
103  addr = omAlloc(size);
104  }
105  }
106  else
107  {
108  if (IS_ZERO(spec))
109  {
110  if (IS_ALIGNED(spec))
111  omTypeAlloc0Aligned(void*, addr, size);
112  else
113  omTypeAlloc0(void*, addr, size);
114  }
115  else
116  {
117  if (IS_ALIGNED(spec))
118  omTypeAllocAligned(void*, addr, size);
119  else
120  omTypeAlloc(void*, addr, size);
121  }
122  }
123  }
124  cell->addr = addr;
125  cell->bin = bin;
126  cell->orig_bin = orig_bin;
127  cell->spec = spec;
128 
129  InitCellAddrContent(cell);
130 
131  omtTestDebug(cell);
132 }
133 
134 void omtTestFree(omMemCell cell)
135 {
136  void* addr = cell->addr;
137  unsigned long spec = cell->spec;
138  omBin bin = cell->bin;
139  omBin orig_bin = cell->orig_bin;
140  size_t size = GET_SIZE(spec);
141 
142  omtTestDebug(cell);
143 
144  if (IS_FREE_SIZE(spec))
145  {
146  if (IS_SLOPPY(spec))
147  omfreeSize(addr, size);
148  else
149  omFreeSize(addr, size);
150  }
151  else if (bin != NULL && IS_FREE_BIN(spec))
152  omFreeBin(addr, bin);
153  else if (IS_FREE_BINADDR(spec) && (bin != NULL) && (size <= OM_MAX_BLOCK_SIZE))
154  {
156  }
157  else
158  {
159  if (IS_SLOPPY(spec))
160  omfree(addr);
161  else
162  omFree(addr);
163  }
164 
165  if (bin != NULL && IS_SPEC_BIN(spec))
166  {
167  if (orig_bin != NULL)
169  else
171  }
172 
173  cell->addr = NULL;
174  cell->spec = 0;
175  cell->bin = NULL;
176  cell->orig_bin = NULL;
177 }
178 
179 void omtTestRealloc(omMemCell cell, unsigned long new_spec)
180 {
181  void* old_addr = cell->addr;
182  unsigned long old_spec = cell->spec;
183  omBin old_bin = cell->bin;
184  omBin old_orig_bin = cell->orig_bin;
185  size_t old_size = GET_SIZE(old_spec);
186  void* new_addr;
187  omBin new_bin = NULL;
188  omBin new_orig_bin = NULL;
189  size_t new_size = GET_SIZE(new_spec);
190  size_t real_old_size = omSizeOfAddr(old_addr);
191  size_t min_size;
192 
193  omtTestDebug(cell);
194 
195  if (old_bin != NULL && IS_FREE_BIN(old_spec) &&
196  IS_BIN(new_spec) && ((new_size <= OM_MAX_BLOCK_SIZE) || IS_SPEC_BIN(new_spec)))
197  {
198  if (IS_SPEC_BIN(new_spec))
199  {
200  if (IS_ALIGNED(new_spec))
201  new_bin = omGetAlignedSpecBin(new_size);
202  else
203  new_bin = omGetSpecBin(new_size);
204  }
205  else
206  {
207  if (IS_ALIGNED(new_spec))
208  new_bin = omSmallSize2AlignedBin(new_size);
209  else
210  new_bin = omSmallSize2Bin(new_size);
211  }
212 
213  if (IS_STICKY_BIN(new_spec))
214  {
215  new_orig_bin = new_bin;
216  new_bin = omtGetStickyBin(new_bin);
217  }
218 
219  if (IS_INLINE(new_spec))
220  {
221  if (IS_ZERO(new_spec)) new_addr = omRealloc0Bin(old_addr, old_bin, new_bin);
222  else new_addr = omReallocBin(old_addr, old_bin, new_bin);
223  }
224  else
225  {
226  if (IS_ZERO(new_spec)) omTypeRealloc0Bin(old_addr, old_bin, void*, new_addr, new_bin);
227  else omTypeReallocBin(old_addr, old_bin, void*, new_addr, new_bin);
228  }
229  }
230  else
231  {
232  if (IS_FREE_SIZE(old_spec))
233  {
234  if (IS_INLINE(new_spec))
235  {
236  if (IS_ZERO(new_spec))
237  {
238  if (IS_ALIGNED(new_spec))
239  {
240  if (IS_SLOPPY(new_spec))
241  new_addr = omrealloc0Size(old_addr, old_size, new_size);
242  else
243  new_addr = omRealloc0AlignedSize(old_addr, old_size, new_size);
244  }
245  else
246  new_addr = omRealloc0Size(old_addr, old_size, new_size);
247  }
248  else
249  {
250  if (IS_ALIGNED(new_spec))
251  {
252  if (IS_SLOPPY(new_spec))
253  new_addr = omreallocSize(old_addr, old_size, new_size);
254  else
255  new_addr = omReallocAlignedSize(old_addr, old_size, new_size);
256  }
257  else new_addr = omReallocSize(old_addr, old_size, new_size);
258  }
259  }
260  else
261  {
262  if (IS_ZERO(new_spec))
263  {
264  if (IS_ALIGNED(new_spec)) omTypeRealloc0AlignedSize(old_addr, old_size, void*, new_addr, new_size);
265  else omTypeRealloc0Size(old_addr, old_size, void*, new_addr, new_size);
266  }
267  else
268  {
269  if (IS_ALIGNED(new_spec)) omTypeReallocAlignedSize(old_addr, old_size, void*, new_addr, new_size);
270  else omTypeReallocSize(old_addr, old_size, void*, new_addr, new_size);
271  }
272  }
273  }
274  else
275  {
276  if (IS_INLINE(new_spec))
277  {
278  if (IS_ZERO(new_spec))
279  {
280  if (IS_ALIGNED(new_spec))
281  {
282  if (IS_SLOPPY(new_spec))
283  new_addr = omrealloc0(old_addr, new_size);
284  else
285  new_addr = omRealloc0Aligned(old_addr, new_size);
286  }
287  else new_addr = omRealloc0(old_addr, new_size);
288  }
289  else
290  {
291  if (IS_ALIGNED(new_spec))
292  {
293  if (IS_SLOPPY(new_spec))
294  new_addr = omrealloc(old_addr, new_size);
295  else
296  new_addr = omReallocAligned(old_addr, new_size);
297  }
298  else new_addr = omRealloc(old_addr, new_size);
299  }
300  }
301  else
302  {
303  if (IS_ZERO(new_spec))
304  {
305  if (IS_ALIGNED(new_spec)) omTypeRealloc0Aligned(old_addr, void*, new_addr, new_size);
306  else omTypeRealloc0(old_addr, void*, new_addr, new_size);
307  }
308  else
309  {
310  if (IS_ALIGNED(new_spec)) omTypeReallocAligned(old_addr, void*, new_addr, new_size);
311  else omTypeRealloc(old_addr, void*, new_addr, new_size);
312  }
313  }
314  }
315  }
316 
317  if (old_bin != NULL && IS_SPEC_BIN(old_spec))
318  {
319  if (old_orig_bin != NULL)
320  omUnGetSpecBin(&old_orig_bin);
321  else
322  omUnGetSpecBin(&old_bin);
323  }
324 
325  new_size = omSizeOfAddr(new_addr);
326  old_size = real_old_size;
327  min_size = (new_size < old_size ? new_size : old_size);
328 
329  if (IS_ZERO(old_spec) && IS_ZERO(new_spec))
330  TestAddrContent(new_addr, 0, new_size);
331  else
332  {
333  TestAddrContent(new_addr, (IS_ZERO(old_spec) ? 0 : old_spec), min_size);
334  if (IS_ZERO(new_spec) && old_size < new_size)
335  TestAddrContent((char *)new_addr + old_size, 0, new_size - old_size);
336  }
337 
338  cell->addr = new_addr;
339  cell->spec = new_spec;
340  cell->bin = new_bin;
341  cell->orig_bin = new_orig_bin;
342  InitCellAddrContent(cell);
343  omtTestDebug(cell);
344 }
345 
346 #define DO_STRDUP(l) (l & 1)
347 void omtTestDup(omMemCell cell, unsigned long spec)
348 {
349  omtTestDebug(cell);
350 
351  if (DO_STRDUP(spec))
352  {
353  size_t size = omSizeOfAddr(cell->addr);
354  void* new_addr;
355  memset(cell->addr, 'a', size - 1);
356  ((char*) cell->addr)[size-1] = '\0';
357  new_addr = omStrDup(cell->addr);
358  TestAddrContentEqual(new_addr, cell->addr, size);
359  omFree(new_addr);
360  InitCellAddrContent(cell);
361  }
362  else
363  {
364  void* new_addr = omMemDup(cell->addr);
365  TestAddrContentEqual(new_addr, cell->addr, omSizeOfAddr(cell->addr));
366  omFree(new_addr);
367  new_addr = omMemDupAligned(cell->addr);
368  TestAddrContentEqual(new_addr, cell->addr, omSizeOfAddr(cell->addr));
369  omDebugAddrAlignedSize(new_addr, omSizeOfAddr(cell->addr));
370  omFree(new_addr);
371  }
372 }
omTypeAlloc
#define omTypeAlloc(type, addr, size)
Definition: omAllocDecl.h:206
omalloc.h
omTypeRealloc0AlignedSize
#define omTypeRealloc0AlignedSize
Definition: omAllocDecl.h:275
IS_ZERO
#define IS_ZERO(spec)
Definition: omtTest.h:55
omMemCell
omMemCell_t * omMemCell
Definition: omtTest.h:34
omtTestAlloc
void omtTestAlloc(omMemCell cell, unsigned long spec)
Definition: omtTestAlloc.c:31
TestAddrContentEqual
void TestAddrContentEqual(void *s1, void *s2, size_t size)
Definition: omtTest.c:94
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
omtTestDup
void omtTestDup(omMemCell cell, unsigned long spec)
Definition: omtTestAlloc.c:346
omRealloc0Aligned
#define omRealloc0Aligned
Definition: omAllocDecl.h:282
IS_FREE_BINADDR
#define IS_FREE_BINADDR(spec)
Definition: omtTest.h:90
omSizeOfAddr
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:98
omGetSpecBin
#define omGetSpecBin(size)
Definition: omBin.h:10
omTypeAlloc0Aligned
#define omTypeAlloc0Aligned
Definition: omAllocDecl.h:270
omReallocAlignedSize
#define omReallocAlignedSize
Definition: omAllocDecl.h:276
DO_STRDUP
#define DO_STRDUP(l)
Definition: omtTestAlloc.c:345
InitCellAddrContent
void InitCellAddrContent(omMemCell cell)
Definition: omtTest.c:134
omTypeReallocSize
#define omTypeReallocSize(o_addr, o_size, type, addr, size)
Definition: omAllocDecl.h:216
omTypeRealloc0Bin
#define omTypeRealloc0Bin(o_addr, o_bin, type, addr, bin)
Definition: omAllocDecl.h:212
omAllocAligned
#define omAllocAligned
Definition: omAllocDecl.h:271
omTypeReallocAlignedSize
#define omTypeReallocAlignedSize
Definition: omAllocDecl.h:274
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
omTypeReallocBin
#define omTypeReallocBin(o_addr, o_bin, type, addr, bin)
Definition: omAllocDecl.h:211
omtTestFree
void omtTestFree(omMemCell cell)
Definition: omtTestAlloc.c:133
omAllocBin
#define omAllocBin(bin)
Definition: omAllocDecl.h:203
omTypeRealloc
#define omTypeRealloc(o_addr, type, addr, size)
Definition: omAllocDecl.h:221
omAlloc0Bin
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:204
omSmallSize2AlignedBin
#define omSmallSize2AlignedBin
Definition: omtTestAlloc.c:28
omTypeRealloc0Aligned
#define omTypeRealloc0Aligned
Definition: omAllocDecl.h:280
omReallocAligned
#define omReallocAligned
Definition: omAllocDecl.h:281
omrealloc0Size
#define omrealloc0Size(addr, o_size, size)
Definition: omAllocDecl.h:230
GET_SIZE
#define GET_SIZE(spec)
Definition: omtTest.h:52
omRealloc
#define omRealloc(addr, size)
Definition: omAllocDecl.h:223
omTypeAlloc0
#define omTypeAlloc0(type, addr, size)
Definition: omAllocDecl.h:207
IS_ALIGNED
#define IS_ALIGNED(spec)
Definition: omtTest.h:54
OM_MAX_BLOCK_SIZE
#define OM_MAX_BLOCK_SIZE
Definition: omTables.c:30
omTypeRealloc0
#define omTypeRealloc0(o_addr, type, addr, size)
Definition: omAllocDecl.h:222
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
omfreeSize
#define omfreeSize(addr, size)
Definition: omAllocDecl.h:234
omFreeBinAddr
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:256
IS_FREE_SIZE
#define IS_FREE_SIZE(spec)
Definition: omtTest.h:87
omtTestDebug
void omtTestDebug(omMemCell cell)
Definition: omtTest.c:34
omMemDup
#define omMemDup(s)
Definition: omAllocDecl.h:262
IS_SPEC_BIN
#define IS_SPEC_BIN(spec)
Definition: omtTest.h:57
omrealloc
#define omrealloc(addr, size)
Definition: omAllocDecl.h:231
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
omTypeAlloc0Bin
#define omTypeAlloc0Bin(type, addr, bin)
Definition: omAllocDecl.h:202
omAlloc0Aligned
#define omAlloc0Aligned
Definition: omAllocDecl.h:272
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
IS_STICKY_BIN
#define IS_STICKY_BIN(spec)
Definition: omtTest.h:50
omTypeAllocBin
#define omTypeAllocBin(type, addr, bin)
Definition: omAllocDecl.h:201
omtTest.h
IS_SLOPPY
#define IS_SLOPPY(spec)
Definition: omtTest.h:89
omSmallSize2Bin
#define omSmallSize2Bin(size)
Definition: omAllocPrivate.h:206
omRealloc0AlignedSize
#define omRealloc0AlignedSize
Definition: omAllocDecl.h:277
omReallocBin
#define omReallocBin(o_addr, o_bin, bin)
Definition: omAllocDecl.h:213
omTypeRealloc0Size
#define omTypeRealloc0Size(o_addr, o_size, type, addr, size)
Definition: omAllocDecl.h:217
omtTestRealloc
void omtTestRealloc(omMemCell cell, unsigned long new_spec)
Definition: omtTestAlloc.c:178
omMemCell_s::bin
omBin bin
Definition: omtTest.h:28
omMemCell_s::addr
void * addr
Definition: omtTest.h:27
IS_FREE_BIN
#define IS_FREE_BIN(spec)
Definition: omtTest.h:88
TestAddrContent
void TestAddrContent(void *addr, unsigned long value, size_t size)
Definition: omtTest.c:110
omMemCell_s::orig_bin
omBin orig_bin
Definition: omtTest.h:30
IS_BIN
#define IS_BIN(spec)
Definition: omtTest.h:56
omBin
omBin_t * omBin
Definition: omStructs.h:11
IS_INLINE
#define IS_INLINE(spec)
Definition: omtTest.h:58
omrealloc0
#define omrealloc0(addr, size)
Definition: omAllocDecl.h:232
omtGetStickyBin
omBin omtGetStickyBin(omBin bin)
Definition: omtTest.c:279
omUnGetSpecBin
#define omUnGetSpecBin(bin_ptr)
Definition: omBin.h:13
omGetAlignedSpecBin
#define omGetAlignedSpecBin(size)
Definition: omBin.h:9
omalloc
#define omalloc(size)
Definition: omAllocDecl.h:226
omreallocSize
#define omreallocSize(addr, o_size, size)
Definition: omAllocDecl.h:229
omDebugAddrAlignedSize
#define omDebugAddrAlignedSize
Definition: omAllocDecl.h:290
omRealloc0
#define omRealloc0(addr, size)
Definition: omAllocDecl.h:224
NULL
#define NULL
Definition: omList.c:9
omRealloc0Size
#define omRealloc0Size(addr, o_size, size)
Definition: omAllocDecl.h:219
omTypeAllocAligned
#define omTypeAllocAligned
Definition: omAllocDecl.h:269
omTypeReallocAligned
#define omTypeReallocAligned
Definition: omAllocDecl.h:279
omFreeBin
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:257
omRealloc0Bin
#define omRealloc0Bin(o_addr, o_bin, bin)
Definition: omAllocDecl.h:214
omMemCell_s::spec
unsigned long spec
Definition: omtTest.h:29
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:209
omalloc0
#define omalloc0(size)
Definition: omAllocDecl.h:227
omMemDupAligned
#define omMemDupAligned
Definition: omAllocDecl.h:284
omReallocSize
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:218
omfree
#define omfree(addr)
Definition: omAllocDecl.h:235