Changeset 6a490b2 for libcfa/src/concurrency/invoke.h

Timestamp:

May 11, 2020, 1:53:29 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

504a7dc

Parents:

b7d6a36 (diff), a7b486b (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' into relaxed_ready

File:

• libcfa/src/concurrency/invoke.h (modified) (11 diffs)

libcfa/src/concurrency/invoke.h

@@ -47 +47 @@
         extern "Cforall" {
                 extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-                        struct thread_desc    * volatile this_thread;
+                        struct $thread    * volatile this_thread;
                         struct processor      * volatile this_processor;
 
@@ -92 +92 @@
         };
 
-        enum coroutine_state { Halted, Start, Inactive, Active, Primed };
-
-        struct coroutine_desc {
-                // context that is switch during a CtxSwitch
+        enum coroutine_state { Halted, Start, Primed, Blocked, Ready, Active, Rerun };
+        enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION, __MANUAL_PREEMPTION };
+
+        struct $coroutine {
+                // context that is switch during a __cfactx_switch
                 struct __stack_context_t context;
 
@@ -108 +109 @@
 
                 // first coroutine to resume this one
-                struct coroutine_desc * starter;
+                struct $coroutine * starter;
 
                 // last coroutine to resume this one
-                struct coroutine_desc * last;
+                struct $coroutine * last;
 
                 // If non-null stack must be unwound with this exception
@@ -117 +118 @@
 
         };
+
+        static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); }
 
         // struct which calls the monitor is accepting
@@ -127 +130 @@
         };
 
-        struct monitor_desc {
+        struct $monitor {
                 // spinlock to protect internal data
                 struct __spinlock_t lock;
 
                 // current owner of the monitor
-                struct thread_desc * owner;
+                struct $thread * owner;
 
                 // queue of threads that are blocked waiting for the monitor
-                __queue_t(struct thread_desc) entry_queue;
+                __queue_t(struct $thread) entry_queue;
 
                 // stack of conditions to run next once we exit the monitor
@@ -152 +155 @@
         struct __monitor_group_t {
                 // currently held monitors
-                __cfa_anonymous_object( __small_array_t(monitor_desc*) );
+                __cfa_anonymous_object( __small_array_t($monitor*) );
 
                 // last function that acquired monitors
@@ -161 +164 @@
         // instrusive link field for threads
         struct __thread_desc_link {
-                struct thread_desc * next;
-                struct thread_desc * prev;
+                struct $thread * next;
+                struct $thread * prev;
                 unsigned long long ts;
         };
 
-        struct thread_desc {
+        struct $thread {
                 // Core threading fields
-                // context that is switch during a CtxSwitch
+                // context that is switch during a __cfactx_switch
                 struct __stack_context_t context;
 
                 // current execution status for coroutine
-                enum coroutine_state state;
+                volatile int state;
+                enum __Preemption_Reason preempted;
 
                 //SKULLDUGGERY errno is not save in the thread data structure because returnToKernel appears to be the only function to require saving and restoring it
 
                 // coroutine body used to store context
-                struct coroutine_desc  self_cor;
+                struct $coroutine  self_cor;
 
                 // current active context
-                struct coroutine_desc * curr_cor;
+                struct $coroutine * curr_cor;
 
                 // monitor body used for mutual exclusion
-                struct monitor_desc    self_mon;
+                struct $monitor    self_mon;
 
                 // pointer to monitor with sufficient lifetime for current monitors
-                struct monitor_desc *  self_mon_p;
+                struct $monitor *  self_mon_p;
 
                 // pointer to the cluster on which the thread is running
@@ -199 +203 @@
 
                 struct {
-                        struct thread_desc * next;
-                        struct thread_desc * prev;
+                        struct $thread * next;
+                        struct $thread * prev;
                 } node;
-        };
+
+                #ifdef __CFA_DEBUG__
+                        // previous function to park/unpark the thread
+                        const char * park_caller;
+                        enum coroutine_state park_result;
+                        bool park_stale;
+                        const char * unpark_caller;
+                        enum coroutine_state unpark_result;
+                        bool unpark_stale;
+                #endif
+        };
+
+        #ifdef __CFA_DEBUG__
+                void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]);
+        #else
+                #define __cfaabi_dbg_record_thrd(x, y, z)
+        #endif
 
         #ifdef __cforall
         extern "Cforall" {
-                static inline thread_desc *& get_next( thread_desc & this ) {
+
+                static inline $thread *& get_next( $thread & this ) __attribute__((const)) {
                         return this.link.next;
                 }
 
-                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
+                static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) {
                         return this.node.[next, prev];
                 }
@@ -220 +241 @@
                 }
 
-                static inline void ?{}(__monitor_group_t & this, struct monitor_desc ** data, __lock_size_t size, fptr_t func) {
+                static inline void ?{}(__monitor_group_t & this, struct $monitor ** data, __lock_size_t size, fptr_t func) {
                         (this.data){data};
                         (this.size){size};
@@ -226 +247 @@
                 }
 
-                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;
@@ -260 +281 @@
 
         // assembler routines that performs the context switch
-        extern void CtxInvokeStub( void );
-        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
+        extern void __cfactx_invoke_stub( void );
+        extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
         // void CtxStore ( void * this ) asm ("CtxStore");
         // void CtxRet   ( void * dst  ) asm ("CtxRet");