Context Navigation

source: tests/malloc.cfa@ c041d29

Visit:

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

Rev	Line
[116a2ea]	1	#include <fstream.hfa> // sout
[191a190]	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;
[116a2ea]	10	struct S1 { int data; } __attribute__(( aligned(32)));
[191a190]	11	typedef struct S1 T1;
	12
[116a2ea]	13	void test_base( void * ip, size_t size, size_t align ) {
[191a190]	14	tests_total += 1;
[116a2ea]	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 );
[191a190]	18	tests_failed += 1;
[116a2ea]	19	} // if
[191a190]	20	}
	21
[116a2ea]	22	void test_fill( void * ip_, size_t start, size_t end, char fill ) {
[191a190]	23	tests_total += 1;
	24	bool passed = true;
	25	char * ip = (char *) ip_;
[116a2ea]	26	for ( i; start ~ end ) passed = passed && (ip[i] == fill);
	27	if ( ! passed ) {
	28	sout \| "fill1 failed test" \| tests_total \| "fill C";
[191a190]	29	tests_failed += 1;
[116a2ea]	30	} // if
[191a190]	31	}
	32
[116a2ea]	33	void test_use( void * ip_ ) {
[191a190]	34	tests_total += 1;
	35	bool passed = true;
	36	int * ip = (int *) ip_;
[116a2ea]	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";
[191a190]	45	tests_failed += 1;
	46	}
	47	}
	48
	49	int main( void ) {
[116a2ea]	50	enum { dim = 8, align = 64, libAlign = libAlign() };
[191a190]	51	size_t elemSize = sizeof(int);
	52	size_t size = dim * elemSize;
	53	char fill = '\xde';
	54	int * ip;
	55	T1 * tp;
	56
[116a2ea]	57	// testing C malloc
[191a190]	58
	59	tests_total = 0;
	60	tests_failed = 0;
	61
[116a2ea]	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;
[191a190]	322
	323	// testing CFA malloc
	324
	325	tests_total = 0;
	326	tests_failed = 0;
	327
	328	ip = malloc();
[116a2ea]	329	test_base( ip, elemSize, libAlign );
	330	test_use( ip );
	331	free( ip );
[191a190]	332
	333	ip = aalloc( dim );
[116a2ea]	334	test_base( ip, size, libAlign );
	335	test_use( ip );
	336	free( ip );
[191a190]	337
	338	ip = aalloc( 0 );
[116a2ea]	339	test_base( ip, 0, libAlign );
	340	test_use( ip );
	341	free( ip );
[191a190]	342
	343	ip = calloc( dim );
[116a2ea]	344	test_base( ip, size, libAlign );
	345	test_fill( ip, 0, size, '\0' );
	346	test_use( ip );
	347	free( ip );
[191a190]	348
	349	ip = calloc( 0 );
[116a2ea]	350	test_base( ip, 0, libAlign );
	351	test_use( ip );
	352	free( ip );
[191a190]	353
	354	ip = aalloc( dim );
	355	ip = resize( ip, size / 4 );
[116a2ea]	356	test_base( ip, size / 4, libAlign );
	357	test_use( ip );
	358	free( ip );
[191a190]	359
	360	ip = aalloc( dim );
	361	ip = resize( ip, size * 4 );
[116a2ea]	362	test_base( ip, size * 4, libAlign );
	363	test_use( ip );
	364	free( ip );
[191a190]	365
	366	ip = aalloc( dim );
	367	ip = resize( ip, 0 );
[116a2ea]	368	test_base( ip, 0, libAlign );
	369	test_use( ip );
	370	free( ip );
[191a190]	371
[116a2ea]	372	ip = resize( 0p, size );
	373	test_base( ip, size, libAlign );
	374	test_use( ip );
	375	free( ip );
[191a190]	376
[116a2ea]	377	ip = resize( 0p, size );
	378	test_base( ip, size, libAlign );
	379	test_use( ip );
	380	free( ip );
[191a190]	381
	382	ip = calloc( dim );
	383	ip = realloc( ip, size / 4 );
[116a2ea]	384	test_base( ip, size / 4, libAlign );
	385	test_fill( ip, 0, size / 4, '\0' );
	386	test_use( ip );
	387	free( ip );
[191a190]	388
	389	ip = calloc( dim );
	390	ip = realloc( ip, size * 4 );
[116a2ea]	391	test_base( ip, size * 4, libAlign );
	392	test_fill( ip, 0, size, '\0' );
	393	test_use( ip );
	394	free( ip );
[191a190]	395
	396	ip = calloc( dim );
	397	ip = realloc( ip, 0 );
[116a2ea]	398	test_base( ip, 0, libAlign );
	399	test_use( ip );
	400	free( ip );
[191a190]	401
[116a2ea]	402	ip = realloc( 0p, size );
	403	test_base( ip, size , libAlign );
	404	test_use( ip );
	405	free( ip );
[191a190]	406
[116a2ea]	407	ip = realloc( 0p, size );
	408	test_base( ip, size, libAlign );
	409	test_use( ip );
	410	free( ip );
[191a190]	411
	412	ip = memalign( align );
[116a2ea]	413	test_base( ip, elemSize, align );
	414	test_use( ip );
	415	free( ip );
[191a190]	416
	417	ip = amemalign( align, dim );
[116a2ea]	418	test_base( ip, size, align );
	419	test_use( ip );
	420	free( ip );
[191a190]	421
	422	ip = amemalign( align, 0 );
[116a2ea]	423	test_base( ip, 0, libAlign );
	424	test_use( ip );
	425	free( ip );
[191a190]	426
	427	ip = cmemalign( align, dim );
[116a2ea]	428	test_base( ip, size, align );
	429	test_fill( ip, 0, size, '\0' );
	430	test_use( ip );
	431	free( ip );
[191a190]	432
	433	ip = cmemalign( align, 0 );
[116a2ea]	434	test_base( ip, 0, libAlign );
	435	test_use( ip );
	436	free( ip );
[191a190]	437
	438	ip = aligned_alloc( align );
[116a2ea]	439	test_base( ip, elemSize, align );
	440	test_use( ip );
	441	free( ip );
[191a190]	442
[116a2ea]	443	posix_memalign( (int **) &ip, align );
	444	test_base( ip, elemSize, align );
	445	test_use( ip );
	446	free( ip );
[191a190]	447
	448	ip = valloc();
[116a2ea]	449	test_base( ip, elemSize, getpagesize() );
	450	test_use( ip );
	451	free( ip );
[191a190]	452
	453	ip = pvalloc();
[116a2ea]	454	test_base( ip, getpagesize(), getpagesize() );
	455	test_use( ip );
	456	free( ip );
[191a190]	457
[116a2ea]	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;
[191a190]	460
[f76ff0b]	461	// testing CFA malloc with aligned struct
[191a190]	462
	463	elemSize = sizeof(T1);
	464	size = dim * elemSize;
	465	tests_total = 0;
	466	tests_failed = 0;
	467
	468	tp = malloc();
[116a2ea]	469	test_base( tp, elemSize, tAlign );
	470	test_use( tp );
	471	free( tp );
[191a190]	472
	473	tp = aalloc( dim );
[116a2ea]	474	test_base( tp, size, tAlign );
	475	test_use( tp );
	476	free( tp );
[191a190]	477
	478	tp = aalloc( 0 );
[116a2ea]	479	test_base( tp, 0, libAlign );
	480	test_use( tp );
	481	free( tp );
[191a190]	482
	483	tp = calloc( dim );
[116a2ea]	484	test_base( tp, size, tAlign );
	485	test_fill( tp, 0, size, '\0' );
	486	test_use( tp );
	487	free( tp );
[191a190]	488
	489	tp = calloc( 0 );
[116a2ea]	490	test_base( tp, 0, libAlign );
	491	test_use( tp );
	492	free( tp );
[191a190]	493
	494	tp = aalloc( dim );
	495	tp = resize( tp, size / 4 );
[116a2ea]	496	test_base( tp, size / 4, tAlign );
	497	test_use( tp );
	498	free( tp );
[191a190]	499
	500	tp = malloc();
	501	tp = resize( tp, size * 4 );
[116a2ea]	502	test_base( tp, size * 4, tAlign );
	503	test_use( tp );
	504	free( tp );
[191a190]	505
	506	tp = aalloc( dim );
	507	tp = resize( tp, 0 );
[116a2ea]	508	test_base( tp, 0, libAlign );
	509	test_use( tp );
	510	free( tp );
[191a190]	511
[68f0c4e]	512	tp = resize( (T1*)0p, size );
[116a2ea]	513	test_base( tp, size, tAlign );
	514	test_use( tp );
	515	free( tp );
[191a190]	516
[68f0c4e]	517	tp = resize( (T1*)0p, size );
[116a2ea]	518	test_base( tp, size, tAlign );
	519	test_use( tp );
	520	free( tp );
[191a190]	521
	522	tp = calloc( dim );
	523	tp = realloc( tp, size / 4 );
[116a2ea]	524	test_base( tp, size / 4, tAlign );
	525	test_fill( tp, 0, size / 4, '\0' );
	526	test_use( tp );
	527	free( tp );
[191a190]	528
	529	tp = calloc( dim );
	530	tp = realloc( tp, size * 4 );
[116a2ea]	531	test_base( tp, size * 4, tAlign );
	532	test_fill( tp, 0, size, '\0' );
	533	test_use( tp );
	534	free( tp );
[191a190]	535
	536	tp = calloc( dim );
	537	tp = realloc( tp, 0 );
[116a2ea]	538	test_base( tp, 0, libAlign );
	539	test_use( tp );
	540	free( tp );
[191a190]	541
[68f0c4e]	542	tp = realloc( (T1*)0p, size );
[116a2ea]	543	test_base( tp, size , tAlign );
	544	test_use( tp );
	545	free( tp );
[191a190]	546
[68f0c4e]	547	tp = realloc( (T1*)0p, size );
[116a2ea]	548	test_base( tp, size, tAlign );
	549	test_use( tp );
	550	free( tp );
[191a190]	551
	552	tp = memalign( align );
[116a2ea]	553	test_base( tp, elemSize, align );
	554	test_use( tp );
	555	free( tp );
[191a190]	556
	557	tp = amemalign( align, dim );
[116a2ea]	558	test_base( tp, size, align );
	559	test_use( tp );
	560	free( tp );
[191a190]	561
	562	tp = amemalign( align, 0 );
[116a2ea]	563	test_base( tp, 0, libAlign );
	564	test_use( tp );
	565	free( tp );
[191a190]	566
	567	tp = cmemalign( align, dim );
[116a2ea]	568	test_base( tp, size, align );
	569	test_fill( tp, 0, size, '\0' );
	570	test_use( tp );
	571	free( tp );
[191a190]	572
	573	tp = cmemalign( align, 0 );
[116a2ea]	574	test_base( tp, 0, libAlign );
	575	test_use( tp );
	576	free( tp );
[191a190]	577
	578	tp = aligned_alloc( align );
[116a2ea]	579	test_base( tp, elemSize, align );
	580	test_use( tp );
	581	free( tp );
[191a190]	582
[116a2ea]	583	posix_memalign( (T1 **)&tp, align );
	584	test_base( tp, elemSize, align );
	585	test_use( tp );
	586	free( tp );
[191a190]	587
	588	tp = valloc();
[116a2ea]	589	test_base( tp, elemSize, getpagesize() );
	590	test_use( tp );
	591	free( tp );
[191a190]	592
	593	tp = pvalloc();
[116a2ea]	594	test_base( tp, getpagesize(), getpagesize() );
	595	test_use( tp );
	596	free( tp );
[191a190]	597
[116a2ea]	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;
[f8acfc0]	600	}
[654d5a47]	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