Changeset 93d2219 for libcfa/src

Timestamp:

Oct 28, 2022, 3:12:16 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master

Children:

fa2e183

Parents:

e874605 (diff), 22a0e87 (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/src

Files:

• Makefile.am (modified) (3 diffs)
• concurrency/clib/cfathread.cfa (modified) (1 diff)
• concurrency/invoke.h (modified) (1 diff)
• concurrency/io.cfa (modified) (1 diff)
• concurrency/io/setup.cfa (modified) (1 diff)
• concurrency/kernel.cfa (modified) (2 diffs)
• concurrency/kernel.hfa (modified) (3 diffs)
• concurrency/kernel/private.hfa (modified) (3 diffs)
• concurrency/kernel/startup.cfa (modified) (12 diffs)
• concurrency/locks.hfa (modified) (2 diffs)
• concurrency/preemption.cfa (modified) (9 diffs)
• concurrency/pthread.cfa (added)
• concurrency/thread.cfa (modified) (2 diffs)
• concurrency/thread.hfa (modified) (1 diff)
• containers/array.hfa (modified) (13 diffs)
• containers/lockfree.hfa (added)
• containers/queueLockFree.hfa (deleted)
• containers/stackLockFree.hfa (deleted)
• device/cpu.cfa (modified) (1 diff)
• heap.cfa (modified) (2 diffs)
• interpose.cfa (modified) (4 diffs)
• interpose_thread.cfa (added)
• parseargs.cfa (modified) (4 diffs)
• parseargs.hfa (modified) (3 diffs)

libcfa/src/Makefile.am

@@ -62 +62 @@
         containers/array.hfa \
         containers/list.hfa \
-        containers/queueLockFree.hfa \
-        containers/stackLockFree.hfa \
+        containers/lockfree.hfa \
         containers/string_sharectx.hfa \
         containers/vector2.hfa \
@@ -127 +126 @@
 
 thread_libsrc = ${inst_thread_headers_src} ${inst_thread_headers_src:.hfa=.cfa} \
+        interpose_thread.cfa \
         bits/signal.hfa \
         concurrency/clib/cfathread.cfa \
@@ -145 +145 @@
         concurrency/stats.cfa \
         concurrency/stats.hfa \
-        concurrency/stats.hfa
+        concurrency/stats.hfa \
+        concurrency/pthread.cfa
 
 else

libcfa/src/concurrency/clib/cfathread.cfa

@@ -172 +172 @@
 
                 pthread_attr_t attr;
-                if (int ret = pthread_attr_init(&attr); 0 != ret) {
+                if (int ret = __cfaabi_pthread_attr_init(&attr); 0 != ret) {
                         abort | "failed to create master epoll thread attr: " | ret | strerror(ret);
                 }
 
-                if (int ret = pthread_create(&master_poller, &attr, master_epoll, 0p); 0 != ret) {
+                if (int ret = __cfaabi_pthread_create(&master_poller, &attr, master_epoll, 0p); 0 != ret) {
                         abort | "failed to create master epoll thread: " | ret | strerror(ret);
                 }

libcfa/src/concurrency/invoke.h

@@ -214 +214 @@
 
                 #if defined( __CFA_WITH_VERIFY__ )
+                        struct processor * volatile executing;
                         void * canary;
                 #endif

libcfa/src/concurrency/io.cfa

@@ -610 +610 @@
                 if( we ) {
                         sigval_t value = { PREEMPT_IO };
-                        pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
+                        __cfaabi_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
                 }
 

libcfa/src/concurrency/io/setup.cfa

@@ -344 +344 @@
         //      iopoll.run = false;
         //      sigval val = { 1 };
-        //      pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
+        //      __cfaabi_pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
 
         //      // Make sure all this is done

libcfa/src/concurrency/kernel.cfa

@@ -321 +321 @@
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
+                /* paranoid */ verify( __atomic_exchange_n( &thrd_dst->executing, this, __ATOMIC_SEQ_CST) == 0p );
                 /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
 
@@ -332 +333 @@
 
                 /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
+                /* paranoid */ verify( __atomic_exchange_n( &thrd_dst->executing, 0p, __ATOMIC_SEQ_CST) == this );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
+                /* paranoid */ verify( thrd_dst->state != Halted );
                 /* paranoid */ verify( thrd_dst->context.SP );
-                /* paranoid */ verify( thrd_dst->curr_cluster == this->cltr );
                 /* paranoid */ verify( kernelTLS().this_thread == thrd_dst );
                 /* paranoid */ verify( ! __preemption_enabled() );

libcfa/src/concurrency/kernel.hfa

@@ -160 +160 @@
 // P9_EMBEDDED( processor, dlink(processor) )
 static inline tytagref( dlink(processor), dlink(processor) ) ?`inner( processor & this ) {
-    dlink(processor) & b = this.link;
-    tytagref( dlink(processor), dlink(processor) ) result = { b };
-    return result;
+        dlink(processor) & b = this.link;
+        tytagref( dlink(processor), dlink(processor) ) result = { b };
+        return result;
 }
 
@@ -269 +269 @@
                 io_context_params params;
         } io;
+
+        struct {
+                struct processor ** procs;
+                unsigned cnt;
+        } managed;
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -298 +303 @@
 static inline struct cluster   * active_cluster  () { return publicTLS_get( this_processor )->cltr; }
 
+// set the number of internal processors
+// these processors are in addition to any explicitly declared processors
+unsigned set_concurrency( cluster & this, unsigned new_count );
+
 #if !defined(__CFA_NO_STATISTICS__)
         void print_stats_now( cluster & this, int flags );

libcfa/src/concurrency/kernel/private.hfa

@@ -20 +20 @@
 #endif
 
+#include <signal.h>
+
 #include "kernel.hfa"
 #include "thread.hfa"
@@ -48 +50 @@
         #endif
 #endif
-
 // #define READYQ_USE_LINEAR_AVG
 #define READYQ_USE_LOGDBL_AVG
@@ -62 +63 @@
 #error must pick a scheme for averaging
 #endif
+
+extern "C" {
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_create(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_join(pthread_t _thread, void **retval);
+        __attribute__((visibility("protected"))) pthread_t __cfaabi_pthread_self(void);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_init(pthread_attr_t *attr);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_destroy(pthread_attr_t *attr);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize );
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize );
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_sigmask( int how, const sigset_t *set, sigset_t *oset);
+}
 
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/kernel/startup.cfa

@@ -16 +16 @@
 #define __cforall_thread__
 #define _GNU_SOURCE
+
+// #define __CFA_DEBUG_PRINT_RUNTIME_CORE__
 
 // C Includes
@@ -222 +224 @@
                 ( this.runner ){};
                 init( this, "Main Processor", *mainCluster, 0p );
-                kernel_thread = pthread_self();
+                kernel_thread = __cfaabi_pthread_self();
 
                 runner{ &this };
@@ -283 +285 @@
 }
 
+extern "C"{
+        void pthread_delete_kernel_threads_();
+}
+
+
 static void __kernel_shutdown(void) {
         if(!cfa_main_returned) return;
+
+        //delete kernel threads for pthread_concurrency
+        pthread_delete_kernel_threads_();
+
         /* paranoid */ verify( __preemption_enabled() );
         disable_interrupts();
@@ -327 +338 @@
 
                 /* paranoid */ verify( this.do_terminate == true );
-                __cfaabi_dbg_print_safe("Kernel : destroyed main processor context %p\n", &runner);
+                __cfadbg_print_safe(runtime_core, "Kernel : destroyed main processor context %p\n", &runner);
         }
 
@@ -388 +399 @@
         (proc->runner){ proc, &info };
 
-        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.storage);
+        __cfadbg_print_safe(runtime_core, "Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.storage);
 
         //Set global state
@@ -520 +531 @@
         random_state = __global_random_mask ? __global_random_prime : __global_random_prime ^ rdtscl();
         #if defined( __CFA_WITH_VERIFY__ )
+                executing = 0p;
                 canary = 0x0D15EA5E0D15EA5Ep;
         #endif
@@ -652 +664 @@
         io.params = io_params;
 
+        managed.procs = 0p;
+        managed.cnt = 0;
+
         doregister(this);
 
@@ -667 +682 @@
 
 void ^?{}(cluster & this) libcfa_public {
+        set_concurrency( this, 0 );
+
         destroy(this.io.arbiter);
 
@@ -777 +794 @@
         pthread_attr_t attr;
 
-        check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
+        check( __cfaabi_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
 
         size_t stacksize = max( PTHREAD_STACK_MIN, DEFAULT_STACK_SIZE );
@@ -804 +821 @@
         #endif
 
-        check( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
-        check( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
+        check( __cfaabi_pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
+        check( __cfaabi_pthread_create( pthread, &attr, start, arg ), "pthread_create" );
         return stack;
 }
 
 void __destroy_pthread( pthread_t pthread, void * stack, void ** retval ) {
-        int err = pthread_join( pthread, retval );
+        int err = __cfaabi_pthread_join( pthread, retval );
         if( err != 0 ) abort("KERNEL ERROR: joining pthread %p caused error %s\n", (void*)pthread, strerror(err));
 
@@ -816 +833 @@
                 pthread_attr_t attr;
 
-                check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
+                check( __cfaabi_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
 
                 size_t stacksize;
                 // default stack size, normally defined by shell limit
-                check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
+                check( __cfaabi_pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
                 assert( stacksize >= PTHREAD_STACK_MIN );
                 stacksize += __page_size;
@@ -838 +855 @@
 }
 
+unsigned set_concurrency( cluster & this, unsigned new ) libcfa_public {
+        unsigned old = this.managed.cnt;
+
+        __cfadbg_print_safe(runtime_core, "Kernel : resizing cluster from %u to %u\n", old, (unsigned)new);
+
+        // Delete all the old unneeded procs
+        if(old > new) for(i; (unsigned)new ~ old) {
+                __cfadbg_print_safe(runtime_core, "Kernel : destroying %u\n", i);
+                delete( this.managed.procs[i] );
+        }
+
+        // Allocate new array (uses realloc and memcpies the data)
+        this.managed.procs = alloc( new, this.managed.procs`realloc );
+        this.managed.cnt = new;
+
+        // Create the desired new procs
+        if(old < new) for(i; old ~ new) {
+                __cfadbg_print_safe(runtime_core, "Kernel : constructing %u\n", i);
+                (*(this.managed.procs[i] = alloc())){ this };
+        }
+
+        // return the old count
+        return old;
+}
+
 #if defined(__CFA_WITH_VERIFY__)
 static bool verify_fwd_bck_rng(void) {

libcfa/src/concurrency/locks.hfa

@@ -21 +21 @@
 
 #include "bits/weakso_locks.hfa"
-#include "containers/queueLockFree.hfa"
+#include "containers/lockfree.hfa"
 #include "containers/list.hfa"
 
@@ -423 +423 @@
 }
 
-static inline size_t on_wait(simple_owner_lock & this) with(this) { 
+static inline size_t on_wait(simple_owner_lock & this) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );

libcfa/src/concurrency/preemption.cfa

@@ -352 +352 @@
         sigset_t oldset;
         int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+        ret = __cfaabi_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -385 +385 @@
         sigaddset( &mask, sig );
 
-        if ( pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
+        if ( __cfaabi_pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
         }
@@ -396 +396 @@
         sigaddset( &mask, sig );
 
-        if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+        if ( __cfaabi_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
                 abort( "internal error, pthread_sigmask" );
         }
@@ -404 +404 @@
 static void preempt( processor * this ) {
         sigval_t value = { PREEMPT_NORMAL };
-        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+        __cfaabi_pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
 }
 
@@ -415 +415 @@
         sigset_t oldset;
         int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+        ret = __cfaabi_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -434 +434 @@
         sigset_t oldset;
         int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+        ret = __cfaabi_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -505 +505 @@
         sigval val;
         val.sival_int = 0;
-        pthread_sigqueue( alarm_thread, SIGALRM, val );
+        __cfaabi_pthread_sigqueue( alarm_thread, SIGALRM, val );
 
         // Wait for the preemption thread to finish
@@ -579 +579 @@
         static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" );
         #endif
-        if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
+        if ( __cfaabi_pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
                 abort( "internal error, sigprocmask" );
         }
@@ -607 +607 @@
         sigset_t mask;
         sigfillset(&mask);
-        if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+        if ( __cfaabi_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
         }

libcfa/src/concurrency/thread.cfa

@@ -50 +50 @@
         random_state = __global_random_mask ? __global_random_prime : __global_random_prime ^ rdtscl();
         #if defined( __CFA_WITH_VERIFY__ )
+                executing = 0p;
                 canary = 0x0D15EA5E0D15EA5Ep;
         #endif
@@ -177 +178 @@
 
 //-----------------------------------------------------------------------------
+bool migrate( thread$ * thrd, struct cluster & cl ) {
+
+        monitor$ * tmon = get_monitor(thrd);
+        monitor$ * __monitors[] = { tmon };
+        monitor_guard_t __guard = { __monitors, 1 };
+
+
+        {
+                // if nothing needs to be done, return false
+                if( thrd->curr_cluster == &cl ) return false;
+
+                // are we migrating ourself?
+                const bool local = thrd == active_thread();
+
+                /* paranoid */ verify( !local || &cl != active_cluster() );
+                /* paranoid */ verify( !local || thrd->curr_cluster == active_cluster() );
+                /* paranoid */ verify( !local || thrd->curr_cluster == active_processor()->cltr );
+                /* paranoid */ verify( local || tmon->signal_stack.top->owner->waiting_thread == thrd );
+                /* paranoid */ verify( local || tmon->signal_stack.top );
+
+                // make sure we aren't interrupted while doing this
+                // not as important if we aren't local
+                disable_interrupts();
+
+                // actually move the thread
+                unregister( thrd->curr_cluster, *thrd );
+                thrd->curr_cluster = &cl;
+                doregister( thrd->curr_cluster, *thrd );
+
+                // restore interrupts
+                enable_interrupts();
+
+                // if this is the local thread, we are still running on the old cluster
+                if(local) yield();
+
+                /* paranoid */ verify( !local || &cl == active_cluster() );
+                /* paranoid */ verify( !local || thrd->curr_cluster == active_cluster() );
+                /* paranoid */ verify( !local || thrd->curr_cluster == active_processor()->cltr );
+                /* paranoid */ verify(  local || tmon->signal_stack.top );
+                /* paranoid */ verify(  local || tmon->signal_stack.top->owner->waiting_thread == thrd );
+
+                return true;
+        }
+}
+
+//-----------------------------------------------------------------------------
 #define GENERATOR LCG
 

libcfa/src/concurrency/thread.hfa

@@ -132 +132 @@
 
 //----------
+// misc
+bool migrate( thread$ * thrd, struct cluster & cl );
+
+forall( T & | is_thread(T) )
+static inline bool migrate( T & mutex thrd, struct cluster & cl ) { return migrate( &(thread&)thrd, cl ); }
+
+
+//----------
 // prng
 static inline {

libcfa/src/containers/array.hfa

@@ +1 @@
+#pragma once
+
 #include <assert.h>
 
@@ -18 +20 @@
     // About the choice of integral types offered as subscript overloads:
     // Intent is to cover these use cases:
+    //    a[0]                                                // i : zero_t
+    //    a[1]                                                // i : one_t
+    //    a[2]                                                // i : int
     //    float foo( ptrdiff_t i ) { return a[i]; }           // i : ptrdiff_t
+    //    float foo( size_t i ) { return a[i]; }              // i : size_t
     //    forall( [N] ) ... for( i; N ) { total += a[i]; }    // i : typeof( sizeof(42) )
     //    for( i; 5 ) { total += a[i]; }                      // i : int
+    //
     // It gets complicated by:
     // -  CFA does overloading on concrete types, like int and unsigned int, not on typedefed
@@ -27 +34 @@
     // -  Given bug of Trac #247, CFA gives sizeof expressions type unsigned long int, when it
     //    should give them type size_t.
-    //    
-    //                          gcc -m32         cfa -m32 given bug         gcc -m64
+    //
+    //                          gcc -m32         cfa -m32 given bug         gcc -m64 (and cfa)
     // ptrdiff_t                int              int                        long int
     // size_t                   unsigned int     unsigned int               unsigned long int
     // typeof( sizeof(42) )     unsigned int     unsigned long int          unsigned long int
     // int                      int              int                        int
+    //
+    // So the solution must support types {zero_t, one_t, int, unsigned int, long int, unsigned long int}
+    //
+    // The solution cannot rely on implicit conversions (e.g. just have one overload for ptrdiff_t)
+    // because assertion satisfaction requires types to match exacly.  Both higher-dimensional
+    // subscripting and operations on slices use asserted subscript operators.  The test case
+    // array-container/array-sbscr-cases covers the combinations.  Mike beleives that commenting out
+    // any of the current overloads leads to one of those cases failing, either on 64- or 32-bit.
+    // Mike is open to being shown a smaller set of overloads that still passes the test.
+
+    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, zero_t ) {
+        assert( 0 < N );
+        return (Timmed &) a.strides[0];
+    }
+
+    static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, one_t ) {
+        assert( 1 < N );
+        return (Timmed &) a.strides[1];
+    }
 
     static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, int i ) {
@@ -39 +65 @@
     }
 
+    static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, int i ) {
+        assert( i < N );
+        return (Timmed &) a.strides[i];
+    }
+
     static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, unsigned int i ) {
         assert( i < N );
@@ -44 +75 @@
     }
 
+    static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, unsigned int i ) {
+        assert( i < N );
+        return (Timmed &) a.strides[i];
+    }
+
     static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, long int i ) {
         assert( i < N );
@@ -49 +85 @@
     }
 
+    static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, long int i ) {
+        assert( i < N );
+        return (Timmed &) a.strides[i];
+    }
+
     static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, unsigned long int i ) {
+        assert( i < N );
+        return (Timmed &) a.strides[i];
+    }
+
+    static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, unsigned long int i ) {
         assert( i < N );
         return (Timmed &) a.strides[i];
@@ -57 +103 @@
         return N;
     }
+
+    static inline void __taglen( tag(arpk(N, S, Timmed, Tbase)), tag(N) ) {}
 
     // workaround #226 (and array relevance thereof demonstrated in mike102/otype-slow-ndims.cfa)
@@ -83 +131 @@
     // Make a FOREACH macro
     #define FE_0(WHAT)
-    #define FE_1(WHAT, X) WHAT(X) 
+    #define FE_1(WHAT, X) WHAT(X)
     #define FE_2(WHAT, X, ...) WHAT(X)FE_1(WHAT, __VA_ARGS__)
     #define FE_3(WHAT, X, ...) WHAT(X)FE_2(WHAT, __VA_ARGS__)
@@ -90 +138 @@
     //... repeat as needed
 
-    #define GET_MACRO(_0,_1,_2,_3,_4,_5,NAME,...) NAME 
+    #define GET_MACRO(_0,_1,_2,_3,_4,_5,NAME,...) NAME
     #define FOR_EACH(action,...) \
     GET_MACRO(_0,__VA_ARGS__,FE_5,FE_4,FE_3,FE_2,FE_1,FE_0)(action,__VA_ARGS__)
@@ -115 +163 @@
 }
 
-#else 
+#else
 
 // Workaround form.  Listing all possibilities up to 4 dims.
@@ -135 +183 @@
 
 #endif
+
+// Available for users to work around Trac #265
+// If `a[...0...]` isn't working, try `a[...ix0...]` instead.
+
+#define ix0 ((ptrdiff_t)0)
+
+
 
 //
@@ -155 +210 @@
 
 // Wrapper
-struct all_t {} all;
+extern struct all_t {} all;
 forall( [N], S & | sized(S), Te &, result &, Tbase & | { tag(result) enq_( tag(Tbase), tag(N), tag(S), tag(Te) ); } )
 static inline result & ?[?]( arpk(N, S, Te, Tbase) & this, all_t ) {
@@ -165 +220 @@
 //
 
-trait ar(A &, Tv &) {
-    Tv& ?[?]( A&, ptrdiff_t );
-    size_t ?`len( A& );
-};
+// desired:
+// trait ar(A &, Tv &, [N]) {
+//     Tv& ?[?]( A&, zero_t );
+//     Tv& ?[?]( A&, one_t  );
+//     Tv& ?[?]( A&, int    );
+//                   ...
+//     size_t ?`len( A& );
+//     void __taglen( tag(C), tag(N) );
+// };
+
+// working around N's not being accepted as arguments to traits
+
+#define ar(A, Tv, N) {                 \
+    Tv& ?[?]( A&, zero_t );            \
+    Tv& ?[?]( A&, one_t );             \
+    Tv& ?[?]( A&, int );               \
+    Tv& ?[?]( A&, unsigned int );      \
+    Tv& ?[?]( A&, long int );          \
+    Tv& ?[?]( A&, unsigned long int ); \
+    size_t ?`len( A& );                \
+    void __taglen( tag(A), tag(N) );   \
+}

libcfa/src/device/cpu.cfa

@@ -359 +359 @@
                 int idxs = count_cache_indexes();
 
+                // Do we actually have a cache?
+                if(idxs == 0) {
+                        // if not just fake the data structure, it makes things easier.
+                        cpu_info.hthrd_count = cpus_c;
+                        cpu_info.llc_count = 0;
+                        struct cpu_map_entry_t * entries = alloc(cpu_info.hthrd_count);
+                        for(i; cpu_info.hthrd_count) {
+                                entries[i].self  = i;
+                                entries[i].start = 0;
+                                entries[i].count = cpu_info.hthrd_count;
+                                entries[i].cache = 0;
+                        }
+                        cpu_info.llc_map = entries;
+                        return;
+                }
+
                 // Count actual cache levels
                 unsigned cache_levels = 0;
                 unsigned llc = 0;
-                if (idxs != 0) {
-                        unsigned char prev = -1u;
-                        void first(unsigned idx, unsigned char level, const char * map, size_t len) {
-                                /* paranoid */ verifyf(level < prev, "Index %u of cpu 0 has cache levels out of order: %u then %u", idx, (unsigned)prev, (unsigned)level);
-                                llc = max(llc, level);
-                                prev = level;
-                                cache_levels++;
-                        }
-                        foreach_cacheidx(0, idxs, first);
-                }
+
+                unsigned char prev = -1u;
+                void first(unsigned idx, unsigned char level, const char * map, size_t len) {
+                        /* paranoid */ verifyf(level < prev, "Index %u of cpu 0 has cache levels out of order: %u then %u", idx, (unsigned)prev, (unsigned)level);
+                        llc = max(llc, level);
+                        prev = level;
+                        cache_levels++;
+                }
+                foreach_cacheidx(0, idxs, first);
 
                 // Read in raw data

libcfa/src/heap.cfa

@@ -211 +211 @@
 #if BUCKETLOCK == SPINLOCK
 #elif BUCKETLOCK == LOCKFREE
-#include <stackLockFree.hfa>
+#include <containers/lockfree.hfa>
 #else
         #error undefined lock type for bucket lock
@@ -505 +505 @@
                                 freeLists[j].blockSize = bucketSizes[j];
                         } // for
-        
+
                         heapBuffer = 0p;
                         heapReserve = 0;

libcfa/src/interpose.cfa

@@ -42 +42 @@
 
 typedef void (* generic_fptr_t)(void);
+static generic_fptr_t do_interpose_symbol( void * library, const char symbol[], const char version[] ) {
+        const char * error;
+
+        union { generic_fptr_t fptr; void * ptr; } originalFunc;
+
+        #if defined( _GNU_SOURCE )
+                if ( version ) {
+                        originalFunc.ptr = dlvsym( library, symbol, version );
+                } else {
+                        originalFunc.ptr = dlsym( library, symbol );
+                }
+        #else
+                originalFunc.ptr = dlsym( library, symbol );
+        #endif // _GNU_SOURCE
+
+        error = dlerror();
+        if ( error ) abort( "interpose_symbol : internal error, %s\n", error );
+
+        return originalFunc.fptr;
+}
+
 static generic_fptr_t interpose_symbol( const char symbol[], const char version[] ) {
         const char * error;
 
         static void * library;
+        static void * pthread_library;
         if ( ! library ) {
                 #if defined( RTLD_NEXT )
@@ -58 +80 @@
                 #endif
         } // if
-
-        union { generic_fptr_t fptr; void * ptr; } originalFunc;
-
-        #if defined( _GNU_SOURCE )
-                if ( version ) {
-                        originalFunc.ptr = dlvsym( library, symbol, version );
-                } else {
-                        originalFunc.ptr = dlsym( library, symbol );
-                }
-        #else
-                originalFunc.ptr = dlsym( library, symbol );
-        #endif // _GNU_SOURCE
-
-        error = dlerror();
-        if ( error ) abort( "interpose_symbol : internal error, %s\n", error );
-
-        return originalFunc.fptr;
+        if ( ! pthread_library ) {
+                #if defined( RTLD_NEXT )
+                        pthread_library = RTLD_NEXT;
+                #else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        pthread_library = dlopen( "libpthread.so", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                abort( "interpose_symbol : failed to open libpthread, %s\n", error );
+                        }
+                #endif
+        } // if
+
+        return do_interpose_symbol(library, symbol, version);
 }
 
@@ -97 +116 @@
 
 extern "C" {
+        void __cfathreadabi_interpose_startup( generic_fptr_t (*do_interpose_symbol)( void * library, const char symbol[], const char version[] ) ) __attribute__((weak));
         void __cfaabi_interpose_startup( void ) {
                 const char *version = 0p;
@@ -108 +128 @@
                 INTERPOSE_LIBC( exit , version );
 #pragma GCC diagnostic pop
+
+                if(__cfathreadabi_interpose_startup) __cfathreadabi_interpose_startup( do_interpose_symbol );
 
                 // As a precaution (and necessity), errors that result in termination are delivered on a separate stack because

libcfa/src/parseargs.cfa

@@ -50 +50 @@
 extern char ** cfa_args_envp __attribute__((weak));
 
-static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * usage, FILE * out)  __attribute__ ((noreturn));
+forall([N])
+static void usage(char * cmd, const array( cfa_option, N ) & options, const char * usage, FILE * out)  __attribute__ ((noreturn));
 //-----------------------------------------------------------------------------
 // checking
-static void check_args(cfa_option options[], size_t opt_count) {
-        for(i; opt_count) {
-                for(j; opt_count) {
+forall([N])
+static void check_args( const array( cfa_option, N ) & options ) {
+        for(i; N) {
+                for(j; N) {
                         if(i == j) continue;
 
@@ -70 +72 @@
 //-----------------------------------------------------------------------------
 // Parsing args
-void parse_args( cfa_option options[], size_t opt_count, const char * usage, char ** & left ) {
-        if( 0p != &cfa_args_argc ) {
-                parse_args(cfa_args_argc, cfa_args_argv, options, opt_count, usage, left );
-        }
-        else {
-                char * temp = "";
-                parse_args(0, &temp, options, opt_count, usage, left );
-        }
-}
-
-void parse_args(
-        int argc,
-        char * argv[],
-        cfa_option options[],
-        size_t opt_count,
-        const char * usage,
-        char ** & left
-) {
-        check_args(options, opt_count);
-
-        int maxv = 'h';
-        char optstring[(opt_count * 3) + 2] = { '\0' };
-        {
-                int idx = 0;
-                for(i; opt_count) {
-                        if (options[i].short_name) {
-                                maxv = max(options[i].short_name, maxv);
-                                optstring[idx] = options[i].short_name;
-                                idx++;
-                                if(    ((intptr_t)options[i].parse) != ((intptr_t)parse_settrue)
-                                && ((intptr_t)options[i].parse) != ((intptr_t)parse_setfalse) ) {
-                                        optstring[idx] = ':';
+forall([opt_count]) {
+        void parse_args( const array( cfa_option, opt_count ) & options, const char * usage, char ** & left ) {
+                if( 0p != &cfa_args_argc ) {
+                        parse_args(cfa_args_argc, cfa_args_argv, options, usage, left );
+                }
+                else {
+                        char * temp = "";
+                        parse_args(0, &temp, options, usage, left );
+                }
+        }
+
+        void parse_args(
+                int argc,
+                char * argv[],
+                const array( cfa_option, opt_count ) & options,
+                const char * usage,
+                char ** & left
+        ) {
+                check_args(options);
+
+                int maxv = 'h';
+                char optstring[(opt_count * 3) + 2] = { '\0' };
+                {
+                        int idx = 0;
+                        for(i; opt_count) {
+                                if (options[i].short_name) {
+                                        maxv = max(options[i].short_name, maxv);
+                                        optstring[idx] = options[i].short_name;
+                                        idx++;
+                                        if(    ((intptr_t)options[i].parse) != ((intptr_t)parse_settrue)
+                                        && ((intptr_t)options[i].parse) != ((intptr_t)parse_setfalse) ) {
+                                                optstring[idx] = ':';
+                                                idx++;
+                                        }
+                                }
+                        }
+                        optstring[idx+0] = 'h';
+                        optstring[idx+1] = '\0';
+                }
+
+                struct option optarr[opt_count + 2];
+                {
+                        int idx = 0;
+                        for(i; opt_count) {
+                                if(options[i].long_name) {
+                                        // we don't have the mutable keyword here, which is really what we would want
+                                        int & val_ref = (int &)(const int &)options[i].val;
+                                        val_ref = (options[i].short_name != '\0') ? ((int)options[i].short_name) : ++maxv;
+
+                                        optarr[idx].name = options[i].long_name;
+                                        optarr[idx].flag = 0p;
+                                        optarr[idx].val  = options[i].val;
+                                        if(    ((intptr_t)options[i].parse) == ((intptr_t)parse_settrue)
+                                        || ((intptr_t)options[i].parse) == ((intptr_t)parse_setfalse) ) {
+                                                optarr[idx].has_arg = no_argument;
+                                        } else {
+                                                optarr[idx].has_arg = required_argument;
+                                        }
                                         idx++;
                                 }
                         }
-                }
-                optstring[idx+0] = 'h';
-                optstring[idx+1] = '\0';
-        }
-
-        struct option optarr[opt_count + 2];
-        {
-                int idx = 0;
-                for(i; opt_count) {
-                        if(options[i].long_name) {
-                                options[i].val = (options[i].short_name != '\0') ? ((int)options[i].short_name) : ++maxv;
-                                optarr[idx].name = options[i].long_name;
-                                optarr[idx].flag = 0p;
-                                optarr[idx].val  = options[i].val;
-                                if(    ((intptr_t)options[i].parse) == ((intptr_t)parse_settrue)
-                                    || ((intptr_t)options[i].parse) == ((intptr_t)parse_setfalse) ) {
-                                        optarr[idx].has_arg = no_argument;
-                                } else {
-                                        optarr[idx].has_arg = required_argument;
-                                }
-                                idx++;
+                        optarr[idx+0].[name, has_arg, flag, val] = ["help", no_argument, 0, 'h'];
+                        optarr[idx+1].[name, has_arg, flag, val] = [0, no_argument, 0, 0];
+                }
+
+                FILE * out = stderr;
+                NEXT_ARG:
+                for() {
+                        int idx = 0;
+                        int opt = getopt_long(argc, argv, optstring, optarr, &idx);
+                        switch(opt) {
+                                case -1:
+                                        if(&left != 0p) left = argv + optind;
+                                        return;
+                                case 'h':
+                                        out = stdout;
+                                case '?':
+                                        usage(argv[0], options, usage, out);
+                                default:
+                                        for(i; opt_count) {
+                                                if(opt == options[i].val) {
+                                                        const char * arg = optarg ? optarg : "";
+                                                        if( arg[0] == '=' ) { arg++; }
+                                                        // work around for some weird bug
+                                                        void * variable = options[i].variable;
+                                                        bool (*parse_func)(const char *, void * ) = options[i].parse;
+                                                        bool success = parse_func( arg, variable );
+                                                        if(success) continue NEXT_ARG;
+
+                                                        fprintf(out, "Argument '%s' for option %c could not be parsed\n\n", arg, (char)opt);
+                                                        usage(argv[0], options, usage, out);
+                                                }
+                                        }
+                                        abort("Internal parse arg error\n");
                         }
-                }
-                optarr[idx+0].[name, has_arg, flag, val] = ["help", no_argument, 0, 'h'];
-                optarr[idx+1].[name, has_arg, flag, val] = [0, no_argument, 0, 0];
-        }
-
-        FILE * out = stderr;
-        NEXT_ARG:
-        for() {
-                int idx = 0;
-                int opt = getopt_long(argc, argv, optstring, optarr, &idx);
-                switch(opt) {
-                        case -1:
-                                if(&left != 0p) left = argv + optind;
-                                return;
-                        case 'h':
-                                out = stdout;
-                        case '?':
-                                usage(argv[0], options, opt_count, usage, out);
-                        default:
-                                for(i; opt_count) {
-                                        if(opt == options[i].val) {
-                                                const char * arg = optarg ? optarg : "";
-                                                if( arg[0] == '=' ) { arg++; }
-                                                bool success = options[i].parse( arg, options[i].variable );
-                                                if(success) continue NEXT_ARG;
-
-                                                fprintf(out, "Argument '%s' for option %c could not be parsed\n\n", arg, (char)opt);
-                                                usage(argv[0], options, opt_count, usage, out);
-                                        }
-                                }
-                                abort("Internal parse arg error\n");
-                }
-
+
+                }
         }
 }
@@ -222 +231 @@
 
 void print_args_usage(cfa_option options[], size_t opt_count, const char * usage, bool error)  __attribute__ ((noreturn)) {
-        usage(cfa_args_argv[0], options, opt_count, usage, error ? stderr : stdout);
+        const array( cfa_option, opt_count ) & arr = (const array( cfa_option, opt_count ) &) *options;
+        usage(cfa_args_argv[0], arr, usage, error ? stderr : stdout);
 }
 
 void print_args_usage(int , char * argv[], cfa_option options[], size_t opt_count, const char * usage, bool error)  __attribute__ ((noreturn)) {
-        usage(argv[0], options, opt_count, usage, error ? stderr : stdout);
-}
-
-static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * help, FILE * out) __attribute__((noreturn)) {
+        const array( cfa_option, opt_count ) & arr = (const array( cfa_option, opt_count ) &) *options;
+        usage(argv[0], arr, usage, error ? stderr : stdout);
+}
+
+forall( [N] ) {
+        void print_args_usage( const array(cfa_option, N ) & options, const char * usage, bool error) {
+                usage(cfa_args_argv[0], options, usage, error ? stderr : stdout);
+        }
+
+        void print_args_usage(int argc, char * argv[], const array( cfa_option, N ) & options, const char * usage, bool error) {
+                usage(argv[0], options, usage, error ? stderr : stdout);
+        }
+}
+
+forall([N])
+static void usage(char * cmd, const array( cfa_option, N ) & options, const char * help, FILE * out) __attribute__((noreturn)) {
         int width = 0;
         {
-                for(i; opt_count) {
+                for(i; N) {
                         if(options[i].long_name) {
                                 int w = strlen(options[i].long_name);
@@ -251 +273 @@
         fprintf(out, "Usage:\n  %s %s\n", cmd, help);
 
-        for(i; opt_count) {
+        for(i; N) {
                 printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help);
         }

libcfa/src/parseargs.hfa

@@ -16 +16 @@
 #pragma once
 
+#include <array.hfa>
+
 struct cfa_option {
-      int val; // reserved
-      char short_name;
-      const char * long_name;
-      const char * help;
-      void * variable;
-      bool (*parse)(const char *, void * );
+        int val; // reserved
+        char short_name;
+        const char * long_name;
+        const char * help;
+        void * variable;
+        bool (*parse)(const char *, void * );
 };
 
@@ -31 +33 @@
 forall(T & | { bool parse(const char *, T & ); })
 static inline void ?{}( cfa_option & this, char short_name, const char * long_name, const char * help, T & variable ) {
-      this.val        = 0;
-      this.short_name = short_name;
-      this.long_name  = long_name;
-      this.help       = help;
-      this.variable   = (void*)&variable;
-      this.parse      = (bool (*)(const char *, void * ))parse;
+        this.val        = 0;
+        this.short_name = short_name;
+        this.long_name  = long_name;
+        this.help       = help;
+        this.variable   = (void*)&variable;
+        this.parse      = (bool (*)(const char *, void * ))parse;
 }
 
 forall(T &)
 static inline void ?{}( cfa_option & this, char short_name, const char * long_name, const char * help, T & variable, bool (*parse)(const char *, T & )) {
-      this.val        = 0;
-      this.short_name = short_name;
-      this.long_name  = long_name;
-      this.help       = help;
-      this.variable   = (void*)&variable;
-      this.parse      = (bool (*)(const char *, void * ))parse;
+        this.val        = 0;
+        this.short_name = short_name;
+        this.long_name  = long_name;
+        this.help       = help;
+        this.variable   = (void*)&variable;
+        this.parse      = (bool (*)(const char *, void * ))parse;
 }
 
@@ -52 +54 @@
 void parse_args( int argc, char * argv[], cfa_option options[], size_t opt_count, const char * usage, char ** & left );
 
+forall( [N] ) {
+        void parse_args( const array( cfa_option, N ) & options, const char * usage, char ** & left );
+        void parse_args( int argc, char * argv[], const array( cfa_option, N ) & options, const char * usage, char ** & left );
+}
+
 void print_args_usage(cfa_option options[], size_t opt_count, const char * usage, bool error)  __attribute__ ((noreturn));
 void print_args_usage(int argc, char * argv[], cfa_option options[], size_t opt_count, const char * usage, bool error)  __attribute__ ((noreturn));
+
+forall( [N] ) {
+        void print_args_usage( const array(cfa_option, N ) & options, const char * usage, bool error)  __attribute__ ((noreturn));
+        void print_args_usage(int argc, char * argv[], const array( cfa_option, N ) & options, const char * usage, bool error)  __attribute__ ((noreturn));
+}
 
 bool parse_yesno    (const char *, bool & );