Changeset ac2b598 for libcfa/src/concurrency/kernel.cfa

Timestamp:

Feb 24, 2020, 2:21:03 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:

959f6ad

Parents:

0f2c555

Message:

Changed descriptors for concurrency to use $ prefix instead of trailing _desc

File:

• libcfa/src/concurrency/kernel.cfa (modified) (18 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -117 +117 @@
 KERNEL_STORAGE(cluster,         mainCluster);
 KERNEL_STORAGE(processor,       mainProcessor);
-KERNEL_STORAGE(thread_desc,     mainThread);
+KERNEL_STORAGE($thread, mainThread);
 KERNEL_STORAGE(__stack_t,       mainThreadCtx);
 
 cluster     * mainCluster;
 processor   * mainProcessor;
-thread_desc * mainThread;
+$thread * mainThread;
 
 extern "C" {
@@ -164 +164 @@
 // Main thread construction
 
-void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
+void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) {
         stack.storage = info->storage;
         with(*stack.storage) {
@@ -179 +179 @@
 }
 
-void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
+void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
         state = Start;
         self_cor{ info };
@@ -264 +264 @@
 // Kernel Scheduling logic
 //=============================================================================================
-static thread_desc * __next_thread(cluster * this);
-static void __run_thread(processor * this, thread_desc * dst);
+static $thread * __next_thread(cluster * this);
+static void __run_thread(processor * this, $thread * dst);
 static void __halt(processor * this);
 
@@ -287 +287 @@
                 __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
 
-                thread_desc * readyThread = 0p;
+                $thread * readyThread = 0p;
                 for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
                         readyThread = __next_thread( this->cltr );
@@ -323 +323 @@
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-static void __run_thread(processor * this, thread_desc * thrd_dst) {
-        coroutine_desc * proc_cor = get_coroutine(this->runner);
+static void __run_thread(processor * this, $thread * thrd_dst) {
+        $coroutine * proc_cor = get_coroutine(this->runner);
 
         // Update global state
@@ -400 +400 @@
 void returnToKernel() {
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
-        thread_desc * thrd_src = kernelTLS.this_thread;
+        $coroutine * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
+        $thread * thrd_src = kernelTLS.this_thread;
 
         // Run the thread on this processor
@@ -495 +495 @@
 // KERNEL_ONLY
 static void __kernel_first_resume( processor * this ) {
-        thread_desc * src = mainThread;
-        coroutine_desc * dst = get_coroutine(this->runner);
+        $thread * src = mainThread;
+        $coroutine * dst = get_coroutine(this->runner);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -527 +527 @@
 // KERNEL_ONLY
 static void __kernel_last_resume( processor * this ) {
-        coroutine_desc * src = &mainThread->self_cor;
-        coroutine_desc * dst = get_coroutine(this->runner);
+        $coroutine * src = &mainThread->self_cor;
+        $coroutine * dst = get_coroutine(this->runner);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -541 +541 @@
 // Scheduler routines
 // KERNEL ONLY
-void __schedule_thread( thread_desc * thrd ) with( *thrd->curr_cluster ) {
+void __schedule_thread( $thread * thrd ) with( *thrd->curr_cluster ) {
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
@@ -571 +571 @@
 
 // KERNEL ONLY
-static thread_desc * __next_thread(cluster * this) with( *this ) {
+static $thread * __next_thread(cluster * this) with( *this ) {
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
-        thread_desc * head = pop_head( ready_queue );
+        $thread * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
 
@@ -582 +582 @@
 }
 
-void unpark( thread_desc * thrd ) {
+void unpark( $thread * thrd ) {
         if( !thrd ) return;
 
@@ -639 +639 @@
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
-        thread_desc * thrd = kernelTLS.this_thread;
+        $thread * thrd = kernelTLS.this_thread;
         /* paranoid */ verify(thrd->state == Active || thrd->state == Rerun);
 
@@ -683 +683 @@
         // SKULLDUGGERY: the mainThread steals the process main thread
         // which will then be scheduled by the mainProcessor normally
-        mainThread = (thread_desc *)&storage_mainThread;
+        mainThread = ($thread *)&storage_mainThread;
         current_stack_info_t info;
         info.storage = (__stack_t*)&storage_mainThreadCtx;
@@ -835 +835 @@
 
 void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
-        thread_desc * thrd = kernel_data;
+        $thread * thrd = kernel_data;
 
         if(thrd) {
@@ -900 +900 @@
 
 void V(semaphore & this) with( this ) {
-        thread_desc * thrd = 0p;
+        $thread * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;
@@ -928 +928 @@
 }
 
-void doregister( cluster * cltr, thread_desc & thrd ) {
+void doregister( cluster * cltr, $thread & thrd ) {
         lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         cltr->nthreads += 1;
@@ -935 +935 @@
 }
 
-void unregister( cluster * cltr, thread_desc & thrd ) {
+void unregister( cluster * cltr, $thread & thrd ) {
         lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         remove(cltr->threads, thrd );