Changes in libcfa/src/concurrency/monitor.cfa [09f357ec:b0c7419]

File:

• libcfa/src/concurrency/monitor.cfa (modified) (19 diffs)

libcfa/src/concurrency/monitor.cfa

@@ -117 +117 @@
 
                         // Some one else has the monitor, wait in line for it
+                        /* paranoid */ verify( thrd->next == 0p );
                         append( this->entry_queue, thrd );
-
-                        BlockInternal( &this->lock );
+                        /* paranoid */ verify( thrd->next == 1p );
+
+                        unlock( this->lock );
+                        park();
 
                         __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
-                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
                         return;
                 }
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
+
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                /* paranoid */ verify( this->lock.lock );
 
                 // Release the lock and leave
@@ -149 +155 @@
                         set_owner( this, thrd );
 
+                        verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+
                         unlock( this->lock );
                         return;
@@ -166 +174 @@
                         // Wake the thread that is waiting for this
                         __condition_criterion_t * urgent = pop( this->signal_stack );
-                        verify( urgent );
+                        /* paranoid */ verify( urgent );
 
                         // Reset mask
@@ -175 +183 @@
 
                         // Some one else has the monitor, wait for him to finish and then run
-                        BlockInternal( &this->lock, urgent->owner->waiting_thread );
+                        unlock( this->lock );
+
+                        // Release the next thread
+                        /* paranoid */ verifyf( urgent->owner->waiting_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                        unpark( urgent->owner->waiting_thread );
+
+                        // Park current thread waiting
+                        park();
 
                         // Some one was waiting for us, enter
-                        set_owner( this, thrd );
+                        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
                 }
                 else {
@@ -187 +202 @@
 
                         // Some one else has the monitor, wait in line for it
+                        /* paranoid */ verify( thrd->next == 0p );
                         append( this->entry_queue, thrd );
-                        BlockInternal( &this->lock );
-
-                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        /* paranoid */ verify( thrd->next == 1p );
+                        unlock( this->lock );
+
+                        // Park current thread waiting
+                        park();
+
+                        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
                         return;
                 }
@@ -205 +225 @@
                 __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
 
-                verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -221 +241 @@
                 thread_desc * new_owner = next_thread( this );
 
+                // Check the new owner is consistent with who we wake-up
+                // new_owner might be null even if someone owns the monitor when the owner is still waiting for another monitor
+                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+
                 // We can now let other threads in safely
                 unlock( this->lock );
 
                 //We need to wake-up the thread
-                WakeThread( new_owner );
+                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+                unpark( new_owner );
         }
 
@@ -252 +277 @@
                 disable_interrupts();
 
-                thrd->self_cor.state = Halted;
-
-                verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
+                thrd->state = Halted;
+
+                /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -266 +291 @@
                 thread_desc * new_owner = next_thread( this );
 
-                // Leave the thread, this will unlock the spinlock
-                // Use leave thread instead of BlockInternal which is
-                // specialized for this case and supports null new_owner
-                LeaveThread( &this->lock, new_owner );
+                // Release the monitor lock
+                unlock( this->lock );
+
+                // Unpark the next owner if needed
+                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                /* paranoid */ verify( ! kernelTLS.this_processor->destroyer );
+                /* paranoid */ verify( thrd->state == Halted );
+
+                kernelTLS.this_processor->destroyer = new_owner;
+
+                // Leave the thread
+                __leave_thread();
 
                 // Control flow should never reach here!
@@ -400 +434 @@
         // Append the current wait operation to the ones already queued on the condition
         // We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion
+        /* paranoid */ verify( waiter.next == 0p );
         append( this.blocked, &waiter );
+        /* paranoid */ verify( waiter.next == 1p );
 
         // Lock all monitors (aggregates the locks as well)
@@ -419 +455 @@
         }
 
+        // Unlock the locks, we don't need them anymore
+        for(int i = 0; i < count; i++) {
+                unlock( *locks[i] );
+        }
+
+        // Wake the threads
+        for(int i = 0; i < thread_count; i++) {
+                unpark( threads[i] );
+        }
+
         // Everything is ready to go to sleep
-        BlockInternal( locks, count, threads, thread_count );
+        park();
 
         // We are back, restore the owners and recursions
@@ -490 +536 @@
         //Find the thread to run
         thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
+        /* paranoid */ verify( signallee->next == 0p );
         set_owner( monitors, count, signallee );
 
         __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
 
+        // unlock all the monitors
+        unlock_all( locks, count );
+
+        // unpark the thread we signalled
+        unpark( signallee );
+
         //Everything is ready to go to sleep
-        BlockInternal( locks, count, &signallee, 1 );
+        park();
 
 
@@ -592 +645 @@
                                 set_owner( monitors, count, next );
 
-                                // Everything is ready to go to sleep
-                                BlockInternal( locks, count, &next, 1 );
+                                // unlock all the monitors
+                                unlock_all( locks, count );
+
+                                // unpark the thread we signalled
+                                unpark( next );
+
+                                //Everything is ready to go to sleep
+                                park();
 
                                 // We are back, restore the owners and recursions
@@ -631 +690 @@
         }
 
+        // unlock all the monitors
+        unlock_all( locks, count );
+
         //Everything is ready to go to sleep
-        BlockInternal( locks, count );
+        park();
 
 
@@ -650 +712 @@
 
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
-        // __cfaabi_dbg_print_safe( "Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+        /* paranoid */ verify( this->lock.lock );
 
         //Pass the monitor appropriately
@@ -660 +722 @@
 
 static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
-        monitors[0]->owner     = owner;
-        monitors[0]->recursion = 1;
+        /* paranoid */ verify ( monitors[0]->lock.lock );
+        /* paranoid */ verifyf( monitors[0]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[0]->owner, monitors[0]->recursion, monitors[0] );
+        monitors[0]->owner        = owner;
+        monitors[0]->recursion    = 1;
         for( __lock_size_t i = 1; i < count; i++ ) {
-                monitors[i]->owner     = owner;
-                monitors[i]->recursion = 0;
+                /* paranoid */ verify ( monitors[i]->lock.lock );
+                /* paranoid */ verifyf( monitors[i]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[i]->owner, monitors[i]->recursion, monitors[i] );
+                monitors[i]->owner        = owner;
+                monitors[i]->recursion    = 0;
         }
 }
@@ -688 +754 @@
                 //regardless of if we are ready to baton pass,
                 //we need to set the monitor as in use
+                /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
                 set_owner( this,  urgent->owner->waiting_thread );
 
@@ -696 +763 @@
         // Get the next thread in the entry_queue
         thread_desc * new_owner = pop_head( this->entry_queue );
+        /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+        /* paranoid */ verify( !new_owner || new_owner->next == 0p );
         set_owner( this, new_owner );
 
@@ -841 +910 @@
         // For each thread in the entry-queue
         for(    thread_desc ** thrd_it = &entry_queue.head;
-                *thrd_it;
+                *thrd_it != 1p;
                 thrd_it = &(*thrd_it)->next
         ) {