Context Navigation

source: tests/malloc.cfa @ 4f89e7b

ADTast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since 4f89e7b was 10d609a, checked in by Peter A. Buhr <pabuhr@…>, 4 years ago
allow free( 0p )
Property mode set to `100644`
File size: 13.2 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, libAlign, size / 2 );
255	test_base(ip, size / 2, libAlign);
256	test_use(ip);
257	free(ip);
258
259	ip = (int ) (void ) aligned_alloc( align, size );
260	ip = (int ) (void ) resize( (void *) ip, align, size / 2 );
261	test_base(ip, size / 2, align);
262	test_use(ip);
263	free(ip);
264
265	ip = (int ) (void ) malloc( size );
266	ip = (int ) (void ) resize( (void *) ip, align, size / 4 );
267	test_base(ip, size / 4, align);
268	test_use(ip);
269	free(ip);
270
271	ip = (int ) (void ) malloc( size );
272	ip = (int ) (void ) resize( (void *) ip, align, 0 );
273	test_base(ip, 0, libAlign);
274	test_use(ip);
275	free(ip);
276
277	ip = (int ) (void ) resize( NULL, align, size );
278	test_base(ip, size, align);
279	test_use(ip);
280	free(ip);
281
282	ip = (int ) (void ) resize( 0p, align, size );
283	test_base(ip, size, align);
284	test_use(ip);
285	free(ip);
286
287	ip = (int ) (void ) calloc( dim, elemSize );
288	ip = (int ) (void ) realloc( (void *) ip, libAlign, size / 2 );
289	test_base(ip, size / 2, libAlign);
290	test_fill(ip, 0, size / 2, '\0');
291	test_use(ip);
292	free(ip);
293
294	ip = (int ) (void ) cmemalign( align, dim, elemSize );
295	ip = (int ) (void ) realloc( (void *) ip, align, size / 2 );
296	test_base(ip, size / 2, align);
297	test_fill(ip, 0, size / 2, '\0');
298	test_use(ip);
299	free(ip);
300
301	ip = (int ) (void ) calloc( dim, elemSize );
302	ip = (int ) (void ) realloc( (void *) ip, align, size / 4 );
303	test_base(ip, size / 4, align);
304	test_fill(ip, 0, size / 4, '\0');
305	test_use(ip);
306	free(ip);
307
308	ip = (int ) (void ) calloc( dim, elemSize );
309	ip = (int ) (void ) realloc( (void ) ip, 0, size 4 );
310	test_base(ip, size * 4, libAlign);
311	test_fill(ip, 0, size * 4, '\0');
312	test_use(ip);
313	free(ip);
314
315	ip = (int ) (void ) calloc( dim, elemSize );
316	ip = (int ) (void ) realloc( (void *) ip, align, 0 );
317	test_base(ip, 0, libAlign);
318	test_use(ip);
319	free(ip);
320
321	free( 0p ); // sanity check
322	free( NULL ); // sanity check
323
324	if (tests_failed == 0) printf("PASSED C malloc tests\n\n");
325	else printf("failed C malloc tests : %d/%d\n\n", tests_failed, tests_total);
326
327	// testing CFA malloc
328
329	tests_total = 0;
330	tests_failed = 0;
331
332	ip = malloc();
333	test_base(ip, elemSize, libAlign);
334	test_use(ip);
335	free(ip);
336
337	ip = aalloc( dim );
338	test_base(ip, size, libAlign);
339	test_use(ip);
340	free(ip);
341
342	ip = aalloc( 0 );
343	test_base(ip, 0, libAlign);
344	test_use(ip);
345	free(ip);
346
347	ip = calloc( dim );
348	test_base(ip, size, libAlign);
349	test_fill(ip, 0, size, '\0');
350	test_use(ip);
351	free(ip);
352
353	ip = calloc( 0 );
354	test_base(ip, 0, libAlign);
355	test_use(ip);
356	free(ip);
357
358	ip = aalloc( dim );
359	ip = resize( ip, size / 4 );
360	test_base(ip, size / 4, libAlign);
361	test_use(ip);
362	free(ip);
363
364	ip = aalloc( dim );
365	ip = resize( ip, size * 4 );
366	test_base(ip, size * 4, libAlign);
367	test_use(ip);
368	free(ip);
369
370	ip = aalloc( dim );
371	ip = resize( ip, 0 );
372	test_base(ip, 0, libAlign);
373	test_use(ip);
374	free(ip);
375
376	ip = resize( (int*)0p, size );
377	test_base(ip, size, libAlign);
378	test_use(ip);
379	free(ip);
380
381	ip = resize( (int*)0p, size );
382	test_base(ip, size, libAlign);
383	test_use(ip);
384	free(ip);
385
386	ip = calloc( dim );
387	ip = realloc( ip, size / 4 );
388	test_base(ip, size / 4, libAlign);
389	test_fill(ip, 0, size / 4, '\0');
390	test_use(ip);
391	free(ip);
392
393	ip = calloc( dim );
394	ip = realloc( ip, size * 4 );
395	test_base(ip, size * 4, libAlign);
396	test_fill(ip, 0, size, '\0');
397	test_use(ip);
398	free(ip);
399
400	ip = calloc( dim );
401	ip = realloc( ip, 0 );
402	test_base(ip, 0, libAlign);
403	test_use(ip);
404	free(ip);
405
406	ip = realloc( (int*)0p, size );
407	test_base(ip, size , libAlign);
408	test_use(ip);
409	free(ip);
410
411	ip = realloc( (int*)0p, size );
412	test_base(ip, size, libAlign);
413	test_use(ip);
414	free(ip);
415
416	ip = memalign( align );
417	test_base(ip, elemSize, align);
418	test_use(ip);
419	free(ip);
420
421	ip = amemalign( align, dim );
422	test_base(ip, size, align);
423	test_use(ip);
424	free(ip);
425
426	ip = amemalign( align, 0 );
427	test_base(ip, 0, libAlign);
428	test_use(ip);
429	free(ip);
430
431	ip = cmemalign( align, dim );
432	test_base(ip, size, align);
433	test_fill(ip, 0, size, '\0');
434	test_use(ip);
435	free(ip);
436
437	ip = cmemalign( align, 0 );
438	test_base(ip, 0, libAlign);
439	test_use(ip);
440	free(ip);
441
442	ip = aligned_alloc( align );
443	test_base(ip, elemSize, align);
444	test_use(ip);
445	free(ip);
446
447	(int) posix_memalign( (int **) &ip, align );
448	test_base(ip, elemSize, align);
449	test_use(ip);
450	free(ip);
451
452	ip = valloc();
453	test_base(ip, elemSize, getpagesize());
454	test_use(ip);
455	free(ip);
456
457	ip = pvalloc();
458	test_base(ip, getpagesize(), getpagesize());
459	test_use(ip);
460	free(ip);
461
462	if (tests_failed == 0) printf("PASSED CFA malloc tests\n\n");
463	else printf("failed CFA malloc tests : %d/%d\n\n", tests_failed, tests_total);
464
465	// testing CFA malloc with aligned struct
466
467	elemSize = sizeof(T1);
468	size = dim * elemSize;
469	tests_total = 0;
470	tests_failed = 0;
471
472	tp = malloc();
473	test_base(tp, elemSize, tAlign );
474	test_use(tp);
475	free(tp);
476
477	tp = aalloc( dim );
478	test_base(tp, size, tAlign );
479	test_use(tp);
480	free(tp);
481
482	tp = aalloc( 0 );
483	test_base(tp, 0, libAlign);
484	test_use(tp);
485	free(tp);
486
487	tp = calloc( dim );
488	test_base(tp, size, tAlign );
489	test_fill(tp, 0, size, '\0');
490	test_use(tp);
491	free(tp);
492
493	tp = calloc( 0 );
494	test_base(tp, 0, libAlign);
495	test_use(tp);
496	free(tp);
497
498	tp = aalloc( dim );
499	tp = resize( tp, size / 4 );
500	test_base(tp, size / 4, tAlign );
501	test_use(tp);
502	free(tp);
503
504	tp = malloc();
505	tp = resize( tp, size * 4 );
506	test_base(tp, size * 4, tAlign );
507	test_use(tp);
508	free(tp);
509
510	tp = aalloc( dim );
511	tp = resize( tp, 0 );
512	test_base(tp, 0, libAlign);
513	test_use(tp);
514	free(tp);
515
516	tp = resize( (T1*)0p, size );
517	test_base(tp, size, tAlign );
518	test_use(tp);
519	free(tp);
520
521	tp = resize( (T1*)0p, size );
522	test_base(tp, size, tAlign );
523	test_use(tp);
524	free(tp);
525
526	tp = calloc( dim );
527	tp = realloc( tp, size / 4 );
528	test_base(tp, size / 4, tAlign );
529	test_fill(tp, 0, size / 4, '\0');
530	test_use(tp);
531	free(tp);
532
533	tp = calloc( dim );
534	tp = realloc( tp, size * 4 );
535	test_base(tp, size * 4, tAlign );
536	test_fill(tp, 0, size, '\0');
537	test_use(tp);
538	free(tp);
539
540	tp = calloc( dim );
541	tp = realloc( tp, 0 );
542	test_base(tp, 0, libAlign);
543	test_use(tp);
544	free(tp);
545
546	tp = realloc( (T1*)0p, size );
547	test_base(tp, size , tAlign );
548	test_use(tp);
549	free(tp);
550
551	tp = realloc( (T1*)0p, size );
552	test_base(tp, size, tAlign );
553	test_use(tp);
554	free(tp);
555
556	tp = memalign( align );
557	test_base(tp, elemSize, align);
558	test_use(tp);
559	free(tp);
560
561	tp = amemalign( align, dim );
562	test_base(tp, size, align);
563	test_use(tp);
564	free(tp);
565
566	tp = amemalign( align, 0 );
567	test_base(tp, 0, libAlign);
568	test_use(tp);
569	free(tp);
570
571	tp = cmemalign( align, dim );
572	test_base(tp, size, align);
573	test_fill(tp, 0, size, '\0');
574	test_use(tp);
575	free(tp);
576
577	tp = cmemalign( align, 0 );
578	test_base(tp, 0, libAlign);
579	test_use(tp);
580	free(tp);
581
582	tp = aligned_alloc( align );
583	test_base(tp, elemSize, align);
584	test_use(tp);
585	free(tp);
586
587	(int) posix_memalign( (T1 **) &tp, align );
588	test_base(tp, elemSize, align);
589	test_use(tp);
590	free(tp);
591
592	tp = valloc();
593	test_base(tp, elemSize, getpagesize());
594	test_use(tp);
595	free(tp);
596
597	tp = pvalloc();
598	test_base(tp, getpagesize(), getpagesize());
599	test_use(tp);
600	free(tp);
601
602	if (tests_failed == 0) printf("PASSED CFA malloc tests (aligned struct)\n\n");
603	else printf("failed CFA malloc tests (aligned struct) : %d/%d\n\n", tests_failed, tests_total);
604
605	return 0;
606	}
607
608	// Local Variables: //
609	// tab-width: 4 //
610	// compile-command: "cfa malloc.cfa" //
611	// End: //

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format