Changes in libcfa/src/concurrency/invoke.h [d25b2d6:09d4b22]

File:

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

libcfa/src/concurrency/invoke.h

@@ -17 +17 @@
 #include "bits/defs.hfa"
 #include "bits/locks.hfa"
-#include "kernel/fwd.hfa"
 
 #ifdef __cforall
@@ -27 +26 @@
 #define _INVOKE_H_
 
-        struct __cfaehm_try_resume_node;
-        struct __cfaehm_base_exception_t;
-        struct exception_context_t {
-                struct __cfaehm_try_resume_node * top_resume;
-                struct __cfaehm_base_exception_t * current_exception;
-        };
+#ifdef __ARM_ARCH
+        // function prototypes are only really used by these macros on ARM
+        void disable_global_interrupts();
+        void enable_global_interrupts();
+
+        #define TL_GET( member ) ( { __typeof__( kernelTLS.member ) target; \
+                disable_global_interrupts(); \
+                target = kernelTLS.member; \
+                enable_global_interrupts(); \
+                target; } )
+        #define TL_SET( member, value ) disable_global_interrupts(); \
+                kernelTLS.member = value; \
+                enable_global_interrupts();
+#else
+        #define TL_GET( member ) kernelTLS.member
+        #define TL_SET( member, value ) kernelTLS.member = value;
+#endif
+
+        #ifdef __cforall
+        extern "Cforall" {
+                extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
+                        struct thread_desc    * volatile this_thread;
+                        struct processor      * volatile this_processor;
+
+                        struct {
+                                volatile unsigned short disable_count;
+                                volatile bool enabled;
+                                volatile bool in_progress;
+                        } preemption_state;
+
+                        uint32_t rand_seed;
+                } kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
+        }
+        #endif
 
         struct __stack_context_t {
@@ -58 +85 @@
                 // base of stack
                 void * base;
-
-                // Information for exception handling.
-                struct exception_context_t exception_context;
         };
 
@@ -68 +92 @@
         };
 
-        enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active, Cancelled, Halting };
-
-        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;
 
@@ -81 +105 @@
 
                 // current execution status for coroutine
-                enum __Coroutine_State state;
+                enum coroutine_state state;
 
                 // 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
@@ -93 +117 @@
 
         };
-        // Wrapper for gdb
-        struct cfathread_coroutine_t { struct $coroutine debug; };
-
-        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
@@ -109 +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
@@ -131 +149 @@
                 struct __condition_node_t * dtor_node;
         };
-        // Wrapper for gdb
-        struct cfathread_monitor_t { struct $monitor debug; };
 
         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
@@ -142 +158 @@
         };
 
-        // Link lists fields
-        // instrusive link field for threads
-        struct __thread_desc_link {
-                struct $thread * next;
-                struct $thread * prev;
-                volatile unsigned long long ts;
-                int preferred;
-        };
-
-        struct $thread {
+        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
-                // Possible values are:
-                //    - TICKET_BLOCKED (-1) thread is blocked
-                //    - TICKET_RUNNING ( 0) thread is running
-                //    - TICKET_UNBLOCK ( 1) thread should ignore next block
-                volatile int ticket;
-                enum __Coroutine_State state:8;
-                enum __Preemption_Reason preempted:8;
+                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_desc  self_cor;
+
+                // current active context
+                struct coroutine_desc * curr_cor;
+
+                // monitor body used for mutual exclusion
+                struct monitor_desc    self_mon;
+
+                // pointer to monitor with sufficient lifetime for current monitors
+                struct monitor_desc *  self_mon_p;
 
                 // pointer to the cluster on which the thread is running
                 struct cluster * curr_cluster;
 
+                // monitors currently held by this thread
+                struct __monitor_group_t monitors;
+
                 // Link lists fields
                 // instrusive link field for threads
-                struct __thread_desc_link link;
-
-                // coroutine body used to store context
-                struct $coroutine  self_cor;
-
-                // current active context
-                struct $coroutine * curr_cor;
-
-                // monitor body used for mutual exclusion
-                struct $monitor    self_mon;
-
-                // pointer to monitor with sufficient lifetime for current monitors
-                struct $monitor *  self_mon_p;
-
-                // monitors currently held by this thread
-                struct __monitor_group_t monitors;
-
-                // used to put threads on user data structures
+                struct thread_desc * next;
+
                 struct {
-                        struct $thread * next;
-                        struct $thread * back;
-                } seqable;
-
-                struct {
-                        struct $thread * next;
-                        struct $thread * prev;
+                        struct thread_desc * next;
+                        struct thread_desc * prev;
                 } node;
-
-                #if defined( __CFA_WITH_VERIFY__ )
-                        void * canary;
-                #endif
-        };
-        // Wrapper for gdb
-        struct cfathread_thread_t { struct $thread debug; };
-
-        #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.link.next;
-                }
-
-                static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) {
+                static inline thread_desc *& get_next( thread_desc & this ) {
+                        return this.next;
+                }
+
+                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
                         return this.node.[next, prev];
-                }
-
-                static inline $thread *& Back( $thread * this ) __attribute__((const)) {
-                        return this->seqable.back;
-                }
-
-                static inline $thread *& Next( $thread * this ) __attribute__((const)) {
-                        return this->seqable.next;
-                }
-
-                static inline bool listed( $thread * this ) {
-                        return this->seqable.next != 0p;
                 }
 
@@ -242 +212 @@
                 }
 
-                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};
@@ -248 +218 @@
                 }
 
-                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;
@@ -282 +252 @@
 
         // 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");