Changes in src/libcfa/concurrency/kernel.c [8fc45b7:b462670]

File:

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

src/libcfa/concurrency/kernel.c

@@ -106 +106 @@
 
 void ?{}( thread_desc & this, current_stack_info_t * info) {
-        (this.self_cor){ info };
+        (this.cor){ info };
 }
 
@@ -158 +158 @@
                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
                 this.do_terminate = true;
-                P( this.terminated );
+                P( &this.terminated );
                 pthread_join( this.kernel_thread, NULL );
         }
@@ -216 +216 @@
         }
 
-        V( this->terminated );
+        V( &this->terminated );
 
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
@@ -328 +328 @@
         // if( !thrd ) return;
         verify( thrd );
-        verify( thrd->self_cor.state != Halted );
+        verify( thrd->cor.state != Halted );
 
         verify( disable_preempt_count > 0 );
@@ -335 +335 @@
 
         lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
-        append( this_processor->cltr->ready_queue, thrd );
+        append( &this_processor->cltr->ready_queue, thrd );
         unlock( &this_processor->cltr->ready_queue_lock );
 
@@ -344 +344 @@
         verify( disable_preempt_count > 0 );
         lock( &this->ready_queue_lock DEBUG_CTX2 );
-        thread_desc * head = pop_head( this->ready_queue );
+        thread_desc * head = pop_head( &this->ready_queue );
         unlock( &this->ready_queue_lock );
         verify( disable_preempt_count > 0 );
@@ -373 +373 @@
         assert(thrd);
         disable_interrupts();
-        assert( thrd->self_cor.state != Halted );
+        assert( thrd->cor.state != Halted );
         this_processor->finish.action_code = Schedule;
         this_processor->finish.thrd = thrd;
@@ -398 +398 @@
 }
 
-void BlockInternal(spinlock * locks [], unsigned short count) {
+void BlockInternal(spinlock ** locks, unsigned short count) {
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi;
@@ -411 +411 @@
 }
 
-void BlockInternal(spinlock * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
+void BlockInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) {
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi_Schedule;
@@ -466 +466 @@
         this_processor = mainProcessor;
         this_thread = mainThread;
-        this_coroutine = &mainThread->self_cor;
+        this_coroutine = &mainThread->cor;
 
         // Enable preemption
@@ -547 +547 @@
         thread_desc * thrd = kernel_data;
 
-        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
-        __lib_debug_write( abort_text, len );
+        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->cor.name, thrd );
+        __lib_debug_write( STDERR_FILENO, abort_text, len );
 
         if ( thrd != this_coroutine ) {
                 len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
-                __lib_debug_write( abort_text, len );
+                __lib_debug_write( STDERR_FILENO, abort_text, len );
         }
         else {
-                __lib_debug_write( ".\n", 2 );
+                __lib_debug_write( STDERR_FILENO, ".\n", 2 );
         }
 }
@@ -618 +618 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore & this) {
-        lock( &this.lock DEBUG_CTX2 );
-        this.count -= 1;
-        if ( this.count < 0 ) {
+void P(semaphore * this) {
+        lock( &this->lock DEBUG_CTX2 );
+        this->count -= 1;
+        if ( this->count < 0 ) {
                 // queue current task
-                append( this.waiting, (thread_desc *)this_thread );
+                append( &this->waiting, (thread_desc *)this_thread );
 
                 // atomically release spin lock and block
-                BlockInternal( &this.lock );
+                BlockInternal( &this->lock );
         }
         else {
-            unlock( &this.lock );
-        }
-}
-
-void V(semaphore & this) {
+            unlock( &this->lock );
+        }
+}
+
+void V(semaphore * this) {
         thread_desc * thrd = NULL;
-        lock( &this.lock DEBUG_CTX2 );
-        this.count += 1;
-        if ( this.count <= 0 ) {
+        lock( &this->lock DEBUG_CTX2 );
+        this->count += 1;
+        if ( this->count <= 0 ) {
                 // remove task at head of waiting list
-                thrd = pop_head( this.waiting );
-        }
-
-        unlock( &this.lock );
+                thrd = pop_head( &this->waiting );
+        }
+
+        unlock( &this->lock );
 
         // make new owner
@@ -655 +655 @@
 }
 
-void append( __thread_queue_t & this, thread_desc * t ) {
-        verify(this.tail != NULL);
-        *this.tail = t;
-        this.tail = &t->next;
-}
-
-thread_desc * pop_head( __thread_queue_t & this ) {
-        thread_desc * head = this.head;
+void append( __thread_queue_t * this, thread_desc * t ) {
+        verify(this->tail != NULL);
+        *this->tail = t;
+        this->tail = &t->next;
+}
+
+thread_desc * pop_head( __thread_queue_t * this ) {
+        thread_desc * head = this->head;
         if( head ) {
-                this.head = head->next;
+                this->head = head->next;
                 if( !head->next ) {
-                        this.tail = &this.head;
+                        this->tail = &this->head;
                 }
                 head->next = NULL;
@@ -673 +673 @@
 }
 
-thread_desc * remove( __thread_queue_t & this, thread_desc ** it ) {
+thread_desc * remove( __thread_queue_t * this, thread_desc ** it ) {
         thread_desc * thrd = *it;
         verify( thrd );
@@ -679 +679 @@
         (*it) = thrd->next;
 
-        if( this.tail == &thrd->next ) {
-                this.tail = it;
+        if( this->tail == &thrd->next ) {
+                this->tail = it;
         }
 
         thrd->next = NULL;
 
-        verify( (this.head == NULL) == (&this.head == this.tail) );
-        verify( *this.tail == NULL );
+        verify( (this->head == NULL) == (&this->head == this->tail) );
+        verify( *this->tail == NULL );
         return thrd;
 }
@@ -694 +694 @@
 }
 
-void push( __condition_stack_t & this, __condition_criterion_t * t ) {
+void push( __condition_stack_t * this, __condition_criterion_t * t ) {
         verify( !t->next );
-        t->next = this.top;
-        this.top = t;
-}
-
-__condition_criterion_t * pop( __condition_stack_t & this ) {
-        __condition_criterion_t * top = this.top;
+        t->next = this->top;
+        this->top = t;
+}
+
+__condition_criterion_t * pop( __condition_stack_t * this ) {
+        __condition_criterion_t * top = this->top;
         if( top ) {
-                this.top = top->next;
+                this->top = top->next;
                 top->next = NULL;
         }