Changeset 50b8885 for libcfa

Timestamp:

Feb 13, 2020, 4:40:16 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b0c7419

Parents:

3381ed7

Message:

Removed owner reason from monitors which was only for debug and did not prove very helpful

Location:

libcfa/src/concurrency

Files:

• invoke.h (modified) (2 diffs)
• monitor.cfa (modified) (15 diffs)
• monitor.hfa (modified) (1 diff)

libcfa/src/concurrency/invoke.h

@@ -94 +94 @@
         enum coroutine_state { Halted, Start, Primed, Inactive, Active, Rerun, Reschedule };
         enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION };
-        enum __Owner_Reason { __NO_OWNER, __ENTER_FREE, __ENTER_ACCEPT, __ENTER_DTOR_FREE, __ENTER_DTOR_ACCEPT, __ENTER_SIGNAL_BLOCK, __WAITFOR, __LEAVE, __LEAVE_THREAD, __WAIT };
 
         struct coroutine_desc {
@@ -135 +134 @@
                 // current owner of the monitor
                 struct thread_desc * owner;
-
-                enum __Owner_Reason owner_reason;
 
                 // queue of threads that are blocked waiting for the monitor

libcfa/src/concurrency/monitor.cfa

@@ -27 +27 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-static inline void set_owner ( monitor_desc * this, thread_desc * owner, enum __Owner_Reason );
-static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner, enum __Owner_Reason );
+static inline void set_owner ( monitor_desc * this, thread_desc * owner );
+static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner );
 static inline void set_mask  ( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
 static inline void reset_mask( monitor_desc * this );
 
-static inline thread_desc * next_thread( monitor_desc * this, enum __Owner_Reason );
+static inline thread_desc * next_thread( monitor_desc * this );
 static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
 
@@ -94 +94 @@
                 if( !this->owner ) {
                         // No one has the monitor, just take it
-                        set_owner( this, thrd, __ENTER_FREE );
+                        set_owner( this, thrd );
 
                         __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
@@ -106 +106 @@
                 else if( is_accepted( this, group) ) {
                         // Some one was waiting for us, enter
-                        set_owner( this, thrd, __ENTER_ACCEPT );
+                        set_owner( this, thrd );
 
                         // Reset mask
@@ -153 +153 @@
 
                         // No one has the monitor, just take it
-                        set_owner( this, thrd, __ENTER_DTOR_FREE );
+                        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 );
@@ -239 +239 @@
 
                 // Get the next thread, will be null on low contention monitor
-                thread_desc * new_owner = next_thread( this, __LEAVE );
+                thread_desc * new_owner = next_thread( this );
 
                 // Check the new owner is consistent with who we wake-up
@@ -289 +289 @@
 
                 // Fetch the next thread, can be null
-                thread_desc * new_owner = next_thread( this, __LEAVE_THREAD );
+                thread_desc * new_owner = next_thread( this );
 
                 // Release the monitor lock
@@ -449 +449 @@
         // Remove any duplicate threads
         for( __lock_size_t i = 0; i < count; i++) {
-                thread_desc * new_owner = next_thread( monitors[i], __WAIT );
+                thread_desc * new_owner = next_thread( monitors[i] );
                 insert_unique( threads, thread_count, new_owner );
         }
@@ -535 +535 @@
         thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
         /* paranoid */ verify( signallee->next == 0p );
-        set_owner( monitors, count, signallee, __ENTER_SIGNAL_BLOCK );
+        set_owner( monitors, count, signallee );
 
         __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
@@ -641 +641 @@
 
                                 // Set the owners to be the next thread
-                                set_owner( monitors, count, next, __WAITFOR );
+                                set_owner( monitors, count, next );
 
                                 // unlock all the monitors
@@ -709 +709 @@
 // Utilities
 
-static inline void set_owner( monitor_desc * this, thread_desc * owner, enum __Owner_Reason reason ) {
+static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
         /* paranoid */ verify( this->lock.lock );
 
         //Pass the monitor appropriately
         this->owner = owner;
-        this->owner_reason = reason;
 
         //We are passing the monitor to someone else, which means recursion level is not 0
@@ -720 +719 @@
 }
 
-static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner, enum __Owner_Reason reason ) {
+static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
         /* 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]->owner_reason = reason;
         monitors[0]->recursion    = 1;
         for( __lock_size_t i = 1; i < count; i++ ) {
@@ -730 +728 @@
                 /* 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]->owner_reason = reason;
                 monitors[i]->recursion    = 0;
         }
@@ -747 +744 @@
 }
 
-static inline thread_desc * next_thread( monitor_desc * this, enum __Owner_Reason reason ) {
+static inline thread_desc * next_thread( monitor_desc * this ) {
         //Check the signaller stack
         __cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
@@ -756 +753 @@
                 //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, reason );
+                set_owner( this,  urgent->owner->waiting_thread );
 
                 return check_condition( urgent );
@@ -766 +763 @@
         /* 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, reason );
+        set_owner( this, new_owner );
 
         return new_owner;

libcfa/src/concurrency/monitor.hfa

@@ -32 +32 @@
         signal_stack{};
         owner         = 0p;
-        owner_reason  = __NO_OWNER;
         recursion     = 0;
         mask.accepted = 0p;