Changeset afd550c for src

Timestamp:

May 8, 2018, 5:22:38 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

b4a835d, de94a60

Parents:

4990812

Message:

Some more work on TLS macros

Location:

src/libcfa/concurrency

Files:

• coroutine.c (modified) (2 diffs)
• invoke.c (modified) (1 diff)
• invoke.h (modified) (1 diff)
• kernel.c (modified) (4 diffs)
• monitor.c (modified) (1 diff)
• preemption.c (modified) (3 diffs)
• thread.c (modified) (1 diff)

src/libcfa/concurrency/coroutine.c

@@ -85 +85 @@
 void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
       // Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
+      verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
       disable_interrupts();
 
@@ -104 +104 @@
       enable_interrupts( __cfaabi_dbg_ctx );
       // Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
+      verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
 } //ctxSwitchDirect
 

src/libcfa/concurrency/invoke.c

@@ -69 +69 @@
         // Fetch the thread handle from the user defined thread structure
         struct thread_desc* thrd = get_thread( this );
+        thrd->self_cor.last = NULL;
 
         // Officially start the thread by enabling preemption

src/libcfa/concurrency/invoke.h

@@ -49 +49 @@
         static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_coroutine ); }
         static inline struct thread_desc    * volatile active_thread   () { return TL_GET( this_thread    ); }
-        // static inline struct processor      * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE
+        static inline struct processor      * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE
         #endif
 

src/libcfa/concurrency/kernel.c

@@ -422 +422 @@
         }
 
-        verify( ! preemption_state.enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! preemption_state.enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -578 +578 @@
         verify( ! kernelTLS.preemption_state.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
-        verify( TL_GET( preemption_state ).enabled );
+        verify( TL_GET( preemption_state.enabled ) );
 }
 
@@ -584 +584 @@
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
-        verify( TL_GET( preemption_state ).enabled );
+        verify( TL_GET( preemption_state.enabled ) );
         disable_interrupts();
         verify( ! kernelTLS.preemption_state.enabled );
@@ -642 +642 @@
 static bool kernel_abort_called = false;
 
-void * kernel_abort    (void) __attribute__ ((__nothrow__)) {
+void * kernel_abort(void) __attribute__ ((__nothrow__)) {
         // abort cannot be recursively entered by the same or different processors because all signal handlers return when
         // the globalAbort flag is true.

src/libcfa/concurrency/monitor.c

@@ -480 +480 @@
 
         // Create the node specific to this wait operation
-        wait_ctx_primed( TL_GET( this_thread ), 0 )
+        wait_ctx_primed( kernelTLS.this_thread, 0 )
 
         //save contexts

src/libcfa/concurrency/preemption.c

@@ -149 +149 @@
         // Disable interrupts by incrementing the counter
         void disable_interrupts() {
-                with( TL_GET( preemption_state ) ) {
+                with( kernelTLS.preemption_state ) {
                         enabled = false;
                         __attribute__((unused)) unsigned short new_val = disable_count + 1;
@@ -160 +160 @@
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                processor   * proc = TL_GET( this_processor ); // Cache the processor now since interrupts can start happening after the atomic add
-                thread_desc * thrd = TL_GET( this_thread );       // Cache the thread now since interrupts can start happening after the atomic add
-
-                with( TL_GET( preemption_state ) ){
+                processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic add
+                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic add
+
+                with( kernelTLS.preemption_state ){
                         unsigned short prev = disable_count;
                         disable_count -= 1;
@@ -185 +185 @@
         // Don't execute any pending CtxSwitch even if counter reaches 0
         void enable_interrupts_noPoll() {
-                unsigned short prev = TL_GET( preemption_state ).disable_count;
-                TL_GET( preemption_state ).disable_count -= 1;
+                unsigned short prev = kernelTLS.preemption_state.disable_count;
+                kernelTLS.preemption_state.disable_count -= 1;
                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
-                        TL_GET( preemption_state ).enabled = true;
+                        kernelTLS.preemption_state.enabled = true;
                 }
         }

src/libcfa/concurrency/thread.c

@@ -100 +100 @@
 void yield( void ) {
         // Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state ).enabled );
+      verify( TL_GET( preemption_state.enabled ) );
         BlockInternal( TL_GET( this_thread ) );
         // Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state ).enabled );
+      verify( TL_GET( preemption_state.enabled ) );
 }