Changes in src/libcfa/concurrency/kernel.c [65deb18:b158d8f]

File:

• src/libcfa/concurrency/kernel.c (modified) (15 diffs)

src/libcfa/concurrency/kernel.c

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 22:33:18 2017
-// Update Count     : 2
+// Last Modified On : Fri Dec  8 16:23:33 2017
+// Update Count     : 3
 //
 
 //C Includes
 #include <stddef.h>
+#define ftype `ftype`
 extern "C" {
 #include <stdio.h>
@@ -23 +24 @@
 #include <unistd.h>
 }
+#undef ftype
 
 //CFA Includes
@@ -85 +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 };
 }
 
@@ -131 +133 @@
 void ?{}(processor & this, cluster * cltr) {
         this.cltr = cltr;
-        this.terminated{ 0 };
+        (this.terminated){ 0 };
         this.do_terminate = false;
         this.preemption_alarm = NULL;
@@ -141 +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;
@@ -152 +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();
 }
 
@@ -238 +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 ) {
-                unlock( *lock );
-        }
-        else if( action_code == Schedule ) {
-                ScheduleThread( thrd );
-        }
-        else if( action_code == Release_Schedule ) {
-                unlock( *lock );
-                ScheduleThread( thrd );
-        }
-        else if( action_code == Release_Multi ) {
-                for(int i = 0; i < lock_count; i++) {
-                        unlock( *locks[i] );
+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] );
                 }
         }
-        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 ) {
+                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);
         }
 }
@@ -332 +334 @@
         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;
@@ -361 +361 @@
         disable_interrupts();
         this_processor->finish.action_code = Release;
-        this_processor->finish.lock        = lock;
+        this_processor->finish.lock = lock;
 
         verify( disable_preempt_count > 0 );
@@ -371 +371 @@
 
 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 );
@@ -386 +388 @@
         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 > 0 );
@@ -399 +401 @@
         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 );
@@ -412 +414 @@
         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 );
@@ -427 +429 @@
         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();
@@ -579 +581 @@
 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