source: tests/malloc.cfa@ f67b983

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since f67b983 was 68f0c4e, checked in by m3zulfiq <m3zulfiq@…>, 5 years ago

stdlib.hfa: changed CFA malloc, realloc and resize as discussed with Peter. malloc.cfa: corrected CFA posix-memalign test. alloc.txt: corrected expected alloc test output (temporarily, yet to be reviewed by Peter) while old expected output is in alloc-old.txt (temporary file to be removed after review with Peter)
  • Property mode set to 100644
File size: 12.3 KB
Line 
1#include <assert.h>
2#include <malloc.h> // malloc_usable_size
3#include <stdint.h> // uintptr_t
4#include <stdlib.h> // posix_memalign
5#include <fstream.hfa>
6#include <stdlib.hfa> // access C malloc, realloc
7#include <unistd.h> // getpagesize
8
9int tests_total;
10int tests_failed;
11size_t tAlign = 32;
12struct S1 { int d1; } __attribute__((aligned(32)));
13typedef struct S1 T1;
14
15void test_base( void * ip, size_t size, size_t align) {
16 tests_total += 1;
17 bool passed = (malloc_size(ip) == size) && (malloc_usable_size(ip) >= size) && (malloc_alignment(ip) == align) && ((uintptr_t)ip % align == 0);
18 if (!passed) {
19 printf("failed test %2d: %4lu %4lu but got %4lu ( %3lu ) %4lu\n", tests_total, size, align, malloc_size(ip), malloc_usable_size(ip), malloc_alignment(ip));
20 tests_failed += 1;
21 }
22}
23
24void test_fill( void * ip_, size_t start, size_t end, char fill) {
25 tests_total += 1;
26 bool passed = true;
27 char * ip = (char *) ip_;
28 for (i; start ~ end) passed = passed && (ip[i] == fill);
29 if (!passed) {
30 printf("failed test %2d: fill\n", tests_total);
31 tests_failed += 1;
32 }
33}
34
35void test_use( void * ip_) {
36 tests_total += 1;
37 bool passed = true;
38 int * ip = (int *) ip_;
39 size_t size = malloc_size(ip);
40 for (i; 0 ~ size ~ sizeof(int)) ip[i/sizeof(int)] = 0xdeadbeef;
41 for (i; 0 ~ size ~ sizeof(int)) passed = passed && (ip[i/sizeof(int)] == 0xdeadbeef);
42 size_t usize = malloc_usable_size(ip);
43 for (i; size ~ usize ~ sizeof(int)) ip[i/sizeof(int)] = -1;
44 for (i; size ~ usize ~ sizeof(int)) passed = passed && (ip[i/sizeof(int)] == -1);
45 if (!passed) {
46 printf("failed test %2d: use\n", tests_total);
47 tests_failed += 1;
48 }
49}
50
51int main( void ) {
52 size_t elemSize = sizeof(int);
53 size_t dim = 8;
54 size_t size = dim * elemSize;
55 size_t align = 64;
56 const size_t libAlign = libAlign();
57 char fill = '\xde';
58 int * ip;
59 T1 * tp;
60
61 // testing C malloc
62
63 tests_total = 0;
64 tests_failed = 0;
65
66 ip = (int *) (void *) malloc( size );
67 test_base(ip, size, libAlign);
68 test_use(ip);
69 free(ip);
70
71 ip = (int *) (void *) malloc( 0 );
72 test_base(ip, 0, libAlign);
73 test_use(ip);
74 free(ip);
75
76 ip = (int *) (void *) aalloc( dim, elemSize );
77 test_base(ip, size, libAlign);
78 test_use(ip);
79 free(ip);
80
81 ip = (int *) (void *) aalloc( 0, elemSize );
82 test_base(ip, 0, libAlign);
83 test_use(ip);
84 free(ip);
85
86 ip = (int *) (void *) aalloc( dim, 0 );
87 test_base(ip, 0, libAlign);
88 test_use(ip);
89 free(ip);
90
91 ip = (int *) (void *) aalloc( 0, 0 );
92 test_base(ip, 0, libAlign);
93 test_use(ip);
94 free(ip);
95
96 ip = (int *) (void *) calloc( dim, elemSize );
97 test_base(ip, size, libAlign);
98 test_fill(ip, 0, size, '\0');
99 test_use(ip);
100 free(ip);
101
102 ip = (int *) (void *) calloc( 0, elemSize );
103 test_base(ip, 0, libAlign);
104 test_fill(ip, 0, 0, '\0');
105 test_use(ip);
106 free(ip);
107
108 ip = (int *) (void *) calloc( dim, 0 );
109 test_base(ip, 0, libAlign);
110 test_fill(ip, 0, 0, '\0');
111 test_use(ip);
112 free(ip);
113
114 ip = (int *) (void *) malloc( size );
115 ip = (int *) (void *) resize( (void *) ip, size / 4 );
116 test_base(ip, size / 4, libAlign);
117 test_use(ip);
118 free(ip);
119
120 ip = (int *) (void *) malloc( size );
121 ip = (int *) (void *) resize( (void *) ip, size * 4 );
122 test_base(ip, size * 4, libAlign);
123 test_use(ip);
124 free(ip);
125
126 ip = (int *) (void *) malloc( size );
127 ip = (int *) (void *) resize( (void *) ip, 0 );
128 test_base(ip, 0, libAlign);
129 test_use(ip);
130 free(ip);
131
132 ip = (int *) (void *) resize( NULL, size );
133 test_base(ip, size, libAlign);
134 test_use(ip);
135 free(ip);
136
137 ip = (int *) (void *) resize( 0p, size );
138 test_base(ip, size, libAlign);
139 test_use(ip);
140 free(ip);
141
142 ip = (int *) (void *) calloc( dim, elemSize );
143 ip = (int *) (void *) realloc( (void *) ip, size / 4 );
144 test_base(ip, size / 4, libAlign);
145 test_fill(ip, 0, size / 4, '\0');
146 test_use(ip);
147 free(ip);
148
149 ip = (int *) (void *) calloc( dim, elemSize );
150 ip = (int *) (void *) realloc( (void *) ip, size * 4 );
151 test_base(ip, size * 4, libAlign);
152 test_fill(ip, 0, size * 4, '\0');
153 test_use(ip);
154 free(ip);
155
156 ip = (int *) (void *) calloc( dim, elemSize );
157 ip = (int *) (void *) realloc( (void *) ip, 0 );
158 test_base(ip, 0, libAlign);
159 test_use(ip);
160 free(ip);
161
162 ip = (int *) (void *) realloc( NULL, size );
163 test_base(ip, size , libAlign);
164 test_use(ip);
165 free(ip);
166
167 ip = (int *) (void *) realloc( 0p, size );
168 test_base(ip, size, libAlign);
169 test_use(ip);
170 free(ip);
171
172 ip = (int *) (void *) memalign( align, size );
173 test_base(ip, size, align);
174 test_use(ip);
175 free(ip);
176
177 ip = (int *) (void *) memalign( align, 0 );
178 test_base(ip, 0, libAlign);
179 test_use(ip);
180 free(ip);
181
182 ip = (int *) (void *) amemalign( align, dim, elemSize );
183 test_base(ip, size, align);
184 test_use(ip);
185 free(ip);
186
187 ip = (int *) (void *) amemalign( align, 0, elemSize );
188 test_base(ip, 0, libAlign);
189 test_use(ip);
190 free(ip);
191
192 ip = (int *) (void *) amemalign( align, dim, 0 );
193 test_base(ip, 0, libAlign);
194 test_use(ip);
195 free(ip);
196
197 ip = (int *) (void *) cmemalign( align, dim, elemSize );
198 test_base(ip, size, align);
199 test_fill(ip, 0, size, '\0');
200 test_use(ip);
201 free(ip);
202
203 ip = (int *) (void *) cmemalign( align, 0, elemSize );
204 test_base(ip, 0, libAlign);
205 test_use(ip);
206 free(ip);
207
208 ip = (int *) (void *) cmemalign( align, dim, 0 );
209 test_base(ip, 0, libAlign);
210 test_use(ip);
211 free(ip);
212
213 ip = (int *) (void *) aligned_alloc( align, size );
214 test_base(ip, size, align);
215 test_use(ip);
216 free(ip);
217
218 ip = (int *) (void *) aligned_alloc( align, 0 );
219 test_base(ip, 0, libAlign);
220 test_use(ip);
221 free(ip);
222
223 (int) posix_memalign( (void **) &ip, align, size );
224 test_base(ip, size, align);
225 test_use(ip);
226 free(ip);
227
228 (int) posix_memalign( (void **) &ip, align, 0 );
229 test_base(ip, 0, libAlign);
230 test_use(ip);
231 free(ip);
232
233 ip = (int *) (void *) valloc( size );
234 test_base(ip, size, getpagesize());
235 test_use(ip);
236 free(ip);
237
238 ip = (int *) (void *) valloc( 0 );
239 test_base(ip, 0, libAlign);
240 test_use(ip);
241 free(ip);
242
243 ip = (int *) (void *) pvalloc( getpagesize() * 3 / 2 );
244 test_base(ip, getpagesize() * 2, getpagesize());
245 test_use(ip);
246 free(ip);
247
248 ip = (int *) (void *) pvalloc( 0 );
249 test_base(ip, 0, libAlign);
250 test_use(ip);
251 free(ip);
252
253 ip = (int *) (void *) malloc( size );
254 ip = (int *) (void *) resize( (void *) ip, align, size / 4 );
255 test_base(ip, size / 4, align);
256 test_use(ip);
257 free(ip);
258
259 ip = (int *) (void *) malloc( size );
260 ip = (int *) (void *) resize( (void *) ip, align, 0 );
261 test_base(ip, 0, libAlign);
262 test_use(ip);
263 free(ip);
264
265 ip = (int *) (void *) resize( NULL, align, size );
266 test_base(ip, size, align);
267 test_use(ip);
268 free(ip);
269
270 ip = (int *) (void *) resize( 0p, align, size );
271 test_base(ip, size, align);
272 test_use(ip);
273 free(ip);
274
275 ip = (int *) (void *) calloc( dim, elemSize );
276 ip = (int *) (void *) realloc( (void *) ip, align, size / 4 );
277 test_base(ip, size / 4, align);
278 test_fill(ip, 0, size / 4, '\0');
279 test_use(ip);
280 free(ip);
281
282 ip = (int *) (void *) calloc( dim, elemSize );
283 ip = (int *) (void *) realloc( (void *) ip, 0, size * 4 );
284 test_base(ip, size * 4, libAlign);
285 test_fill(ip, 0, size * 4, '\0');
286 test_use(ip);
287 free(ip);
288
289 ip = (int *) (void *) calloc( dim, elemSize );
290 ip = (int *) (void *) realloc( (void *) ip, align, 0 );
291 test_base(ip, 0, libAlign);
292 test_use(ip);
293 free(ip);
294
295 free( 0p ); // sanity check
296 free( NULL ); // sanity check
297
298 if (tests_failed == 0) printf("PASSED C malloc tests\n\n");
299 else printf("failed C malloc tests : %d/%d\n\n", tests_failed, tests_total);
300
301 // testing CFA malloc
302
303 tests_total = 0;
304 tests_failed = 0;
305
306 ip = malloc();
307 test_base(ip, elemSize, libAlign);
308 test_use(ip);
309 free(ip);
310
311 ip = aalloc( dim );
312 test_base(ip, size, libAlign);
313 test_use(ip);
314 free(ip);
315
316 ip = aalloc( 0 );
317 test_base(ip, 0, libAlign);
318 test_use(ip);
319 free(ip);
320
321 ip = calloc( dim );
322 test_base(ip, size, libAlign);
323 test_fill(ip, 0, size, '\0');
324 test_use(ip);
325 free(ip);
326
327 ip = calloc( 0 );
328 test_base(ip, 0, libAlign);
329 test_use(ip);
330 free(ip);
331
332 ip = aalloc( dim );
333 ip = resize( ip, size / 4 );
334 test_base(ip, size / 4, libAlign);
335 test_use(ip);
336 free(ip);
337
338 ip = aalloc( dim );
339 ip = resize( ip, size * 4 );
340 test_base(ip, size * 4, libAlign);
341 test_use(ip);
342 free(ip);
343
344 ip = aalloc( dim );
345 ip = resize( ip, 0 );
346 test_base(ip, 0, libAlign);
347 test_use(ip);
348 free(ip);
349
350 ip = resize( (int*)0p, size );
351 test_base(ip, size, libAlign);
352 test_use(ip);
353 free(ip);
354
355 ip = resize( (int*)0p, size );
356 test_base(ip, size, libAlign);
357 test_use(ip);
358 free(ip);
359
360 ip = calloc( dim );
361 ip = realloc( ip, size / 4 );
362 test_base(ip, size / 4, libAlign);
363 test_fill(ip, 0, size / 4, '\0');
364 test_use(ip);
365 free(ip);
366
367 ip = calloc( dim );
368 ip = realloc( ip, size * 4 );
369 test_base(ip, size * 4, libAlign);
370 test_fill(ip, 0, size, '\0');
371 test_use(ip);
372 free(ip);
373
374 ip = calloc( dim );
375 ip = realloc( ip, 0 );
376 test_base(ip, 0, libAlign);
377 test_use(ip);
378 free(ip);
379
380 ip = realloc( (int*)0p, size );
381 test_base(ip, size , libAlign);
382 test_use(ip);
383 free(ip);
384
385 ip = realloc( (int*)0p, size );
386 test_base(ip, size, libAlign);
387 test_use(ip);
388 free(ip);
389
390 ip = memalign( align );
391 test_base(ip, elemSize, align);
392 test_use(ip);
393 free(ip);
394
395 ip = amemalign( align, dim );
396 test_base(ip, size, align);
397 test_use(ip);
398 free(ip);
399
400 ip = amemalign( align, 0 );
401 test_base(ip, 0, libAlign);
402 test_use(ip);
403 free(ip);
404
405 ip = cmemalign( align, dim );
406 test_base(ip, size, align);
407 test_fill(ip, 0, size, '\0');
408 test_use(ip);
409 free(ip);
410
411 ip = cmemalign( align, 0 );
412 test_base(ip, 0, libAlign);
413 test_use(ip);
414 free(ip);
415
416 ip = aligned_alloc( align );
417 test_base(ip, elemSize, align);
418 test_use(ip);
419 free(ip);
420
421 (int) posix_memalign( (int **) &ip, align );
422 test_base(ip, elemSize, align);
423 test_use(ip);
424 free(ip);
425
426 ip = valloc();
427 test_base(ip, elemSize, getpagesize());
428 test_use(ip);
429 free(ip);
430
431 ip = pvalloc();
432 test_base(ip, getpagesize(), getpagesize());
433 test_use(ip);
434 free(ip);
435
436 if (tests_failed == 0) printf("PASSED CFA malloc tests\n\n");
437 else printf("failed CFA malloc tests : %d/%d\n\n", tests_failed, tests_total);
438
439 // testing CFA malloc
440
441 elemSize = sizeof(T1);
442 size = dim * elemSize;
443 tests_total = 0;
444 tests_failed = 0;
445
446 tp = malloc();
447 test_base(tp, elemSize, tAlign );
448 test_use(tp);
449 free(tp);
450
451 tp = aalloc( dim );
452 test_base(tp, size, tAlign );
453 test_use(tp);
454 free(tp);
455
456 tp = aalloc( 0 );
457 test_base(tp, 0, libAlign);
458 test_use(tp);
459 free(tp);
460
461 tp = calloc( dim );
462 test_base(tp, size, tAlign );
463 test_fill(tp, 0, size, '\0');
464 test_use(tp);
465 free(tp);
466
467 tp = calloc( 0 );
468 test_base(tp, 0, libAlign);
469 test_use(tp);
470 free(tp);
471
472 tp = aalloc( dim );
473 tp = resize( tp, size / 4 );
474 test_base(tp, size / 4, tAlign );
475 test_use(tp);
476 free(tp);
477
478 tp = malloc();
479 tp = resize( tp, size * 4 );
480 test_base(tp, size * 4, tAlign );
481 test_use(tp);
482 free(tp);
483
484 tp = aalloc( dim );
485 tp = resize( tp, 0 );
486 test_base(tp, 0, libAlign);
487 test_use(tp);
488 free(tp);
489
490 tp = resize( (T1*)0p, size );
491 test_base(tp, size, tAlign );
492 test_use(tp);
493 free(tp);
494
495 tp = resize( (T1*)0p, size );
496 test_base(tp, size, tAlign );
497 test_use(tp);
498 free(tp);
499
500 tp = calloc( dim );
501 tp = realloc( tp, size / 4 );
502 test_base(tp, size / 4, tAlign );
503 test_fill(tp, 0, size / 4, '\0');
504 test_use(tp);
505 free(tp);
506
507 tp = calloc( dim );
508 tp = realloc( tp, size * 4 );
509 test_base(tp, size * 4, tAlign );
510 test_fill(tp, 0, size, '\0');
511 test_use(tp);
512 free(tp);
513
514 tp = calloc( dim );
515 tp = realloc( tp, 0 );
516 test_base(tp, 0, libAlign);
517 test_use(tp);
518 free(tp);
519
520/*
521 tp = realloc( (T1*)0p, size );
522 est_base(tp, size , tAlign );
523 est_use(tp);
524 free(tp);
525
526 tp = realloc( (T1*)0p, size );
527 est_base(tp, size, tAlign );
528 est_use(tp);
529 free(tp);
530*/
531
532 tp = memalign( align );
533 test_base(tp, elemSize, align);
534 test_use(tp);
535 free(tp);
536
537 tp = amemalign( align, dim );
538 test_base(tp, size, align);
539 test_use(tp);
540 free(tp);
541
542 tp = amemalign( align, 0 );
543 test_base(tp, 0, libAlign);
544 test_use(tp);
545 free(tp);
546
547 tp = cmemalign( align, dim );
548 test_base(tp, size, align);
549 test_fill(tp, 0, size, '\0');
550 test_use(tp);
551 free(tp);
552
553 tp = cmemalign( align, 0 );
554 test_base(tp, 0, libAlign);
555 test_use(tp);
556 free(tp);
557
558 tp = aligned_alloc( align );
559 test_base(tp, elemSize, align);
560 test_use(tp);
561 free(tp);
562
563 (int) posix_memalign( (T1 **) &tp, align );
564 test_base(tp, elemSize, align);
565 test_use(tp);
566 free(tp);
567
568 tp = valloc();
569 test_base(tp, elemSize, getpagesize());
570 test_use(tp);
571 free(tp);
572
573 tp = pvalloc();
574 test_base(tp, getpagesize(), getpagesize());
575 test_use(tp);
576 free(tp);
577
578 if (tests_failed == 0) printf("PASSED CFA malloc tests (aligned struct)\n\n");
579 else printf("failed CFA malloc tests (aligned struct) : %d/%d\n\n", tests_failed, tests_total);
580
581 return 0;
582}
Note: See TracBrowser for help on using the repository browser.