Context Navigation

source: tests/alloc.cfa @ 136f86b

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

Last change on this file since 136f86b was 8725c74, checked in by Peter A. Buhr <pabuhr@…>, 5 years ago
remove unnecessary print
Property mode set to `100644`
File size: 9.4 KB

Line
1	//
2	// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3	//
4	// The contents of this file are covered under the licence agreement in the
5	// file "LICENCE" distributed with Cforall.
6	//
7	// alloc.cfa --
8	//
9	// Author : Peter A. Buhr
10	// Created On : Wed Feb 3 07:56:22 2016
11	// Last Modified By : Peter A. Buhr
12	// Last Modified On : Sun Feb 16 09:21:13 2020
13	// Update Count : 405
14	//
15
16	#include <assert.h>
17	#include <malloc.h> // malloc_usable_size
18	#include <stdint.h> // uintptr_t
19	#include <stdlib.h> // posix_memalign
20	#include <fstream.hfa>
21	#include <stdlib.hfa> // access C malloc, realloc
22
23	int * foo( int * p, int c ) { return p; }
24	int * bar( int * p, int c ) { return p; }
25	int * baz( int * p, int c ) { return p; }
26
27	int main( void ) {
28	size_t dim = 10;
29	char fill = '\xde';
30	int * p, * p1;
31
32	// allocation, non-array types
33
34	p = (int )malloc( sizeof(p) ); // C malloc, type unsafe
35	*p = 0xdeadbeef;
36	printf( "C malloc %#x\n", *p );
37	free( p );
38
39	p = malloc(); // CFA malloc, type safe
40	*p = 0xdeadbeef;
41	printf( "CFA malloc %#x\n", *p );
42	free( p );
43
44	p = alloc(); // CFA alloc, type safe
45	*p = 0xdeadbeef;
46	printf( "CFA alloc %#x\n", *p );
47	free( p );
48
49	p = alloc_set( fill ); // CFA alloc, fill
50	printf( "CFA alloc, fill %08x\n", *p );
51	free( p );
52
53	p = alloc_set( 3 ); // CFA alloc, fill
54	printf( "CFA alloc, fill %d\n", *p );
55	free( p );
56
57
58	// allocation, array types
59	printf( "\n" );
60
61	p = (int )calloc( dim, sizeof( p ) ); // C array calloc, type unsafe
62	printf( "C array calloc, fill 0\n" );
63	for ( i; dim ) { printf( "%#x ", p[i] ); }
64	printf( "\n" );
65	free( p );
66
67	p = calloc( dim ); // CFA array calloc, type safe
68	printf( "CFA array calloc, fill 0\n" );
69	for ( i; dim ) { printf( "%#x ", p[i] ); }
70	printf( "\n" );
71	free( p );
72
73	p = alloc( dim ); // CFA array alloc, type safe
74	for ( i; dim ) { p[i] = 0xdeadbeef; }
75	printf( "CFA array alloc, no fill\n" );
76	for ( i; dim ) { printf( "%#x ", p[i] ); }
77	printf( "\n" );
78	free( p );
79
80	p = alloc_set( 2 * dim, fill ); // CFA array alloc, fill
81	printf( "CFA array alloc, fill %#hhx\n", fill );
82	for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
83	printf( "\n" );
84	free( p );
85
86	p = alloc_set( 2 * dim, 0xdeadbeef ); // CFA array alloc, fill
87	printf( "CFA array alloc, fill %#hhx\n", 0xdeadbeef );
88	for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
89	printf( "\n" );
90	// do not free
91
92	p1 = alloc_set( 2 * dim, p ); // CFA array alloc, fill
93	printf( "CFA array alloc, fill from array\n" );
94	for ( i; 2 * dim ) { printf( "%#x %#x, ", p[i], p1[i] ); }
95	free( p1 );
96	printf( "\n" );
97
98
99	// resize, non-array types
100	printf( "\n" );
101
102	p = (int )realloc( p, dim sizeof(*p) ); // C realloc
103	printf( "C realloc\n" );
104	for ( i; dim ) { printf( "%#x ", p[i] ); }
105	printf( "\n" );
106	// do not free
107
108	p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc
109	for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }
110	printf( "CFA realloc\n" );
111	for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
112	printf( "\n" );
113	// do not free
114
115
116	// resize, array types
117	printf( "\n" );
118
119	p = alloc( p, dim ); // CFA resize array alloc
120	for ( i; dim ) { p[i] = 0xdeadbeef; }
121	printf( "CFA resize array alloc\n" );
122	for ( i; dim ) { printf( "%#x ", p[i] ); }
123	printf( "\n" );
124	// do not free
125
126	p = alloc( p, 2 * dim ); // CFA resize array alloc
127	for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; } // fill upper part
128	printf( "CFA resize array alloc\n" );
129	for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
130	printf( "\n" );
131	// do not free
132
133	p = alloc( p, dim ); // CFA resize array alloc
134	printf( "CFA resize array alloc\n" );
135	for ( i; dim ) { printf( "%#x ", p[i] ); }
136	printf( "\n" );
137	// do not free
138
139	p = alloc_set( p, 3 * dim, fill ); // CFA resize array alloc, fill
140	printf( "CFA resize array alloc\n" );
141	for ( i; 3 * dim ) { printf( "%#x ", p[i] ); }
142	printf( "\n" );
143	// do not free
144
145	p = alloc_set( p, dim, fill ); // CFA resize array alloc, fill
146	printf( "CFA resize array alloc\n" );
147	for ( i; dim ) { printf( "%#x ", p[i] ); }
148	printf( "\n" );
149	// do not free
150
151	p = alloc_set( p, 3 * dim, fill ); // CFA resize array alloc, fill
152	printf( "CFA resize array alloc, fill\n" );
153	for ( i; 3 * dim ) { printf( "%#x ", p[i] );; }
154	printf( "\n" );
155	free( p );
156
157
158	struct Struct { int x; double y; };
159	Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
160
161	// alignment, non-array types
162	printf( "\n" );
163	enum { Alignment = 128 };
164
165	stp = &((Struct)memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
166	assert( (uintptr_t)stp % Alignment == 0 );
167	printf( "C memalign %d %g\n", stp->x, stp->y );
168	free( stp );
169
170	stp = &(*memalign( Alignment )){ 42, 42.5 }; // CFA memalign
171	assert( (uintptr_t)stp % Alignment == 0 );
172	printf( "CFA memalign %d %g\n", stp->x, stp->y );
173	free( stp );
174
175	posix_memalign( (void *)&stp, Alignment, sizeof( stp ) ); // C posix_memalign
176	*stp = (Struct){ 42, 42.5 };
177	assert( (uintptr_t)stp % Alignment == 0 );
178	printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
179	free( stp );
180
181	posix_memalign( &stp, Alignment ); // CFA posix_memalign
182	*stp = (Struct){ 42, 42.5 };
183	assert( (uintptr_t)stp % Alignment == 0 );
184	printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
185	free( stp );
186
187	stp = &(*alloc_align( Alignment)){ 42, 42.5 }; // CFA alloc_align
188	assert( (uintptr_t)stp % Alignment == 0 );
189	printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
190	free( stp );
191
192	stp = &(*alloc_align( Alignment )){ 42, 42.5 }; // CFA alloc_align
193	assert( (uintptr_t)stp % Alignment == 0 );
194	printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
195	free( stp );
196
197	stp = alloc_align_set( Alignment, fill ); // CFA memalign, fill
198	assert( (uintptr_t)stp % Alignment == 0 );
199	printf( "CFA alloc_align fill %#x %a\n", stp->x, stp->y );
200	free( stp );
201
202	stp = alloc_align_set( Alignment, (Struct){ 42, 42.5 } ); // CFA memalign, fill
203	assert( (uintptr_t)stp % Alignment == 0 );
204	printf( "CFA alloc_align fill %d %g\n", stp->x, stp->y );
205	// do not free
206
207	stp = &(*alloc_align( stp, 4096 )){ 42, 42.5 }; // CFA realign
208	assert( (uintptr_t)stp % 4096 == 0 );
209	printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
210	free( stp );
211
212
213	// alignment, array types
214	printf( "\n" );
215
216	stp = alloc_align( Alignment, dim ); // CFA array memalign
217	assert( (uintptr_t)stp % Alignment == 0 );
218	for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
219	printf( "CFA array alloc_align\n" );
220	for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
221	printf( "\n" );
222	free( stp );
223
224	stp = alloc_align_set( Alignment, dim, fill ); // CFA array memalign, fill
225	assert( (uintptr_t)stp % Alignment == 0 );
226	printf( "CFA array alloc_align, fill\n" );
227	for ( i; dim ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
228	printf( "\n" );
229	free( stp );
230
231	stp = alloc_align_set( Alignment, dim, (Struct){ 42, 42.5 } ); // CFA array memalign, fill
232	assert( (uintptr_t)stp % Alignment == 0 );
233	printf( "CFA array alloc_align, fill\n" );
234	for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
235	printf( "\n" );
236	// do not free
237
238	stp1 = alloc_align_set( Alignment, dim, stp ); // CFA array memalign, fill
239	assert( (uintptr_t)stp % Alignment == 0 );
240	printf( "CFA array alloc_align, fill array\n" );
241	for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
242	printf( "\n" );
243	free( stp1 );
244
245	stp = alloc_align( stp, 4096, dim ); // CFA aligned realloc array
246	assert( (uintptr_t)stp % 4096 == 0 );
247	for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
248	printf( "CFA realloc array alloc_align\n" );
249	for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
250	printf( "\n" );
251	free( stp );
252
253
254	// data, non-array types
255	printf( "\n" );
256
257	memset( &st, fill ); // CFA memset, type safe
258	printf( "CFA memset %#x %a\n", st.x, st.y );
259	memcpy( &st1, &st ); // CFA memcpy, type safe
260	printf( "CFA memcpy %#x %a\n", st1.x, st1.y );
261
262
263	// data, array types
264	printf( "\n" );
265
266	amemset( sta, fill, dim ); // CFA array memset, type safe
267	printf( "CFA array memset\n" );
268	for ( i; dim ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
269	printf( "\n" );
270
271	amemcpy( sta1, sta, dim ); // CFA array memcpy, type safe
272	printf( "CFA array memcpy\n" );
273	for ( i; dim ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
274	printf( "\n" );
275
276
277	// new, non-array types
278	printf( "\n" );
279
280	stp = new( 42, 42.5 );
281	stp1 = new( 42, 42.5 );
282	printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y );
283	delete( stp, stp1 );
284
285	// new, array types
286	stp = anew( dim, 42, 42.5 );
287	printf( "CFA array new initialize\n" );
288	for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
289	printf( "\n" );
290	stp1 = anew( dim, 42, 42.5 );
291	for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
292	printf( "\n" );
293	adelete( dim, stp, dim, stp1 );
294
295	// extras
296	printf( "\n" );
297
298	float * fp = malloc() + 1;
299	printf( "pointer arithmetic %d\n", fp == fp - 1 );
300	free( fp - 1 );
301
302	p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
303	*p = 0xdeadbeef;
304	printf( "CFA deep malloc %#x\n", *p );
305	free( p );
306
307	#ifdef ERR1
308	stp = malloc();
309	printf( "\nSHOULD FAIL\n" );
310	p = realloc( stp, dim * sizeof( *stp ) );
311	p = alloc( stp, dim * sizeof( *stp ) );
312	p = memset( stp, 10 );
313	p = memcpy( &st1, &st );
314	#endif
315	} // main
316
317	// Local Variables: //
318	// tab-width: 4 //
319	// compile-command: "cfa alloc.cfa" //
320	// End: //

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

Download in other formats:

Original Format