Changes in / [7416d46a:42be3c3]

Location:

src

Files:

• libcfa/bits/containers.h (modified) (3 diffs)
• libcfa/concurrency/coroutine.c (modified) (2 diffs)
• libcfa/concurrency/kernel.c (modified) (13 diffs)
• libcfa/concurrency/preemption.c (modified) (2 diffs)
• libcfa/concurrency/thread.c (modified) (2 diffs)
• libcfa/interpose.h (modified) (1 diff)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)

src/libcfa/bits/containers.h

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

src/libcfa/concurrency/coroutine.c

@@ -118 +118 @@
 } //ctxSwitchDirect
 
-void create_stack( coStack_t* this, unsigned int storageSize ) with( *this ) {
+void create_stack( coStack_t* this, unsigned int storageSize ) {
         //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)storage == 0 ) {
-                userStack = false;
-                size = libCeiling( storageSize, 16 );
+        if ( (intptr_t)this->storage == 0 ) {
+                this->userStack = false;
+                this->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( storage = memalign( pageSize, cxtSize + size + pageSize ) );
-                __cfaabi_dbg_no_debug_do( storage = malloc( cxtSize + size + 8 ) );
+                __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(
-                        if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) {
+                        if ( mprotect( this->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)storage == 0 ) {
-                        abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", size );
+                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
 
-                __cfaabi_dbg_debug_do( limit = (char *)storage + pageSize );
-                __cfaabi_dbg_no_debug_do( limit = (char *)libCeiling( (unsigned long)storage, 16 ) ); // minimum alignment
+                __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
 
         } else {
-                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;
+                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;
 
-                if ( size % 16 != 0u ) size -= 8;
+                if ( this->size % 16 != 0u ) this->size -= 8;
 
-                limit = (char *)libCeiling( (unsigned long)storage, 16 ); // minimum alignment
+                this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ); // minimum alignment
         } // if
-        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
+        assertf( this->size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
 
-        base = (char *)limit + size;
-        context = base;
-        top = (char *)context + cxtSize;
+        this->base = (char *)this->limit + this->size;
+        this->context = this->base;
+        this->top = (char *)this->context + cxtSize;
 }
 

src/libcfa/concurrency/kernel.c

@@ -87 +87 @@
 }
 
-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 };
+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 };
 }
 
@@ -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) with( this ){
-        if( ! do_terminate ) {
+void ^?{}(processor & this) {
+        if( ! this.do_terminate ) {
                 __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
-                do_terminate = true;
-                P( terminated );
-                pthread_join( kernel_thread, NULL );
-        }
-}
-
-void ?{}(cluster & this) with( this ) {
-        ready_queue{};
-        ready_queue_lock{};
-
-        preemption = default_preemption();
+                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();
 }
 
@@ -240 +240 @@
 // Once a thread has finished running, some of
 // its final actions must be executed from the kernel
-void finishRunning(processor * this) with( this->finish ) {
-        if( action_code == Release ) {
+void finishRunning(processor * this) {
+        if( this->finish.action_code == Release ) {
                 verify( disable_preempt_count > 1 );
-                unlock( *lock );
-        }
-        else if( action_code == Schedule ) {
-                ScheduleThread( thrd );
-        }
-        else if( action_code == Release_Schedule ) {
+                unlock( *this->finish.lock );
+        }
+        else if( this->finish.action_code == Schedule ) {
+                ScheduleThread( this->finish.thrd );
+        }
+        else if( this->finish.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] );
+                unlock( *this->finish.lock );
+                ScheduleThread( this->finish.thrd );
+        }
+        else if( this->finish.action_code == Release_Multi ) {
+                verify( disable_preempt_count > this->finish.lock_count );
+                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] );
+        else if( this->finish.action_code == Release_Multi_Schedule ) {
+                verify( disable_preempt_count > this->finish.lock_count );
+                for(int i = 0; i < this->finish.lock_count; i++) {
+                        unlock( *this->finish.locks[i] );
                 }
-                for(int i = 0; i < thrd_count; i++) {
-                        ScheduleThread( thrds[i] );
+                for(int i = 0; i < this->finish.thrd_count; i++) {
+                        ScheduleThread( this->finish.thrds[i] );
                 }
         }
         else {
-                assert(action_code == No_Action);
+                assert(this->finish.action_code == No_Action);
         }
 }
@@ -337 +338 @@
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        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 );
+        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 );
         verify( disable_preempt_count > 0 );
         return head;
@@ -366 +365 @@
         disable_interrupts();
         this_processor->finish.action_code = Release;
-        this_processor->finish.lock        = lock;
+        this_processor->finish.lock = lock;
 
         verify( disable_preempt_count > 1 );
@@ -376 +375 @@
 
 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 );
@@ -391 +392 @@
         disable_interrupts();
         this_processor->finish.action_code = Release_Schedule;
-        this_processor->finish.lock        = lock;
-        this_processor->finish.thrd        = thrd;
+        this_processor->finish.lock = lock;
+        this_processor->finish.thrd = thrd;
 
         verify( disable_preempt_count > 1 );
@@ -404 +405 @@
         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 );
@@ -417 +418 @@
         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 );
@@ -432 +433 @@
         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();
@@ -589 +590 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore & this) with( this ){
-        lock( lock __cfaabi_dbg_ctx2 );
-        count -= 1;
-        if ( count < 0 ) {
+void P(semaphore & this) {
+        lock( this.lock __cfaabi_dbg_ctx2 );
+        this.count -= 1;
+        if ( this.count < 0 ) {
                 // queue current task
-                append( waiting, (thread_desc *)this_thread );
+                append( this.waiting, (thread_desc *)this_thread );
 
                 // atomically release spin lock and block
-                BlockInternal( &lock );
+                BlockInternal( &this.lock );
         }
         else {
-            unlock( lock );
-        }
-}
-
-void V(semaphore & this) with( this ) {
+            unlock( this.lock );
+        }
+}
+
+void V(semaphore & this) {
         thread_desc * thrd = NULL;
-        lock( lock __cfaabi_dbg_ctx2 );
-        count += 1;
-        if ( count <= 0 ) {
+        lock( this.lock __cfaabi_dbg_ctx2 );
+        this.count += 1;
+        if ( this.count <= 0 ) {
                 // remove task at head of waiting list
-                thrd = pop_head( waiting );
-        }
-
-        unlock( lock );
+                thrd = pop_head( this.waiting );
+        }
+
+        unlock( this.lock );
 
         // make new owner

src/libcfa/concurrency/preemption.c

@@ -60 +60 @@
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
 
-void ?{}(event_kernel_t & this) with( this ) {
-        alarms{};
-        lock{};
+void ?{}(event_kernel_t & this) {
+        (this.alarms){};
+        (this.lock){};
 }
 
@@ -149 +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
 

src/libcfa/concurrency/thread.c

@@ -31 +31 @@
 // Thread ctors and dtors
 
-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;
+void ?{}(thread_desc& this) {
+        (this.self_cor){};
+        this.self_cor.name = "Anonymous Thread";
+        this.self_mon.owner = &this;
+        this.self_mon.recursion = 1;
+        this.self_mon_p = &this.self_mon;
+        this.next = NULL;
         __cfaabi_dbg_debug_do(
-                dbg_next = NULL;
-                dbg_prev = NULL;
+                this.dbg_next = NULL;
+                this.dbg_prev = NULL;
                 __cfaabi_dbg_thread_register(&this);
         )
 
-        monitors{ &self_mon_p, 1, (fptr_t)0 };
+        (this.monitors){ &this.self_mon_p, 1, (fptr_t)0 };
 }
 
-void ^?{}(thread_desc& this) with( this ) {
-        ^self_cor{};
+void ^?{}(thread_desc& this) {
+        __cfaabi_dbg_debug_do(
+                __cfaabi_dbg_thread_unregister(&this);
+        )
+        ^(this.self_cor){};
 }
 
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
-void ?{}( scoped(T)& this ) with( this ) {
-        handle{};
-        __thrd_start(handle);
+void ?{}( scoped(T)& this ) {
+        (this.handle){};
+        __thrd_start(this.handle);
 }
 
 forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
-void ?{}( scoped(T)& this, P params ) with( this ) {
-        handle{ params };
-        __thrd_start(handle);
+void ?{}( scoped(T)& this, P params ) {
+        (this.handle){ params };
+        __thrd_start(this.handle);
 }
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)& this ) with( this ) {
-        ^handle{};
+void ^?{}( scoped(T)& this ) {
+        ^(this.handle){};
 }
 
@@ -73 +76 @@
 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.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/tests/Makefile.am

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

src/tests/Makefile.in

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