source: tests/malloc.cfa @ 68f0c4e

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 68f0c4e was 68f0c4e, checked in by m3zulfiq <m3zulfiq@…>, 15 months 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.