source: tests/heap.cfa @ 474d610

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 474d610 was 5dc5da7, checked in by Peter A. Buhr <pabuhr@…>, 10 months ago

set default heap expansion to 10M

  • Property mode set to 100644
File size: 19.0 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2017 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// heap.cfa --
8//
9// Author           : Peter A. Buhr
10// Created On       : Tue Nov  6 17:54:56 2018
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Tue Dec 15 12:11:51 2020
13// Update Count     : 79
14//
15
16#include <thread.hfa>
17#include <kernel.hfa>                                                                   // processor
18#include <stdlib.hfa>                                                                   // *allocs
19#include <malloc.h>                                                                             // malloc_*
20
21// #include <time.hfa>
22// #define __CFA_DEFAULT_PREEMPTION__ 1000`us
23// //#define __CFA_DEFAULT_PREEMPTION__ 0
24
25// Duration default_preemption() {
26//      return __CFA_DEFAULT_PREEMPTION__;
27// }
28
29size_t default_heap_expansion() {
30        return 10 * 1024 * 1024;
31} // default_heap_expansion
32
33size_t default_mmap_start() {
34        return 512 * 1024 + 1;
35} // default_mmap_start
36
37thread Worker {
38}; // Worker
39
40void main( Worker & ) {
41        enum { NoOfAllocs = 5000, NoOfMmaps = 10 };
42        char * locns[NoOfAllocs];
43        size_t amount;
44        enum { limit = 64 * 1024 };                                                     // check alignments up to here
45
46        // check alloc/free
47
48        for ( j; 40 ) {
49                for ( i; NoOfAllocs ) {
50                        locns[i] = alloc( i );
51                        //sout | (void *)locns[i];
52                        for ( k; i ) locns[i][k] = '\345';
53                } // for
54                //sout | (char *)sbrk(0) - start | " bytes";
55
56                for ( i; NoOfAllocs ) {
57                        //sout | (void *)locns[i];
58                        for ( k; i ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage1" );
59                        free( locns[i] );
60                } // for
61                //sout | (char *)sbrk(0) - start | " bytes";
62
63                for ( i; NoOfAllocs ) {
64                        locns[i] = alloc( i );
65                        //sout | (void *)locns[i];
66                        for ( k; i ) locns[i][k] = '\345';
67                } // for
68                for ( i; NoOfAllocs - 1 -~= 0 ) {
69                        //sout | (void *)locns[i];
70                        for ( k; i ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage2" );
71                        free( locns[i] );
72                } // for
73        } // for
74
75        // check malloc/free (sbrk)
76
77        for ( i; NoOfAllocs ) {
78                size_t s = (i + 1) * 20;
79                char * area = (char *)malloc( s );
80                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
81                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
82                free( area );
83        } // for
84
85        for ( i; NoOfAllocs ) {
86                size_t s = i + 1;                                                               // +1 to make initialization simpler
87                locns[i] = (char *)malloc( s );
88                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
89                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
90        } // for
91        for ( i; NoOfAllocs ) {
92                size_t s = i + 1;
93                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
94                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "malloc/free corrupt storage" );
95                free( locns[i] );
96        } // for
97
98        // check malloc/free (mmap)
99
100        for ( i; NoOfMmaps ) {
101                size_t s = i + default_mmap_start();                    // cross over point
102                char * area = (char *)malloc( s );
103                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
104                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
105                free( area );
106        } // for
107
108        for ( i; NoOfMmaps ) {
109                size_t s = i + default_mmap_start();                    // cross over point
110                locns[i] = (char *)malloc( s );
111                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
112                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
113        } // for
114        for ( i; NoOfMmaps ) {
115                size_t s = i + default_mmap_start();                    // cross over point
116                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
117                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "malloc/free corrupt storage" );
118                free( locns[i] );
119        } // for
120
121        // check calloc/free (sbrk)
122
123        for ( i; NoOfAllocs ) {
124                size_t s = (i + 1) * 20;
125                char * area = (char *)calloc( 5, s );
126                if ( area[0] != '\0' || area[s - 1] != '\0' ||
127                         area[malloc_size( area ) - 1] != '\0' ||
128                         ! malloc_zero_fill( area ) ) abort( "calloc/free corrupt storage1" );
129                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
130                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
131                free( area );
132        } // for
133
134        for ( i; NoOfAllocs ) {
135                size_t s = i + 1;
136                locns[i] = (char *)calloc( 5, s );
137                if ( locns[i][0] != '\0' || locns[i][s - 1] != '\0' ||
138                         locns[i][malloc_size( locns[i] ) - 1] != '\0' ||
139                         ! malloc_zero_fill( locns[i] ) ) abort( "calloc/free corrupt storage2" );
140                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
141                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
142        } // for
143        for ( i; NoOfAllocs ) {
144                size_t s = i + 1;
145                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
146                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "calloc/free corrupt storage3" );
147                free( locns[i] );
148        } // for
149
150        // check calloc/free (mmap)
151
152        for ( i; NoOfMmaps ) {
153                size_t s = i + default_mmap_start();                    // cross over point
154                char * area = (char *)calloc( 1, s );
155                if ( area[0] != '\0' || area[s - 1] != '\0' ) abort( "calloc/free corrupt storage4.1" );
156                if ( area[malloc_size( area ) - 1] != '\0' ) abort( "calloc/free corrupt storage4.2" );
157                if ( ! malloc_zero_fill( area ) ) abort( "calloc/free corrupt storage4.3" );
158                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
159                area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
160                free( area );
161        } // for
162
163        for ( i; NoOfMmaps ) {
164                size_t s = i + default_mmap_start();                    // cross over point
165                locns[i] = (char *)calloc( 1, s );
166                if ( locns[i][0] != '\0' || locns[i][s - 1] != '\0' ||
167                         locns[i][malloc_size( locns[i] ) - 1] != '\0' ||
168                         ! malloc_zero_fill( locns[i] ) ) abort( "calloc/free corrupt storage5" );
169                locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
170                locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
171        } // for
172        for ( i; NoOfMmaps ) {
173                size_t s = i + default_mmap_start();                    // cross over point
174                if ( locns[i][0] != '\345' || locns[i][s - 1] != '\345' ||
175                         locns[i][malloc_usable_size( locns[i] ) - 1] != '\345' ) abort( "calloc/free corrupt storage6" );
176                free( locns[i] );
177        } // for
178
179        // check memalign/free (sbrk)
180
181        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
182                //sout | alignments[a];
183                for ( s; 1 ~ NoOfAllocs ) {                                             // allocation of size 0 can return null
184                        char * area = (char *)memalign( a, s );
185                        //sout | i | area;
186                        if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
187                                abort( "memalign/free bad alignment : memalign(%d,%d) = %p", (int)a, s, area );
188                        } // if
189                        area[0] = '\345'; area[s - 1] = '\345';         // fill first/last byte
190                        area[malloc_usable_size( area ) - 1] = '\345'; // fill ultimate byte
191                        free( area );
192                } // for
193        } // for
194
195        // check memalign/free (mmap)
196
197        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
198                //sout | alignments[a];
199                for ( i; 1 ~ NoOfMmaps ) {
200                        size_t s = i + default_mmap_start();            // cross over point
201                        char * area = (char *)memalign( a, s );
202                        //sout | i | area;
203                        if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
204                                abort( "memalign/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)s, area );
205                        } // if
206                        area[0] = '\345'; area[s - 1] = '\345';         // fill first/last byte
207                        area[malloc_usable_size( area ) - 1] = '\345'; // fill ultimate byte
208                        free( area );
209                } // for
210        } // for
211
212        // check malloc/resize/free (sbrk)
213
214        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
215                // initial N byte allocation
216                char * area = (char *)malloc( i );
217                area[0] = '\345'; area[i - 1] = '\345';                 // fill first/penultimate byte
218
219                // Do not start this loop index at 0 because resize of 0 bytes frees the storage.
220                int prev = i;
221                for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
222                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/resize/free corrupt storage" );
223                        area = (char *)resize( area, s );                       // attempt to reuse storage
224                        area[0] = area[s - 1] = '\345';                         // fill last byte
225                        prev = s;
226                } // for
227                free( area );
228        } // for
229
230        // check malloc/resize/free (mmap)
231
232        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
233                // initial N byte allocation
234                size_t s = i + default_mmap_start();                    // cross over point
235                char * area = (char *)malloc( s );
236                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/penultimate byte
237
238                // Do not start this loop index at 0 because resize of 0 bytes frees the storage.
239                int prev = s;
240                for ( r; s ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
241                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/resize/free corrupt storage" );
242                        area = (char *)resize( area, s );                       // attempt to reuse storage
243                        area[0] = area[r - 1] = '\345';                         // fill last byte
244                        prev = r;
245                } // for
246                free( area );
247        } // for
248
249        // check malloc/realloc/free (sbrk)
250
251        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
252                // initial N byte allocation
253                char * area = (char *)malloc( i );
254                area[0] = '\345'; area[i - 1] = '\345';                 // fill first/penultimate byte
255
256                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
257                int prev = i;
258                for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
259                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/realloc/free corrupt storage" );
260                        area = (char *)realloc( area, s );                      // attempt to reuse storage
261                        area[s - 1] = '\345';                                           // fill last byte
262                        prev = s;
263                } // for
264                free( area );
265        } // for
266
267        // check malloc/realloc/free (mmap)
268
269        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
270                // initial N byte allocation
271                size_t s = i + default_mmap_start();                    // cross over point
272                char * area = (char *)malloc( s );
273                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/penultimate byte
274
275                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
276                int prev = s;
277                for ( r; s ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
278                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/realloc/free corrupt storage" );
279                        area = (char *)realloc( area, s );                      // attempt to reuse storage
280                        area[r - 1] = '\345';                                           // fill last byte
281                        prev = r;
282                } // for
283                free( area );
284        } // for
285
286        // check calloc/realloc/free (sbrk)
287
288        for ( i; 1 ~ 10_000 ~ 12 ) {
289                // initial N byte allocation
290                char * area = (char *)calloc( 5, i );
291                if ( area[0] != '\0' || area[i - 1] != '\0' ||
292                         area[malloc_size( area ) - 1] != '\0' ||
293                         ! malloc_zero_fill( area ) ) abort( "calloc/realloc/free corrupt storage1" );
294
295                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
296                for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
297                        area = (char *)realloc( area, s );                      // attempt to reuse storage
298                        if ( area[0] != '\0' || area[s - 1] != '\0' ||
299                                 area[malloc_size( area ) - 1] != '\0' ||
300                                 ! malloc_zero_fill( area ) ) abort( "calloc/realloc/free corrupt storage2" );
301                } // for
302                free( area );
303        } // for
304
305        // check calloc/realloc/free (mmap)
306
307        for ( i; 1 ~ 10_000 ~ 12 ) {
308                // initial N byte allocation
309                size_t s = i + default_mmap_start();                    // cross over point
310                char * area = (char *)calloc( 1, s );
311                if ( area[0] != '\0' || area[s - 1] != '\0' ||
312                         area[malloc_size( area ) - 1] != '\0' ||
313                         ! malloc_zero_fill( area ) ) abort( "calloc/realloc/free corrupt storage3" );
314
315                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
316                for ( r; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
317                        area = (char *)realloc( area, r );                      // attempt to reuse storage
318                        if ( area[0] != '\0' || area[r - 1] != '\0' ||
319                                 area[malloc_size( area ) - 1] != '\0' ||
320                                 ! malloc_zero_fill( area ) ) abort( "calloc/realloc/free corrupt storage4" );
321                } // for
322                free( area );
323        } // for
324
325        // check memalign/realloc/free
326
327        amount = 2;
328        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
329                // initial N byte allocation
330                char * area = (char *)memalign( a, amount );    // aligned N-byte allocation
331                //sout | alignments[a] | area;
332                if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
333                        abort( "memalign/realloc/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)amount, area );
334                } // if
335                area[0] = '\345'; area[amount - 2] = '\345';    // fill first/penultimate byte
336
337                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
338                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
339                        if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "memalign/realloc/free corrupt storage" );
340                        area = (char *)realloc( area, s );                      // attempt to reuse storage
341                        //sout | i | area;
342                        if ( (size_t)area % a != 0 ) {                          // check for initial alignment
343                                abort( "memalign/realloc/free bad alignment %p", area );
344                        } // if
345                        area[s - 1] = '\345';                                           // fill last byte
346                } // for
347                free( area );
348        } // for
349
350        // check cmemalign/free
351
352        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
353                //sout | alignments[a];
354                for ( s; 1 ~ limit ) {                                                  // allocation of size 0 can return null
355                        char * area = (char *)cmemalign( a, 1, s );
356                        //sout | i | area;
357                        if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
358                                abort( "cmemalign/free bad alignment : cmemalign(%d,%d) = %p", (int)a, s, area );
359                        } // if
360                        if ( area[0] != '\0' || area[s - 1] != '\0' ||
361                                 area[malloc_size( area ) - 1] != '\0' ||
362                                 ! malloc_zero_fill( area ) ) abort( "cmemalign/free corrupt storage" );
363                        area[0] = '\345'; area[s - 1] = '\345';         // fill first/last byte
364                        free( area );
365                } // for
366        } // for
367
368        // check cmemalign/realloc/free
369
370        amount = 2;
371        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
372                // initial N byte allocation
373                char * area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation
374                //sout | alignments[a] | area;
375                if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
376                        abort( "cmemalign/realloc/free bad alignment : cmemalign(%d,%d) = %p", (int)a, (int)amount, area );
377                } // if
378                if ( area[0] != '\0' || area[amount - 1] != '\0' ||
379                         area[malloc_size( area ) - 1] != '\0' ||
380                         ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc/free corrupt storage1" );
381                area[0] = '\345'; area[amount - 2] = '\345';    // fill first/penultimate byte
382
383                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
384                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
385                        if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "cmemalign/realloc/free corrupt storage2" );
386                        area = (char *)realloc( area, s );                      // attempt to reuse storage
387                        //sout | i | area;
388                        if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
389                                abort( "cmemalign/realloc/free bad alignment %p", area );
390                        } // if
391                        if ( area[0] != '\345' || area[s - 1] != '\0' ||
392                                 area[malloc_size( area ) - 1] != '\0' ||
393                                 ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc/free corrupt storage3" );
394                        area[s - 1] = '\345';                                           // fill last byte
395                } // for
396                free( area );
397        } // for
398
399        // check memalign/resize with align/free
400
401        amount = 2;
402        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
403                // initial N byte allocation
404                char * area = (char *)memalign( a, amount );    // aligned N-byte allocation
405                //sout | alignments[a] | area | endl;
406                if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
407                        abort( "memalign/resize with align/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)amount, area );
408                } // if
409                area[0] = '\345'; area[amount - 2] = '\345';    // fill first/penultimate byte
410
411                // Do not start this loop index at 0 because resize of 0 bytes frees the storage.
412                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
413                        area = (char *)resize( area, a * 2, s );        // attempt to reuse storage
414                        //sout | i | area | endl;
415                        if ( (size_t)area % a * 2 != 0 ) {                      // check for initial alignment
416                                abort( "memalign/resize with align/free bad alignment %p", area );
417                        } // if
418                        area[s - 1] = '\345';                                           // fill last byte
419                } // for
420                free( area );
421        } // for
422
423        // check memalign/realloc with align/free
424
425        amount = 2;
426        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
427                // initial N byte allocation
428                char * area = (char *)memalign( a, amount );    // aligned N-byte allocation
429                //sout | alignments[a] | area | endl;
430                if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
431                        abort( "memalign/realloc with align/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)amount, area );
432                } // if
433                area[0] = '\345'; area[amount - 2] = '\345';    // fill first/penultimate byte
434
435                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
436                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
437                        if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "memalign/realloc/free corrupt storage" );
438                        area = (char *)realloc( area, a * 2, s );       // attempt to reuse storage
439                        //sout | i | area | endl;
440                        if ( (size_t)area % a * 2 != 0 ) {                      // check for initial alignment
441                                abort( "memalign/realloc with align/free bad alignment %p", area );
442                        } // if
443                        area[s - 1] = '\345';                                           // fill last byte
444                } // for
445                free( area );
446        } // for
447
448        // check cmemalign/realloc with align/free
449
450        amount = 2;
451        for ( size_t a = libAlign() + libAlign(); a <= limit; a += a ) { // generate powers of 2
452                // initial N byte allocation
453                char * area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation
454                //sout | alignments[a] | area | endl;
455                if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
456                        abort( "cmemalign/realloc with align/free bad alignment : cmemalign(%d,%d) = %p", (int)a, (int)amount, area );
457                } // if
458                if ( area[0] != '\0' || area[amount - 1] != '\0' ||
459                         area[malloc_size( area ) - 1] != '\0' ||
460                         ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc with align/free corrupt storage1" );
461                area[0] = '\345'; area[amount - 2] = '\345';    // fill first/penultimate byte
462
463                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
464                for ( int s = amount; s < 256 * 1024; s += 1 ) { // start at initial memory request
465                        if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "cmemalign/realloc with align/free corrupt storage2" );
466                        area = (char *)realloc( area, a * 2, s );       // attempt to reuse storage
467                        //sout | i | area | endl;
468                        if ( (size_t)area % a * 2 != 0 || malloc_alignment( area ) != a * 2 ) { // check for initial alignment
469                                abort( "cmemalign/realloc with align/free bad alignment %p %zd %zd", area, malloc_alignment( area ), a * 2 );
470                        } // if
471                        if ( area[s - 1] != '\0' || area[s - 1] != '\0' ||
472                                 area[malloc_size( area ) - 1] != '\0' ||
473                                 ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc/free corrupt storage3" );
474                        area[s - 1] = '\345';                                           // fill last byte
475                } // for
476                free( area );
477        } // for
478
479        //sout | "worker" | thisTask() | "successful completion";
480} // Worker main
481
482int main() {
483        const unsigned int NoOfWorkers = 4;
484        {
485                processor processors[NoOfWorkers - 1] __attribute__(( unused )); // more than one processor
486                Worker workers[NoOfWorkers] __attribute__(( unused ));
487        }
488        // checkFreeOn();
489        // malloc_stats();
490        printf( "done\n" );                                                                     // non-empty .expect file
491}
492
493// Local Variables: //
494// tab-width: 4 //
495// compile-command: "cfa -nodebug -O2 heap.cfa" //
496// End: //
Note: See TracBrowser for help on using the repository browser.