Changes in src/libcfa/concurrency/kernel.c [ea7d2b0:6a5be52]

File:

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

src/libcfa/concurrency/kernel.c

@@ -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);
@@ -242 +242 @@
 void finishRunning(processor * this) {
         if( this->finish.action_code == Release ) {
-                unlock( *this->finish.lock );
+                unlock( this->finish.lock );
         }
         else if( this->finish.action_code == Schedule ) {
@@ -248 +248 @@
         }
         else if( this->finish.action_code == Release_Schedule ) {
-                unlock( *this->finish.lock );
+                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] );
+                        unlock( this->finish.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] );
+                        unlock( this->finish.locks[i] );
                 }
                 for(int i = 0; i < this->finish.thrd_count; i++) {
@@ -334 +334 @@
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        lock(   this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
-        append( this_processor->cltr->ready_queue, thrd );
-        unlock( this_processor->cltr->ready_queue_lock );
+        lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
+        append( &this_processor->cltr->ready_queue, thrd );
+        unlock( &this_processor->cltr->ready_queue_lock );
 
         verify( disable_preempt_count > 0 );
@@ -343 +343 @@
 thread_desc * nextThread(cluster * this) {
         verify( disable_preempt_count > 0 );
-        lock( this->ready_queue_lock DEBUG_CTX2 );
-        thread_desc * head = pop_head( this->ready_queue );
-        unlock( this->ready_queue_lock );
+        lock( &this->ready_queue_lock DEBUG_CTX2 );
+        thread_desc * head = pop_head( &this->ready_queue );
+        unlock( &this->ready_queue_lock );
         verify( disable_preempt_count > 0 );
         return head;
@@ -358 +358 @@
 }
 
-void BlockInternal( __spinlock_t * lock ) {
+void BlockInternal( spinlock * lock ) {
         disable_interrupts();
         this_processor->finish.action_code = Release;
@@ -384 +384 @@
 }
 
-void BlockInternal( __spinlock_t * lock, thread_desc * thrd ) {
+void BlockInternal( spinlock * lock, thread_desc * thrd ) {
         assert(thrd);
         disable_interrupts();
@@ -398 +398 @@
 }
 
-void BlockInternal(__spinlock_t * 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_t * 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;
@@ -426 +426 @@
 }
 
-void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
+void LeaveThread(spinlock * lock, thread_desc * thrd) {
         verify( disable_preempt_count > 0 );
         this_processor->finish.action_code = thrd ? Release_Schedule : Release;
@@ -516 +516 @@
 }
 
-static __spinlock_t kernel_abort_lock;
-static __spinlock_t kernel_debug_lock;
+static spinlock kernel_abort_lock;
+static spinlock kernel_debug_lock;
 static bool kernel_abort_called = false;
 
@@ -523 +523 @@
         // abort cannot be recursively entered by the same or different processors because all signal handlers return when
         // the globalAbort flag is true.
-        lock( kernel_abort_lock DEBUG_CTX2 );
+        lock( &kernel_abort_lock DEBUG_CTX2 );
 
         // first task to abort ?
         if ( !kernel_abort_called ) {                   // not first task to abort ?
                 kernel_abort_called = true;
-                unlock( kernel_abort_lock );
+                unlock( &kernel_abort_lock );
         }
         else {
-                unlock( kernel_abort_lock );
+                unlock( &kernel_abort_lock );
 
                 sigset_t mask;
@@ -561 +561 @@
 extern "C" {
         void __lib_debug_acquire() {
-                lock( kernel_debug_lock DEBUG_CTX2 );
+                lock( &kernel_debug_lock DEBUG_CTX2 );
         }
 
         void __lib_debug_release() {
-                unlock( kernel_debug_lock );
+                unlock( &kernel_debug_lock );
         }
 }
@@ -574 +574 @@
 //-----------------------------------------------------------------------------
 // Locks
+void ?{}( spinlock & this ) {
+        this.lock = 0;
+}
+void ^?{}( spinlock & this ) {
+
+}
+
+bool try_lock( spinlock * this DEBUG_CTX_PARAM2 ) {
+        return this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
+}
+
+void lock( spinlock * this DEBUG_CTX_PARAM2 ) {
+        for ( unsigned int i = 1;; i += 1 ) {
+                if ( this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0 ) { break; }
+        }
+        LIB_DEBUG_DO(
+                this->prev_name = caller;
+                this->prev_thrd = this_thread;
+        )
+}
+
+void lock_yield( spinlock * this DEBUG_CTX_PARAM2 ) {
+        for ( unsigned int i = 1;; i += 1 ) {
+                if ( this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0 ) { break; }
+                yield();
+        }
+        LIB_DEBUG_DO(
+                this->prev_name = caller;
+                this->prev_thrd = this_thread;
+        )
+}
+
+
+void unlock( spinlock * this ) {
+        __sync_lock_release_4( &this->lock );
+}
+
 void  ?{}( semaphore & this, int count = 1 ) {
         (this.lock){};
@@ -581 +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
@@ -618 +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;
@@ -636 +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 );
@@ -642 +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;
 }
@@ -657 +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;
         }