Changeset c86ee4c for libcfa/src/concurrency/kernel

Timestamp:

Jul 7, 2021, 6:24:42 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

d83b266

Parents:

1f45c7d (diff), b1a2c4a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

libcfa/src/concurrency/kernel

Files:

• fwd.hfa (modified) (11 diffs)
• startup.cfa (modified) (13 diffs)

libcfa/src/concurrency/kernel/fwd.hfa

@@ -24 +24 @@
 #endif
 
-struct $thread;
+struct thread$;
 struct processor;
 struct cluster;
@@ -36 +36 @@
         extern "Cforall" {
                 extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-                        struct $thread          * volatile this_thread;
+                        struct thread$          * volatile this_thread;
                         struct processor        * volatile this_processor;
                         volatile bool sched_lock;
@@ -120 +120 @@
         extern "Cforall" {
                 extern void park( void );
-                extern void unpark( struct $thread * this );
-                static inline struct $thread * active_thread () {
-                        struct $thread * t = publicTLS_get( this_thread );
+                extern void unpark( struct thread$ * this );
+                static inline struct thread$ * active_thread () {
+                        struct thread$ * t = publicTLS_get( this_thread );
                         /* paranoid */ verify( t );
                         return t;
@@ -144 +144 @@
                 // Semaphore which only supports a single thread
                 struct single_sem {
-                        struct $thread * volatile ptr;
+                        struct thread$ * volatile ptr;
                 };
 
@@ -156 +156 @@
                         bool wait(single_sem & this) {
                                 for() {
-                                        struct $thread * expected = this.ptr;
+                                        struct thread$ * expected = this.ptr;
                                         if(expected == 1p) {
                                                 if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
@@ -175 +175 @@
                         bool post(single_sem & this) {
                                 for() {
-                                        struct $thread * expected = this.ptr;
+                                        struct thread$ * expected = this.ptr;
                                         if(expected == 1p) return false;
                                         if(expected == 0p) {
@@ -200 +200 @@
                         //     1p     : fulfilled (wait won't block)
                         // any thread : a thread is currently waiting
-                        struct $thread * volatile ptr;
+                        struct thread$ * volatile ptr;
                 };
 
@@ -214 +214 @@
                         bool wait(oneshot & this) {
                                 for() {
-                                        struct $thread * expected = this.ptr;
+                                        struct thread$ * expected = this.ptr;
                                         if(expected == 1p) return false;
                                         /* paranoid */ verify( expected == 0p );
@@ -227 +227 @@
                         // Mark as fulfilled, wake thread if needed
                         // return true if a thread was unparked
-                        $thread * post(oneshot & this, bool do_unpark = true) {
-                                struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
+                        thread$ * post(oneshot & this, bool do_unpark = true) {
+                                struct thread$ * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
                                 if( got == 0p ) return 0p;
                                 if(do_unpark) unpark( got );
@@ -343 +343 @@
                         // from the server side, mark the future as fulfilled
                         // delete it if needed
-                        $thread * fulfil( future_t & this, bool do_unpark = true  ) {
+                        thread$ * fulfil( future_t & this, bool do_unpark = true  ) {
                                 for() {
                                         struct oneshot * expected = this.ptr;
@@ -364 +364 @@
                                         if(__atomic_compare_exchange_n(&this.ptr, &expected, want, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
                                                 if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return 0p; }
-                                                $thread * ret = post( *expected, do_unpark );
+                                                thread$ * ret = post( *expected, do_unpark );
                                                 __atomic_store_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
                                                 return ret;

libcfa/src/concurrency/kernel/startup.cfa

@@ -77 +77 @@
 static void __kernel_first_resume( processor * this );
 static void __kernel_last_resume ( processor * this );
-static void init(processor & this, const char name[], cluster & _cltr, $thread * initT);
+static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT);
 static void deinit(processor & this);
 static void doregister( struct cluster & cltr );
@@ -83 +83 @@
 static void register_tls( processor * this );
 static void unregister_tls( processor * this );
-static void ?{}( $coroutine & this, current_stack_info_t * info);
-static void ?{}( $thread & this, current_stack_info_t * info);
+static void ?{}( coroutine$ & this, current_stack_info_t * info);
+static void ?{}( thread$ & this, current_stack_info_t * info);
 static void ?{}(processorCtx_t & this) {}
 static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info);
@@ -105 +105 @@
 KERNEL_STORAGE(cluster,              mainCluster);
 KERNEL_STORAGE(processor,            mainProcessor);
-KERNEL_STORAGE($thread,              mainThread);
+KERNEL_STORAGE(thread$,              mainThread);
 KERNEL_STORAGE(__stack_t,            mainThreadCtx);
 KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock);
@@ -114 +114 @@
 cluster              * mainCluster;
 processor            * mainProcessor;
-$thread              * mainThread;
+thread$              * mainThread;
 __scheduler_RWLock_t * __scheduler_lock;
 
@@ -203 +203 @@
         // SKULLDUGGERY: the mainThread steals the process main thread
         // which will then be scheduled by the mainProcessor normally
-        mainThread = ($thread *)&storage_mainThread;
+        mainThread = (thread$ *)&storage_mainThread;
         current_stack_info_t info;
         info.storage = (__stack_t*)&storage_mainThreadCtx;
@@ -397 +397 @@
 
 static void __kernel_first_resume( processor * this ) {
-        $thread * src = mainThread;
-        $coroutine * dst = get_coroutine(this->runner);
+        thread$ * src = mainThread;
+        coroutine$ * dst = get_coroutine(this->runner);
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -430 +430 @@
 // KERNEL_ONLY
 static void __kernel_last_resume( processor * this ) {
-        $coroutine * src = &mainThread->self_cor;
-        $coroutine * dst = get_coroutine(this->runner);
+        coroutine$ * src = &mainThread->self_cor;
+        coroutine$ * dst = get_coroutine(this->runner);
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -459 +459 @@
 //-----------------------------------------------------------------------------
 // Main thread construction
-static void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) {
+static void ?{}( coroutine$ & this, current_stack_info_t * info) with( this ) {
         stack.storage = info->storage;
         with(*stack.storage) {
@@ -474 +474 @@
 }
 
-static void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
+static void ?{}( thread$ & this, current_stack_info_t * info) with( this ) {
         ticket = TICKET_RUNNING;
         state = Start;
@@ -507 +507 @@
 }
 
-static void init(processor & this, const char name[], cluster & _cltr, $thread * initT) with( this ) {
+static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT) with( this ) {
         this.name = name;
         this.cltr = &_cltr;
@@ -546 +546 @@
 }
 
-void ?{}(processor & this, const char name[], cluster & _cltr, $thread * initT) {
+void ?{}(processor & this, const char name[], cluster & _cltr, thread$ * initT) {
         ( this.terminated ){};
         ( this.runner ){};
@@ -664 +664 @@
 }
 
-void doregister( cluster * cltr, $thread & thrd ) {
+void doregister( cluster * cltr, thread$ & thrd ) {
         lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         cltr->nthreads += 1;
@@ -671 +671 @@
 }
 
-void unregister( cluster * cltr, $thread & thrd ) {
+void unregister( cluster * cltr, thread$ & thrd ) {
         lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         remove(cltr->threads, thrd );