Changeset 6c144d8

Timestamp:

Aug 6, 2020, 3:34:47 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

1eb239e4, c8e4b23d

Parents:

d3a518c (diff), 74cfe054 (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

Files:

• libcfa/src/exception.hfa (modified) (1 diff)
• libcfa/src/heap.cfa (modified) (15 diffs)
• libcfa/src/heap.hfa (modified) (2 diffs)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (2 diffs)
• tests/exceptions/.expect/polymorphic.txt (moved) (moved from tests/exceptions/.expect/polymophic.txt)
• tests/exceptions/polymorphic.cfa (moved) (moved from tests/exceptions/polymophic.cfa) (1 diff)

libcfa/src/exception.hfa

@@ -160 +160 @@
 
 #define _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters) \
-        forall(_UNPACK assertions | VTABLE_ASSERTION(exception_name, assertions, parameters) ) \
-                /*| { VTABLE_TYPE(exception_name) parameters VTABLE_NAME(exception_name); } ) */ \
+        forall(_UNPACK assertions | VTABLE_ASSERTION(exception_name, parameters) ) \
         void ?{}(exception_name parameters & this)
 

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug  3 19:01:22 2020
-// Update Count     : 828
+// Last Modified On : Wed Aug  5 22:21:27 2020
+// Update Count     : 853
 //
 
@@ -80 +80 @@
 };
 
+size_t default_mmap_start() __attribute__(( weak )) {
+        return __CFA_DEFAULT_MMAP_START__;
+} // default_mmap_start
+
 size_t default_heap_expansion() __attribute__(( weak )) {
         return __CFA_DEFAULT_HEAP_EXPANSION__;
 } // default_heap_expansion
 
-size_t default_mmap_start() __attribute__(( weak )) {
-        return __CFA_DEFAULT_MMAP_START__;
-} // default_mmap_start
+bool default_heap_exhausted() __attribute__(( weak )) { // find and free some storage
+        // Returning false prints "out of heap memory" message and aborts.
+        return false;
+} // default_heap_exhausted
 
 
@@ -473 +478 @@
 } // headers
 
+#define NO_MEMORY_MSG "no heap memory available for allocating %zd new bytes."
 
 static inline void * extend( size_t size ) with( heapManager ) {
@@ -481 +487 @@
 
                 size_t increase = libCeiling( size > heapExpand ? size : heapExpand, libAlign() );
-                if ( sbrk( increase ) == (void *)-1 ) {
+          Succeed:
+                {
+                        if ( sbrk( increase ) != (void *)-1 ) break Succeed; // succeed ?
+                        if ( default_heap_exhausted() ) {                       // try fix
+                                if ( sbrk( increase ) != (void *)-1 ) break Succeed; // succeed ?
+                        } // if
                         unlock( extlock );
-                        errno = ENOMEM;
-//                      return 0p;
-                        abort( "no memory" );
-                } // if
+                        abort( NO_MEMORY_MSG, size );                           // give up
+                }
                 #ifdef __STATISTICS__
                 sbrk_calls += 1;
@@ -554 +563 @@
 
                         block = (HeapManager.Storage *)extend( tsize ); // mutual exclusion on call
-//      if ( unlikely( block == 0p ) ) return 0p;
                 #if BUCKETLOCK == SPINLOCK
                 } else {
@@ -570 +578 @@
                 __atomic_add_fetch( &mmap_storage, tsize, __ATOMIC_SEQ_CST );
                 #endif // __STATISTICS__
-                block = (HeapManager.Storage *)mmap( 0, tsize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, mmapFd, 0 );
-                if ( block == (HeapManager.Storage *)MAP_FAILED ) {
+          Succeed:
+                {
+                        block = (HeapManager.Storage *)mmap( 0, tsize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, mmapFd, 0 );
+                        if ( block != (HeapManager.Storage *)MAP_FAILED ) break Succeed; // succeed ?
+                        if ( errno == ENOMEM && default_heap_exhausted() ) { // out of memory and try again ?
+                                block = (HeapManager.Storage *)mmap( 0, tsize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, mmapFd, 0 );
+                                if ( block != (HeapManager.Storage *)MAP_FAILED ) break Succeed; // succeed ?
+                        } // if
+                        if ( errno == ENOMEM ) abort( NO_MEMORY_MSG, tsize );
                         // Do not call strerror( errno ) as it may call malloc.
                         abort( "(HeapManager &)0x%p.doMalloc() : internal error, mmap failure, size:%zu error:%d.", &heapManager, tsize, errno );
-                } // if
+                }
                 #ifdef __CFA_DEBUG__
                 // Set new memory to garbage so subsequent uninitialized usages might fail.
@@ -751 +766 @@
 static inline void * mallocNoStats( size_t size ) {             // necessary for malloc statistics
         verify( heapManager.heapBegin != 0 );                           // called before memory_startup ?
-  if ( size == 0 ) return 0p;                                                   // 0 BYTE ALLOCATION RETURNS NULL POINTER
+  if ( unlikely( size ) == 0 ) return 0p;                               // 0 BYTE ALLOCATION RETURNS NULL POINTER
 
 #if __SIZEOF_POINTER__ == 8
@@ -762 +777 @@
 static inline void * callocNoStats( size_t dim, size_t elemSize ) {
         size_t size = dim * elemSize;
-  if ( size == 0 ) return 0p;                                                   // 0 BYTE ALLOCATION RETURNS NULL POINTER
+  if ( unlikely( size ) == 0 ) return 0p;                               // 0 BYTE ALLOCATION RETURNS NULL POINTER
         char * addr = (char *)mallocNoStats( size );
 
@@ -773 +788 @@
                 headers( "calloc", addr, header, freeElem, bsize, alignment );
         #ifndef __CFA_DEBUG__
+
         // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
         if ( ! mapped )
@@ -786 +802 @@
 
 static inline void * memalignNoStats( size_t alignment, size_t size ) { // necessary for malloc statistics
-  if ( size == 0 ) return 0p;                                                   // 0 BYTE ALLOCATION RETURNS NULL POINTER
+  if ( unlikely( size ) == 0 ) return 0p;                               // 0 BYTE ALLOCATION RETURNS NULL POINTER
 
         #ifdef __CFA_DEBUG__
@@ -825 +841 @@
 static inline void * cmemalignNoStats( size_t alignment, size_t dim, size_t elemSize ) {
         size_t size = dim * elemSize;
-  if ( size == 0 ) return 0p;                                                   // 0 BYTE ALLOCATION RETURNS NULL POINTER
+  if ( unlikely( size ) == 0 ) return 0p;                               // 0 BYTE ALLOCATION RETURNS NULL POINTER
         char * addr = (char *)memalignNoStats( alignment, size );
 
@@ -831 +847 @@
         HeapManager.FreeHeader * freeElem;
         size_t bsize;
-        bool mapped __attribute__(( unused )) = headers( "cmemalign", addr, header, freeElem, bsize, alignment );
         #ifndef __CFA_DEBUG__
+        bool mapped =
+        #endif // __CFA_DEBUG__
+                headers( "cmemalign", addr, header, freeElem, bsize, alignment );
+        #ifndef __CFA_DEBUG__
+
         // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
         if ( ! mapped )
         #endif // __CFA_DEBUG__
-                memset( addr, '\0', dataStorage( bsize, addr, header ) ); // set to zeros
+                // <-------0000000000000000000000000000UUUUUUUUUUUUUUUUUUUUUUUUU> bsize (bucket size) U => undefined
+                // `-header`-addr                      `-size
+                memset( addr, '\0', size );                                             // set to zeros
 
         header->kind.real.blockSize |= 2;                                       // mark as zero filled
@@ -1135 +1157 @@
 
                 headers( "malloc_usable_size", addr, header, freeElem, bsize, alignment );
-                return dataStorage( bsize, addr, header );      // data storage in bucket
+                return dataStorage( bsize, addr, header );              // data storage in bucket
         } // malloc_usable_size
 
@@ -1233 +1255 @@
                 if ( size <= odsize && odsize <= size * 2 ) {   // allow 50% wasted storage for smaller size
                         header->kind.real.blockSize &= -2;                      // turn off 0 fill
-                        if ( size != odsize ) header->kind.real.size = size; // reset allocation size
+                        header->kind.real.size = size;                          // reset allocation size
                         return oaddr;
                 } // if
         } // if
 
-        // change size
-
-        void * naddr = memalignNoStats( nalign, size );         // create new aligned area
+        // change size, DO NOT preserve STICKY PROPERTIES.
         free( oaddr );
-        return naddr;
+        return memalignNoStats( nalign, size );                         // create new aligned area
 } // resize
 
@@ -1272 +1292 @@
         #endif // __STATISTICS__
 
-        size_t osize = header->kind.real.size;                  // old allocation size
-        bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
-
         // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
   if ( unlikely( size == 0 ) ) { free( oaddr ); return 0p; } // special cases
   if ( unlikely( oaddr == 0p ) ) return memalignNoStats( nalign, size );
 
-        void * naddr;
-        if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill
-                naddr = cmemalignNoStats( nalign, 1, size );    // create new aligned area
-        } else {
-                naddr = memalignNoStats( nalign, size );                // create new aligned area
-        } // if
+        size_t osize = header->kind.real.size;                          // old allocation size
+        bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
+
+        void * naddr = memalignNoStats( nalign, size );         // create new aligned area
 
         headers( "realloc", naddr, header, freeElem, bsize, oalign );

libcfa/src/heap.hfa

@@ -10 +10 @@
 // Created On       : Tue May 26 11:23:55 2020
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jul 20 18:52:31 2020
-// Update Count     : 11
+// Last Modified On : Wed Aug  5 14:55:55 2020
+// Update Count     : 14
 // 
 
@@ -18 +18 @@
 size_t default_mmap_start();                                                    // CFA extras
 size_t default_heap_expansion();
+bool default_heap_exhausted();                                                  // unsafe to call printf!
 
 bool traceHeap();

tests/Makefile.am

@@ -19 +19 @@
 
 include $(top_srcdir)/src/cfa.make
+
+DEFAULT_INCLUDES = -I${abs_srcdir}
 
 debug=yes

tests/Makefile.in

@@ -133 +133 @@
 am__v_at_0 = @
 am__v_at_1 = 
-DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
 depcomp = $(SHELL) $(top_srcdir)/automake/depcomp
 am__depfiles_maybe = depfiles
@@ -394 +393 @@
 am__v_JAVAC_0 = @echo "  JAVAC   " $@;
 am__v_JAVAC_1 = 
+DEFAULT_INCLUDES = -I${abs_srcdir}
 debug = yes
 installed = no

tests/exceptions/polymorphic.cfa

@@ -3 +3 @@
 #include <exception.hfa>
 
-FORALL_TRIVIAL_EXCEPTION_(proxy, (otype U3), (U3));
-FORALL_TRIVIAL_INSTANCE_(proxy, (otype U4), (U4))
+FORALL_TRIVIAL_EXCEPTION(proxy, (otype T), (T));
+FORALL_TRIVIAL_INSTANCE(proxy, (otype U), (U))
 
 const char * msg(proxy(int) * this) { return "proxy(int)"; }