[dc8511c] | 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 |
---|
[505450a] | 12 | // Last Modified On : Sun Aug 9 08:05:16 2020 |
---|
| 13 | // Update Count : 57 |
---|
[dc8511c] | 14 | // |
---|
| 15 | |
---|
[73abe95] | 16 | #include <thread.hfa> |
---|
[80228a7] | 17 | #include <kernel.hfa> // processor |
---|
| 18 | #include <stdlib.hfa> // *allocs |
---|
[5d4fa18] | 19 | #include <malloc.h> // malloc_* |
---|
| 20 | |
---|
[73abe95] | 21 | // #include <time.hfa> |
---|
[5d4fa18] | 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) |
---|
| 30 | size_t default_mmap_start() __attribute__(( weak )) { |
---|
[3e91703] | 31 | return __U_DEFAULT_MMAP_START__; |
---|
[5d4fa18] | 32 | } // default_mmap_start |
---|
| 33 | |
---|
| 34 | thread Worker { |
---|
| 35 | }; // Worker |
---|
| 36 | |
---|
| 37 | void main( Worker & ) { |
---|
[3e91703] | 38 | enum { NoOfAllocs = 5000, NoOfMmaps = 10 }; |
---|
| 39 | char * locns[NoOfAllocs]; |
---|
[58e280f4] | 40 | size_t amount; |
---|
| 41 | enum { limit = 64 * 1024 }; // check alignments up to here |
---|
[5d4fa18] | 42 | |
---|
[3e91703] | 43 | // check alloc/free |
---|
[5d4fa18] | 44 | |
---|
[3e91703] | 45 | for ( j; 40 ) { |
---|
[80228a7] | 46 | for ( i; NoOfAllocs ) { |
---|
[5d4fa18] | 47 | locns[i] = alloc( i ); |
---|
[200fcb3] | 48 | //sout | (void *)locns[i]; |
---|
[80228a7] | 49 | for ( k; i ) locns[i][k] = '\345'; |
---|
[5d4fa18] | 50 | } // for |
---|
[200fcb3] | 51 | //sout | (char *)sbrk(0) - start | " bytes"; |
---|
[5d4fa18] | 52 | |
---|
[80228a7] | 53 | for ( i; NoOfAllocs ) { |
---|
[200fcb3] | 54 | //sout | (void *)locns[i]; |
---|
[80228a7] | 55 | for ( k; i ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage1" ); |
---|
[5d4fa18] | 56 | free( locns[i] ); |
---|
| 57 | } // for |
---|
[200fcb3] | 58 | //sout | (char *)sbrk(0) - start | " bytes"; |
---|
[5d4fa18] | 59 | |
---|
[80228a7] | 60 | for ( i; NoOfAllocs ) { |
---|
[5d4fa18] | 61 | locns[i] = alloc( i ); |
---|
[200fcb3] | 62 | //sout | (void *)locns[i]; |
---|
[80228a7] | 63 | for ( k; i ) locns[i][k] = '\345'; |
---|
[5d4fa18] | 64 | } // for |
---|
[80228a7] | 65 | for ( i; NoOfAllocs - 1 -~= 0 ) { |
---|
[200fcb3] | 66 | //sout | (void *)locns[i]; |
---|
[80228a7] | 67 | for ( k; i ) if ( locns[i][k] != '\345' ) abort( "new/delete corrupt storage2" ); |
---|
[5d4fa18] | 68 | free( locns[i] ); |
---|
| 69 | } // for |
---|
[3e91703] | 70 | } // for |
---|
[5d4fa18] | 71 | |
---|
[3e91703] | 72 | // check malloc/free (sbrk) |
---|
[5d4fa18] | 73 | |
---|
[3e91703] | 74 | for ( i; NoOfAllocs ) { |
---|
[5d4fa18] | 75 | size_t s = (i + 1) * 20; |
---|
[80228a7] | 76 | char * area = (char *)malloc( s ); |
---|
[5d4fa18] | 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 ); |
---|
[3e91703] | 80 | } // for |
---|
[5d4fa18] | 81 | |
---|
[3e91703] | 82 | for ( i; NoOfAllocs ) { |
---|
[80228a7] | 83 | size_t s = i + 1; // +1 to make initialization simpler |
---|
[5d4fa18] | 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 |
---|
[3e91703] | 87 | } // for |
---|
| 88 | for ( i; NoOfAllocs ) { |
---|
[5d4fa18] | 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] ); |
---|
[3e91703] | 93 | } // for |
---|
[5d4fa18] | 94 | |
---|
[3e91703] | 95 | // check malloc/free (mmap) |
---|
[5d4fa18] | 96 | |
---|
[3e91703] | 97 | for ( i; NoOfMmaps ) { |
---|
[80228a7] | 98 | size_t s = i + default_mmap_start(); // cross over point |
---|
| 99 | char * area = (char *)malloc( s ); |
---|
[5d4fa18] | 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 ); |
---|
[3e91703] | 103 | } // for |
---|
[5d4fa18] | 104 | |
---|
[3e91703] | 105 | for ( i; NoOfMmaps ) { |
---|
[80228a7] | 106 | size_t s = i + default_mmap_start(); // cross over point |
---|
[5d4fa18] | 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 |
---|
[3e91703] | 110 | } // for |
---|
| 111 | for ( i; NoOfMmaps ) { |
---|
[80228a7] | 112 | size_t s = i + default_mmap_start(); // cross over point |
---|
[5d4fa18] | 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] ); |
---|
[3e91703] | 116 | } // for |
---|
[5d4fa18] | 117 | |
---|
[3e91703] | 118 | // check calloc/free (sbrk) |
---|
[5d4fa18] | 119 | |
---|
[3e91703] | 120 | for ( i; NoOfAllocs ) { |
---|
[5d4fa18] | 121 | size_t s = (i + 1) * 20; |
---|
[80228a7] | 122 | char * area = (char *)calloc( 5, s ); |
---|
[5d4fa18] | 123 | if ( area[0] != '\0' || area[s - 1] != '\0' || |
---|
[25cbd99] | 124 | area[malloc_size( area ) - 1] != '\0' || |
---|
[5d4fa18] | 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 ); |
---|
[3e91703] | 129 | } // for |
---|
[5d4fa18] | 130 | |
---|
[3e91703] | 131 | for ( i; NoOfAllocs ) { |
---|
[5d4fa18] | 132 | size_t s = i + 1; |
---|
| 133 | locns[i] = (char *)calloc( 5, s ); |
---|
| 134 | if ( locns[i][0] != '\0' || locns[i][s - 1] != '\0' || |
---|
[25cbd99] | 135 | locns[i][malloc_size( locns[i] ) - 1] != '\0' || |
---|
[5d4fa18] | 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 |
---|
[3e91703] | 139 | } // for |
---|
| 140 | for ( i; NoOfAllocs ) { |
---|
[5d4fa18] | 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] ); |
---|
[3e91703] | 145 | } // for |
---|
[5d4fa18] | 146 | |
---|
[3e91703] | 147 | // check calloc/free (mmap) |
---|
[5d4fa18] | 148 | |
---|
[3e91703] | 149 | for ( i; NoOfMmaps ) { |
---|
[80228a7] | 150 | size_t s = i + default_mmap_start(); // cross over point |
---|
| 151 | char * area = (char *)calloc( 1, s ); |
---|
[5d4fa18] | 152 | if ( area[0] != '\0' || area[s - 1] != '\0' ) abort( "calloc/free corrupt storage4.1" ); |
---|
[25cbd99] | 153 | if ( area[malloc_size( area ) - 1] != '\0' ) abort( "calloc/free corrupt storage4.2" ); |
---|
[5d4fa18] | 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 ); |
---|
[3e91703] | 158 | } // for |
---|
[5d4fa18] | 159 | |
---|
[3e91703] | 160 | for ( i; NoOfMmaps ) { |
---|
[80228a7] | 161 | size_t s = i + default_mmap_start(); // cross over point |
---|
[5d4fa18] | 162 | locns[i] = (char *)calloc( 1, s ); |
---|
| 163 | if ( locns[i][0] != '\0' || locns[i][s - 1] != '\0' || |
---|
[25cbd99] | 164 | locns[i][malloc_size( locns[i] ) - 1] != '\0' || |
---|
[5d4fa18] | 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 |
---|
[3e91703] | 168 | } // for |
---|
| 169 | for ( i; NoOfMmaps ) { |
---|
[80228a7] | 170 | size_t s = i + default_mmap_start(); // cross over point |
---|
[5d4fa18] | 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] ); |
---|
[3e91703] | 174 | } // for |
---|
[5d4fa18] | 175 | |
---|
[3e91703] | 176 | // check memalign/free (sbrk) |
---|
[5d4fa18] | 177 | |
---|
[80228a7] | 178 | for ( a; libAlign() ~= limit ~ a ) { // generate powers of 2 |
---|
[200fcb3] | 179 | //sout | alignments[a]; |
---|
[80228a7] | 180 | for ( s; 1 ~ NoOfAllocs ) { // allocation of size 0 can return null |
---|
| 181 | char * area = (char *)memalign( a, s ); |
---|
[6a25b8f] | 182 | //sout | i | area; |
---|
[5d4fa18] | 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 |
---|
[6a25b8f] | 186 | area[0] = '\345'; area[s - 1] = '\345'; // fill first/last byte |
---|
[5d4fa18] | 187 | area[malloc_usable_size( area ) - 1] = '\345'; // fill ultimate byte |
---|
| 188 | free( area ); |
---|
| 189 | } // for |
---|
[3e91703] | 190 | } // for |
---|
[5d4fa18] | 191 | |
---|
[3e91703] | 192 | // check memalign/free (mmap) |
---|
[5d4fa18] | 193 | |
---|
[80228a7] | 194 | for ( a; libAlign() ~= limit ~ a ) { // generate powers of 2 |
---|
[200fcb3] | 195 | //sout | alignments[a]; |
---|
[80228a7] | 196 | for ( i; 1 ~ NoOfMmaps ) { |
---|
| 197 | size_t s = i + default_mmap_start(); // cross over point |
---|
| 198 | char * area = (char *)memalign( a, s ); |
---|
[6a25b8f] | 199 | //sout | i | area; |
---|
[5d4fa18] | 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 |
---|
[3e91703] | 207 | } // for |
---|
[5d4fa18] | 208 | |
---|
[3e91703] | 209 | // check calloc/realloc/free (sbrk) |
---|
[5d4fa18] | 210 | |
---|
[3e91703] | 211 | for ( i; 1 ~ 10_000 ~ 12 ) { |
---|
[5d4fa18] | 212 | // initial N byte allocation |
---|
[80228a7] | 213 | char * area = (char *)calloc( 5, i ); |
---|
[5d4fa18] | 214 | if ( area[0] != '\0' || area[i - 1] != '\0' || |
---|
[25cbd99] | 215 | area[malloc_size( area ) - 1] != '\0' || |
---|
[5d4fa18] | 216 | ! malloc_zero_fill( area ) ) abort( "calloc/realloc/free corrupt storage1" ); |
---|
| 217 | |
---|
| 218 | // Do not start this loop index at 0 because realloc of 0 bytes frees the storage. |
---|
[80228a7] | 219 | for ( s; i ~ 256 * 1024 ~ 26 ) { // start at initial memory request |
---|
[5d4fa18] | 220 | area = (char *)realloc( area, s ); // attempt to reuse storage |
---|
| 221 | if ( area[0] != '\0' || area[s - 1] != '\0' || |
---|
[25cbd99] | 222 | area[malloc_size( area ) - 1] != '\0' || |
---|
[5d4fa18] | 223 | ! malloc_zero_fill( area ) ) abort( "calloc/realloc/free corrupt storage2" ); |
---|
| 224 | } // for |
---|
| 225 | free( area ); |
---|
[3e91703] | 226 | } // for |
---|
[5d4fa18] | 227 | |
---|
[3e91703] | 228 | // check calloc/realloc/free (mmap) |
---|
[5d4fa18] | 229 | |
---|
[3e91703] | 230 | for ( i; 1 ~ 10_000 ~ 12 ) { |
---|
[5d4fa18] | 231 | // initial N byte allocation |
---|
[80228a7] | 232 | size_t s = i + default_mmap_start(); // cross over point |
---|
| 233 | char * area = (char *)calloc( 1, s ); |
---|
[5d4fa18] | 234 | if ( area[0] != '\0' || area[s - 1] != '\0' || |
---|
[25cbd99] | 235 | area[malloc_size( area ) - 1] != '\0' || |
---|
[505450a] | 236 | ! malloc_zero_fill( area ) ) abort( "calloc/realloc/free corrupt storage3" ); |
---|
[5d4fa18] | 237 | |
---|
| 238 | // Do not start this loop index at 0 because realloc of 0 bytes frees the storage. |
---|
[80228a7] | 239 | for ( r; i ~ 256 * 1024 ~ 26 ) { // start at initial memory request |
---|
| 240 | area = (char *)realloc( area, r ); // attempt to reuse storage |
---|
[5d4fa18] | 241 | if ( area[0] != '\0' || area[r - 1] != '\0' || |
---|
[25cbd99] | 242 | area[malloc_size( area ) - 1] != '\0' || |
---|
| 243 | ! malloc_zero_fill( area ) ) abort( "calloc/realloc/free corrupt storage4" ); |
---|
[5d4fa18] | 244 | } // for |
---|
| 245 | free( area ); |
---|
[3e91703] | 246 | } // for |
---|
[5d4fa18] | 247 | |
---|
[3e91703] | 248 | // check memalign/realloc/free |
---|
[5d4fa18] | 249 | |
---|
[58e280f4] | 250 | amount = 2; |
---|
[80228a7] | 251 | for ( a; libAlign() ~= limit ~ a ) { // generate powers of 2 |
---|
[5d4fa18] | 252 | // initial N byte allocation |
---|
[80228a7] | 253 | char * area = (char *)memalign( a, amount ); // aligned N-byte allocation |
---|
[6a25b8f] | 254 | //sout | alignments[a] | area; |
---|
[5d4fa18] | 255 | if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment |
---|
| 256 | abort( "memalign/realloc/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)amount, area ); |
---|
| 257 | } // if |
---|
| 258 | area[0] = '\345'; area[amount - 2] = '\345'; // fill first/penultimate byte |
---|
| 259 | |
---|
| 260 | // Do not start this loop index at 0 because realloc of 0 bytes frees the storage. |
---|
[80228a7] | 261 | for ( s; amount ~ 256 * 1024 ) { // start at initial memory request |
---|
[5d4fa18] | 262 | if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "memalign/realloc/free corrupt storage" ); |
---|
| 263 | area = (char *)realloc( area, s ); // attempt to reuse storage |
---|
[6a25b8f] | 264 | //sout | i | area; |
---|
[5d4fa18] | 265 | if ( (size_t)area % a != 0 ) { // check for initial alignment |
---|
| 266 | abort( "memalign/realloc/free bad alignment %p", area ); |
---|
| 267 | } // if |
---|
| 268 | area[s - 1] = '\345'; // fill last byte |
---|
| 269 | } // for |
---|
| 270 | free( area ); |
---|
[3e91703] | 271 | } // for |
---|
[5d4fa18] | 272 | |
---|
[3e91703] | 273 | // check cmemalign/free |
---|
[5d4fa18] | 274 | |
---|
[80228a7] | 275 | for ( a; libAlign() ~= limit ~ a ) { // generate powers of 2 |
---|
[200fcb3] | 276 | //sout | alignments[a]; |
---|
[80228a7] | 277 | for ( s; 1 ~ limit ) { // allocation of size 0 can return null |
---|
| 278 | char * area = (char *)cmemalign( a, 1, s ); |
---|
[6a25b8f] | 279 | //sout | i | area; |
---|
[5d4fa18] | 280 | if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment |
---|
| 281 | abort( "cmemalign/free bad alignment : cmemalign(%d,%d) = %p", (int)a, s, area ); |
---|
| 282 | } // if |
---|
| 283 | if ( area[0] != '\0' || area[s - 1] != '\0' || |
---|
[25cbd99] | 284 | area[malloc_size( area ) - 1] != '\0' || |
---|
[5d4fa18] | 285 | ! malloc_zero_fill( area ) ) abort( "cmemalign/free corrupt storage" ); |
---|
| 286 | area[0] = '\345'; area[s - 1] = '\345'; // fill first/last byte |
---|
| 287 | free( area ); |
---|
| 288 | } // for |
---|
[3e91703] | 289 | } // for |
---|
[5d4fa18] | 290 | |
---|
[3e91703] | 291 | // check cmemalign/realloc/free |
---|
[5d4fa18] | 292 | |
---|
[3e91703] | 293 | amount = 2; |
---|
[80228a7] | 294 | for ( a; libAlign() ~= limit ~ a ) { // generate powers of 2 |
---|
[5d4fa18] | 295 | // initial N byte allocation |
---|
[80228a7] | 296 | char * area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation |
---|
[6a25b8f] | 297 | //sout | alignments[a] | area; |
---|
[5d4fa18] | 298 | if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment |
---|
| 299 | abort( "cmemalign/realloc/free bad alignment : cmemalign(%d,%d) = %p", (int)a, (int)amount, area ); |
---|
| 300 | } // if |
---|
| 301 | if ( area[0] != '\0' || area[amount - 1] != '\0' || |
---|
[25cbd99] | 302 | area[malloc_size( area ) - 1] != '\0' || |
---|
[5d4fa18] | 303 | ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc/free corrupt storage1" ); |
---|
| 304 | area[0] = '\345'; area[amount - 2] = '\345'; // fill first/penultimate byte |
---|
| 305 | |
---|
| 306 | // Do not start this loop index at 0 because realloc of 0 bytes frees the storage. |
---|
[80228a7] | 307 | for ( s; amount ~ 256 * 1024 ) { // start at initial memory request |
---|
[5d4fa18] | 308 | if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "cmemalign/realloc/free corrupt storage2" ); |
---|
| 309 | area = (char *)realloc( area, s ); // attempt to reuse storage |
---|
[6a25b8f] | 310 | //sout | i | area; |
---|
[5d4fa18] | 311 | if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment |
---|
| 312 | abort( "cmemalign/realloc/free bad alignment %p", area ); |
---|
| 313 | } // if |
---|
[25cbd99] | 314 | if ( area[0] != '\345' || area[s - 1] != '\0' || |
---|
| 315 | area[malloc_size( area ) - 1] != '\0' || |
---|
[5d4fa18] | 316 | ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc/free corrupt storage3" ); |
---|
| 317 | area[s - 1] = '\345'; // fill last byte |
---|
| 318 | } // for |
---|
| 319 | free( area ); |
---|
[3e91703] | 320 | } // for |
---|
[6a25b8f] | 321 | |
---|
| 322 | // check memalign/realloc with align/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 | endl; |
---|
| 329 | if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment |
---|
| 330 | abort( "memalign/realloc with align/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, a * 2, s ); // attempt to reuse storage |
---|
| 338 | //sout | i | area | endl; |
---|
| 339 | if ( (size_t)area % a * 2 != 0 ) { // check for initial alignment |
---|
| 340 | abort( "memalign/realloc with align/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/realloc with align/free |
---|
| 348 | |
---|
| 349 | amount = 2; |
---|
| 350 | for ( size_t a = libAlign() + libAlign(); a <= limit; a += a ) { // generate powers of 2 |
---|
| 351 | // initial N byte allocation |
---|
[2ff42f4] | 352 | char * area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation |
---|
[6a25b8f] | 353 | //sout | alignments[a] | area | endl; |
---|
| 354 | if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment |
---|
| 355 | abort( "cmemalign/realloc with align/free bad alignment : cmemalign(%d,%d) = %p", (int)a, (int)amount, area ); |
---|
| 356 | } // if |
---|
| 357 | if ( area[0] != '\0' || area[amount - 1] != '\0' || |
---|
[25cbd99] | 358 | area[malloc_size( area ) - 1] != '\0' || |
---|
[6a25b8f] | 359 | ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc with align/free corrupt storage1" ); |
---|
| 360 | area[0] = '\345'; area[amount - 2] = '\345'; // fill first/penultimate byte |
---|
| 361 | |
---|
| 362 | // Do not start this loop index at 0 because realloc of 0 bytes frees the storage. |
---|
| 363 | for ( int s = amount; s < 256 * 1024; s += 1 ) { // start at initial memory request |
---|
| 364 | if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "cmemalign/realloc with align/free corrupt storage2" ); |
---|
| 365 | area = (char *)realloc( area, a * 2, s ); // attempt to reuse storage |
---|
| 366 | //sout | i | area | endl; |
---|
| 367 | if ( (size_t)area % a * 2 != 0 || malloc_alignment( area ) != a * 2 ) { // check for initial alignment |
---|
[2ff42f4] | 368 | abort( "cmemalign/realloc with align/free bad alignment %p %zd %zd", area, malloc_alignment( area ), a * 2 ); |
---|
[6a25b8f] | 369 | } // if |
---|
| 370 | if ( area[s - 1] != '\0' || area[s - 1] != '\0' || |
---|
[25cbd99] | 371 | area[malloc_size( area ) - 1] != '\0' || |
---|
[6a25b8f] | 372 | ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc/free corrupt storage3" ); |
---|
| 373 | area[s - 1] = '\345'; // fill last byte |
---|
| 374 | } // for |
---|
| 375 | free( area ); |
---|
| 376 | } // for |
---|
[58e280f4] | 377 | |
---|
[200fcb3] | 378 | //sout | "worker" | thisTask() | "successful completion"; |
---|
[5d4fa18] | 379 | } // Worker main |
---|
| 380 | |
---|
| 381 | int main() { |
---|
[3e91703] | 382 | const unsigned int NoOfWorkers = 4; |
---|
| 383 | { |
---|
[5d4fa18] | 384 | processor processors[NoOfWorkers - 1] __attribute__(( unused )); // more than one processor |
---|
| 385 | Worker workers[NoOfWorkers] __attribute__(( unused )); |
---|
[3e91703] | 386 | } |
---|
[5d4fa18] | 387 | // checkFreeOn(); |
---|
[3e91703] | 388 | // malloc_stats(); |
---|
[5d4fa18] | 389 | } |
---|
| 390 | |
---|
| 391 | // Local Variables: // |
---|
| 392 | // tab-width: 4 // |
---|
[dc8511c] | 393 | // compile-command: "cfa -nodebug -O2 heap.cfa" // |
---|
[5d4fa18] | 394 | // End: // |
---|