source: tests/heap.cfa @ 943a079

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 943a079 was 943a079, checked in by Peter A. Buhr <pabuhr@…>, 15 months ago

additional heap tests for heap update

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