Changes in / [af4487d:29d618e]

Files:

• libcfa/src/Makefile.am (modified) (1 diff)
• libcfa/src/concurrency/CtxSwitch-arm32.S (deleted)
• libcfa/src/concurrency/coroutine.cfa (modified) (1 diff)
• libcfa/src/concurrency/exception.cfa (deleted)
• libcfa/src/concurrency/exception.hfa (deleted)
• libcfa/src/concurrency/invoke.c (modified) (2 diffs)
• libcfa/src/concurrency/invoke.h (modified) (1 diff)
• libcfa/src/concurrency/io/setup.cfa (modified) (1 diff)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (4 diffs)
• libcfa/src/concurrency/ready_queue.cfa (modified) (11 diffs)
• libcfa/src/exception.c (modified) (2 diffs)
• libcfa/src/stdlib.hfa (modified) (1 diff)
• tests/concurrent/.expect/cluster.txt (deleted)
• tests/concurrent/cluster.cfa (deleted)

libcfa/src/Makefile.am

@@ -53 +53 @@
 
 thread_headers = concurrency/coroutine.hfa concurrency/thread.hfa concurrency/kernel.hfa \
-                concurrency/monitor.hfa concurrency/mutex.hfa concurrency/exception.hfa
+                concurrency/monitor.hfa concurrency/mutex.hfa
 
 thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa \

libcfa/src/concurrency/coroutine.cfa

@@ -215 +215 @@
                 return cor;
         }
+
+        struct $coroutine * __cfactx_cor_active(void) {
+                return active_coroutine();
+        }
 }
 

libcfa/src/concurrency/invoke.c

@@ -29 +29 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
+extern struct $coroutine * __cfactx_cor_active(void);
 extern struct $coroutine * __cfactx_cor_finish(void);
 extern void __cfactx_cor_leave ( struct $coroutine * );
@@ -35 +36 @@
 extern void disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+
+struct exception_context_t * this_exception_context() {
+        return &__get_stack( __cfactx_cor_active() )->exception_context;
+}
 
 void __cfactx_invoke_coroutine(

libcfa/src/concurrency/invoke.h

@@ -98 +98 @@
         }
 
+        struct exception_context_t * this_exception_context();
+
         // struct which calls the monitor is accepting
         struct __waitfor_mask_t {

libcfa/src/concurrency/io/setup.cfa

@@ -384 +384 @@
                         /* paranoid */ verify( is_pow2( params_in.num_ready ) || (params_in.num_ready < 8) );
                         sq.ready_cnt = max( params_in.num_ready, 8 );
-                        sq.ready = alloc( sq.ready_cnt, 64`align );
+                        sq.ready = alloc_align( 64, sq.ready_cnt );
                         for(i; sq.ready_cnt) {
                                 sq.ready[i] = -1ul32;

libcfa/src/concurrency/kernel/startup.cfa

@@ -579 +579 @@
 
         // Lock the RWlock so no-one pushes/pops while we are changing the queue
-        disable_interrupts();
         uint_fast32_t last_size = ready_mutate_lock();
 
@@ -587 +586 @@
         // Unlock the RWlock
         ready_mutate_unlock( last_size );
-        enable_interrupts_noPoll(); // Don't poll, could be in main cluster
-
 
         this.io.cnt  = num_io;
@@ -604 +601 @@
 
         // Lock the RWlock so no-one pushes/pops while we are changing the queue
-        disable_interrupts();
         uint_fast32_t last_size = ready_mutate_lock();
 
@@ -612 +608 @@
         // Unlock the RWlock
         ready_mutate_unlock( last_size );
-        enable_interrupts_noPoll(); // Don't poll, could be in main cluster
 
         #if !defined(__CFA_NO_STATISTICS__)

libcfa/src/concurrency/ready_queue.cfa

@@ -215 +215 @@
 }
 
-static inline [unsigned, bool] idx_from_r(unsigned r, unsigned preferred) {
-        unsigned i;
-        bool local;
-        #if defined(BIAS)
-                unsigned rlow  = r % BIAS;
-                unsigned rhigh = r / BIAS;
-                if((0 != rlow) && preferred >= 0) {
-                        // (BIAS - 1) out of BIAS chances
-                        // Use perferred queues
-                        i = preferred + (rhigh % 4);
-                        local = true;
-                }
-                else {
-                        // 1 out of BIAS chances
-                        // Use all queues
-                        i = rhigh;
-                        local = false;
-                }
-        #else
-                i = r;
-                local = false;
-        #endif
-        return [i, local];
-}
-
 //-----------------------------------------------------------------------
 __attribute__((hot)) bool push(struct cluster * cltr, struct $thread * thrd) with (cltr->ready_queue) {
@@ -247 +222 @@
         thrd->link.ts = rdtscl();
 
-        __attribute__((unused)) bool local;
-        __attribute__((unused)) int preferred;
-        #if defined(BIAS)
-                preferred =
+        #if defined(BIAS) && !defined(__CFA_NO_STATISTICS__)
+                bool local = false;
+                int preferred =
                         //*
                         kernelTLS.this_processor ? kernelTLS.this_processor->id * 4 : -1;
@@ -256 +230 @@
                         thrd->link.preferred * 4;
                         //*/
+
+
         #endif
 
@@ -262 +238 @@
         do {
                 // Pick the index of a lane
-                // unsigned r = __tls_rand();
-                unsigned r = __tls_rand_fwd();
-                [i, local] = idx_from_r(r, preferred);
-
-                #if !defined(__CFA_NO_STATISTICS__)
-                        if(local) {
-                                __tls_stats()->ready.pick.push.local++;
-                        }
+                #if defined(BIAS)
+                        unsigned r = __tls_rand();
+                        unsigned rlow  = r % BIAS;
+                        unsigned rhigh = r / BIAS;
+                        if((0 != rlow) && preferred >= 0) {
+                                // (BIAS - 1) out of BIAS chances
+                                // Use perferred queues
+                                i = preferred + (rhigh % 4);
+
+                                #if !defined(__CFA_NO_STATISTICS__)
+                                        local = true;
+                                        __tls_stats()->ready.pick.push.local++;
+                                #endif
+                        }
+                        else {
+                                // 1 out of BIAS chances
+                                // Use all queues
+                                i = rhigh;
+                                local = false;
+                        }
+                #else
+                        i = __tls_rand();
                 #endif
 
@@ -284 +274 @@
 
         // Actually push it
-        #ifdef USE_SNZI
-                bool lane_first =
-        #endif
-
-        push(lanes.data[i], thrd);
+        bool lane_first = push(lanes.data[i], thrd);
 
         #ifdef USE_SNZI
@@ -301 +287 @@
         #endif
 
-        __tls_rand_advance_bck();
-
         // Unlock and return
         __atomic_unlock( &lanes.data[i].lock );
@@ -327 +311 @@
         /* paranoid */ verify( lanes.count > 0 );
         unsigned count = __atomic_load_n( &lanes.count, __ATOMIC_RELAXED );
-        int preferred;
         #if defined(BIAS)
                 // Don't bother trying locally too much
                 int local_tries = 8;
-                preferred = kernelTLS.this_processor->id * 4;
-        #endif
-
+        #endif
 
         // As long as the list is not empty, try finding a lane that isn't empty and pop from it
@@ -342 +323 @@
         #endif
                 // Pick two lists at random
-                // unsigned ri = __tls_rand();
-                // unsigned rj = __tls_rand();
-                unsigned ri = __tls_rand_bck();
-                unsigned rj = __tls_rand_bck();
-
-                unsigned i, j;
-                __attribute__((unused)) bool locali, localj;
-                [i, locali] = idx_from_r(ri, preferred);
-                [j, localj] = idx_from_r(rj, preferred);
-
-                #if !defined(__CFA_NO_STATISTICS__)
-                        if(locali) {
-                                __tls_stats()->ready.pick.pop.local++;
-                        }
-                        if(localj) {
-                                __tls_stats()->ready.pick.pop.local++;
-                        }
+                unsigned i,j;
+                #if defined(BIAS)
+                        #if !defined(__CFA_NO_STATISTICS__)
+                                bool local = false;
+                        #endif
+                        uint64_t r = __tls_rand();
+                        unsigned rlow  = r % BIAS;
+                        uint64_t rhigh = r / BIAS;
+                        if(local_tries && 0 != rlow) {
+                                // (BIAS - 1) out of BIAS chances
+                                // Use perferred queues
+                                unsigned pid = kernelTLS.this_processor->id * 4;
+                                i = pid + (rhigh % 4);
+                                j = pid + ((rhigh >> 32ull) % 4);
+
+                                // count the tries
+                                local_tries--;
+
+                                #if !defined(__CFA_NO_STATISTICS__)
+                                        local = true;
+                                        __tls_stats()->ready.pick.pop.local++;
+                                #endif
+                        }
+                        else {
+                                // 1 out of BIAS chances
+                                // Use all queues
+                                i = rhigh;
+                                j = rhigh >> 32ull;
+                        }
+                #else
+                        i = __tls_rand();
+                        j = __tls_rand();
                 #endif
 
@@ -368 +364 @@
                 if(thrd) {
                         #if defined(BIAS) && !defined(__CFA_NO_STATISTICS__)
-                                if( locali || localj ) __tls_stats()->ready.pick.pop.lsuccess++;
+                                if( local ) __tls_stats()->ready.pick.pop.lsuccess++;
                         #endif
                         return thrd;
@@ -547 +543 @@
 
                 // Allocate new array (uses realloc and memcpies the data)
-                lanes.data = alloc( ncount, lanes.data`realloc );
+                lanes.data = alloc(lanes.data, ncount);
 
                 // Fix the moved data
@@ -638 +634 @@
 
                 // Allocate new array (uses realloc and memcpies the data)
-                lanes.data = alloc( lanes.count, lanes.data`realloc );
+                lanes.data = alloc(lanes.data, lanes.count);
 
                 // Fix the moved data

libcfa/src/exception.c

@@ -209 +209 @@
                 void * stop_param) {
         // Verify actions follow the rules we expect.
-        verify(actions & _UA_CLEANUP_PHASE);
-        verify(actions & _UA_FORCE_UNWIND);
-        verify(!(actions & _UA_SEARCH_PHASE));
-        verify(!(actions & _UA_HANDLER_FRAME));
+        verify((actions & _UA_CLEANUP_PHASE) && (actions & _UA_FORCE_UNWIND));
+        verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDLER_FRAME)));
 
         if ( actions & _UA_END_OF_STACK ) {
-                abort();
+                exit(1);
         } else {
                 return _URC_NO_REASON;
@@ -221 +219 @@
 }
 
-__attribute__((weak)) _Unwind_Reason_Code
-__cfaehm_cancellation_unwind( struct _Unwind_Exception * exception ) {
-        return _Unwind_ForcedUnwind( exception, _Stop_Fn, (void*)0x22 );
-}
+static struct _Unwind_Exception cancel_exception_storage;
 
 // Cancel the current stack, prefroming approprate clean-up and messaging.
 void __cfaehm_cancel_stack( exception_t * exception ) {
-        __cfaehm_allocate_exception( exception );
-
-        struct exception_context_t * context = this_exception_context();
-        struct __cfaehm_node * node = EXCEPT_TO_NODE(context->current_exception);
-
-        // Preform clean-up of any extra active exceptions.
-        while ( node->next ) {
-                struct __cfaehm_node * to_free = node->next;
-                node->next = to_free->next;
-                exception_t * except = NODE_TO_EXCEPT( to_free );
-                except->virtual_table->free( except );
-            free( to_free );
-        }
-
+        // TODO: Detect current stack and pick a particular stop-function.
         _Unwind_Reason_Code ret;
-        ret = __cfaehm_cancellation_unwind( &node->unwind_exception );
+        ret = _Unwind_ForcedUnwind( &cancel_exception_storage, _Stop_Fn, (void*)0x22 );
         printf("UNWIND ERROR %d after force unwind\n", ret);
         abort();

libcfa/src/stdlib.hfa

@@ -114 +114 @@
 } // distribution
 
-/*
-        FIX ME : fix alloc interface after Ticker Number 214 is resolved, define and add union to S_fill. Then, modify postfix-fill functions to support T * with nmemb, char, and T object of any size. Finally, change alloc_internal.
-        Or, just follow the instructions below for that.
-
-        1. Replace the current forall-block that contains defintions of S_fill and S_realloc with following:
-                forall( dtype T | sized(T) ) {
-                        union  U_fill           { char c; T * a; T t; };
-                        struct S_fill           { char tag; char c; size_t size; T * at; char t[50]; };
-                        struct S_realloc        { inline T *; };
-                }
-
-        2. Replace all current postfix-fill functions with following for updated S_fill:
-                S_fill(T) ?`fill( char a )                                      { S_fill(T) ret = {'c'}; ret.fill.c = a; return ret; }
-                S_fill(T) ?`fill( T    a )                                      { S_fill(T) ret = {'t'}; memcpy(&ret.fill.t, &a, sizeof(T)); return ret; }
-                S_fill(T) ?`fill( T    a[], size_t nmemb )      { S_fill(T) ret = {'a', nmemb}; ret.fill.a = a; return ret; }
-
-        3. Replace the $alloc_internal function which is outside ttype forall-block with following function:
-                T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
-                        T * ptr = NULL;
-                        size_t size = sizeof(T);
-                        size_t copy_end = 0;
-
-                        if(Resize) {
-                                ptr = (T*) (void *) resize( (int *)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 );
-                        } else {
-                                ptr = (T*) (void *) memalign( Align, Dim * size );
-                        }
-
-                        if(Fill.tag == 'c') {
-                                memset( (char *)ptr + copy_end, (int)Fill.fill.c, Dim * size - copy_end );
-                        } else if(Fill.tag == 't') {
-                                for ( int i = copy_end; i <= Dim * size - size ; i += size ) {
-                                        memcpy( (char *)ptr + i, &Fill.fill.t, size );
-                                }
-                        } else if(Fill.tag == 'a') {
-                                memcpy( (char *)ptr + copy_end, Fill.fill.a, min(Dim * size - copy_end, size * Fill.nmemb) );
-                        }
-
-                        return ptr;
-                } // $alloc_internal
-*/
-
-typedef struct S_align                  { inline size_t;  } T_align;
-typedef struct S_resize                 { inline void *;  }     T_resize;
-
-forall( dtype T ) {
-        struct S_fill           { char tag; char c; size_t size; T * at; char t[50]; };
-        struct S_realloc        { inline T *; };
-}
-
-static inline T_align   ?`align   ( size_t a )  { return (T_align){a}; }
-static inline T_resize  ?`resize  ( void * a )  { return (T_resize){a}; }
-static inline forall( dtype T | sized(T) ) {
-
-        S_fill(T) ?`fill ( T t ) {
-                S_fill(T) ret = { 't' };
-                size_t size = sizeof(T);
-                if(size > sizeof(ret.t)) { printf("ERROR: const object of size greater than 50 bytes given for dynamic memory fill\n"); exit(1); }
-                memcpy( &ret.t, &t, size );
-                return ret;
-        }
-        S_fill(T)               ?`fill ( char c )                               { return (S_fill(T)){ 'c', c }; }
-        S_fill(T)               ?`fill ( T * a )                                { return (S_fill(T)){ 'T', '0', 0, a }; }
-        S_fill(T)               ?`fill ( T a[], size_t nmemb )  { return (S_fill(T)){ 'a', '0', nmemb * sizeof(T), a }; }
-
-        S_realloc(T)    ?`realloc ( T * a )                             { return (S_realloc(T)){a}; }
-
-        T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
-                T * ptr = NULL;
-                size_t size = sizeof(T);
-                size_t copy_end = 0;
-
-                if(Resize) {
-                        ptr = (T*) (void *) resize( (int *)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 );
+static inline forall( dtype T | sized(T) ) {
+        // Cforall safe general allocation, fill, resize, array
+
+        T * alloc( void ) {
+                return malloc();
+        } // alloc
+
+        T * alloc( size_t dim ) {
+                return aalloc( dim );
+        } // alloc
+
+        forall( dtype S | sized(S) )
+        T * alloc( S ptr[], size_t dim = 1 ) {                          // singleton/array resize
+                return resize( (T *)ptr, dim * sizeof(T) );             // CFA resize
+        } // alloc
+
+        T * alloc( T ptr[], size_t dim = 1, bool copy = true ) {
+                if ( copy ) {
+                        return realloc( ptr, dim * sizeof(T) );         // CFA realloc
                 } else {
-                        ptr = (T*) (void *) memalign( Align, Dim * size );
-                }
-
-                if(Fill.tag == 'c') {
-                        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 ) {
-                                memcpy( (char *)ptr + i, &Fill.t, size );
-                        }
-                } else if(Fill.tag == 'a') {
-                        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 ) {
-                                memcpy( (char *)ptr + i, Fill.at, size );
-                        }
-                }
-
-                return ptr;
-        } // $alloc_internal
-
-        forall( ttype TT | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
-
-                T * $alloc_internal( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
-                return $alloc_internal( Resize, (T*)0p, Align, Dim, Fill, rest);
-                }
-
-                T * $alloc_internal( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
-                return $alloc_internal( (void*)0p, Realloc, Align, Dim, Fill, rest);
-                }
-
-                T * $alloc_internal( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
-                return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
-                }
-
-                T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
-                return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
-                }
-
-            T * alloc( TT all ) {
-                return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
-            }
-
-            T * alloc( size_t dim, TT all ) {
-                return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
-            }
-
-        } // distribution TT
-
-} // distribution T
+                        return resize( ptr, dim * sizeof(T) );          // CFA resize
+                } // if
+        } // alloc
+
+        T * alloc_set( char fill ) {
+                return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value
+        } // alloc_set
+
+        T * alloc_set( const T & fill ) {
+                return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value
+        } // alloc_set
+
+        T * alloc_set( size_t dim, char fill ) {
+                return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
+        } // alloc_set
+
+        T * alloc_set( size_t dim, const T & fill ) {
+                T * r = (T *)alloc( dim );
+                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
+                return r;
+        } // alloc_set
+
+        T * alloc_set( size_t dimNew, const T fill[], size_t dimOld ) {
+                return (T *)memcpy( (T *)alloc( dimNew ), fill, min( dimNew, dimOld ) * sizeof(T) ); // initialize with fill value
+        } // alloc_set
+
+        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
+                size_t osize = malloc_size( ptr );                              // current allocation
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                T * nptr = realloc( ptr, nsize );                               // CFA realloc
+                if ( nsize > osize ) {                                                  // larger ?
+                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
+                } // if
+                return nptr;
+        } // alloc_set
+
+        T * alloc_set( T ptr[], size_t dim, const T & fill ) {  // realloc array with fill
+                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                size_t ndim = nsize / sizeof(T);                                // new dimension
+                T * nptr = realloc( ptr, nsize );                               // CFA realloc
+                if ( ndim > odim ) {                                                    // larger ?
+                        for ( i; odim ~ ndim ) {
+                                memcpy( &nptr[i], &fill, sizeof(T) );   // initialize with fill value
+                        } // for
+                } // if
+                return nptr;
+        } // alloc_set
+} // distribution
+
+static inline forall( dtype T | sized(T) ) {
+        T * alloc_align( size_t align ) {
+                return (T *)memalign( align, sizeof(T) );
+        } // alloc_align
+
+        T * alloc_align( size_t align, size_t dim ) {
+                return (T *)memalign( align, dim * sizeof(T) );
+        } // alloc_align
+
+        T * alloc_align( T * ptr, size_t align ) {                      // aligned realloc array
+                return (T *)(void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA C realloc
+        } // alloc_align
+
+        forall( dtype S | sized(S) )
+        T * alloc_align( S ptr[], size_t align ) {                      // aligned reuse array
+                return (T *)(void *)resize( (void *)ptr, align, sizeof(T) ); // CFA realloc
+        } // alloc_align
+
+        T * alloc_align( T ptr[], size_t align, size_t dim ) { // aligned realloc array
+                return (T *)(void *)realloc( (void *)ptr, align, dim * sizeof(T) ); // CFA realloc
+        } // alloc_align
+
+        T * alloc_align_set( size_t align, char fill ) {
+                return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
+        } // alloc_align_set
+
+        T * alloc_align_set( size_t align, const T & fill ) {
+                return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value
+        } // alloc_align_set
+
+        T * alloc_align_set( size_t align, size_t dim, char fill ) {
+                return (T *)memset( (T *)alloc_align( align, dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
+        } // alloc_align_set
+
+        T * alloc_align_set( size_t align, size_t dim, const T & fill ) {
+                T * r = (T *)alloc_align( align, dim );
+                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
+                return r;
+        } // alloc_align_set
+
+        T * alloc_align_set( size_t align, size_t dimNew, const T fill[], size_t dimOld ) {
+                return (T *)memcpy( (T *)alloc_align( align, dimNew ), fill, min( dimNew, dimOld ) * sizeof(T) );
+        } // alloc_align_set
+
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) {
+                size_t osize = malloc_size( ptr );                              // current allocation
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                T * nptr = alloc_align( ptr, align, nsize );
+                if ( nsize > osize ) {                                                  // larger ?
+                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
+                } // if
+                return nptr;
+        } // alloc_align_set
+
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, const T & fill ) {
+                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
+                size_t nsize = dim * sizeof(T);                                 // new allocation
+                size_t ndim = nsize / sizeof(T);                                // new dimension
+                T * nptr = alloc_align( ptr, align, nsize );
+                if ( ndim > odim ) {                                                    // larger ?
+                        for ( i; odim ~ ndim ) {
+                                memcpy( &nptr[i], &fill, sizeof(T) );   // initialize with fill value
+                        } // for
+                } // if
+                return nptr;
+        } // alloc_align_set
+} // distribution
 
 static inline forall( dtype T | sized(T) ) {