source: src/tests/alloc.c@ 934d200

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum with_gc
Last change on this file since 934d200 was 6ea0408, checked in by Peter A. Buhr <pabuhr@…>, 8 years ago

fixed format and output for printing fill character
  • Property mode set to 100644
File size: 8.3 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.c --
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 Feb 16 15:42:31 2018
13// Update Count : 330
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>
21#include <stdlib> // 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 = '\xff';
30 int * p;
31
32 // allocation, non-array types
33
34 // int & r = malloc();
35 // r = 0xdeadbeef;
36 // printf( "C malloc %#x\n", r );
37 // free( &r );
38
39 p = (int *)malloc( sizeof(*p) ); // C malloc, type unsafe
40 *p = 0xdeadbeef;
41 printf( "C malloc %#x\n", *p );
42 free( p );
43
44 p = malloc(); // CFA malloc, type safe
45 *p = 0xdeadbeef;
46 printf( "CFA malloc %#x\n", *p );
47 free( p );
48
49 p = alloc(); // CFA alloc, type safe
50 *p = 0xdeadbeef;
51 printf( "CFA alloc %#x\n", *p );
52 free( p );
53
54 p = alloc( fill ); // CFA alloc, fill
55 printf( "CFA alloc, fill %08x\n", *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 ( int i = 0; i < dim; i += 1 ) { 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 ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
70 printf( "\n" );
71 free( p );
72
73 p = alloc( dim ); // CFA array alloc, type safe
74 for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
75 printf( "CFA array alloc, no fill\n" );
76 for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
77 printf( "\n" );
78 free( p );
79
80 p = alloc( 2 * dim, fill ); // CFA array alloc, fill
81 printf( "CFA array alloc, fill %#hhx\n", fill );
82 for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
83 printf( "\n" );
84 // do not free
85
86
87 // resize, non-array types
88 printf( "\n" );
89
90 p = (int *)realloc( p, dim * sizeof(*p) ); // C realloc
91 for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
92 printf( "C realloc\n" );
93 for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
94 printf( "\n" );
95
96 p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc
97 for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
98 printf( "CFA realloc\n" );
99 for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
100 printf( "\n" );
101 // do not free
102
103
104 // resize, array types
105 printf( "\n" );
106
107 p = alloc( p, dim ); // CFA resize array alloc
108 for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
109 printf( "CFA resize alloc\n" );
110 for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
111 printf( "\n" );
112
113 p = alloc( p, 2 * dim ); // CFA resize array alloc
114 for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
115 printf( "CFA resize array alloc\n" );
116 for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
117 printf( "\n" );
118
119 p = alloc( p, dim ); // CFA array alloc
120 printf( "CFA resize array alloc\n" );
121 for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
122 printf( "\n" );
123
124 free( p );
125 p = 0;
126
127 p = alloc( p, dim, fill ); // CFA array alloc, fill
128 printf( "CFA resize array alloc, fill\n" );
129 for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
130 printf( "\n" );
131
132 p = alloc( p, 2 * dim, fill ); // CFA array alloc, fill
133 printf( "CFA resize array alloc, fill\n" );
134 for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
135 printf( "\n" );
136
137 p = alloc( p, dim, fill ); // CFA array alloc, fill
138 printf( "CFA resize array alloc, fill\n" );
139 for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; }
140 printf( "\n" );
141 free( p );
142
143
144 struct Struct { int x; double y; };
145 Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
146
147 // alignment, non-array types
148 printf( "\n" );
149 enum { Alignment = 128 };
150
151 stp = &(*(Struct*)memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
152 assert( (uintptr_t)stp % Alignment == 0 );
153 printf( "C memalign %d %g\n", stp->x, stp->y );
154 free( stp );
155
156 stp = &(*memalign( Alignment )){ 42, 42.5 }; // CFA memalign
157 assert( (uintptr_t)stp % Alignment == 0 );
158 printf( "CFA memalign %d %g\n", stp->x, stp->y );
159 free( stp );
160
161 posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign
162 *stp = (Struct){ 42, 42.5 };
163 assert( (uintptr_t)stp % Alignment == 0 );
164 printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
165 free( stp );
166
167 posix_memalign( &stp, Alignment ); // CFA posix_memalign
168 *stp = (Struct){ 42, 42.5 };
169 assert( (uintptr_t)stp % Alignment == 0 );
170 printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
171 free( stp );
172
173 stp = &(*aligned_alloc( Alignment )){ 42, 42.5 }; // CFA aligned_alloc
174 assert( (uintptr_t)stp % Alignment == 0 );
175 printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
176 free( stp );
177
178 stp = &(*align_alloc( Alignment )){ 42, 42.5 }; // CFA align_alloc
179 assert( (uintptr_t)stp % Alignment == 0 );
180 printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
181 free( stp );
182
183 stp = align_alloc( Alignment, fill ); // CFA memalign, fill
184 assert( (uintptr_t)stp % Alignment == 0 );
185 printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
186 free( stp );
187
188
189 // alignment, array types
190 printf( "\n" );
191
192 stp = align_alloc( Alignment, dim ); // CFA array memalign
193 assert( (uintptr_t)stp % Alignment == 0 );
194 for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; }
195 printf( "CFA array align_alloc\n" );
196 for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
197 printf( "\n" );
198 free( stp );
199
200 stp = align_alloc( Alignment, dim, fill ); // CFA array memalign, fill
201 assert( (uintptr_t)stp % Alignment == 0 );
202 printf( "CFA array align_alloc, fill\n" );
203 for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
204 printf( "\n" );
205 free( stp );
206
207
208 // data, non-array types
209 printf( "\n" );
210
211 memset( &st, fill ); // CFA memset, type safe
212 printf( "CFA memset %#x %a\n", st.x, st.y );
213 memcpy( &st1, &st ); // CFA memcpy, type safe
214 printf( "CFA memcpy %#x %a\n", st1.x, st1.y );
215
216
217 // data, array types
218 printf( "\n" );
219
220 memset( sta, dim, fill ); // CFA array memset, type safe
221 printf( "CFA array memset\n" );
222 for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
223 printf( "\n" );
224
225 memcpy( sta1, sta, dim ); // CFA array memcpy, type safe
226 printf( "CFA memcpy\n" );
227 for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
228 printf( "\n" );
229
230
231 // new, non-array types
232 printf( "\n" );
233
234 stp = new( 42, 42.5 );
235 stp1 = new( 42, 42.5 );
236 printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y );
237 delete( stp, stp1 );
238
239 // new, array types
240 stp = anew( dim, 42, 42.5 );
241 printf( "CFA array new initialize\n" );
242 for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
243 printf( "\n" );
244 stp1 = anew( dim, 42, 42.5 );
245 for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
246 printf( "\n" );
247 adelete( dim, stp, dim, stp1 );
248
249 // extras
250 printf( "\n" );
251
252 float * fp = malloc() + 1;
253 printf( "pointer arithmetic %d\n", fp == fp - 1 );
254 free( fp - 1 );
255
256 p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
257 *p = 0xdeadbeef;
258 printf( "CFA deep malloc %#x\n", *p );
259 free( p );
260
261#ifdef ERR1
262 stp = malloc();
263 printf( "\nSHOULD FAIL\n" );
264 p = realloc( stp, dim * sizeof( *stp ) );
265 p = alloc( stp, dim * sizeof( *stp ) );
266 p = memset( stp, 10 );
267 p = memcpy( &st1, &st );
268#endif
269} // main
270
271// Local Variables: //
272// tab-width: 4 //
273// compile-command: "cfa alloc.c" //
274// End: //
Note: See TracBrowser for help on using the repository browser.