Changeset ce55a81 for libcfa

Timestamp:

Sep 4, 2020, 2:14:10 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:

14d8a9b

Parents:

56c44dc (diff), 2801829 (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:

libcfa

Files:

• Makefile.dist.am (added)
• prelude/Makefile.am (modified) (1 diff)
• src/Makefile.am (modified) (4 diffs)
• src/bits/defs.hfa (modified) (3 diffs)
• src/bits/locks.hfa (modified) (4 diffs)
• src/concurrency/CtxSwitch-arm64.S (modified) (3 diffs)
• src/concurrency/kernel.cfa (modified) (3 diffs)
• src/concurrency/preemption.cfa (modified) (2 diffs)
• src/exception.c (modified) (5 diffs)
• src/heap.cfa (modified) (9 diffs)
• src/stdlib.hfa (modified) (7 diffs)

libcfa/prelude/Makefile.am

@@ -22 +22 @@
 cfalibdir = ${CFA_LIBDIR}
 cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c defines.hfa
+
+EXTRA_DIST = bootloader.cf builtins.c builtins.def extras.c extras.regx extras.regx2 prelude-gen.cc prototypes.awk prototypes.c prototypes.sed sync-builtins.cf
 
 CC = @LOCAL_CFACC@

libcfa/src/Makefile.am

@@ -31 +31 @@
 # AM_CFAFLAGS for only cfa source
 # use -no-include-stdhdr to prevent rebuild cycles
-# The built sources must not depend on the installed headers
-AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
+# The built sources must not depend on the installed inst_headers_src
+AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr -I$(srcdir)/concurrency $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
 AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -fexceptions -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
@@ -39 +39 @@
 #----------------------------------------------------------------------------------------------------------------
 if BUILDLIB
-headers_nosrc = bitmanip.hfa exception.hfa math.hfa gmp.hfa time_t.hfa clock.hfa \
-                bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa \
-                containers/list.hfa containers/stackLockFree.hfa concurrency/iofwd.hfa
+inst_headers_nosrc = \
+        bitmanip.hfa \
+        clock.hfa \
+        exception.hfa \
+        gmp.hfa \
+        math.hfa \
+        time_t.hfa \
+        bits/align.hfa \
+        bits/containers.hfa \
+        bits/debug.hfa \
+        bits/defs.hfa \
+        bits/locks.hfa \
+        concurrency/iofwd.hfa \
+        containers/list.hfa \
+        containers/stackLockFree.hfa
 
-headers = common.hfa fstream.hfa heap.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa \
-                time.hfa stdlib.hfa parseargs.hfa \
-                containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa
+inst_headers_src = \
+        common.hfa \
+        fstream.hfa \
+        heap.hfa \
+        iostream.hfa \
+        iterator.hfa \
+        limits.hfa \
+        parseargs.hfa \
+        rational.hfa \
+        stdlib.hfa \
+        time.hfa \
+        containers/maybe.hfa \
+        containers/pair.hfa \
+        containers/result.hfa \
+        containers/vector.hfa
 
-libsrc = startup.cfa interpose.cfa bits/debug.cfa assert.cfa exception.c virtual.c ${headers:.hfa=.cfa}
+libsrc = ${inst_headers_src} ${inst_headers_src:.hfa=.cfa} \
+        assert.cfa \
+        bits/algorithm.hfa \
+        bits/debug.cfa \
+        exception.c \
+        exception.h \
+        interpose.cfa \
+        lsda.h \
+        startup.cfa \
+        startup.hfa \
+        virtual.c \
+        virtual.h
 
 # not all platforms support concurrency, add option do disable it
-thread_headers_nosrc = bits/random.hfa concurrency/invoke.h concurrency/kernel/fwd.hfa
+inst_thread_headers_nosrc = \
+        bits/random.hfa \
+        concurrency/invoke.h \
+        concurrency/kernel/fwd.hfa
 
-thread_headers = concurrency/coroutine.hfa concurrency/thread.hfa concurrency/kernel.hfa \
-                concurrency/monitor.hfa concurrency/mutex.hfa concurrency/exception.hfa
+inst_thread_headers_src = \
+        concurrency/coroutine.hfa \
+        concurrency/exception.hfa \
+        concurrency/kernel.hfa \
+        concurrency/monitor.hfa \
+        concurrency/mutex.hfa \
+        concurrency/thread.hfa
 
-thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa \
-                concurrency/invoke.c concurrency/io.cfa concurrency/iocall.cfa \
-                concurrency/io/setup.cfa \
-                concurrency/kernel/startup.cfa concurrency/preemption.cfa \
-                concurrency/ready_queue.cfa concurrency/stats.cfa \
-                ${thread_headers:.hfa=.cfa}
+thread_libsrc = ${inst_thread_headers_src} ${inst_thread_headers_src:.hfa=.cfa} \
+        bits/signal.hfa \
+        concurrency/alarm.cfa \
+        concurrency/alarm.hfa \
+        concurrency/CtxSwitch-@ARCHITECTURE@.S \
+        concurrency/invoke.c \
+        concurrency/io.cfa \
+        concurrency/io/setup.cfa \
+        concurrency/io/types.hfa \
+        concurrency/iocall.cfa \
+        concurrency/iofwd.hfa \
+        concurrency/kernel_private.hfa \
+        concurrency/kernel/startup.cfa \
+        concurrency/preemption.cfa \
+        concurrency/preemption.hfa \
+        concurrency/ready_queue.cfa \
+        concurrency/ready_subqueue.hfa \
+        concurrency/snzi.hfa \
+        concurrency/stats.cfa \
+        concurrency/stats.hfa \
+        concurrency/stats.hfa
+
 else
-headers =
-thread_headers =
-headers_nosrc =
-thread_headers_nosrc =
+inst_headers_src =
+inst_thread_headers_src =
+inst_headers_nosrc =
+inst_thread_headers_nosrc =
 libsrc =
 endif
@@ -115 +174 @@
 
 #----------------------------------------------------------------------------------------------------------------
-libcfa_la_SOURCES = prelude.cfa ${libsrc}
+libcfa_la_SOURCES = ${libsrc}
+nodist_libcfa_la_SOURCES = prelude.cfa
 libcfa_la_LDFLAGS = -version-info @CFA_VERSION@
 
@@ -124 +184 @@
 
 cfa_includedir = $(CFA_INCDIR)
-nobase_cfa_include_HEADERS = ${stdhdr} ${headers} ${headers_nosrc} ${thread_headers} ${thread_headers_nosrc}
+nobase_cfa_include_HEADERS = ${stdhdr} ${inst_headers_src} ${inst_headers_nosrc} ${inst_thread_headers_src} ${inst_thread_headers_nosrc}
+EXTRA_DIST = stdhdr
 
 #----------------------------------------------------------------------------------------------------------------

libcfa/src/bits/defs.hfa

@@ -10 +10 @@
 // Created On       : Thu Nov  9 13:24:10 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 13 22:00:23 2020
-// Update Count     : 19
+// Last Modified On : Wed Aug 26 16:22:32 2020
+// Update Count     : 20
 //
 
@@ -49 +49 @@
 
 static inline long long int rdtscl(void) {
-        #if defined( __aarch64__ )
+        #if defined( __i386 ) || defined( __x86_64 )
+        unsigned int lo, hi;
+        __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
+        return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+        #elif defined( __aarch64__ ) || defined( __arm__ )
         // https://github.com/google/benchmark/blob/v1.1.0/src/cycleclock.h#L116
         long long int virtual_timer_value;
@@ -55 +59 @@
         return virtual_timer_value;
         #else
-        unsigned int lo, hi;
-        __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
-        return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+                #error unsupported hardware architecture
         #endif // __ARM_ARCH
 }

libcfa/src/bits/locks.hfa

@@ -218 +218 @@
         }
 
-        // Semaphore which only supports a single thread and one post
-        // Semaphore which only supports a single thread
+        // Synchronozation primitive which only supports a single thread and one post
+        // Similar to a binary semaphore with a 'one shot' semantic
+        // is expected to be discarded after each party call their side
         struct oneshot {
+                // Internal state :
+                //     0p     : is initial state (wait will block)
+                //     1p     : fulfilled (wait won't block)
+                // any thread : a thread is currently waiting
                 struct $thread * volatile ptr;
         };
@@ -231 +236 @@
                 void ^?{}(oneshot & this) {}
 
+                // Wait for the post, return immidiately if it already happened.
+                // return true if the thread was parked
                 bool wait(oneshot & this) {
                         for() {
@@ -244 +251 @@
                 }
 
+                // Mark as fulfilled, wake thread if needed
+                // return true if a thread was unparked
                 bool post(oneshot & this) {
                         struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
@@ -251 +260 @@
                 }
         }
+
+        // base types for future to build upon
+        // It is based on the 'oneshot' type to allow multiple futures
+        // to block on the same instance, permitting users to block a single
+        // thread on "any of" [a given set of] futures.
+        // does not support multiple threads waiting on the same future
+        struct future_t {
+                // Internal state :
+                //     0p      : is initial state (wait will block)
+                //     1p      : fulfilled (wait won't block)
+                //     2p      : in progress ()
+                //     3p      : abandoned, server should delete
+                // any oneshot : a context has been setup to wait, a thread could wait on it
+                struct oneshot * volatile ptr;
+        };
+
+        static inline {
+                void  ?{}(future_t & this) {
+                        this.ptr = 0p;
+                }
+
+                void ^?{}(future_t & this) {}
+
+                // check if the future is available
+                bool available( future_t & this ) {
+                        return this.ptr == 1p;
+                }
+
+                // Prepare the future to be waited on
+                // intented to be use by wait, wait_any, waitfor, etc. rather than used directly
+                bool setup( future_t & this, oneshot & wait_ctx ) {
+                        /* paranoid */ verify( wait_ctx.ptr == 0p );
+                        // The future needs to set the wait context
+                        for() {
+                                struct oneshot * expected = this.ptr;
+                                // Is the future already fulfilled?
+                                if(expected == 1p) return false; // Yes, just return false (didn't block)
+
+                                // The future is not fulfilled, try to setup the wait context
+                                /* paranoid */ verify( expected == 0p );
+                                if(__atomic_compare_exchange_n(&this.ptr, &expected, &wait_ctx, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                        return true;
+                                }
+                        }
+                }
+
+                // Stop waiting on a future
+                // When multiple futures are waited for together in "any of" pattern
+                // futures that weren't fulfilled before the thread woke up
+                // should retract the wait ctx
+                // intented to be use by wait, wait_any, waitfor, etc. rather than used directly
+                void retract( future_t & this, oneshot & wait_ctx ) {
+                        // Remove the wait context
+                        struct oneshot * got = __atomic_exchange_n( &this.ptr, 0p, __ATOMIC_SEQ_CST);
+
+                        // got == 0p: future was never actually setup, just return
+                        if( got == 0p ) return;
+
+                        // got == wait_ctx: since fulfil does an atomic_swap,
+                        // if we got back the original then no one else saw context
+                        // It is safe to delete (which could happen after the return)
+                        if( got == &wait_ctx ) return;
+
+                        // got == 1p: the future is ready and the context was fully consumed
+                        // the server won't use the pointer again
+                        // It is safe to delete (which could happen after the return)
+                        if( got == 1p ) return;
+
+                        // got == 2p: the future is ready but the context hasn't fully been consumed
+                        // spin until it is safe to move on
+                        if( got == 2p ) {
+                                while( this.ptr != 1p ) Pause();
+                                return;
+                        }
+
+                        // got == any thing else, something wen't wrong here, abort
+                        abort("Future in unexpected state");
+                }
+
+                // Mark the future as abandoned, meaning it will be deleted by the server
+                void abandon( future_t & this ) {
+                        struct oneshot * got = __atomic_exchange_n( &this.ptr, 3p, __ATOMIC_SEQ_CST);
+
+                        // got == 2p: the future is ready but the context hasn't fully been consumed
+                        // spin until it is safe to move on
+                        if( got == 2p ) {
+                                while( this.ptr != 1p ) Pause();
+                        }
+                        return;
+                }
+
+                // from the server side, mark the future as fulfilled
+                // delete it if needed
+                bool fulfil( future_t & this ) {
+                        for() {
+                                struct oneshot * expected = this.ptr;
+                                // was this abandoned?
+                                if( expected == 3p ) { free( &this ); return false; }
+
+                                /* paranoid */ verify( expected != 1p ); // Future is already fulfilled, should not happen
+                                /* paranoid */ verify( expected != 2p ); // Future is bein fulfilled by someone else, this is even less supported then the previous case.
+
+                                // If there is a wait context, we need to consume it and mark it as consumed after
+                                // If there is no context then we can skip the in progress phase
+                                struct oneshot * want = expected == 0p ? 1p : 2p;
+                                if(__atomic_compare_exchange_n(&this.ptr, &expected, want, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                        if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return false; }
+                                        bool ret = post( *expected );
+                                        __atomic_store_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
+                                        return ret;
+                                }
+                        }
+
+                }
+
+                // Wait for the future to be fulfilled
+                bool wait( future_t & this ) {
+                        oneshot temp;
+                        if( !setup(this, temp) ) return false;
+
+                        // Wait context is setup, just wait on it
+                        bool ret = wait( temp );
+
+                        // Wait for the future to tru
+                        while( this.ptr == 2p ) Pause();
+                        // Make sure the state makes sense
+                        // Should be fulfilled, could be in progress but it's out of date if so
+                        // since if that is the case, the oneshot was fulfilled (unparking this thread)
+                        // and the oneshot should not be needed any more
+                        __attribute__((unused)) struct oneshot * was = this.ptr;
+                        /* paranoid */ verifyf( was == 1p, "Expected this.ptr to be 1p, was %p\n", was );
+
+                        // Mark the future as fulfilled, to be consistent
+                        // with potential calls to avail
+                        // this.ptr = 1p;
+                        return ret;
+                }
+        }
 #endif

libcfa/src/concurrency/CtxSwitch-arm64.S

@@ -2 +2 @@
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 // 
-// CtxSwitch-arm.S -- 
+// CtxSwitch-arm64.S -- 
 // 
 // Author           : Peter A. Buhr
 // Created On       : Sun Aug 16 07:50:13 2020
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 20 18:43:51 2020
-// Update Count     : 24
+// Last Modified On : Wed Aug 26 16:24:59 2020
+// Update Count     : 25
 // 
 
@@ -26 +26 @@
 #define SAVE            20 * 8
 
-        .file "CtxSwitch-arm.S"
+        .file "CtxSwitch-arm64.S"
         .text
         .align 2
         .global __cfactx_switch
-        .type __cfactx_switch, @function
+        .type __cfactx_switch, %function
 __cfactx_switch:
 
@@ -91 +91 @@
         .align 2
         .global __cfactx_invoke_stub
-        .type __cfactx_invoke_stub, @function
+        .type __cfactx_invoke_stub, %function
 __cfactx_invoke_stub:
         mov x0, x19                                                     // load main as parameter 0

libcfa/src/concurrency/kernel.cfa

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Aug 14 15:23:00 2020
-// Update Count     : 69
+// Last Modified On : Mon Aug 31 07:08:20 2020
+// Update Count     : 71
 //
 
@@ -74 +74 @@
                 )
 
-#elif defined( __ARM_ARCH )
+#elif defined( __arm__ )
+        #define __x87_store
+        #define __x87_load
+
+#elif defined( __aarch64__ )
         #define __x87_store              \
                 uint32_t __fpcntl[2];    \
@@ -93 +97 @@
 
 #else
-        #error unknown hardware architecture
+        #error unsupported hardware architecture
 #endif
 

libcfa/src/concurrency/preemption.cfa

@@ -10 +10 @@
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Aug 21 13:45:32 2020
-// Update Count     : 52
+// Last Modified On : Wed Aug 26 16:46:03 2020
+// Update Count     : 53
 //
 
@@ -56 +56 @@
 #elif defined( __x86_64 )
 #define CFA_REG_IP gregs[REG_RIP]
-#elif defined( __ARM_ARCH )
+#elif defined( __arm__ )
+#define CFA_REG_IP arm_pc
+#elif defined( __aarch64__ )
 #define CFA_REG_IP pc
 #else
-#error unknown hardware architecture
+#error unsupported hardware architecture
 #endif
 

libcfa/src/exception.c

@@ -10 +10 @@
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Aug 21 11:27:56 2020
-// Update Count     : 29
+// Last Modified On : Sat Aug 29 15:52:22 2020
+// Update Count     : 34
 //
 
@@ -18 +18 @@
 
 #include "exception.h"
-
-// Implementation of the secret header is hardware dependent.
-#if defined( __x86_64 ) || defined( __i386 )
-#elif defined( __ARM_ARCH )
-#warning FIX ME: check if anything needed for ARM
-#else
-#warning Exception Handling: No known architecture detected.
-#endif
 
 #include <stdlib.h>
@@ -34 +26 @@
 #include "stdhdr/assert.h"
 
-// FIX ME: temporary hack to keep ARM build working
+#if defined( __ARM_ARCH )
+#warning FIX ME: temporary hack to keep ARM build working
 #ifndef _URC_FATAL_PHASE1_ERROR
 #define _URC_FATAL_PHASE1_ERROR 3
@@ -41 +34 @@
 #define _URC_FATAL_PHASE2_ERROR 2
 #endif // ! _URC_FATAL_PHASE2_ERROR
+#endif // __ARM_ARCH
 
 #include "lsda.h"
@@ -626 +620 @@
 
 #pragma GCC pop_options
+
+#elif defined( __ARM_ARCH )
+_Unwind_Reason_Code __gcfa_personality_v0(
+                int version,
+                _Unwind_Action actions,
+                unsigned long long exception_class,
+                struct _Unwind_Exception * unwind_exception,
+                struct _Unwind_Context * unwind_context) {
+        return _URC_CONTINUE_UNWIND;
+}
+
+__attribute__((noinline))
+void __cfaehm_try_terminate(void (*try_block)(),
+                void (*catch_block)(int index, exception_t * except),
+                __attribute__((unused)) int (*match_block)(exception_t * except)) {
+}
+#else
+        #error unsupported hardware architecture
 #endif // __x86_64 || __i386

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 24 20:29:24 2020
-// Update Count     : 926
+// Last Modified On : Thu Sep  3 16:22:54 2020
+// Update Count     : 943
 //
 
@@ -29 +29 @@
 #include "math.hfa"                                                                             // ceiling
 #include "bitmanip.hfa"                                                                 // is_pow2, ceiling2
-
-#define MIN(x, y) (y > x ? x : y)
 
 static bool traceHeap = false;
@@ -956 +954 @@
 
                 headers( "realloc", naddr, header, freeElem, bsize, oalign );
-                memcpy( naddr, oaddr, MIN( osize, size ) );             // copy bytes
+                memcpy( naddr, oaddr, min( osize, size ) );             // copy bytes
                 free( oaddr );
 
@@ -1218 +1216 @@
         #endif // __STATISTICS__
 
-        // 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 ) ) {
-                #ifdef __STATISTICS__
-                __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
-                #endif // __STATISTICS__
-                return memalignNoStats( nalign, size );
-        } // if
-
         if ( unlikely( nalign < libAlign() ) ) nalign = libAlign(); // reset alignment to minimum
         #ifdef __CFA_DEBUG__
@@ -1233 +1222 @@
         #endif // __CFA_DEBUG__
 
-        HeapManager.Storage.Header * header;
-        HeapManager.FreeHeader * freeElem;
-        size_t bsize, oalign;
-        headers( "resize", oaddr, header, freeElem, bsize, oalign );
-        size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
-
-        if ( oalign <= nalign && (uintptr_t)oaddr % nalign == 0 ) { // <= alignment and new alignment happens to match
-                if ( oalign > libAlign() ) {                                    // fake header ?
+        // 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 ) ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+                return memalignNoStats( nalign, size );
+        } // if
+
+        // Attempt to reuse existing storage.
+        HeapManager.Storage.Header * header = headerAddr( oaddr );
+        if ( unlikely ( ( header->kind.fake.alignment & 1 == 1 &&       // old fake header ?
+                                 (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
+                                 header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
+                                 nalign <= 128 )                                                                // not too much alignment storage wasted ?
+                        ||   ( header->kind.fake.alignment & 1 != 1 &&          // old real header ( aligned on libAlign ) ?
+                                 nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
+
+                HeapManager.FreeHeader * freeElem;
+                size_t bsize, oalign;
+                headers( "resize", oaddr, header, freeElem, bsize, oalign );
+                size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
+
+                if ( size <= odsize && odsize <= size * 2 ) { // allow 50% wasted data storage
                         headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
-                } // if
-                if ( size <= odsize && odsize <= size * 2 ) {   // allow 50% wasted storage for smaller size
-                        header->kind.real.blockSize &= -2;                      // turn off 0 fill
-                        header->kind.real.size = size;                          // reset allocation size
+
+                        header->kind.real.blockSize &= -2;              // turn off 0 fill
+                        header->kind.real.size = size;                  // reset allocation size
                         return oaddr;
                 } // if
@@ -1267 +1271 @@
         #endif // __CFA_DEBUG__
 
+        // 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 ) ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
+                __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+                return memalignNoStats( nalign, size );
+        } // if
+
         HeapManager.Storage.Header * header;
         HeapManager.FreeHeader * freeElem;
@@ -1272 +1286 @@
         headers( "realloc", oaddr, header, freeElem, bsize, oalign );
 
-        if ( oalign <= nalign && (uintptr_t)oaddr % nalign == 0 ) { // <= alignment and new alignment happens to match
-                if ( oalign > libAlign() ) {                                    // fake header ?
-                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
-                } // if
+        // Attempt to reuse existing storage.
+        if ( unlikely ( ( header->kind.fake.alignment & 1 == 1 &&       // old fake header ?
+                                 (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
+                                 header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
+                                 nalign <= 128 )                                                                // not too much alignment storage wasted ?
+                        ||   ( header->kind.fake.alignment & 1 != 1 &&          // old real header ( aligned on libAlign ) ?
+                                 nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
+
+                headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
                 return realloc( oaddr, size );
+
         } // if
 
@@ -1286 +1306 @@
         #endif // __STATISTICS__
 
-        // 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 );
-
         size_t osize = header->kind.real.size;                          // old allocation size
         bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
@@ -1296 +1312 @@
 
         headers( "realloc", naddr, header, freeElem, bsize, oalign );
-        memcpy( naddr, oaddr, MIN( osize, size ) );                     // copy bytes
+        memcpy( naddr, oaddr, min( osize, size ) );                     // copy bytes
         free( oaddr );
 

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Aug 14 23:38:50 2020
-// Update Count     : 504
+// Last Modified On : Tue Sep  1 20:32:34 2020
+// Update Count     : 505
 //
 
@@ -44 +44 @@
 
 // Macro because of returns
-#define $VAR_ALLOC( allocation, alignment ) \
-        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( (size_t)sizeof(T) ); /* C allocation */ \
-        else return (T *)alignment( _Alignof(T), sizeof(T) )
-
 #define $ARRAY_ALLOC( allocation, alignment, dim ) \
         if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
         else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
 
-#define $RE_SPECIALS( ptr, size, allocation, alignment ) \
-        if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { \
-                if ( unlikely( size == 0 ) ) free( ptr ); \
-                $VAR_ALLOC( malloc, memalign ); \
-        } /* if */
-
 static inline forall( dtype T | sized(T) ) {
         // Cforall safe equivalents, i.e., implicit size specification
 
         T * malloc( void ) {
-                $VAR_ALLOC( malloc, memalign );
+                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C allocation
+                else return (T *)memalign( _Alignof(T), sizeof(T) );
         } // malloc
 
@@ -74 +65 @@
 
         T * resize( T * ptr, size_t size ) {                            // CFA resize, eliminate return-type cast
-                $RE_SPECIALS( ptr, size, malloc, memalign );
                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)resize( (void *)ptr, size ); // CFA resize
                 else return (T *)(void *)resize( (void *)ptr, _Alignof(T), size ); // CFA resize
@@ -80 +70 @@
 
         T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
-                $RE_SPECIALS( ptr, size, malloc, memalign );
                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
                 else return (T *)(void *)realloc( (void *)ptr, _Alignof(T), size ); // CFA realloc
@@ -189 +178 @@
                 size_t copy_end = 0;
 
-                if(Resize) {
-                        ptr = (T*) (void *) resize( (int *)Resize, Align, Dim * size );
-                } else if (Realloc) {
+                if ( Resize ) {
+                        ptr = (T*) (void *) resize( (void *)Resize, Align, Dim * size );
+                } else if ( Realloc ) {
                         if (Fill.tag != '0') copy_end = min(malloc_size( Realloc ), Dim * size);
-                        ptr = (T*) (void *) realloc( (int *)Realloc, Align, Dim * size );
+                        ptr = (T*) (void *) realloc( (void *)Realloc, Align, Dim * size );
                 } else {
                         ptr = (T*) (void *) memalign( Align, Dim * size );
@@ -201 +190 @@
                         memset( (char *)ptr + copy_end, (int)Fill.c, Dim * size - copy_end );
                 } else if(Fill.tag == 't') {
-                        for ( int i = copy_end; i <= Dim * size - size ; i += size ) {
+                        for ( int i = copy_end; i < Dim * size; i += size ) {
                                 memcpy( (char *)ptr + i, &Fill.t, size );
                         }
@@ -207 +196 @@
                         memcpy( (char *)ptr + copy_end, Fill.at, min(Dim * size - copy_end, Fill.size) );
                 } else if(Fill.tag == 'T') {
-                        for ( int i = copy_end; i <= Dim * size - size ; i += size ) {
+                        for ( int i = copy_end; i < Dim * size; i += size ) {
                                 memcpy( (char *)ptr + i, Fill.at, size );
                         }