Changes in libcfa/src/concurrency/preemption.cfa [b5344a3:1b033b8]

File:

• libcfa/src/concurrency/preemption.cfa (modified) (19 diffs)

libcfa/src/concurrency/preemption.cfa

@@ -215 +215 @@
 // available.
 
-//-----------------------------------------------------------------------------
-// Some assembly required
-#define __cfaasm_label(label, when) when: asm volatile goto(".global __cfaasm_" #label "_" #when "\n" "__cfaasm_" #label "_" #when ":":::"memory":when)
-
 //----------
 // special case for preemption since used often
@@ -224 +220 @@
         // create a assembler label before
         // marked as clobber all to avoid movement
-        __cfaasm_label(check, before);
+        asm volatile("__cfaasm_check_before:":::"memory");
 
         // access tls as normal
@@ -231 +227 @@
         // create a assembler label after
         // marked as clobber all to avoid movement
-        __cfaasm_label(check, after);
+        asm volatile("__cfaasm_check_after:":::"memory");
         return enabled;
 }
@@ -250 +246 @@
 uintptr_t __cfatls_get( unsigned long int offset ) __attribute__((__noinline__)); //no inline to avoid problems
 uintptr_t __cfatls_get( unsigned long int offset ) {
+        // __cfaasm_get.before = ({ void * value; asm("movq $__cfaasm_get_before, %[v]\n\t" : [v]"=r"(value) ); value; });
+        // __cfaasm_get.after  = ({ void * value; asm("movq $__cfaasm_get_after , %[v]\n\t" : [v]"=r"(value) ); value; });
         // create a assembler label before
         // marked as clobber all to avoid movement
-        __cfaasm_label(get, before);
+        asm volatile("__cfaasm_get_before:":::"memory");
 
         // access tls as normal (except for pointer arithmetic)
@@ -259 +257 @@
         // create a assembler label after
         // marked as clobber all to avoid movement
-        __cfaasm_label(get, after);
+        asm volatile("__cfaasm_get_after:":::"memory");
         return val;
 }
@@ -268 +266 @@
                 // create a assembler label before
                 // marked as clobber all to avoid movement
-                __cfaasm_label(dsable, before);
+                asm volatile("__cfaasm_dsable_before:":::"memory");
 
                 with( __cfaabi_tls.preemption_state ) {
@@ -290 +288 @@
                 // create a assembler label after
                 // marked as clobber all to avoid movement
-                __cfaasm_label(dsable, after);
-
+                asm volatile("__cfaasm_dsable_after:":::"memory");
         }
 
@@ -297 +294 @@
         // If counter reaches 0, execute any pending __cfactx_switch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                // Cache the processor now since interrupts can start happening after the atomic store
-                processor   * proc = __cfaabi_tls.this_processor;
+                // create a assembler label before
+                // marked as clobber all to avoid movement
+                asm volatile("__cfaasm_enble_before:":::"memory");
+
+                processor   * proc = __cfaabi_tls.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
                 /* paranoid */ verify( proc );
 
@@ -304 +304 @@
                         unsigned short prev = disable_count;
                         disable_count -= 1;
-
-                        // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
-                        /* paranoid */ verify( prev != 0u );
+                        verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
 
                         // Check if we need to prempt the thread because an interrupt was missed
                         if( prev == 1 ) {
                                 #if GCC_VERSION > 50000
-                                        static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
+                                static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
                                 #endif
 
@@ -330 +328 @@
                 // For debugging purposes : keep track of the last person to enable the interrupts
                 __cfaabi_dbg_debug_do( proc->last_enable = caller; )
+
+                // create a assembler label after
+                // marked as clobber all to avoid movement
+                asm volatile("__cfaasm_enble_after:":::"memory");
         }
 
@@ -335 +337 @@
         // Don't execute any pending __cfactx_switch even if counter reaches 0
         void enable_interrupts_noPoll() {
+                // create a assembler label before
+                // marked as clobber all to avoid movement
+                asm volatile("__cfaasm_nopoll_before:":::"memory");
+
                 unsigned short prev = __cfaabi_tls.preemption_state.disable_count;
                 __cfaabi_tls.preemption_state.disable_count -= 1;
-                // If this triggers someone is enabled already enabled interrupts
-                /* paranoid */ verifyf( prev != 0u, "Incremented from %u\n", prev );
+                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
                         #if GCC_VERSION > 50000
-                                static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
+                        static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
                         #endif
                         // Set enabled flag to true
@@ -351 +356 @@
                         __atomic_signal_fence(__ATOMIC_RELEASE);
                 }
-        }
-}
-
-#undef __cfaasm_label
+
+                // create a assembler label after
+                // marked as clobber all to avoid movement
+                asm volatile("__cfaasm_nopoll_after:":::"memory");
+        }
+}
 
 // sigprocmask wrapper : unblock a single signal
@@ -386 +393 @@
 // reserved for future use
 static void timeout( $thread * this ) {
-        #if !defined( __CFA_NO_STATISTICS__ )
-                kernelTLS().this_stats = this->curr_cluster->stats;
-        #endif
         unpark( this );
 }
@@ -439 +443 @@
 #elif defined( __aarch64__ )
         #ifdef __PIC__
-                // Note that this works only for gcc
-                #define __cfaasm_label( label ) static struct asm_region label = \
+                #define RELOC_TAG "@PLT"
+        #else
+                #define RELOC_TAG ""
+        #endif
+        #define __cfaasm_label( label ) \
                 ({ \
                         struct asm_region region; \
                         asm( \
-                                "adrp %[vb], _GLOBAL_OFFSET_TABLE_"                              "\n\t" \
-                                "ldr  %[vb], [%[vb], #:gotpage_lo15:__cfaasm_" #label "_before]" "\n\t" \
-                                "adrp %[va], _GLOBAL_OFFSET_TABLE_"                              "\n\t" \
-                                "ldr  %[va], [%[va], #:gotpage_lo15:__cfaasm_" #label "_after]"  "\n\t" \
+                                "mov %[vb], __cfaasm_" #label "_before@GOTPCREL(%%rip)"  "\n\t" \
+                                "mov %[va], __cfaasm_" #label "_after@GOTPCREL(%%rip)"   "\n\t" \
                                  : [vb]"=r"(region.before), [va]"=r"(region.after) \
                         ); \
                         region; \
                 });
-        #else
-                #error this is not the right thing to do
-                /*
-                #define __cfaasm_label( label ) static struct asm_region label = \
-                ({ \
-                        struct asm_region region; \
-                        asm( \
-                                "adrp %[vb], __cfaasm_" #label "_before"              "\n\t" \
-                                "add  %[vb], %[vb], :lo12:__cfaasm_" #label "_before" "\n\t" \
-                                "adrp %[va], :got:__cfaasm_" #label "_after"          "\n\t" \
-                                "add  %[va], %[va], :lo12:__cfaasm_" #label "_after"  "\n\t" \
-                                 : [vb]"=r"(region.before), [va]"=r"(region.after) \
-                        ); \
-                        region; \
-                });
-                */
-        #endif
 #else
         #error unknown hardware architecture
@@ -482 +470 @@
         __cfaasm_label( check  );
         __cfaasm_label( dsable );
+        __cfaasm_label( enble );
+        __cfaasm_label( nopoll );
 
         // Check if preemption is safe
@@ -488 +478 @@
         if( __cfaasm_in( ip, check  ) ) { ready = false; goto EXIT; };
         if( __cfaasm_in( ip, dsable ) ) { ready = false; goto EXIT; };
+        if( __cfaasm_in( ip, enble  ) ) { ready = false; goto EXIT; };
+        if( __cfaasm_in( ip, nopoll ) ) { ready = false; goto EXIT; };
         if( !__cfaabi_tls.preemption_state.enabled) { ready = false; goto EXIT; };
         if( __cfaabi_tls.preemption_state.in_progress ) { ready = false; goto EXIT; };
@@ -614 +606 @@
         abort("SIGALRM should never reach the signal handler");
 }
+
+#if !defined(__CFA_NO_STATISTICS__)
+        int __print_alarm_stats = 0;
+#endif
 
 // Main of the alarm thread
@@ -622 +618 @@
         id.id = doregister(&id);
         __cfaabi_tls.this_proc_id = &id;
+
+        #if !defined(__CFA_NO_STATISTICS__)
+                struct __stats_t local_stats;
+                __cfaabi_tls.this_stats = &local_stats;
+                __init_stats( &local_stats );
+        #endif
 
         // Block sigalrms to control when they arrive
@@ -681 +683 @@
         __cfaabi_dbg_print_safe( "Kernel : Preemption thread stopping\n" );
         unregister(&id);
+
+        #if !defined(__CFA_NO_STATISTICS__)
+                if( 0 != __print_alarm_stats ) {
+                        __print_stats( &local_stats, __print_alarm_stats, "Alarm", "Thread", 0p );
+                }
+        #endif
         return 0p;
 }