Changeset e2e7330 for src

Timestamp:

Jan 31, 2018, 5:50:34 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

295e5071

Parents:

bc6f918 (diff), 281806b6 (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:/u/cforall/software/cfa/cfa-cc

Location:

src

Files:

• benchmark/Makefile.am (modified) (1 diff)
• benchmark/Makefile.in (modified) (1 diff)
• driver/cfa.cc (modified) (3 diffs)
• libcfa/bits/containers.h (modified) (3 diffs)
• libcfa/bits/locks.h (modified) (4 diffs)
• libcfa/bits/signal.h (added)
• libcfa/concurrency/coroutine.c (modified) (2 diffs)
• libcfa/concurrency/invoke.h (modified) (1 diff)
• libcfa/concurrency/kernel.c (modified) (15 diffs)
• libcfa/concurrency/kernel_private.h (modified) (1 diff)
• libcfa/concurrency/monitor.c (modified) (10 diffs)
• libcfa/concurrency/preemption.c (modified) (10 diffs)
• libcfa/concurrency/thread.c (modified) (2 diffs)
• libcfa/interpose.c (modified) (3 diffs)
• libcfa/interpose.h (modified) (1 diff)
• prelude/prelude.cf (modified) (8 diffs)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)
• tests/concurrent/examples/quickSort.c (modified) (2 diffs)
• tests/functions.c (modified) (11 diffs)
• tests/identFuncDeclarator.c (modified) (5 diffs)
• tests/identParamDeclarator.c (modified) (2 diffs)
• tests/preempt_longrun/Makefile.am (modified) (2 diffs)
• tests/preempt_longrun/Makefile.in (modified) (2 diffs)
• tests/preempt_longrun/block.c (modified) (1 diff)
• tests/preempt_longrun/create.c (modified) (1 diff)
• tests/preempt_longrun/disjoint.c (modified) (1 diff)
• tests/preempt_longrun/enter.c (modified) (1 diff)
• tests/preempt_longrun/enter3.c (modified) (1 diff)
• tests/preempt_longrun/processor.c (modified) (1 diff)
• tests/preempt_longrun/stack.c (modified) (1 diff)
• tests/preempt_longrun/wait.c (modified) (1 diff)
• tests/preempt_longrun/yield.c (modified) (1 diff)

src/benchmark/Makefile.am

@@ -59 +59 @@
         @echo -e '\t"githash": "'${githash}'",'
         @echo -e '\t"arch": "'   ${arch}   '",'
+        @echo -e '\t"compile": {'
+        @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
+        @echo -e '\t\t"dummy" : {}'
+        @echo -e '\t},'
         @echo -e '\t"ctxswitch": {'
         @echo -en '\t\t"coroutine":'

src/benchmark/Makefile.in

@@ -473 +473 @@
         @echo -e '\t"githash": "'${githash}'",'
         @echo -e '\t"arch": "'   ${arch}   '",'
+        @echo -e '\t"compile": {'
+        @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
+        @echo -e '\t\t"dummy" : {}'
+        @echo -e '\t},'
         @echo -e '\t"ctxswitch": {'
         @echo -en '\t\t"coroutine":'

src/driver/cfa.cc

@@ -10 +10 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct 31 11:40:44 2017
-// Update Count     : 160
+// Last Modified On : Tue Jan 30 15:46:15 2018
+// Update Count     : 161
 //
 
@@ -277 +277 @@
                 args[nargs] = "--undefined=__cfaabi_dbg_bits_write";
                 nargs += 1;
+                args[nargs] = "-Xlinker";
+                nargs += 1;
+                args[nargs] = "--undefined=__cfaabi_interpose_startup";
+                nargs += 1;
 
         } // if
@@ -353 +357 @@
                 nargs += 1;
                 args[nargs] = "-D__int8_t_defined";                             // prevent gcc type-size attributes
+                nargs += 1;
+                args[nargs] = "-D__NO_STRING_INLINES";                  // prevent gcc strcmp unrolling
                 nargs += 1;
                 args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str();

src/libcfa/bits/containers.h

@@ -140 +140 @@
 
 #ifdef __cforall
+
         forall(dtype T | is_node(T))
-        static inline void ?{}( __queue(T) & this ) {
-                (this.head){ NULL };
-                (this.tail){ &this.head };
+        static inline void ?{}( __queue(T) & this ) with( this ) {
+                head{ NULL };
+                tail{ &head };
         }
 
         forall(dtype T | is_node(T) | sized(T))
-        static inline void append( __queue(T) & this, T * val ) {
-                verify(this.tail != NULL);
-                *this.tail = val;
-                this.tail = &get_next( *val );
+        static inline void append( __queue(T) & this, T * val ) with( this ) {
+                verify(tail != NULL);
+                *tail = val;
+                tail = &get_next( *val );
         }
 
@@ -167 +168 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        static inline T * remove( __queue(T) & this, T ** it ) {
+        static inline T * remove( __queue(T) & this, T ** it ) with( this ) {
                 T * val = *it;
                 verify( val );
@@ -173 +174 @@
                 (*it) = get_next( *val );
 
-                if( this.tail == &get_next( *val ) ) {
-                        this.tail = it;
+                if( tail == &get_next( *val ) ) {
+                        tail = it;
                 }
 
                 get_next( *val ) = NULL;
 
-                verify( (this.head == NULL) == (&this.head == this.tail) );
-                verify( *this.tail == NULL );
+                verify( (head == NULL) == (&head == tail) );
+                verify( *tail == NULL );
                 return val;
         }
 #endif
+
+//-----------------------------------------------------------------------------
+// Tools
+//-----------------------------------------------------------------------------
+#ifdef __cforall
+
+#endif

src/libcfa/bits/locks.h

@@ -58 +58 @@
 
 #ifdef __cforall
+        extern "C" {
+                extern void disable_interrupts();
+                extern void enable_interrupts_noPoll();
+        }
+
         extern void yield( unsigned int );
         extern thread_local struct thread_desc *    volatile this_thread;
+        extern thread_local struct processor *      volatile this_processor;
 
         static inline void ?{}( __spinlock_t & this ) {
@@ -68 +74 @@
         static inline _Bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
                 _Bool result = __lock_test_and_test_and_set( this.lock );
-                __cfaabi_dbg_debug_do(
-                        if( result ) {
+                if( result ) {
+                        disable_interrupts();
+                        __cfaabi_dbg_debug_do(
                                 this.prev_name = caller;
                                 this.prev_thrd = this_thread;
-                        }
-                )
+                        )
+                }
                 return result;
         }
@@ -99 +106 @@
                         #endif
                 }
+                disable_interrupts();
                 __cfaabi_dbg_debug_do(
                         this.prev_name = caller;
@@ -105 +113 @@
         }
 
-        // Lock the spinlock, spin if already acquired
-        static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
-                for ( unsigned int i = 1;; i += 1 ) {
-                        if ( __lock_test_and_test_and_set( this.lock ) ) break;
-                        yield( i );
-                }
-                __cfaabi_dbg_debug_do(
-                        this.prev_name = caller;
-                        this.prev_thrd = this_thread;
-                )
-        }
+        // // Lock the spinlock, yield if already acquired
+        // static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
+        //      for ( unsigned int i = 1;; i += 1 ) {
+        //              if ( __lock_test_and_test_and_set( this.lock ) ) break;
+        //              yield( i );
+        //      }
+        //      disable_interrupts();
+        //      __cfaabi_dbg_debug_do(
+        //              this.prev_name = caller;
+        //              this.prev_thrd = this_thread;
+        //      )
+        // }
 
         static inline void unlock( __spinlock_t & this ) {
+                enable_interrupts_noPoll();
                 __lock_release( this.lock );
         }

src/libcfa/concurrency/coroutine.c

@@ -118 +118 @@
 } //ctxSwitchDirect
 
-void create_stack( coStack_t* this, unsigned int storageSize ) {
+void create_stack( coStack_t* this, unsigned int storageSize ) with( *this ) {
         //TEMP HACK do this on proper kernel startup
         if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
@@ -124 +124 @@
         size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
 
-        if ( (intptr_t)this->storage == 0 ) {
-                this->userStack = false;
-                this->size = libCeiling( storageSize, 16 );
+        if ( (intptr_t)storage == 0 ) {
+                userStack = false;
+                size = libCeiling( storageSize, 16 );
                 // use malloc/memalign because "new" raises an exception for out-of-memory
 
                 // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
-                __cfaabi_dbg_debug_do( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
-                __cfaabi_dbg_no_debug_do( this->storage = malloc( cxtSize + this->size + 8 ) );
+                __cfaabi_dbg_debug_do( storage = memalign( pageSize, cxtSize + size + pageSize ) );
+                __cfaabi_dbg_no_debug_do( storage = malloc( cxtSize + size + 8 ) );
 
                 __cfaabi_dbg_debug_do(
-                        if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) {
+                        if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) {
                                 abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
                         } // if
                 );
 
-                if ( (intptr_t)this->storage == 0 ) {
-                        abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", this->size );
+                if ( (intptr_t)storage == 0 ) {
+                        abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", size );
                 } // if
 
-                __cfaabi_dbg_debug_do( this->limit = (char *)this->storage + pageSize );
-                __cfaabi_dbg_no_debug_do( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
+                __cfaabi_dbg_debug_do( limit = (char *)storage + pageSize );
+                __cfaabi_dbg_no_debug_do( limit = (char *)libCeiling( (unsigned long)storage, 16 ) ); // minimum alignment
 
         } else {
-                assertf( ((size_t)this->storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", this->storage, (int)libAlign() );
-                this->userStack = true;
-                this->size = storageSize - cxtSize;
+                assertf( ((size_t)storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", storage, (int)libAlign() );
+                userStack = true;
+                size = storageSize - cxtSize;
 
-                if ( this->size % 16 != 0u ) this->size -= 8;
+                if ( size % 16 != 0u ) size -= 8;
 
-                this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ); // minimum alignment
+                limit = (char *)libCeiling( (unsigned long)storage, 16 ); // minimum alignment
         } // if
-        assertf( this->size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
+        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
 
-        this->base = (char *)this->limit + this->size;
-        this->context = this->base;
-        this->top = (char *)this->context + cxtSize;
+        base = (char *)limit + size;
+        context = base;
+        top = (char *)context + cxtSize;
 }
 

src/libcfa/concurrency/invoke.h

@@ -134 +134 @@
                 // instrusive link field for threads
                 struct thread_desc * next;
+
+                __cfaabi_dbg_debug_do(
+                        // instrusive link field for debugging
+                        struct thread_desc * dbg_next;
+                        struct thread_desc * dbg_prev;
+                )
      };
 

src/libcfa/concurrency/kernel.c

@@ -87 +87 @@
 }
 
-void ?{}( coStack_t & this, current_stack_info_t * info) {
-        this.size = info->size;
-        this.storage = info->storage;
-        this.limit = info->limit;
-        this.base = info->base;
-        this.context = info->context;
-        this.top = info->top;
-        this.userStack = true;
-}
-
-void ?{}( coroutine_desc & this, current_stack_info_t * info) {
-        (this.stack){ info };
-        this.name = "Main Thread";
-        this.errno_ = 0;
-        this.state = Start;
-        this.starter = NULL;
-}
-
-void ?{}( thread_desc & this, current_stack_info_t * info) {
-        (this.self_cor){ info };
+void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
+        size      = info->size;
+        storage   = info->storage;
+        limit     = info->limit;
+        base      = info->base;
+        context   = info->context;
+        top       = info->top;
+        userStack = true;
+}
+
+void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
+        stack{ info };
+        name = "Main Thread";
+        errno_ = 0;
+        state = Start;
+        starter = NULL;
+}
+
+void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
+        self_cor{ info };
 }
 
@@ -133 +133 @@
 void ?{}(processor & this, cluster * cltr) {
         this.cltr = cltr;
-        (this.terminated){ 0 };
+        this.terminated{ 0 };
         this.do_terminate = false;
         this.preemption_alarm = NULL;
@@ -143 +143 @@
 void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
         this.cltr = cltr;
-        (this.terminated){ 0 };
+        this.terminated{ 0 };
         this.do_terminate = false;
         this.preemption_alarm = NULL;
@@ -154 +154 @@
 }
 
-void ^?{}(processor & this) {
-        if( ! this.do_terminate ) {
+void ^?{}(processor & this) with( this ){
+        if( ! do_terminate ) {
                 __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
-                this.do_terminate = true;
-                P( this.terminated );
-                pthread_join( this.kernel_thread, NULL );
-        }
-}
-
-void ?{}(cluster & this) {
-        (this.ready_queue){};
-        ( this.ready_queue_lock ){};
-
-        this.preemption = default_preemption();
+                do_terminate = true;
+                P( terminated );
+                pthread_join( kernel_thread, NULL );
+        }
+}
+
+void ?{}(cluster & this) with( this ) {
+        ready_queue{};
+        ready_queue_lock{};
+
+        preemption = default_preemption();
 }
 
@@ -240 +240 @@
 // Once a thread has finished running, some of
 // its final actions must be executed from the kernel
-void finishRunning(processor * this) {
-        if( this->finish.action_code == Release ) {
-                unlock( *this->finish.lock );
-        }
-        else if( this->finish.action_code == Schedule ) {
-                ScheduleThread( this->finish.thrd );
-        }
-        else if( this->finish.action_code == Release_Schedule ) {
-                unlock( *this->finish.lock );
-                ScheduleThread( this->finish.thrd );
-        }
-        else if( this->finish.action_code == Release_Multi ) {
-                for(int i = 0; i < this->finish.lock_count; i++) {
-                        unlock( *this->finish.locks[i] );
+void finishRunning(processor * this) with( this->finish ) {
+        if( action_code == Release ) {
+                verify( disable_preempt_count > 1 );
+                unlock( *lock );
+        }
+        else if( action_code == Schedule ) {
+                ScheduleThread( thrd );
+        }
+        else if( action_code == Release_Schedule ) {
+                verify( disable_preempt_count > 1 );
+                unlock( *lock );
+                ScheduleThread( thrd );
+        }
+        else if( action_code == Release_Multi ) {
+                verify( disable_preempt_count > lock_count );
+                for(int i = 0; i < lock_count; i++) {
+                        unlock( *locks[i] );
                 }
         }
-        else if( this->finish.action_code == Release_Multi_Schedule ) {
-                for(int i = 0; i < this->finish.lock_count; i++) {
-                        unlock( *this->finish.locks[i] );
+        else if( action_code == Release_Multi_Schedule ) {
+                for(int i = 0; i < lock_count; i++) {
+                        unlock( *locks[i] );
                 }
-                for(int i = 0; i < this->finish.thrd_count; i++) {
-                        ScheduleThread( this->finish.thrds[i] );
+                for(int i = 0; i < thrd_count; i++) {
+                        ScheduleThread( thrds[i] );
                 }
         }
         else {
-                assert(this->finish.action_code == No_Action);
+                assert(action_code == No_Action);
         }
 }
@@ -334 +337 @@
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        lock(   this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 );
-        append( this_processor->cltr->ready_queue, thrd );
-        unlock( this_processor->cltr->ready_queue_lock );
-
-        verify( disable_preempt_count > 0 );
-}
-
-thread_desc * nextThread(cluster * this) {
-        verify( disable_preempt_count > 0 );
-        lock( this->ready_queue_lock __cfaabi_dbg_ctx2 );
-        thread_desc * head = pop_head( this->ready_queue );
-        unlock( this->ready_queue_lock );
+        with( *this_processor->cltr ) {
+                lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+                append( ready_queue, thrd );
+                unlock( ready_queue_lock );
+        }
+
+        verify( disable_preempt_count > 0 );
+}
+
+thread_desc * nextThread(cluster * this) with( *this ) {
+        verify( disable_preempt_count > 0 );
+        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
+        thread_desc * head = pop_head( ready_queue );
+        unlock( ready_queue_lock );
         verify( disable_preempt_count > 0 );
         return head;
@@ -361 +366 @@
         disable_interrupts();
         this_processor->finish.action_code = Release;
-        this_processor->finish.lock = lock;
-
-        verify( disable_preempt_count > 0 );
+        this_processor->finish.lock        = lock;
+
+        verify( disable_preempt_count > 1 );
         suspend();
         verify( disable_preempt_count > 0 );
@@ -371 +376 @@
 
 void BlockInternal( thread_desc * thrd ) {
-        assert(thrd);
         disable_interrupts();
-        assert( thrd->self_cor.state != Halted );
         this_processor->finish.action_code = Schedule;
-        this_processor->finish.thrd = thrd;
+        this_processor->finish.thrd        = thrd;
 
         verify( disable_preempt_count > 0 );
@@ -388 +391 @@
         disable_interrupts();
         this_processor->finish.action_code = Release_Schedule;
-        this_processor->finish.lock = lock;
-        this_processor->finish.thrd = thrd;
-
-        verify( disable_preempt_count > 0 );
+        this_processor->finish.lock        = lock;
+        this_processor->finish.thrd        = thrd;
+
+        verify( disable_preempt_count > 1 );
         suspend();
         verify( disable_preempt_count > 0 );
@@ -401 +404 @@
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi;
-        this_processor->finish.locks = locks;
-        this_processor->finish.lock_count = count;
+        this_processor->finish.locks       = locks;
+        this_processor->finish.lock_count  = count;
 
         verify( disable_preempt_count > 0 );
@@ -414 +417 @@
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi_Schedule;
-        this_processor->finish.locks = locks;
-        this_processor->finish.lock_count = lock_count;
-        this_processor->finish.thrds = thrds;
-        this_processor->finish.thrd_count = thrd_count;
+        this_processor->finish.locks       = locks;
+        this_processor->finish.lock_count  = lock_count;
+        this_processor->finish.thrds       = thrds;
+        this_processor->finish.thrd_count  = thrd_count;
 
         verify( disable_preempt_count > 0 );
@@ -429 +432 @@
         verify( disable_preempt_count > 0 );
         this_processor->finish.action_code = thrd ? Release_Schedule : Release;
-        this_processor->finish.lock = lock;
-        this_processor->finish.thrd = thrd;
+        this_processor->finish.lock        = lock;
+        this_processor->finish.thrd        = thrd;
 
         suspend();
@@ -516 +519 @@
 }
 
+//=============================================================================================
+// Unexpected Terminating logic
+//=============================================================================================
+
+
 static __spinlock_t kernel_abort_lock;
 static __spinlock_t kernel_debug_lock;
@@ -581 +589 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore & this) {
-        lock( this.lock __cfaabi_dbg_ctx2 );
-        this.count -= 1;
-        if ( this.count < 0 ) {
+void P(semaphore & this) with( this ){
+        lock( lock __cfaabi_dbg_ctx2 );
+        count -= 1;
+        if ( count < 0 ) {
                 // queue current task
-                append( this.waiting, (thread_desc *)this_thread );
+                append( waiting, (thread_desc *)this_thread );
 
                 // atomically release spin lock and block
-                BlockInternal( &this.lock );
+                BlockInternal( &lock );
         }
         else {
-            unlock( this.lock );
-        }
-}
-
-void V(semaphore & this) {
+            unlock( lock );
+        }
+}
+
+void V(semaphore & this) with( this ) {
         thread_desc * thrd = NULL;
-        lock( this.lock __cfaabi_dbg_ctx2 );
-        this.count += 1;
-        if ( this.count <= 0 ) {
+        lock( lock __cfaabi_dbg_ctx2 );
+        count += 1;
+        if ( count <= 0 ) {
                 // remove task at head of waiting list
-                thrd = pop_head( this.waiting );
-        }
-
-        unlock( this.lock );
+                thrd = pop_head( waiting );
+        }
+
+        unlock( lock );
 
         // make new owner
@@ -611 +619 @@
 }
 
+//-----------------------------------------------------------------------------
+// Debug
+__cfaabi_dbg_debug_do(
+        struct {
+                thread_desc * tail;
+        } __cfaabi_dbg_thread_list = { NULL };
+
+        void __cfaabi_dbg_thread_register( thread_desc * thrd ) {
+                if( !__cfaabi_dbg_thread_list.tail ) {
+                        __cfaabi_dbg_thread_list.tail = thrd;
+                        return;
+                }
+                __cfaabi_dbg_thread_list.tail->dbg_next = thrd;
+                thrd->dbg_prev = __cfaabi_dbg_thread_list.tail;
+                __cfaabi_dbg_thread_list.tail = thrd;
+        }
+
+        void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) {
+                thread_desc * prev = thrd->dbg_prev;
+                thread_desc * next = thrd->dbg_next;
+
+                if( next ) { next->dbg_prev = prev; }
+                else       {
+                        assert( __cfaabi_dbg_thread_list.tail == thrd );
+                        __cfaabi_dbg_thread_list.tail = prev;
+                }
+
+                if( prev ) { prev->dbg_next = next; }
+
+                thrd->dbg_prev = NULL;
+                thrd->dbg_next = NULL;
+        }
+)
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/kernel_private.h

@@ -85 +85 @@
 extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
 
+__cfaabi_dbg_debug_do(
+        extern void __cfaabi_dbg_thread_register  ( thread_desc * thrd );
+        extern void __cfaabi_dbg_thread_unregister( thread_desc * thrd );
+)
+
 //-----------------------------------------------------------------------------
 // Utils

src/libcfa/concurrency/monitor.c

@@ -53 +53 @@
 static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
 
-#ifndef __CFA_LOCK_NO_YIELD
-#define DO_LOCK lock_yield
-#else
-#define DO_LOCK lock
-#endif
-
 //-----------------------------------------------------------------------------
 // Useful defines
@@ -90 +84 @@
         static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                lock( this->lock __cfaabi_dbg_ctx2 );
                 thread_desc * thrd = this_thread;
+
+                verify( disable_preempt_count > 0 );
 
                 __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
@@ -121 +117 @@
                         // Some one else has the monitor, wait in line for it
                         append( this->entry_queue, thrd );
+
+                        verify( disable_preempt_count > 0 );
+
                         BlockInternal( &this->lock );
 
@@ -138 +137 @@
         static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                lock( this->lock __cfaabi_dbg_ctx2 );
                 thread_desc * thrd = this_thread;
 
@@ -201 +200 @@
         // Leave single monitor
         void __leave_monitor_desc( monitor_desc * this ) {
-                // Lock the monitor spinlock, DO_LOCK to reduce contention
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                // Lock the monitor spinlock
+                lock( this->lock __cfaabi_dbg_ctx2 );
 
                 __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
@@ -248 +247 @@
 
                 // Lock the monitor now
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                lock( this->lock __cfaabi_dbg_ctx2 );
 
                 disable_interrupts();
@@ -397 +396 @@
         append( this.blocked, &waiter );
 
+        verify( disable_preempt_count == 0 );
+
         // Lock all monitors (aggregates the locks as well)
         lock_all( monitors, locks, count );
+
+        // verifyf( disable_preempt_count == count, "Got %d, expected %d\n", disable_preempt_count, count );
+        if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); }
 
         // Find the next thread(s) to run
@@ -473 +477 @@
         monitor_ctx( this.monitors, this.monitor_count );
 
+        verify( disable_preempt_count == 0 );
+
         // Lock all monitors (aggregates the locks them as well)
         lock_all( monitors, locks, count );
+
+        // verify( disable_preempt_count == count );
+        if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); }
+
 
         // Create the node specific to this wait operation
@@ -737 +747 @@
 static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
-                DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 );
+                lock( *locks[i] __cfaabi_dbg_ctx2 );
         }
 }
@@ -744 +754 @@
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
-                DO_LOCK( *l __cfaabi_dbg_ctx2 );
+                lock( *l __cfaabi_dbg_ctx2 );
                 if(locks) locks[i] = l;
         }

src/libcfa/concurrency/preemption.c

@@ -19 +19 @@
 extern "C" {
 #include <errno.h>
-#include <execinfo.h>
-#define __USE_GNU
-#include <signal.h>
-#undef __USE_GNU
 #include <stdio.h>
 #include <string.h>
@@ -29 +25 @@
 #undef ftype
 
-#ifdef __USE_STREAM__
-#include "fstream"
-#endif
+#include "bits/signal.h"
 
 //TODO move to defaults
@@ -40 +34 @@
         return __CFA_DEFAULT_PREEMPTION__;
 }
-
-// Short hands for signal context information
-#define __CFA_SIGCXT__ ucontext_t *
-#define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt
 
 // FwdDeclarations : timeout handlers
@@ -53 +43 @@
 void sigHandler_segv     ( __CFA_SIGPARMS__ );
 void sigHandler_abort    ( __CFA_SIGPARMS__ );
-
-// FwdDeclarations : sigaction wrapper
-static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags );
 
 // FwdDeclarations : alarm thread main
@@ -73 +60 @@
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
 
-void ?{}(event_kernel_t & this) {
-        (this.alarms){};
-        (this.lock){};
+void ?{}(event_kernel_t & this) with( this ) {
+        alarms{};
+        lock{};
 }
 
@@ -162 +149 @@
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                processor * proc   = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
+                processor   * proc = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
                 thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
 
@@ -182 +169 @@
         void enable_interrupts_noPoll() {
                 __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
-                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interrupts
+                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
         }
 }
@@ -246 +233 @@
         // Setup proper signal handlers
         __kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART );         // CtxSwitch handler
-        // __kernel_sigaction( SIGSEGV, sigHandler_segv     , SA_SIGINFO );      // Failure handler
-        // __kernel_sigaction( SIGBUS , sigHandler_segv     , SA_SIGINFO );      // Failure handler
 
         signal_block( SIGALRM );
@@ -308 +293 @@
         if( !preemption_ready() ) { return; }
 
-        // __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
+        __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
 
         preemption_in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
@@ -380 +365 @@
 }
 
-// Sigaction wrapper : register an signal handler
-static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) {
-        struct sigaction act;
-
-        act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
-        act.sa_flags = flags;
-
-        if ( sigaction( sig, &act, NULL ) == -1 ) {
-                __cfaabi_dbg_print_buffer_decl(
-                        " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
-                        sig, handler, flags, errno, strerror( errno )
-                );
-                _exit( EXIT_FAILURE );
-        }
-}
-
-// Sigaction wrapper : restore default handler
-static void __kernel_sigdefault( int sig ) {
-        struct sigaction act;
-
-        act.sa_handler = SIG_DFL;
-        act.sa_flags = 0;
-        sigemptyset( &act.sa_mask );
-
-        if ( sigaction( sig, &act, NULL ) == -1 ) {
-                __cfaabi_dbg_print_buffer_decl(
-                        " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
-                        sig, errno, strerror( errno )
-                );
-                _exit( EXIT_FAILURE );
-        }
-}
-
-//=============================================================================================
-// Terminating Signals logic
-//=============================================================================================
-
-__cfaabi_dbg_debug_do(
-        static void __kernel_backtrace( int start ) {
-                // skip first N stack frames
-
-                enum { Frames = 50 };
-                void * array[Frames];
-                int size = backtrace( array, Frames );
-                char ** messages = backtrace_symbols( array, size );
-
-                // find executable name
-                *index( messages[0], '(' ) = '\0';
-                #ifdef __USE_STREAM__
-                serr | "Stack back trace for:" | messages[0] | endl;
-                #else
-                fprintf( stderr, "Stack back trace for: %s\n", messages[0]);
-                #endif
-
-                // skip last 2 stack frames after main
-                for ( int i = start; i < size && messages != NULL; i += 1 ) {
-                        char * name = NULL;
-                        char * offset_begin = NULL;
-                        char * offset_end = NULL;
-
-                        for ( char *p = messages[i]; *p; ++p ) {
-                                // find parantheses and +offset
-                                if ( *p == '(' ) {
-                                        name = p;
-                                }
-                                else if ( *p == '+' ) {
-                                        offset_begin = p;
-                                }
-                                else if ( *p == ')' ) {
-                                        offset_end = p;
-                                        break;
-                                }
-                        }
-
-                        // if line contains symbol print it
-                        int frameNo = i - start;
-                        if ( name && offset_begin && offset_end && name < offset_begin ) {
-                                // delimit strings
-                                *name++ = '\0';
-                                *offset_begin++ = '\0';
-                                *offset_end++ = '\0';
-
-                                #ifdef __USE_STREAM__
-                                serr    | "("  | frameNo | ")" | messages[i] | ":"
-                                        | name | "+" | offset_begin | offset_end | endl;
-                                #else
-                                fprintf( stderr, "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end);
-                                #endif
-                        }
-                        // otherwise, print the whole line
-                        else {
-                                #ifdef __USE_STREAM__
-                                serr | "(" | frameNo | ")" | messages[i] | endl;
-                                #else
-                                fprintf( stderr, "(%i) %s\n", frameNo, messages[i] );
-                                #endif
-                        }
-                }
-
-                free( messages );
-        }
-)
-
-// void sigHandler_segv( __CFA_SIGPARMS__ ) {
-//      __cfaabi_dbg_debug_do(
-//              #ifdef __USE_STREAM__
-//              serr    | "*CFA runtime error* program cfa-cpp terminated with"
-//                      | (sig == SIGSEGV ? "segment fault." : "bus error.")
-//                      | endl;
-//              #else
-//              fprintf( stderr, "*CFA runtime error* program cfa-cpp terminated with %s\n", sig == SIGSEGV ? "segment fault." : "bus error." );
-//              #endif
-
-//              // skip first 2 stack frames
-//              __kernel_backtrace( 1 );
-//      )
-//      exit( EXIT_FAILURE );
-// }
-
-// void sigHandler_abort( __CFA_SIGPARMS__ ) {
-//      // skip first 6 stack frames
-//      __cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); )
-
-//      // reset default signal handler
-//      __kernel_sigdefault( SIGABRT );
-
-//      raise( SIGABRT );
-// }
-
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/thread.c

@@ -31 +31 @@
 // Thread ctors and dtors
 
-void ?{}(thread_desc& this) {
-        (this.self_cor){};
-        this.self_cor.name = "Anonymous Coroutine";
-        this.self_mon.owner = &this;
-        this.self_mon.recursion = 1;
-        this.self_mon_p = &this.self_mon;
-        this.next = NULL;
+void ?{}(thread_desc& this) with( this ) {
+        self_cor{};
+        self_cor.name = "Anonymous Coroutine";
+        self_mon.owner = &this;
+        self_mon.recursion = 1;
+        self_mon_p = &self_mon;
+        next = NULL;
+        __cfaabi_dbg_debug_do(
+                dbg_next = NULL;
+                dbg_prev = NULL;
+                __cfaabi_dbg_thread_register(&this);
+        )
 
-        (this.monitors){ &this.self_mon_p, 1, (fptr_t)0 };
+        monitors{ &self_mon_p, 1, (fptr_t)0 };
 }
 
-void ^?{}(thread_desc& this) {
-        ^(this.self_cor){};
+void ^?{}(thread_desc& this) with( this ) {
+        ^self_cor{};
 }
 
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
-void ?{}( scoped(T)& this ) {
-        (this.handle){};
-        __thrd_start(this.handle);
+void ?{}( scoped(T)& this ) with( this ) {
+        handle{};
+        __thrd_start(handle);
 }
 
 forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
-void ?{}( scoped(T)& this, P params ) {
-        (this.handle){ params };
-        __thrd_start(this.handle);
+void ?{}( scoped(T)& this, P params ) with( this ) {
+        handle{ params };
+        __thrd_start(handle);
 }
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)& this ) {
-        ^(this.handle){};
+void ^?{}( scoped(T)& this ) with( this ) {
+        ^handle{};
 }
 
@@ -68 +73 @@
 void __thrd_start( T& this ) {
         coroutine_desc* thrd_c = get_coroutine(this);
-        thread_desc*  thrd_h = get_thread   (this);
+        thread_desc   * thrd_h = get_thread   (this);
         thrd_c->last = this_coroutine;
 

src/libcfa/interpose.c

@@ -22 +22 @@
 #include <dlfcn.h>
 #include <unistd.h>
+#define __USE_GNU
+#include <signal.h>
+#undef __USE_GNU
+#include <execinfo.h>
 }
 
 #include "bits/debug.h"
 #include "bits/defs.h"
+#include "bits/signal.h"
 #include "startup.h"
 
-void interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
+void __cfaabi_interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
 
 typedef void (*generic_fptr_t)(void);
@@ -84 +89 @@
 #define INIT_REALRTN( x, ver ) assign_ptr( (void**)&libc_##x, #x, ver)
 
-void interpose_startup() {
+void sigHandler_segv ( __CFA_SIGPARMS__ );
+void sigHandler_abort( __CFA_SIGPARMS__ );
+
+void __cfaabi_interpose_startup() {
         const char *version = NULL;
 
         INIT_REALRTN( abort, version );
         INIT_REALRTN( exit, version );
-}
+
+        __kernel_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO );      // Failure handler
+        __kernel_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO );      // Failure handler
+        __kernel_sigaction( SIGABRT, sigHandler_abort, SA_SIGINFO );      // Failure handler
+}
+
+//=============================================================================================
+// Terminating Signals logic
+//=============================================================================================
 
 extern "C" {
@@ -137 +153 @@
                 libc_abort();
         }
+}
+
+// skip first 6 stack frames by default
+static void __kernel_backtrace() {
+        // skip first N stack frames
+        int start = 6;
+
+        enum { Frames = 50 };
+        void * array[Frames];
+        int size = backtrace( array, Frames );
+        char ** messages = backtrace_symbols( array, size );
+
+        // find executable name
+        *index( messages[0], '(' ) = '\0';
+        __cfaabi_dbg_bits_print_nolock( "Stack back trace for: %s\n", messages[0]);
+
+        // skip last 2 stack frames after main
+        for ( int i = start; i < size && messages != NULL; i += 1 ) {
+                char * name = NULL;
+                char * offset_begin = NULL;
+                char * offset_end = NULL;
+
+                for ( char *p = messages[i]; *p; ++p ) {
+                        // find parantheses and +offset
+                        if ( *p == '(' ) {
+                                name = p;
+                        }
+                        else if ( *p == '+' ) {
+                                offset_begin = p;
+                        }
+                        else if ( *p == ')' ) {
+                                offset_end = p;
+                                break;
+                        }
+                }
+
+                // if line contains symbol print it
+                int frameNo = i - start;
+                if ( name && offset_begin && offset_end && name < offset_begin ) {
+                        // delimit strings
+                        *name++ = '\0';
+                        *offset_begin++ = '\0';
+                        *offset_end++ = '\0';
+
+                        __cfaabi_dbg_bits_print_nolock( "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end);
+                }
+                // otherwise, print the whole line
+                else {
+                        __cfaabi_dbg_bits_print_nolock( "(%i) %s\n", frameNo, messages[i] );
+                }
+        }
+
+        free( messages );
+}
+
+void sigHandler_segv( __CFA_SIGPARMS__ ) {
+        // skip first only 1 stack frames in case of segfault.
+        abortf( "*CFA runtime error* program cfa-cpp terminated with %s\n", sig == SIGSEGV ? "segment fault." : "bus error." );
+}
+
+void sigHandler_abort( __CFA_SIGPARMS__ ) {
+        __kernel_backtrace();
+
+        // reset default signal handler
+        __kernel_sigdefault( SIGABRT );
+
+        raise( SIGABRT );
 }
 

src/libcfa/interpose.h

@@ -16 +16 @@
 #pragma once
 
-void * interpose_symbol( const char* symbol, , const char *version );
+void * interpose_symbol( const char* symbol, const char *version );
 
 extern __typeof__( abort ) libc_abort __attribute__(( noreturn ));

src/prelude/prelude.cf

@@ -39 +39 @@
 // ------------------------------------------------------------
 
-_Bool                   ?++( _Bool & ),                         ?++( volatile _Bool & );
-_Bool                   ?--( _Bool & ),                         ?--( volatile _Bool & );
 signed short            ?++( signed short & ),                  ?++( volatile signed short & );
 signed short            ?--( signed short & ),                  ?--( volatile signed short & );
@@ -94 +92 @@
 // ------------------------------------------------------------
 
-_Bool                   ++?( _Bool & ),                         --?( _Bool & );
 signed short    ++?( signed short & ),                  --?( signed short & );
 signed int              ++?( signed int & ),                    --?( signed int & );
@@ -125 +122 @@
 forall( ftype FT ) FT &          *?( FT * );
 
-_Bool                   +?( _Bool ),                    -?( _Bool ),                    ~?( _Bool );
+_Bool                   +?( _Bool ),                    -?( _Bool );
 signed int              +?( signed int ),               -?( signed int ),               ~?( signed int );
 unsigned int            +?( unsigned int ),             -?( unsigned int ),             ~?( unsigned int );
@@ -157 +154 @@
 // ------------------------------------------------------------
 
-_Bool                   ?*?( _Bool, _Bool ),                                    ?/?( _Bool, _Bool ),                            ?%?( _Bool, _Bool );
 signed int              ?*?( signed int, signed int ),                          ?/?( signed int, signed int ),                  ?%?( signed int, signed int );
 unsigned int            ?*?( unsigned int, unsigned int ),                      ?/?( unsigned int, unsigned int ),              ?%?( unsigned int, unsigned int );
@@ -215 +211 @@
 // ------------------------------------------------------------
 
-_Bool                   ?<<?( _Bool, _Bool ),                                   ?>>?( _Bool, _Bool );
 signed int              ?<<?( signed int, signed int ),                         ?>>?( signed int, signed int );
 unsigned int            ?<<?( unsigned int, unsigned int ),                     ?>>?( unsigned int, unsigned int );
@@ -467 +462 @@
 
 
-_Bool                   ?*=?( _Bool &, _Bool ),                                 ?*=?( volatile _Bool &, _Bool );
 char                    ?*=?( char &, char ),                                   ?*=?( volatile char &, char );
 char signed             ?*=?( char signed &, char signed ),                     ?*=?( volatile char signed &, char signed );
@@ -534 +528 @@
 unsigned long long int  ?-=?( unsigned long long int &, unsigned long long int ), ?-=?( volatile unsigned long long int &, unsigned long long int );
 
-_Bool                   ?<<=?( _Bool &, _Bool ),                                ?<<=?( volatile _Bool &, _Bool );
 char                    ?<<=?( char &, char ),                                  ?<<=?( volatile char &, char );
 char signed             ?<<=?( char signed &, char signed ),                    ?<<=?( volatile char signed &, char signed );
@@ -547 +540 @@
 unsigned long long int  ?<<=?( unsigned long long int &, unsigned long long int ), ?<<=?( volatile unsigned long long int &, unsigned long long int );
 
-_Bool                   ?>>=?( _Bool &, _Bool ),                                ?>>=?( volatile _Bool &, _Bool );
 char                    ?>>=?( char &, char ),                                  ?>>=?( volatile char &, char );
 char signed             ?>>=?( char signed &, char signed ),                    ?>>=?( volatile char signed &, char signed );

src/tests/Makefile.am

@@ -65 +65 @@
 
 concurrency :
-        @+python test.py --debug=${debug} ${concurrent} ${concurrent_test}
+        @+python test.py --debug=${debug} -Iconcurrent
 
 .dummy : .dummy.c @CFA_BINDIR@/@CFA_NAME@

src/tests/Makefile.in

@@ -743 +743 @@
 
 concurrency :
-        @+python test.py --debug=${debug} ${concurrent} ${concurrent_test}
+        @+python test.py --debug=${debug} -Iconcurrent
 
 .dummy : .dummy.c @CFA_BINDIR@/@CFA_NAME@

src/tests/concurrent/examples/quickSort.c

@@ -9 +9 @@
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 29 08:41:37 2018
-// Update Count     : 155
+// Last Modified On : Tue Jan 30 15:58:58 2018
+// Update Count     : 162
 //
 
@@ -100 +100 @@
         if ( argc != 1 ) {                                                                      // do not use defaults
                 if ( argc < 2 || argc > 4 ) usage( argv );              // wrong number of options
-//              if ( strcmp( argv[1], "-t" ) == 0 ) {                   // timing ?
-                if ( argv[1][0] == '-' && argv[1][1] == 't' ) { // timing ?
+                if ( strcmp( argv[1], "-t" ) == 0 ) {                   // timing ?
                         &unsortedfile = (ifstream *)0;                          // no input
                         choose ( argc ) {

src/tests/functions.c

@@ -10 +10 @@
 // Created On       : Wed Aug 17 08:39:58 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Nov 27 18:08:54 2017
-// Update Count     : 11
+// Last Modified On : Wed Jan 17 22:44:12 2018
+// Update Count     : 12
 // 
 
@@ -25 +25 @@
         void g(void)
         ) {
-        (*g)();
+        (* g)();
         g();
         g = h;
@@ -32 +32 @@
 int f1() {}
 int (f2()) {}
-int (*f3())() {}
-int *((f4())) {}
-int ((*f5()))() {}
-int *f6() {}
-int *(f7)() {}
-int **f8() {}
-int * const *(f9)() {}
-int (*f10())[] {}
-int (*f11())[][3] {}
-int ((*f12())[])[3] {}
+int (* f3())() {}
+int * ((f4())) {}
+int ((* f5()))() {}
+int * f6() {}
+int * (f7)() {}
+int ** f8() {}
+int * const * (f9)() {}
+int (* f10())[] {}
+int (* f11())[][3] {}
+int ((* f12())[])[3] {}
 
 // "implicit int" otype specifier (not ANSI)
@@ -50 +50 @@
 extern const fII4( int i ) {}
 
-*fII5() {}
-const *fII6() {}
-const long *fII7() {}
-static const long *fII8() {}
-const static long *fII9() {}
+* fII5() {}
+const * fII6() {}
+const long * fII7() {}
+static const long * fII8() {}
+const static long * fII9() {}
 
 // K&R function definitions
@@ -117 +117 @@
         [int](int)
         ) {
-        int (*(*pc)[][10])[][3];
+        int (* (* pc)[][10])[][3];
         * [][10] * [][3] int p;
         * [] * [int](int) p;
 }
 
-static const int *f1() {}
+static const int * f1() {}
 static [ const int ] f2() {}
 static inline [ const * int ] f3() {}
@@ -133 +133 @@
         int (),
 
-        int *(),
-        int **(),
-        int * const *(),
+        int * (),
+        int ** (),
+        int * const * (),
         int * const * const (),
 
@@ -141 +141 @@
         int ([10]),
 
-        int *([]),
-        int *([10]),
-        int **([]),
-        int **([10]),
-        int * const *([]),
-        int * const *([10]),
+        int * ([]),
+        int * ([10]),
+        int ** ([]),
+        int ** ([10]),
+        int * const * ([]),
+        int * const * ([10]),
         int * const * const ([]),
         int * const * const ([10])
@@ -154 +154 @@
         int (),
 
-        int *(),
-        int **(),
-        int * const *(),
+        int * (),
+        int ** (),
+        int * const * (),
         int * const * const (),
 
@@ -162 +162 @@
         int ([10]),
 
-        int *([]),
-        int *([10]),
-        int **([]),
-        int **([10]),
-        int * const *([]),
-        int * const *([10]),
+        int * ([]),
+        int * ([10]),
+        int ** ([]),
+        int ** ([10]),
+        int * const * ([]),
+        int * const * ([10]),
         int * const * const ([]),
         int * const * const ([10])
@@ -175 +175 @@
 typedef int T;
 
-int f( T (*f), T t ) {
+int f( T (* f), T t ) {
         T (T);
 }
@@ -184 +184 @@
 //int (f[])() {}
 //int f[]() {}
-//int ((*f15())())[] {}
+//int ((* f15())())[] {}
 
 // Local Variables: //

src/tests/identFuncDeclarator.c

@@ -10 +10 @@
 // Created On       : Wed Aug 17 08:36:34 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 17 08:37:06 2016
-// Update Count     : 1
+// Last Modified On : Wed Jan 17 22:39:13 2018
+// Update Count     : 2
 // 
 
@@ -18 +18 @@
         int (f2);
 
-        int *f3;
-        int **f4;
-        int * const *f5;
+        int * f3;
+        int ** f4;
+        int * const * f5;
         int * const * const f6;
 
-        int *(f7);
-        int **(f8);
-        int * const *(f9);
+        int * (f7);
+        int ** (f8);
+        int * const * (f9);
         int * const * const (f10);
 
-        int (*f11);
-        int (**f12);
-        int (* const *f13);
+        int (* f11);
+        int (** f12);
+        int (* const * f13);
         int (* const * const f14);
 
@@ -38 +38 @@
         int (f18[10]);
 
-        int *f19[2];
-        int *f20[10];
-        int **f21[2];
-        int **f22[10];
-        int * const *f23[2];
-        int * const *f24[10];
+        int * f19[2];
+        int * f20[10];
+        int ** f21[2];
+        int ** f22[10];
+        int * const * f23[2];
+        int * const * f24[10];
         int * const * const f25[2];
         int * const * const f26[10];
 
-        int *(f27[2]);
-        int *(f28[10]);
-        int **(f29[2]);
-        int **(f30[10]);
-        int * const *(f31[2]);
-        int * const *(f32[10]);
+        int * (f27[2]);
+        int * (f28[10]);
+        int ** (f29[2]);
+        int ** (f30[10]);
+        int * const * (f31[2]);
+        int * const * (f32[10]);
         int * const * const (f33[2]);
         int * const * const (f34[10]);
 
-        int (*f35[2]);
-        int (*f36[10]);
-        int (**f37[2]);
-        int (**f38[10]);
-        int (* const *f39[2]);
-        int (* const *f40[10]);
+        int (* f35[2]);
+        int (* f36[10]);
+        int (** f37[2]);
+        int (** f38[10]);
+        int (* const * f39[2]);
+        int (* const * f40[10]);
         int (* const * const f41[2]);
         int (* const * const f42[10]);
@@ -72 +72 @@
         int ((f48[3]))[3];
 
-        int *f49[2][3];
-        int *f50[3][3];
-        int **f51[2][3];
-        int **f52[3][3];
-        int * const *f53[2][3];
-        int * const *f54[3][3];
+        int * f49[2][3];
+        int * f50[3][3];
+        int ** f51[2][3];
+        int ** f52[3][3];
+        int * const * f53[2][3];
+        int * const * f54[3][3];
         int * const * const f55[2][3];
         int * const * const f56[3][3];
 
-        int (*f57[2][3]);
-        int (*f58[3][3]);
-        int (**f59[2][3]);
-        int (**f60[3][3]);
-        int (* const *f61[2][3]);
-        int (* const *f62[3][3]);
+        int (* f57[2][3]);
+        int (* f58[3][3]);
+        int (** f59[2][3]);
+        int (** f60[3][3]);
+        int (* const * f61[2][3]);
+        int (* const * f62[3][3]);
         int (* const * const f63[2][3]);
         int (* const * const f64[3][3]);
@@ -93 +93 @@
         int (f66)(int);
 
-        int *f67(int);
-        int **f68(int);
-        int * const *f69(int);
+        int * f67(int);
+        int ** f68(int);
+        int * const * f69(int);
         int * const * const f70(int);
 
-        int *(f71)(int);
-        int **(f72)(int);
-        int * const *(f73)(int);
+        int * (f71)(int);
+        int ** (f72)(int);
+        int * const * (f73)(int);
         int * const * const (f74)(int);
 
-        int (*f75)(int);
-        int (**f76)(int);
-        int (* const *f77)(int);
+        int (* f75)(int);
+        int (** f76)(int);
+        int (* const * f77)(int);
         int (* const * const f78)(int);
 
-        int (*(*f79)(int))();
-        int (*(* const f80)(int))();
+        int (* (* f79)(int))();
+        int (* (* const f80)(int))();
         int (* const(* const f81)(int))();
 }

src/tests/identParamDeclarator.c

@@ -10 +10 @@
 // Created On       : Wed Aug 17 08:37:56 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 17 08:38:42 2016
-// Update Count     : 1
+// Last Modified On : Wed Jan 17 22:36:11 2018
+// Update Count     : 2
 // 
 
-int fred(
+int fred (
         int f1,
         int (f2),
@@ -157 +157 @@
     );
 
-//Dummy main
-int main(int argc, char const *argv[])
-{
+int main( int argc, char const *argv[] ) {                              // dummy main
         return 0;
 }

src/tests/preempt_longrun/Makefile.am

@@ -19 +19 @@
 preempt=1_000ul
 
-REPEAT = ${abs_top_srcdir}/tools/repeat -s
+REPEAT = ${abs_top_srcdir}/tools/repeat
+TIME = /usr/bin/time -f "%E"
 
 BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -debug -O2 -DPREEMPTION_RATE=${preempt}
@@ -37 +38 @@
         ${AM_V_GEN}${CC} ${CFLAGS} ${<} -o ${@}
 
-%.run : %
-        @ time ${REPEAT} $(repeats) timeout ${max_time} ./${<}
+%.run : % ${REPEAT}
+        @ time ${REPEAT} -r out.log -i -s $(repeats) timeout ${max_time} ./${<}
         @ rm ${<}
         @ echo -e "${<}: SUCCESS\n"
+
+%.time : % ${REPEAT}
+        @ ${REPEAT} -i -s -- $(repeats) $(TIME) -a -o times.log ./${<}
+        @ rm ${<}
+        @ echo -e "${<}: SUCCESS\n"
+
+${REPEAT}:
+        @+make -C ${abs_top_srcdir}/tools/

src/tests/preempt_longrun/Makefile.in

@@ -451 +451 @@
 max_time = 600
 preempt = 1_000ul
-REPEAT = ${abs_top_srcdir}/tools/repeat -s
+REPEAT = ${abs_top_srcdir}/tools/repeat
+TIME = /usr/bin/time -f "%E"
 BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -debug -O2 -DPREEMPTION_RATE=${preempt}
 TESTS = block create disjoint enter enter3 processor stack wait yield
@@ -874 +875 @@
         ${AM_V_GEN}${CC} ${CFLAGS} ${<} -o ${@}
 
-%.run : %
-        @ time ${REPEAT} $(repeats) timeout ${max_time} ./${<}
+%.run : % ${REPEAT}
+        @ time ${REPEAT} -r out.log -i -s $(repeats) timeout ${max_time} ./${<}
         @ rm ${<}
         @ echo -e "${<}: SUCCESS\n"
+
+%.time : % ${REPEAT}
+        @ ${REPEAT} -i -s -- $(repeats) $(TIME) -a -o times.log ./${<}
+        @ rm ${<}
+        @ echo -e "${<}: SUCCESS\n"
+
+${REPEAT}:
+        @+make -C ${abs_top_srcdir}/tools/
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

src/tests/preempt_longrun/block.c

@@ -1 @@
-../sched-int-block.c
+../concurrent/signal/block.c

src/tests/preempt_longrun/create.c

@@ -14 +14 @@
 thread worker_t {};
 
-void main(worker_t * this) {}
+void main(worker_t & this) {}
 
 int main(int argc, char* argv[]) {

src/tests/preempt_longrun/disjoint.c

@@ -1 @@
-../sched-int-disjoint.c
+../concurrent/signal/disjoint.c

src/tests/preempt_longrun/enter.c

@@ -17 +17 @@
 mon_t mon;
 
-void foo( mon_t * mutex this ) {}
+void foo( mon_t & mutex this ) {}
 
 thread worker_t {};
 
-void main( worker_t * this ) {
+void main( worker_t & this ) {
         for( unsigned long i = 0; i < N; i++ ) {
-                foo( &mon );
+                foo( mon );
         }
 }

src/tests/preempt_longrun/enter3.c

@@ -17 +17 @@
 mon_t mon1, mon2, mon3;
 
-void foo( mon_t * mutex a, mon_t * mutex b, mon_t * mutex c ) {}
+void foo( mon_t & mutex a, mon_t & mutex b, mon_t & mutex c ) {}
 
 thread worker_t {};
 
-void main( worker_t * this ) {
+void main( worker_t & this ) {
         for( unsigned long i = 0; i < N; i++ ) {
-                foo( &mon1, &mon2, &mon3 );
+                foo( mon1, mon2, mon3 );
         }
 }

src/tests/preempt_longrun/processor.c

@@ -14 +14 @@
 thread worker_t {};
 
-void main(worker_t * this) {}
+void main(worker_t & this) {}
 
 int main(int argc, char* argv[]) {

src/tests/preempt_longrun/stack.c

@@ -14 +14 @@
 thread worker_t {};
 
-void main(worker_t * this) {
+void main(worker_t & this) {
         volatile long long p = 5_021_609ul;
         volatile long long a = 326_417ul;

src/tests/preempt_longrun/wait.c

@@ -1 @@
-../sched-int-wait.c
+../concurrent/signal/wait.c

src/tests/preempt_longrun/yield.c

@@ -14 +14 @@
 thread worker_t {};
 
-void main(worker_t * this) {
+void main(worker_t & this) {
         for(int i = 0; i < N; i++) {
                 yield();