Changeset 09800e9 for src/libcfa/concurrency

Timestamp:

May 29, 2018, 4:17:30 PM (6 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, with_gc

Children:

6c7099a

Parents:

8ebbfc4

Message:

First draft at locks in Cforall

Location:

src/libcfa/concurrency

Files:

• kernel (modified) (1 diff)
• kernel.c (modified) (4 diffs)
• kernel_private.h (modified) (1 diff)
• monitor.c (modified) (1 diff)
• mutex (added)
• mutex.c (added)

src/libcfa/concurrency/kernel

@@ -43 +43 @@
 extern struct cluster * mainCluster;
 
-enum FinishOpCode { No_Action, Release, Schedule, Release_Schedule, Release_Multi, Release_Multi_Schedule };
+enum FinishOpCode { No_Action, Release, Schedule, Release_Schedule, Release_Multi, Release_Multi_Schedule, Callback };
+
+typedef void (*__finish_callback_fptr_t)(void);
 
 //TODO use union, many of these fields are mutually exclusive (i.e. MULTI vs NOMULTI)
 struct FinishAction {
         FinishOpCode action_code;
+        /*
+        // Union of possible actions
+        union {
+                // Option 1 : locks and threads
+                struct {
+                        // 1 thread or N thread
+                        union {
+                                thread_desc * thrd;
+                                struct {
+                                        thread_desc ** thrds;
+                                        unsigned short thrd_count;
+                                };
+                        };
+                        // 1 lock or N lock
+                        union {
+                                __spinlock_t * lock;
+                                struct {
+                                        __spinlock_t ** locks;
+                                        unsigned short lock_count;
+                                };
+                        };
+                };
+                // Option 2 : action pointer
+                __finish_callback_fptr_t callback;
+        };
+        /*/
         thread_desc * thrd;
+        thread_desc ** thrds;
+        unsigned short thrd_count;
         __spinlock_t * lock;
         __spinlock_t ** locks;
         unsigned short lock_count;
-        thread_desc ** thrds;
-        unsigned short thrd_count;
+        __finish_callback_fptr_t callback;
+        //*/
 };
 static inline void ?{}(FinishAction & this) {

src/libcfa/concurrency/kernel.c

@@ -49 +49 @@
 thread_desc * mainThread;
 
-struct { __dllist_t(cluster    ) list; __spinlock_t lock; } global_clusters;
+struct { __dllist_t(cluster) list; __spinlock_t lock; } global_clusters;
 
 //-----------------------------------------------------------------------------
@@ -257 +257 @@
 // its final actions must be executed from the kernel
 void finishRunning(processor * this) with( this->finish ) {
-        if( action_code == Release ) {
-                verify( ! kernelTLS.preemption_state.enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
+        choose( action_code ) {
+        case No_Action:
+                break;
+        case Release:
                 unlock( *lock );
-        }
-        else if( action_code == Schedule ) {
+        case Schedule:
                 ScheduleThread( thrd );
-        }
-        else if( action_code == Release_Schedule ) {
-                verify( ! kernelTLS.preemption_state.enabled );
+        case Release_Schedule:
                 unlock( *lock );
                 ScheduleThread( thrd );
-        }
-        else if( action_code == Release_Multi ) {
-                verify( ! kernelTLS.preemption_state.enabled );
+        case Release_Multi:
                 for(int i = 0; i < lock_count; i++) {
                         unlock( *locks[i] );
                 }
-        }
-        else if( action_code == Release_Multi_Schedule ) {
+        case Release_Multi_Schedule:
                 for(int i = 0; i < lock_count; i++) {
                         unlock( *locks[i] );
@@ -282 +279 @@
                         ScheduleThread( thrds[i] );
                 }
-        }
-        else {
-                assert(action_code == No_Action);
+        case Callback:
+                callback();
+        default:
+                abort("KERNEL ERROR: Unexpected action to run after thread");
         }
 }
@@ -497 +495 @@
 }
 
+void BlockInternal(__finish_callback_fptr_t callback) {
+        disable_interrupts();
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Callback;
+                finish.callback    = callback;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
 // KERNEL ONLY
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {

src/libcfa/concurrency/kernel_private.h

@@ -48 +48 @@
 void BlockInternal(__spinlock_t * locks [], unsigned short count);
 void BlockInternal(__spinlock_t * locks [], unsigned short count, thread_desc * thrds [], unsigned short thrd_count);
+void BlockInternal(__finish_callback_fptr_t callback);
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd);
 

src/libcfa/concurrency/monitor.c

@@ -297 +297 @@
         this.count = count;
 
-        // Sort monitors based on address -> TODO use a sort specialized for small numbers
+        // Sort monitors based on address
         __libcfa_small_sort(this.m, count);