Context Navigation

source: tests/malloc.cfa @ 262c600

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

Last change on this file since 262c600 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

Rev	Line
[191a190]	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
[f76ff0b]	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
[191a190]	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
[f76ff0b]	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
[191a190]	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
[10d609a]	321	free( 0p ); // sanity check
[191a190]	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
[68f0c4e]	376	ip = resize( (int*)0p, size );
[191a190]	377	test_base(ip, size, libAlign);
	378	test_use(ip);
	379	free(ip);
	380
[68f0c4e]	381	ip = resize( (int*)0p, size );
[191a190]	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
[68f0c4e]	406	ip = realloc( (int*)0p, size );
[191a190]	407	test_base(ip, size , libAlign);
	408	test_use(ip);
	409	free(ip);
	410
[68f0c4e]	411	ip = realloc( (int*)0p, size );
[191a190]	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
[f76ff0b]	465	// testing CFA malloc with aligned struct
[191a190]	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
[68f0c4e]	516	tp = resize( (T1*)0p, size );
[191a190]	517	test_base(tp, size, tAlign );
	518	test_use(tp);
	519	free(tp);
	520
[68f0c4e]	521	tp = resize( (T1*)0p, size );
[191a190]	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
[68f0c4e]	546	tp = realloc( (T1*)0p, size );
[f8acfc0]	547	test_base(tp, size , tAlign );
	548	test_use(tp);
[191a190]	549	free(tp);
	550
[68f0c4e]	551	tp = realloc( (T1*)0p, size );
[f8acfc0]	552	test_base(tp, size, tAlign );
	553	test_use(tp);
[191a190]	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
[68f0c4e]	587	(int) posix_memalign( (T1 **) &tp, align );
[191a190]	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;
[f8acfc0]	606	}
[654d5a47]	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