Context Navigation

source: tests/malloc.cfa @ 4557bcf7

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since 4557bcf7 was 68f0c4e, checked in by m3zulfiq <m3zulfiq@…>, 4 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
9	int tests_total;
10	int tests_failed;
11	size_t tAlign = 32;
12	struct S1 { int d1; } __attribute__((aligned(32)));
13	typedef struct S1 T1;
14
15	void 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
24	void 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
35	void 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
51	int 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.

Download in other formats:

Original Format