Changes in libcfa/src/concurrency/kernel/fwd.hfa [e235429:8fc652e0]

File:

• libcfa/src/concurrency/kernel/fwd.hfa (modified) (6 diffs)

libcfa/src/concurrency/kernel/fwd.hfa

@@ -35 +35 @@
         extern "Cforall" {
                 extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-                        struct $thread    * volatile this_thread;
-                        struct processor  * volatile this_processor;
-                        struct __stats_t  * volatile this_stats;
+                        struct $thread          * volatile this_thread;
+                        struct processor        * volatile this_processor;
+                        struct __processor_id_t * volatile this_proc_id;
+                        struct __stats_t        * volatile this_stats;
 
                         struct {
@@ -54 +55 @@
                                 uint64_t bck_seed;
                         } ready_rng;
-                } kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
+                } __cfaabi_tls __attribute__ ((tls_model ( "initial-exec" )));
 
+                extern bool __preemption_enabled();
 
+                static inline KernelThreadData & kernelTLS( void ) {
+                        /* paranoid */ verify( ! __preemption_enabled() );
+                        return __cfaabi_tls;
+                }
+
+                extern uintptr_t __cfatls_get( unsigned long int member );
+                // #define publicTLS_get( member ) ((typeof(__cfaabi_tls.member))__cfatls_get( __builtin_offsetof(KernelThreadData, member) ))
+                #define publicTLS_get( member ) (__cfaabi_tls.member)
+                // extern forall(otype T) T __cfatls_get( T * member, T value );
+                // #define publicTLS_set( member, value ) __cfatls_set( (typeof(member)*)__builtin_offsetof(KernelThreadData, member), value );
 
                 static inline uint64_t __tls_rand() {
                         #if defined(__SIZEOF_INT128__)
-                                return __lehmer64( kernelTLS.rand_seed );
+                                return __lehmer64( kernelTLS().rand_seed );
                         #else
-                                return __xorshift64( kernelTLS.rand_seed );
+                                return __xorshift64( kernelTLS().rand_seed );
                         #endif
                 }
@@ -74 +86 @@
                 static inline unsigned __tls_rand_fwd() {
 
-                        kernelTLS.ready_rng.fwd_seed = (A * kernelTLS.ready_rng.fwd_seed + C) & (M - 1);
-                        return kernelTLS.ready_rng.fwd_seed >> D;
+                        kernelTLS().ready_rng.fwd_seed = (A * kernelTLS().ready_rng.fwd_seed + C) & (M - 1);
+                        return kernelTLS().ready_rng.fwd_seed >> D;
                 }
 
                 static inline unsigned __tls_rand_bck() {
-                        unsigned int r = kernelTLS.ready_rng.bck_seed >> D;
-                        kernelTLS.ready_rng.bck_seed = AI * (kernelTLS.ready_rng.bck_seed - C) & (M - 1);
+                        unsigned int r = kernelTLS().ready_rng.bck_seed >> D;
+                        kernelTLS().ready_rng.bck_seed = AI * (kernelTLS().ready_rng.bck_seed - C) & (M - 1);
                         return r;
                 }
@@ -91 +103 @@
 
                 static inline void __tls_rand_advance_bck(void) {
-                        kernelTLS.ready_rng.bck_seed = kernelTLS.ready_rng.fwd_seed;
+                        kernelTLS().ready_rng.bck_seed = kernelTLS().ready_rng.fwd_seed;
                 }
         }
 
-        #if 0 // def __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
 
         extern void disable_interrupts();
@@ -120 +116 @@
                 extern void park( void );
                 extern void unpark( struct $thread * this );
-                static inline struct $thread * active_thread () { return TL_GET( this_thread ); }
+                static inline struct $thread * active_thread () {
+                        struct $thread * t = publicTLS_get( this_thread );
+                        /* paranoid */ verify( t );
+                        return t;
+                }
 
                 extern bool force_yield( enum __Preemption_Reason );
@@ -139 +139 @@
                 #if !defined(__CFA_NO_STATISTICS__)
                         static inline struct __stats_t * __tls_stats() {
-                                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-                                /* paranoid */ verify( kernelTLS.this_stats );
-                                return kernelTLS.this_stats;
+                                /* paranoid */ verify( ! __preemption_enabled() );
+                                /* paranoid */ verify( kernelTLS().this_stats );
+                                return kernelTLS().this_stats;
                         }