Changeset 14d8a9b for tests

Timestamp:

Sep 8, 2020, 1:33:50 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

2b7f6f0

Parents:

ce55a81 (diff), dfc13bb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

tests

Files:

• alloc2.cfa (modified) (9 diffs)
• heap.cfa (modified) (3 diffs)

tests/alloc2.cfa

@@ -13 +13 @@
 void test_base( void * ip, size_t size, size_t align) {
         tests_total += 1;
+//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = (malloc_size(ip) == size) && (malloc_usable_size(ip) >= size) && (malloc_alignment(ip) == align) && ((uintptr_t)ip % align  == 0);
         if (!passed) {
@@ -18 +19 @@
                 tests_failed += 1;
         }
+//      printf("DEBUG: done test %d\n", tests_total);
 }
 
 void test_fill( void * ip_, size_t start, size_t end, char fill) {
         tests_total += 1;
+//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         char * ip = (char *) ip_;
@@ -29 +32 @@
                 tests_failed += 1;
         }
+//      printf("DEBUG: done test %d\n", tests_total);
 }
 
 void test_fill( void * ip_, size_t start, size_t end, int fill) {
         tests_total += 1;
+//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         int * ip = (int *) ip_;
@@ -40 +45 @@
                 tests_failed += 1;
         }
+//      printf("DEBUG: done test %d\n", tests_total);
 }
 
 void test_fill( void * ip_, size_t start, size_t end, int * fill) {
         tests_total += 1;
+//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = (memcmp((void*)((uintptr_t)ip_ + start), (void*)fill, end) == 0);
         if (!passed) {
@@ -49 +56 @@
                 tests_failed += 1;
         }
+//      printf("DEBUG: done test %d\n", tests_total);
 }
 
 void test_fill( void * ip_, size_t start, size_t end, T1 fill) {
         tests_total += 1;
+//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         T1 * ip = (T1 *) ip_;
@@ -60 +69 @@
                 tests_failed += 1;
         }
+//      printf("DEBUG: done test %d\n", tests_total);
 }
 
 void test_fill( void * ip_, size_t start, size_t end, T1 * fill) {
         tests_total += 1;
+//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = (memcmp((void*)((uintptr_t)ip_ + start), (void*)fill, end) == 0);
         if (!passed) {
@@ -69 +80 @@
                 tests_failed += 1;
         }
+//      printf("DEBUG: done test %d\n", tests_total);
 }
 
 void test_use( int * ip, size_t dim) {
         tests_total += 1;
+//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         for (i; 0 ~ dim) ip[i] = 0xdeadbeef;
@@ -80 +93 @@
                 tests_failed += 1;
         }
+//      printf("DEBUG: done test %d\n", tests_total);
 }
 
 void test_use( T1 * ip, size_t dim) {
         tests_total += 1;
+//      printf("DEBUG: starting test %d\n", tests_total);
         bool passed = true;
         for (i; 0 ~ dim) ip[i].data = 0xdeadbeef;
@@ -91 +106 @@
                 tests_failed += 1;
         }
+//      printf("DEBUG: done test %d\n", tests_total);
 }
 

tests/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Nov  6 17:54:56 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Aug  9 08:05:16 2020
-// Update Count     : 57
+// Last Modified On : Mon Sep  7 18:37:41 2020
+// Update Count     : 72
 // 
 
@@ -205 +205 @@
                         free( area );
                 } // for
+        } // for
+
+        // check malloc/resize/free (sbrk)
+
+        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
+                // initial N byte allocation
+                char * area = (char *)malloc( i );
+                area[0] = '\345'; area[i - 1] = '\345';                 // fill first/penultimate byte
+
+                // Do not start this loop index at 0 because resize of 0 bytes frees the storage.
+                int prev = i;
+                for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
+                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/resize/free corrupt storage" );
+                        area = (char *)resize( area, s );                       // attempt to reuse storage
+                        area[0] = area[s - 1] = '\345';                         // fill last byte
+                        prev = s;
+                } // for
+                free( area );
+        } // for
+
+        // check malloc/resize/free (mmap)
+
+        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
+                // initial N byte allocation
+                size_t s = i + default_mmap_start();                    // cross over point
+                char * area = (char *)malloc( s );
+                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/penultimate byte
+
+                // Do not start this loop index at 0 because resize of 0 bytes frees the storage.
+                int prev = s;
+                for ( r; s ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
+                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/resize/free corrupt storage" );
+                        area = (char *)resize( area, s );                       // attempt to reuse storage
+                        area[0] = area[r - 1] = '\345';                         // fill last byte
+                        prev = r;
+                } // for
+                free( area );
+        } // for
+
+        // check malloc/realloc/free (sbrk)
+
+        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
+                // initial N byte allocation
+                char * area = (char *)malloc( i );
+                area[0] = '\345'; area[i - 1] = '\345';                 // fill first/penultimate byte
+
+                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
+                int prev = i;
+                for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
+                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/realloc/free corrupt storage" );
+                        area = (char *)realloc( area, s );                      // attempt to reuse storage
+                        area[s - 1] = '\345';                                           // fill last byte
+                        prev = s;
+                } // for
+                free( area );
+        } // for
+
+        // check malloc/realloc/free (mmap)
+
+        for ( i; 2 ~ NoOfAllocs ~ 12 ) {
+                // initial N byte allocation
+                size_t s = i + default_mmap_start();                    // cross over point
+                char * area = (char *)malloc( s );
+                area[0] = '\345'; area[s - 1] = '\345';                 // fill first/penultimate byte
+
+                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
+                int prev = s;
+                for ( r; s ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
+                        if ( area[0] != '\345' || area[prev - 1] != '\345' ) abort( "malloc/realloc/free corrupt storage" );
+                        area = (char *)realloc( area, s );                      // attempt to reuse storage
+                        area[r - 1] = '\345';                                           // fill last byte
+                        prev = r;
+                } // for
+                free( area );
         } // for
 
@@ -320 +394 @@
         } // for
 
+        // check memalign/resize with align/free
+
+        amount = 2;
+        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
+                // initial N byte allocation
+                char * area = (char *)memalign( a, amount );    // aligned N-byte allocation
+                //sout | alignments[a] | area | endl;
+                if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
+                        abort( "memalign/resize with align/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)amount, area );
+                } // if
+                area[0] = '\345'; area[amount - 2] = '\345';    // fill first/penultimate byte
+
+                // Do not start this loop index at 0 because resize of 0 bytes frees the storage.
+                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
+                        area = (char *)resize( area, a * 2, s );        // attempt to reuse storage
+                        //sout | i | area | endl;
+                        if ( (size_t)area % a * 2 != 0 ) {                      // check for initial alignment
+                                abort( "memalign/resize with align/free bad alignment %p", area );
+                        } // if
+                        area[s - 1] = '\345';                                           // fill last byte
+                } // for
+                free( area );
+        } // for
+
         // check memalign/realloc with align/free