Changeset 4cedd9f for src/libcfa

Timestamp:

Nov 2, 2017, 2:15:19 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:

8fc45b7

Parents:

e1e8408

Message:

Updated public concurrency API to use references

Location:

src/libcfa/concurrency

Files:

• kernel (modified) (2 diffs)
• kernel.c (modified) (3 diffs)
• monitor (modified) (1 diff)
• monitor.c (modified) (9 diffs)

src/libcfa/concurrency/kernel

@@ -39 +39 @@
 void  ?{}(semaphore & this, int count = 1);
 void ^?{}(semaphore & this);
-void P(semaphore * this);
-void V(semaphore * this);
+void   P (semaphore & this);
+void   V (semaphore & this);
 
 
@@ -51 +51 @@
 };
 
-void ?{}(cluster & this);
+void ?{} (cluster & this);
 void ^?{}(cluster & this);
 

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);
@@ -618 +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

src/libcfa/concurrency/monitor

@@ -116 +116 @@
 }
 
-void wait( condition * this, uintptr_t user_info = 0 );
-bool signal( condition * this );
-bool signal_block( condition * this );
-static inline bool is_empty( condition * this ) { return !this->blocked.head; }
-uintptr_t front( condition * this );
+void wait( condition & this, uintptr_t user_info = 0 );
+bool signal( condition & this );
+bool signal_block( condition & this );
+static inline bool is_empty( condition & this ) { return !this.blocked.head; }
+uintptr_t front( condition & this );
 
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/monitor.c

@@ -45 +45 @@
 
 static inline thread_desc *        check_condition   ( __condition_criterion_t * );
-static inline void                 brand_condition   ( condition * );
+static inline void                 brand_condition   ( condition & );
 static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc ** monitors, int count );
 
@@ -69 +69 @@
         unsigned short count = cnt;                               /* Save the count to a local variable                                                  */ \
         unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
-        __waitfor_mask_t masks[ count ];                          /* Save the current waitfor masks to restore them later                                */ \
+        __waitfor_mask_t masks [ count ];                         /* Save the current waitfor masks to restore them later                                */ \
         spinlock *   locks     [ count ];                         /* We need to pass-in an array of locks to BlockInternal                               */ \
 
@@ -387 +387 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling
-void wait( condition * this, uintptr_t user_info = 0 ) {
+void wait( condition & this, uintptr_t user_info = 0 ) {
         brand_condition( this );
 
         // Check that everything is as expected
-        assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
-        verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
-        verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
+        assertf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%i)", this.monitor_count );
+        verifyf( this.monitor_count < 32u, "Excessive monitor count (%i)", this.monitor_count );
 
         // Create storage for monitor context
-        monitor_ctx( this->monitors, this->monitor_count );
+        monitor_ctx( this.monitors, this.monitor_count );
 
         // Create the node specific to this wait operation
@@ -403 +403 @@
         // 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
-        append( &this->blocked, &waiter );
+        append( &this.blocked, &waiter );
 
         // Lock all monitors (aggregates the locks as well)
@@ -429 +429 @@
 }
 
-bool signal( condition * this ) {
+bool signal( condition & this ) {
         if( is_empty( this ) ) { return false; }
 
         //Check that everything is as expected
-        verify( this->monitors );
-        verify( this->monitor_count != 0 );
+        verify( this.monitors );
+        verify( this.monitor_count != 0 );
 
         //Some more checking in debug
         LIB_DEBUG_DO(
                 thread_desc * this_thrd = this_thread;
-                if ( this->monitor_count != this_thrd->monitors.size ) {
-                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->monitors.size );
-                }
-
-                for(int i = 0; i < this->monitor_count; i++) {
-                        if ( this->monitors[i] != this_thrd->monitors.list[i] ) {
-                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->monitors.list[i] );
+                if ( this.monitor_count != this_thrd->monitors.size ) {
+                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", &this, this.monitor_count, this_thrd->monitors.size );
+                }
+
+                for(int i = 0; i < this.monitor_count; i++) {
+                        if ( this.monitors[i] != this_thrd->monitors.list[i] ) {
+                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors.list[i] );
                         }
                 }
         );
 
-        unsigned short count = this->monitor_count;
+        unsigned short count = this.monitor_count;
 
         // Lock all monitors
-        lock_all( this->monitors, NULL, count );
+        lock_all( this.monitors, NULL, count );
 
         //Pop the head of the waiting queue
-        __condition_node_t * node = pop_head( &this->blocked );
+        __condition_node_t * node = pop_head( &this.blocked );
 
         //Add the thread to the proper AS stack
@@ -466 +466 @@
 
         //Release
-        unlock_all( this->monitors, count );
+        unlock_all( this.monitors, count );
 
         return true;
 }
 
-bool signal_block( condition * this ) {
-        if( !this->blocked.head ) { return false; }
+bool signal_block( condition & this ) {
+        if( !this.blocked.head ) { return false; }
 
         //Check that everything is as expected
-        verifyf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
-        verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+        verifyf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%i)", this.monitor_count );
 
         // Create storage for monitor context
-        monitor_ctx( this->monitors, this->monitor_count );
+        monitor_ctx( this.monitors, this.monitor_count );
 
         // Lock all monitors (aggregates the locks them as well)
@@ -491 +491 @@
 
         //Find the thread to run
-        thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
+        thread_desc * signallee = pop_head( &this.blocked )->waiting_thread;
         set_owner( monitors, count, signallee );
 
-        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", this, signallee );
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
 
         //Everything is ready to go to sleep
@@ -512 +512 @@
 
 // Access the user_info of the thread waiting at the front of the queue
-uintptr_t front( condition * this ) {
+uintptr_t front( condition & this ) {
         verifyf( !is_empty(this),
                 "Attempt to access user data on an empty condition.\n"
                 "Possible cause is not checking if the condition is empty before reading stored data."
         );
-        return this->blocked.head->user_info;
+        return this.blocked.head->user_info;
 }
 
@@ -811 +811 @@
 }
 
-static inline void brand_condition( condition * this ) {
+static inline void brand_condition( condition & this ) {
         thread_desc * thrd = this_thread;
-        if( !this->monitors ) {
+        if( !this.monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
                 assertf( thrd->monitors.list != NULL, "No current monitor to brand condition %p", thrd->monitors.list );
-                this->monitor_count = thrd->monitors.size;
-
-                this->monitors = malloc( this->monitor_count * sizeof( *this->monitors ) );
-                for( int i = 0; i < this->monitor_count; i++ ) {
-                        this->monitors[i] = thrd->monitors.list[i];
+                this.monitor_count = thrd->monitors.size;
+
+                this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
+                for( int i = 0; i < this.monitor_count; i++ ) {
+                        this.monitors[i] = thrd->monitors.list[i];
                 }
         }