Changeset 8c50aed

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

Location:

libcfa/src/concurrency

Files:

• coroutine.hfa (modified) (3 diffs)
• invoke.h (modified) (2 diffs)
• kernel.cfa (modified) (21 diffs)
• kernel.hfa (modified) (2 diffs)
• kernel_private.hfa (modified) (3 diffs)
• preemption.cfa (modified) (1 diff)
• thread.cfa (modified) (3 diffs)
• thread.hfa (modified) (1 diff)

libcfa/src/concurrency/coroutine.hfa

@@ -54 +54 @@
 void prime(T & cor);
 
-static inline struct coroutine_desc * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
+static inline struct coroutine_desc * active_coroutine() __attribute__((const)) { return TL_GET( this_thread )->curr_cor; }
 
 //-----------------------------------------------------------------------------
@@ -73 +73 @@
 // Private wrappers for context switch and stack creation
 // Wrapper for co
-static inline void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
+static inline void CoroutineCtxSwitch( coroutine_desc * src, coroutine_desc * dst ) __attribute__((nonnull (1, 2))) {
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Inactive;
@@ -152 +152 @@
 }
 
-static inline void resume(coroutine_desc * dst) {
+static inline void resume( coroutine_desc * dst ) __attribute__((nonnull (1))) {
         // optimization : read TLS once and reuse it
         // Safety note: this is preemption safe since if

libcfa/src/concurrency/invoke.h

@@ -200 +200 @@
         #ifdef __cforall
         extern "Cforall" {
-                static inline thread_desc *& get_next( thread_desc & this ) {
+                static inline thread_desc *& get_next( thread_desc & this ) __attribute__((const)) {
                         return this.next;
                 }
 
-                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
+                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) /*__attribute__((const))*/ {
                         return this.node.[next, prev];
                 }
@@ -220 +220 @@
                 }
 
-                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
+                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) __attribute__((const)) {
                         if( (lhs.data != 0) != (rhs.data != 0) ) return false;
                         if( lhs.size != rhs.size ) return false;

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;
 }

libcfa/src/concurrency/kernel.hfa

@@ -108 +108 @@
 static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
 
-static inline [processor *&, processor *& ] __get( processor & this ) {
-        return this.node.[next, prev];
-}
+static inline [processor *&, processor *& ] __get( processor & this ) /*__attribute__((const))*/ { return this.node.[next, prev]; }
 
 //-----------------------------------------------------------------------------
@@ -153 +151 @@
 static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
 
-static inline [cluster *&, cluster *& ] __get( cluster & this ) {
-        return this.node.[next, prev];
-}
+static inline [cluster *&, cluster *& ] __get( cluster & this ) /*__attribute__((const))*/ { return this.node.[next, prev]; }
 
-static inline struct processor * active_processor() { return TL_GET( this_processor ); } // UNSAFE
-static inline struct cluster   * active_cluster  () { return TL_GET( this_processor )->cltr; }
+static inline struct processor * active_processor() __attribute__((const)) { return TL_GET( this_processor ); } // UNSAFE
+static inline struct cluster   * active_cluster  () __attribute__((const)) { return TL_GET( this_processor )->cltr; }
 
 // Local Variables: //

libcfa/src/concurrency/kernel_private.hfa

@@ -31 +31 @@
 }
 
-void ScheduleThread( thread_desc * ) __attribute__((nonnull (1)));
+void __schedule_thread( thread_desc * ) __attribute__((nonnull (1)));
 
 //Block current thread and release/wake-up the following resources
@@ -40 +40 @@
 void main(processorCtx_t *);
 
-void * create_pthread( pthread_t *, void * (*)(void *), void * );
+void * __create_pthread( pthread_t *, void * (*)(void *), void * );
 
 static inline void wake_fast(processor * this) {
@@ -85 +85 @@
 #define KERNEL_STORAGE(T,X) static char storage_##X[sizeof(T)]
 
-static inline uint32_t tls_rand() {
+static inline uint32_t __tls_rand() {
         kernelTLS.rand_seed ^= kernelTLS.rand_seed << 6;
         kernelTLS.rand_seed ^= kernelTLS.rand_seed >> 21;

libcfa/src/concurrency/preemption.cfa

@@ -306 +306 @@
         signal_block( SIGALRM );
 
-        alarm_stack = create_pthread( &alarm_thread, alarm_loop, 0p );
+        alarm_stack = __create_pthread( &alarm_thread, alarm_loop, 0p );
 }
 

libcfa/src/concurrency/thread.cfa

@@ -22 +22 @@
 #define __CFA_INVOKE_PRIVATE__
 #include "invoke.h"
-
-extern "C" {
-        #include <fenv.h>
-        #include <stddef.h>
-}
-
-//extern volatile thread_local processor * this_processor;
 
 //-----------------------------------------------------------------------------
@@ -56 +49 @@
 }
 
+//-----------------------------------------------------------------------------
+// Starting and stopping threads
+forall( dtype T | is_thread(T) )
+void __thrd_start( T & this, void (*main_p)(T &) ) {
+        thread_desc * this_thrd = get_thread(this);
+
+        disable_interrupts();
+        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
+
+        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
+        verify( this_thrd->context.SP );
+
+        __schedule_thread(this_thrd);
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+//-----------------------------------------------------------------------------
+// Support for threads that don't ues the thread keyword
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
 void ?{}( scoped(T)& this ) with( this ) {
@@ -73 +84 @@
 }
 
-//-----------------------------------------------------------------------------
-// Starting and stopping threads
-forall( dtype T | is_thread(T) )
-void __thrd_start( T & this, void (*main_p)(T &) ) {
-        thread_desc * this_thrd = get_thread(this);
-
-        disable_interrupts();
-        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
-
-        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
-        verify( this_thrd->context.SP );
-
-        ScheduleThread(this_thrd);
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/thread.hfa

@@ -31 +31 @@
 };
 
-#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)
+// define that satisfies the trait without using the thread keyword
+#define DECL_THREAD(X) thread_desc* get_thread(X& this) __attribute__((const)) { return &this.__thrd; } void main(X& this)
+
+// Inline getters for threads/coroutines/monitors
+forall( dtype T | is_thread(T) )
+static inline coroutine_desc* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; }
 
 forall( dtype T | is_thread(T) )
-static inline coroutine_desc* get_coroutine(T & this) {
-        return &get_thread(this)->self_cor;
-}
+static inline monitor_desc  * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
 
-forall( dtype T | is_thread(T) )
-static inline monitor_desc* get_monitor(T & this) {
-        return &get_thread(this)->self_mon;
-}
+static inline coroutine_desc* get_coroutine(thread_desc * this) __attribute__((const)) { return &this->self_cor; }
+static inline monitor_desc  * get_monitor  (thread_desc * this) __attribute__((const)) { return &this->self_mon; }
 
-static inline coroutine_desc* get_coroutine(thread_desc * this) {
-        return &this->self_cor;
-}
-
-static inline monitor_desc* get_monitor(thread_desc * this) {
-        return &this->self_mon;
-}
-
+//-----------------------------------------------------------------------------
+// forward declarations needed for threads
 extern struct cluster * mainCluster;