Changes in libcfa/src/concurrency/invoke.h [ae7be7a:b798713]

File:

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

libcfa/src/concurrency/invoke.h

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec  5 16:26:03 2019
-// Update Count     : 44
+// Last Modified On : Sat Jun 22 18:19:13 2019
+// Update Count     : 40
 //
 
@@ -47 +47 @@
         extern "Cforall" {
                 extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-                        struct $thread    * volatile this_thread;
+                        struct thread_desc    * volatile this_thread;
                         struct processor      * volatile this_processor;
 
@@ -92 +92 @@
         };
 
-        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
+        enum coroutine_state { Halted, Start, Inactive, Active, Primed };
+
+        struct coroutine_desc {
+                // context that is switch during a CtxSwitch
                 struct __stack_context_t context;
 
@@ -109 +108 @@
 
                 // first coroutine to resume this one
-                struct $coroutine * starter;
+                struct coroutine_desc * starter;
 
                 // last coroutine to resume this one
-                struct $coroutine * last;
+                struct coroutine_desc * last;
 
                 // If non-null stack must be unwound with this exception
@@ -118 +117 @@
 
         };
-
-        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
@@ -130 +127 @@
         };
 
-        struct $monitor {
+        struct monitor_desc {
                 // spinlock to protect internal data
                 struct __spinlock_t lock;
 
                 // current owner of the monitor
-                struct $thread * owner;
+                struct thread_desc * owner;
 
                 // queue of threads that are blocked waiting for the monitor
-                __queue_t(struct $thread) entry_queue;
+                __queue_t(struct thread_desc) entry_queue;
 
                 // stack of conditions to run next once we exit the monitor
@@ -155 +152 @@
         struct __monitor_group_t {
                 // currently held monitors
-                __cfa_anonymous_object( __small_array_t($monitor*) );
+                __cfa_anonymous_object( __small_array_t(monitor_desc*) );
 
                 // last function that acquired monitors
@@ -161 +158 @@
         };
 
-        struct $thread {
+        // Link lists fields
+        // instrusive link field for threads
+        struct __thread_desc_link {
+                struct thread_desc * next;
+                struct thread_desc * prev;
+                unsigned long long ts;
+        };
+
+        struct thread_desc {
                 // Core threading fields
-                // context that is switch during a __cfactx_switch
+                // context that is switch during a CtxSwitch
                 struct __stack_context_t context;
 
                 // current execution status for coroutine
-                volatile int state;
-                enum __Preemption_Reason preempted;
+                enum coroutine_state state;
 
                 //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  self_cor;
+                struct coroutine_desc  self_cor;
 
                 // current active context
-                struct $coroutine * curr_cor;
+                struct coroutine_desc * curr_cor;
 
                 // monitor body used for mutual exclusion
-                struct $monitor    self_mon;
+                struct monitor_desc    self_mon;
 
                 // pointer to monitor with sufficient lifetime for current monitors
-                struct $monitor *  self_mon_p;
+                struct monitor_desc *  self_mon_p;
 
                 // pointer to the cluster on which the thread is running
@@ -192 +196 @@
                 // Link lists fields
                 // instrusive link field for threads
-                struct $thread * next;
+                struct __thread_desc_link link;
 
                 struct {
-                        struct $thread * next;
-                        struct $thread * prev;
+                        struct thread_desc * next;
+                        struct thread_desc * 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 *& get_next( $thread & this ) __attribute__((const)) {
-                        return this.next;
-                }
-
-                static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) {
+                static inline thread_desc *& get_next( thread_desc & this ) {
+                        return this.link.next;
+                }
+
+                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
                         return this.node.[next, prev];
                 }
 
                 static inline void ?{}(__monitor_group_t & this) {
-                        (this.data){0p};
+                        (this.data){NULL};
                         (this.size){0};
                         (this.func){NULL};
                 }
 
-                static inline void ?{}(__monitor_group_t & this, struct $monitor ** data, __lock_size_t size, fptr_t func) {
+                static inline void ?{}(__monitor_group_t & this, struct monitor_desc ** data, __lock_size_t size, fptr_t func) {
                         (this.data){data};
                         (this.size){size};
@@ -238 +226 @@
                 }
 
-                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) __attribute__((const)) {
+                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
                         if( (lhs.data != 0) != (rhs.data != 0) ) return false;
                         if( lhs.size != rhs.size ) return false;
@@ -272 +260 @@
 
         // assembler routines that performs the context switch
-        extern void __cfactx_invoke_stub( void );
-        extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
+        extern void CtxInvokeStub( void );
+        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
         // void CtxStore ( void * this ) asm ("CtxStore");
         // void CtxRet   ( void * dst  ) asm ("CtxRet");