Changeset 69ec0fb for libcfa

Timestamp:

Apr 25, 2022, 7:00:39 PM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

c73213b

Parents:

e357efb

Message:

fix error in second update of heap allocator

File:

• libcfa/src/heap.cfa (modified) (10 diffs)

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Apr 24 09:58:01 2022
-// Update Count     : 1146
+// Last Modified On : Mon Apr 25 18:51:36 2022
+// Update Count     : 1147
 //
 
@@ -116 +116 @@
 
 // statically allocated variables => zero filled.
-size_t __page_size;                                                                             // architecture pagesize
-int __map_prot;                                                                                 // common mmap/mprotect protection
 static size_t heapExpand;                                                               // sbrk advance
 static size_t mmapStart;                                                                // cross over point for mmap
 static unsigned int maxBucketsUsed;                                             // maximum number of buckets in use
+// extern visibility, used by runtime kernel
+size_t __page_size;                                                                             // architecture pagesize
+int __map_prot;                                                                                 // common mmap/mprotect protection
 
 
@@ -540 +541 @@
                 // If the size requested is bigger than the current remaining storage, increase the size of the heap.
 
-                size_t increase = ceiling2( size > heapExpand ? size : heapExpand, libAlign() );
+                size_t increase = ceiling2( size > heapExpand ? size : heapExpand, __page_size );
                 // Do not call abort or strerror( errno ) as they may call malloc.
                 if ( sbrk( increase ) == (void *)-1 ) {                 // failed, no memory ?
@@ -549 +550 @@
 
                 // Make storage executable for thunks.
-                // if ( mprotect( (char *)heapEnd + heapRemaining, increase, __map_prot ) ) {
-                //      unlock( extlock );
-                //      __cfaabi_bits_print_nolock( STDERR_FILENO, "extend() : internal error, mprotect failure, heapEnd:%p size:%zd, errno:%d.\n", heapEnd, increase, errno );
-                //      _exit( EXIT_FAILURE );
-                // } // if
+                if ( mprotect( (char *)heapEnd + heapRemaining, increase, __map_prot ) ) {
+                        unlock( extlock );
+                        __cfaabi_bits_print_nolock( STDERR_FILENO, "extend() : internal error, mprotect failure, heapEnd:%p size:%zd, errno:%d.\n", heapEnd, increase, errno );
+                        _exit( EXIT_FAILURE );
+                } // if
 
                 #ifdef __STATISTICS__
@@ -580 +581 @@
         // Look up size in the size list.  Make sure the user request includes space for the header that must be allocated
         // along with the block and is a multiple of the alignment size.
+
         size_t tsize = size + sizeof(Heap.Storage);
 
@@ -855 +857 @@
         // SKULLDUGGERY: insert the offset to the start of the actual storage block and remember alignment
         fakeHeader->kind.fake.offset = (char *)fakeHeader - (char *)RealHeader;
-        // SKULLDUGGERY: odd alignment imples fake header
+        // SKULLDUGGERY: odd alignment implies fake header
         fakeHeader->kind.fake.alignment = MarkAlignmentBit( alignment );
 
@@ -1135 +1137 @@
         // free(3).
         int posix_memalign( void ** memptr, size_t alignment, size_t size ) {
-                if ( unlikely( alignment < libAlign() || ! is_pow2( alignment ) ) ) return EINVAL; // check alignment
+          if ( unlikely( alignment < libAlign() || ! is_pow2( alignment ) ) ) return EINVAL; // check alignment
                 *memptr = memalign( alignment, size );
                 return 0;
@@ -1189 +1191 @@
 
 
-        // Set the alignment for an the allocation and return previous alignment or 0 if no alignment.
-        // size_t malloc_alignment_set$( void * addr, size_t alignment ) {
-        //   if ( unlikely( addr == 0p ) ) return libAlign();   // minimum alignment
-        //      size_t ret;
-        //      Heap.Storage.Header * header = HeaderAddr( addr );
-        //      if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
-        //              ret = header->kind.fake.alignment & -2;         // remove flag from old value
-        //              header->kind.fake.alignment = alignment | 1; // add flag to new value
-        //      } else {
-        //              ret = 0;                                                                        // => no alignment to change
-        //      } // if
-        //      return ret;
-        // } // malloc_alignment_set$
-
-
         // Returns true if the allocation is zero filled, e.g., allocated by calloc().
         bool malloc_zero_fill( void * addr ) {
@@ -1214 +1201 @@
         } // malloc_zero_fill
 
-        // Set allocation is zero filled and return previous zero filled.
-        // bool malloc_zero_fill_set$( void * addr ) {
-        //   if ( unlikely( addr == 0p ) ) return false;                // null allocation is not zero fill
-        //      Heap.Storage.Header * header = HeaderAddr( addr );
-        //      if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
-        //              header = RealHeader( header );                          // backup from fake to real header
-        //      } // if
-        //      bool ret = (header->kind.real.blockSize & 2) != 0; // zero filled ?
-        //      header->kind.real.blockSize |= 2;                               // mark as zero filled
-        //      return ret;
-        // } // malloc_zero_fill_set$
-
 
         // Returns original total allocation size (not bucket size) => array size is dimension * sizeof(T).
@@ -1236 +1211 @@
                 return header->kind.real.size;
         } // malloc_size
-
-        // Set allocation size and return previous size.
-        // size_t malloc_size_set$( void * addr, size_t size ) {
-        //   if ( unlikely( addr == 0p ) ) return 0;                    // null allocation has 0 size
-        //      Heap.Storage.Header * header = HeaderAddr( addr );
-        //      if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
-        //              header = RealHeader( header );                          // backup from fake to real header
-        //      } // if
-        //      size_t ret = header->kind.real.size;
-        //      header->kind.real.size = size;
-        //      return ret;
-        // } // malloc_size_set$