Changeset 8c50aed for libcfa/src/concurrency/kernel.cfa

Timestamp:

Feb 21, 2020, 3:33:14 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:

a505021

Parents:

b0c7419

Message:

Some clean-up and renaming, also adding attribute((const/pure)) where relevant

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -110 +110 @@
 //-----------------------------------------------------------------------------
 //Start and stop routine for the kernel, declared first to make sure they run first
-static void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
-static void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
+static void __kernel_startup (void) __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
+static void __kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
 
 //-----------------------------------------------------------------------------
@@ -208 +208 @@
 }
 
-static void start(processor * this);
+static void * CtxInvokeProcessor(void * arg);
+
 void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
         this.name = name;
@@ -221 +222 @@
         idleLock{};
 
-        start( &this );
+        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", &this);
+
+        this.stack = __create_pthread( &this.kernel_thread, CtxInvokeProcessor, (void *)&this );
+
+        __cfaabi_dbg_print_safe("Kernel : core %p started\n", &this);
 }
 
@@ -259 +264 @@
 // Kernel Scheduling logic
 //=============================================================================================
-static thread_desc * nextThread(cluster * this);
-static void runThread(processor * this, thread_desc * dst);
-static void halt(processor * this);
+static thread_desc * __next_thread(cluster * this);
+static void __run_thread(processor * this, thread_desc * dst);
+static void __halt(processor * this);
 
 //Main of the processor contexts
@@ -284 +289 @@
                 thread_desc * readyThread = 0p;
                 for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
-                        readyThread = nextThread( this->cltr );
+                        readyThread = __next_thread( this->cltr );
 
                         if(readyThread) {
@@ -291 +296 @@
                                 /* paranoid */ verifyf( readyThread->next == 0p, "Expected null got %p", readyThread->next );
 
-                                runThread(this, readyThread);
+                                __run_thread(this, readyThread);
 
                                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -298 +303 @@
                         } else {
                                 // spin(this, &spin_count);
-                                // halt(this);
+                                __halt(this);
                         }
                 }
@@ -318 +323 @@
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-static void runThread(processor * this, thread_desc * thrd_dst) {
+static void __run_thread(processor * this, thread_desc * thrd_dst) {
         coroutine_desc * proc_cor = get_coroutine(this->runner);
 
@@ -359 +364 @@
                 if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
                         // The thread was preempted, reschedule it and reset the flag
-                        ScheduleThread( thrd_dst );
+                        __schedule_thread( thrd_dst );
                         break RUNNING;
                 }
@@ -460 +465 @@
 } // Abort
 
-void * create_pthread( pthread_t * pthread, void * (*start)(void *), void * arg ) {
+void * __create_pthread( pthread_t * pthread, void * (*start)(void *), void * arg ) {
         pthread_attr_t attr;
 
@@ -488 +493 @@
 }
 
-static void start(processor * this) {
-        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
-
-        this->stack = create_pthread( &this->kernel_thread, CtxInvokeProcessor, (void *)this );
-
-        __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
-}
-
 // KERNEL_ONLY
-void kernel_first_resume( processor * this ) {
+static void __kernel_first_resume( processor * this ) {
         thread_desc * src = mainThread;
         coroutine_desc * dst = get_coroutine(this->runner);
@@ -529 +526 @@
 
 // KERNEL_ONLY
-void kernel_last_resume( processor * this ) {
+static void __kernel_last_resume( processor * this ) {
         coroutine_desc * src = &mainThread->self_cor;
         coroutine_desc * dst = get_coroutine(this->runner);
@@ -544 +541 @@
 // Scheduler routines
 // KERNEL ONLY
-void ScheduleThread( thread_desc * thrd ) with( *thrd->curr_cluster ) {
+void __schedule_thread( thread_desc * thrd ) with( *thrd->curr_cluster ) {
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
@@ -574 +571 @@
 
 // KERNEL ONLY
-static thread_desc * nextThread(cluster * this) with( *this ) {
+static thread_desc * __next_thread(cluster * this) with( *this ) {
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
@@ -600 +597 @@
                         // Wake lost the race,
                         thrd->state = Inactive;
-                        ScheduleThread( thrd );
+                        __schedule_thread( thrd );
                         break;
                 case Rerun:
@@ -668 +665 @@
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
-static void kernel_startup(void) {
+static void __kernel_startup(void) {
         verify( ! kernelTLS.preemption_state.enabled );
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
@@ -729 +726 @@
         // Add the main thread to the ready queue
         // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
-        ScheduleThread(mainThread);
+        __schedule_thread(mainThread);
 
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
-        kernel_first_resume( kernelTLS.this_processor );
+        __kernel_first_resume( kernelTLS.this_processor );
 
 
@@ -746 +743 @@
 }
 
-static void kernel_shutdown(void) {
+static void __kernel_shutdown(void) {
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
@@ -757 +754 @@
         // which is currently here
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
-        kernel_last_resume( kernelTLS.this_processor );
+        __kernel_last_resume( kernelTLS.this_processor );
         mainThread->self_cor.state = Halted;
 
@@ -783 +780 @@
 // Kernel Quiescing
 //=============================================================================================
-static void halt(processor * this) with( *this ) {
+static void __halt(processor * this) with( *this ) {
         // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
 
@@ -972 +969 @@
 //-----------------------------------------------------------------------------
 // Debug
-bool threading_enabled(void) {
+bool threading_enabled(void) __attribute__((const)) {
         return true;
 }