Context Navigation

source: tests/malloc.cfa @ d2b94f2

ADTast-experimental

Last change on this file since d2b94f2 was 116a2ea, checked in by Peter A. Buhr <pabuhr@…>, 2 years ago
new heap and associated tests updated
Property mode set to `100644`
File size: 13.0 KB

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

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

Download in other formats:

Original Format