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

File:

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

src/libcfa/concurrency/kernel.c

@@ -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 );
+        lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
         append( this_processor->cltr->ready_queue, thrd );
-        unlock( this_processor->cltr->ready_queue_lock );
+        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 );
+        lock( &this->ready_queue_lock DEBUG_CTX2 );
         thread_desc * head = pop_head( this->ready_queue );
-        unlock( this->ready_queue_lock );
+        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){};
@@ -582 +619 @@
 
 void P(semaphore & this) {
-        lock( this.lock DEBUG_CTX2 );
+        lock( &this.lock DEBUG_CTX2 );
         this.count -= 1;
         if ( this.count < 0 ) {
@@ -592 +629 @@
         }
         else {
-            unlock( this.lock );
+            unlock( &this.lock );
         }
 }
@@ -598 +635 @@
 void V(semaphore & this) {
         thread_desc * thrd = NULL;
-        lock( this.lock DEBUG_CTX2 );
+        lock( &this.lock DEBUG_CTX2 );
         this.count += 1;
         if ( this.count <= 0 ) {
@@ -605 +642 @@
         }
 
-        unlock( this.lock );
+        unlock( &this.lock );
 
         // make new owner