source: tests/alloc.cfa@ ee0bfa9

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since ee0bfa9 was 6a25b8f, checked in by Peter A. Buhr <pabuhr@…>, 6 years ago

update allocation tests to reflect allocation changes, change from NULL to 0p, update expected values for changed tests
  • Property mode set to 100644
File size: 9.5 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 : Fri Nov 22 15:34:19 2019
13// Update Count : 404
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
23int * foo( int * p, int c ) { return p; }
24int * bar( int * p, int c ) { return p; }
25int * baz( int * p, int c ) { return p; }
26
27int 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 array alloc, fill %#hhx\n", fill );
51 printf( "CFA alloc, fill %08x\n", *p );
52 free( p );
53
54 p = alloc_set( 3 ); // CFA alloc, fill
55 printf( "CFA alloc, fill %d\n", *p );
56 free( p );
57
58
59 // allocation, array types
60 printf( "\n" );
61
62 p = (int *)calloc( dim, sizeof( *p ) ); // C array calloc, type unsafe
63 printf( "C array calloc, fill 0\n" );
64 for ( i; dim ) { printf( "%#x ", p[i] ); }
65 printf( "\n" );
66 free( p );
67
68 p = calloc( dim ); // CFA array calloc, type safe
69 printf( "CFA array calloc, fill 0\n" );
70 for ( i; dim ) { printf( "%#x ", p[i] ); }
71 printf( "\n" );
72 free( p );
73
74 p = alloc( dim ); // CFA array alloc, type safe
75 for ( i; dim ) { p[i] = 0xdeadbeef; }
76 printf( "CFA array alloc, no fill\n" );
77 for ( i; dim ) { printf( "%#x ", p[i] ); }
78 printf( "\n" );
79 free( p );
80
81 p = alloc_set( 2 * dim, fill ); // CFA array alloc, fill
82 printf( "CFA array alloc, fill %#hhx\n", fill );
83 for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
84 printf( "\n" );
85 free( p );
86
87 p = alloc_set( 2 * dim, 0xdeadbeef ); // CFA array alloc, fill
88 printf( "CFA array alloc, fill %#hhx\n", 0xdeadbeef );
89 for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
90 printf( "\n" );
91 // do not free
92
93 p1 = alloc_set( 2 * dim, p ); // CFA array alloc, fill
94 printf( "CFA array alloc, fill from array\n" );
95 for ( i; 2 * dim ) { printf( "%#x %#x, ", p[i], p1[i] ); }
96 free( p1 );
97 printf( "\n" );
98
99
100 // resize, non-array types
101 printf( "\n" );
102
103 p = (int *)realloc( p, dim * sizeof(*p) ); // C realloc
104 printf( "C realloc\n" );
105 for ( i; dim ) { printf( "%#x ", p[i] ); }
106 printf( "\n" );
107 // do not free
108
109 p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc
110 for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }
111 printf( "CFA realloc\n" );
112 for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
113 printf( "\n" );
114 // do not free
115
116
117 // resize, array types
118 printf( "\n" );
119
120 p = alloc( p, dim ); // CFA resize array alloc
121 for ( i; dim ) { p[i] = 0xdeadbeef; }
122 printf( "CFA resize array alloc\n" );
123 for ( i; dim ) { printf( "%#x ", p[i] ); }
124 printf( "\n" );
125 // do not free
126
127 p = alloc( p, 2 * dim ); // CFA resize array alloc
128 for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; } // fill upper part
129 printf( "CFA resize array alloc\n" );
130 for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
131 printf( "\n" );
132 // do not free
133
134 p = alloc( p, dim ); // CFA resize array alloc
135 printf( "CFA resize array alloc\n" );
136 for ( i; dim ) { printf( "%#x ", p[i] ); }
137 printf( "\n" );
138 // do not free
139
140 p = alloc_set( p, 3 * dim, fill ); // CFA resize array alloc, fill
141 printf( "CFA resize array alloc\n" );
142 for ( i; 3 * dim ) { printf( "%#x ", p[i] ); }
143 printf( "\n" );
144 // do not free
145
146 p = alloc_set( p, dim, fill ); // CFA resize array alloc, fill
147 printf( "CFA resize array alloc\n" );
148 for ( i; dim ) { printf( "%#x ", p[i] ); }
149 printf( "\n" );
150 // do not free
151
152 p = alloc_set( p, 3 * dim, fill ); // CFA resize array alloc, fill
153 printf( "CFA resize array alloc, fill\n" );
154 for ( i; 3 * dim ) { printf( "%#x ", p[i] );; }
155 printf( "\n" );
156 free( p );
157
158
159 struct Struct { int x; double y; };
160 Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
161
162 // alignment, non-array types
163 printf( "\n" );
164 enum { Alignment = 128 };
165
166 stp = &(*(Struct*)memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
167 assert( (uintptr_t)stp % Alignment == 0 );
168 printf( "C memalign %d %g\n", stp->x, stp->y );
169 free( stp );
170
171 stp = &(*memalign( Alignment )){ 42, 42.5 }; // CFA memalign
172 assert( (uintptr_t)stp % Alignment == 0 );
173 printf( "CFA memalign %d %g\n", stp->x, stp->y );
174 free( stp );
175
176 posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign
177 *stp = (Struct){ 42, 42.5 };
178 assert( (uintptr_t)stp % Alignment == 0 );
179 printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
180 free( stp );
181
182 posix_memalign( &stp, Alignment ); // CFA posix_memalign
183 *stp = (Struct){ 42, 42.5 };
184 assert( (uintptr_t)stp % Alignment == 0 );
185 printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
186 free( stp );
187
188 stp = &(*alloc_align( Alignment)){ 42, 42.5 }; // CFA alloc_align
189 assert( (uintptr_t)stp % Alignment == 0 );
190 printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
191 free( stp );
192
193 stp = &(*alloc_align( Alignment )){ 42, 42.5 }; // CFA alloc_align
194 assert( (uintptr_t)stp % Alignment == 0 );
195 printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
196 free( stp );
197
198 stp = alloc_align_set( Alignment, fill ); // CFA memalign, fill
199 assert( (uintptr_t)stp % Alignment == 0 );
200 printf( "CFA alloc_align fill %#x %a\n", stp->x, stp->y );
201 free( stp );
202
203 stp = alloc_align_set( Alignment, (Struct){ 42, 42.5 } ); // CFA memalign, fill
204 assert( (uintptr_t)stp % Alignment == 0 );
205 printf( "CFA alloc_align fill %d %g\n", stp->x, stp->y );
206 // do not free
207
208 stp = &(*alloc_align( stp, 4096 )){ 42, 42.5 }; // CFA realign
209 assert( (uintptr_t)stp % 4096 == 0 );
210 printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
211 free( stp );
212
213
214 // alignment, array types
215 printf( "\n" );
216
217 stp = alloc_align( Alignment, dim ); // CFA array memalign
218 assert( (uintptr_t)stp % Alignment == 0 );
219 for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
220 printf( "CFA array alloc_align\n" );
221 for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
222 printf( "\n" );
223 free( stp );
224
225 stp = alloc_align_set( Alignment, dim, fill ); // CFA array memalign, fill
226 assert( (uintptr_t)stp % Alignment == 0 );
227 printf( "CFA array alloc_align, fill\n" );
228 for ( i; dim ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
229 printf( "\n" );
230 free( stp );
231
232 stp = alloc_align_set( Alignment, dim, (Struct){ 42, 42.5 } ); // CFA array memalign, fill
233 assert( (uintptr_t)stp % Alignment == 0 );
234 printf( "CFA array alloc_align, fill\n" );
235 for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
236 printf( "\n" );
237 // do not free
238
239 stp1 = alloc_align_set( Alignment, dim, stp ); // CFA array memalign, fill
240 assert( (uintptr_t)stp % Alignment == 0 );
241 printf( "CFA array alloc_align, fill array\n" );
242 for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
243 printf( "\n" );
244 free( stp1 );
245
246 stp = alloc_align( stp, 4096, dim ); // CFA aligned realloc array
247 assert( (uintptr_t)stp % 4096 == 0 );
248 for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
249 printf( "CFA realloc array alloc_align\n" );
250 for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
251 printf( "\n" );
252 free( stp );
253
254
255 // data, non-array types
256 printf( "\n" );
257
258 memset( &st, fill ); // CFA memset, type safe
259 printf( "CFA memset %#x %a\n", st.x, st.y );
260 memcpy( &st1, &st ); // CFA memcpy, type safe
261 printf( "CFA memcpy %#x %a\n", st1.x, st1.y );
262
263
264 // data, array types
265 printf( "\n" );
266
267 amemset( sta, fill, dim ); // CFA array memset, type safe
268 printf( "CFA array memset\n" );
269 for ( i; dim ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
270 printf( "\n" );
271
272 amemcpy( sta1, sta, dim ); // CFA array memcpy, type safe
273 printf( "CFA array memcpy\n" );
274 for ( i; dim ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
275 printf( "\n" );
276
277
278 // new, non-array types
279 printf( "\n" );
280
281 stp = new( 42, 42.5 );
282 stp1 = new( 42, 42.5 );
283 printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y );
284 delete( stp, stp1 );
285
286 // new, array types
287 stp = anew( dim, 42, 42.5 );
288 printf( "CFA array new initialize\n" );
289 for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
290 printf( "\n" );
291 stp1 = anew( dim, 42, 42.5 );
292 for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
293 printf( "\n" );
294 adelete( dim, stp, dim, stp1 );
295
296 // extras
297 printf( "\n" );
298
299 float * fp = malloc() + 1;
300 printf( "pointer arithmetic %d\n", fp == fp - 1 );
301 free( fp - 1 );
302
303 p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
304 *p = 0xdeadbeef;
305 printf( "CFA deep malloc %#x\n", *p );
306 free( p );
307
308#ifdef ERR1
309 stp = malloc();
310 printf( "\nSHOULD FAIL\n" );
311 p = realloc( stp, dim * sizeof( *stp ) );
312 p = alloc( stp, dim * sizeof( *stp ) );
313 p = memset( stp, 10 );
314 p = memcpy( &st1, &st );
315#endif
316} // main
317
318// Local Variables: //
319// tab-width: 4 //
320// compile-command: "cfa alloc.cfa" //
321// End: //
Note: See TracBrowser for help on using the repository browser.