Changeset 2e9aed4

Timestamp:

Jan 30, 2018, 2:04:27 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

ffd0ac2

Parents:

813ddcaa

Message:

Fixed non-preemptive locks

Location:

src/libcfa

Files:

• bits/locks.h (modified) (2 diffs)
• concurrency/kernel.c (modified) (5 diffs)
• concurrency/monitor.c (modified) (10 diffs)
• concurrency/preemption.c (modified) (2 diffs)

src/libcfa/bits/locks.h ¶

@@ -65 +65 @@
         extern void yield( unsigned int );
         extern thread_local struct thread_desc *    volatile this_thread;
+        extern thread_local struct processor *      volatile this_processor;
 
         static inline void ?{}( __spinlock_t & this ) {
@@ -112 +113 @@
         }
 
-        // Lock the spinlock, spin if already acquired
-        static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
-                for ( unsigned int i = 1;; i += 1 ) {
-                        if ( __lock_test_and_test_and_set( this.lock ) ) break;
-                        yield( i );
-                }
-                disable_interrupts();
-                __cfaabi_dbg_debug_do(
-                        this.prev_name = caller;
-                        this.prev_thrd = this_thread;
-                )
-        }
+        // // Lock the spinlock, yield if already acquired
+        // static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
+        //      for ( unsigned int i = 1;; i += 1 ) {
+        //              if ( __lock_test_and_test_and_set( this.lock ) ) break;
+        //              yield( i );
+        //      }
+        //      disable_interrupts();
+        //      __cfaabi_dbg_debug_do(
+        //              this.prev_name = caller;
+        //              this.prev_thrd = this_thread;
+        //      )
+        // }
 
         static inline void unlock( __spinlock_t & this ) {
+                enable_interrupts_noPoll();
                 __lock_release( this.lock );
-                enable_interrupts_noPoll();
         }
 #endif

src/libcfa/concurrency/kernel.c ¶

@@ -242 +242 @@
 void finishRunning(processor * this) {
         if( this->finish.action_code == Release ) {
+                verify( disable_preempt_count > 1 );
                 unlock( *this->finish.lock );
         }
@@ -248 +249 @@
         }
         else if( this->finish.action_code == Release_Schedule ) {
+                verify( disable_preempt_count > 1 );
                 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] );
@@ -257 +260 @@
         }
         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] );
@@ -363 +367 @@
         this_processor->finish.lock = lock;
 
-        verify( disable_preempt_count > 0 );
+        verify( disable_preempt_count > 1 );
         suspend();
         verify( disable_preempt_count > 0 );
@@ -391 +395 @@
         this_processor->finish.thrd = thrd;
 
-        verify( disable_preempt_count > 0 );
+        verify( disable_preempt_count > 1 );
         suspend();
         verify( disable_preempt_count > 0 );

src/libcfa/concurrency/monitor.c ¶

@@ -53 +53 @@
 static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
 
-#ifndef __CFA_LOCK_NO_YIELD
-#define DO_LOCK lock_yield
-#else
-#define DO_LOCK lock
-#endif
-
 //-----------------------------------------------------------------------------
 // Useful defines
@@ -90 +84 @@
         static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                lock( this->lock __cfaabi_dbg_ctx2 );
                 thread_desc * thrd = this_thread;
+
+                verify( disable_preempt_count > 0 );
 
                 __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
@@ -121 +117 @@
                         // Some one else has the monitor, wait in line for it
                         append( this->entry_queue, thrd );
+
+                        verify( disable_preempt_count > 0 );
+
                         BlockInternal( &this->lock );
 
@@ -138 +137 @@
         static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                lock( this->lock __cfaabi_dbg_ctx2 );
                 thread_desc * thrd = this_thread;
 
@@ -201 +200 @@
         // Leave single monitor
         void __leave_monitor_desc( monitor_desc * this ) {
-                // Lock the monitor spinlock, DO_LOCK to reduce contention
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                // Lock the monitor spinlock
+                lock( this->lock __cfaabi_dbg_ctx2 );
 
                 __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
@@ -248 +247 @@
 
                 // Lock the monitor now
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                lock( this->lock __cfaabi_dbg_ctx2 );
 
                 disable_interrupts();
@@ -397 +396 @@
         append( this.blocked, &waiter );
 
+        verify( disable_preempt_count == 0 );
+
         // Lock all monitors (aggregates the locks as well)
         lock_all( monitors, locks, count );
+
+        // verifyf( disable_preempt_count == count, "Got %d, expected %d\n", disable_preempt_count, count );
+        if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); }
 
         // Find the next thread(s) to run
@@ -473 +477 @@
         monitor_ctx( this.monitors, this.monitor_count );
 
+        verify( disable_preempt_count == 0 );
+
         // Lock all monitors (aggregates the locks them as well)
         lock_all( monitors, locks, count );
+
+        // verify( disable_preempt_count == count );
+        if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); }
+
 
         // Create the node specific to this wait operation
@@ -737 +747 @@
 static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
-                DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 );
+                lock( *locks[i] __cfaabi_dbg_ctx2 );
         }
 }
@@ -744 +754 @@
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
-                DO_LOCK( *l __cfaabi_dbg_ctx2 );
+                lock( *l __cfaabi_dbg_ctx2 );
                 if(locks) locks[i] = l;
         }

src/libcfa/concurrency/preemption.c ¶

@@ -169 +169 @@
         void enable_interrupts_noPoll() {
                 __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
-                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interrupts
+                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
         }
 }
@@ -293 +293 @@
         if( !preemption_ready() ) { return; }
 
-        // __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
+        __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
 
         preemption_in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler