Changes in libcfa/src/concurrency/preemption.cfa [8fc652e0:e235429]

File:

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

libcfa/src/concurrency/preemption.cfa

@@ -38 +38 @@
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
-static void timeout( $thread * this );
+static void timeout( struct __processor_id_t * id, $thread * this );
 
 // FwdDeclarations : Signal handlers
@@ -91 +91 @@
 
 // Tick one frame of the Discrete Event Simulation for alarms
-static void tick_preemption(void) {
+static void tick_preemption( struct __processor_id_t * id ) {
         alarm_node_t * node = 0p;                                                       // Used in the while loop but cannot be declared in the while condition
         alarm_list_t * alarms = &event_kernel->alarms;          // Local copy for ease of reading
@@ -105 +105 @@
 
                 // Check if this is a kernel
-                if( node->type == Kernel ) {
+                if( node->kernel_alarm ) {
                         preempt( node->proc );
                 }
-                else if( node->type == User ) {
-                        timeout( node->thrd );
-                }
                 else {
-                        node->callback(*node);
+                        timeout( id, node->thrd );
                 }
 
@@ -164 +161 @@
 //=============================================================================================
 
-//----------
-// special case for preemption since used often
-bool __preemption_enabled() {
-        // create a assembler label before
-        // marked as clobber all to avoid movement
-        asm volatile("__cfaasm_check_before:":::"memory");
-
-        // access tls as normal
-        bool enabled = __cfaabi_tls.preemption_state.enabled;
-
-        // create a assembler label after
-        // marked as clobber all to avoid movement
-        asm volatile("__cfaasm_check_after:":::"memory");
-        return enabled;
-}
-
-//----------
-// Get data from the TLS block
-uintptr_t __cfatls_get( unsigned long int offset ) __attribute__((__noinline__)); //no inline to avoid problems
-uintptr_t __cfatls_get( unsigned long int offset ) {
-        // create a assembler label before
-        // marked as clobber all to avoid movement
-        asm volatile("__cfaasm_get_before:":::"memory");
-
-        // access tls as normal (except for pointer arithmetic)
-        uintptr_t val = *(uintptr_t*)((uintptr_t)&__cfaabi_tls + offset);
-
-        // create a assembler label after
-        // marked as clobber all to avoid movement
-        asm volatile("__cfaasm_get_after:":::"memory");
-        return val;
-}
-
-// //----------
-// // Write data to the TLS block
-// // sadly it looses the type information and can only write 1 word at a time
-// // use with __builtin_offsetof
-// void __cfatls_set(uintptr_t offset, void * value) __attribute__((__noinline__));
-// void __cfatls_set(uintptr_t offset, void * value) {
-//     // create a assembler label before
-//     // marked as clobber all to avoid movement
-//     asm volatile("__cfaasm_set_before:":::"memory");
-
-//     // access tls as normal (except for type information)
-//     *(void**)(offset + (uintptr_t)&my_tls) = value;
-
-//     // create a assembler label after
-//     // marked as clobber all to avoid movement
-//     asm volatile("__cfaasm_set_after:":::"memory");
-// }
-
-// //----------
-// #include <stdio.h>
-// int main() {
-//     // Get the information
-//     // Must use inline assembly to get access to label
-//     // C is annoying here because this could easily be a static const but "initializer element is not a compile-time constant"
-//     // The big advantage of this approach is that there is 0 overhead for the read and writes function
-//     void * __cfaasm_addr_get_before = ({ void * value; asm("movq $__cfaasm_get_before, %[v]\n\t" : [v]"=r"(value) ); value; });
-//     void * __cfaasm_addr_get_after  = ({ void * value; asm("movq $__cfaasm_get_after , %[v]\n\t" : [v]"=r"(value) ); value; });
-//     void * __cfaasm_addr_set_before = ({ void * value; asm("movq $__cfaasm_set_before, %[v]\n\t" : [v]"=r"(value) ); value; });
-//     void * __cfaasm_addr_set_after  = ({ void * value; asm("movq $__cfaasm_set_after , %[v]\n\t" : [v]"=r"(value) ); value; });
-
-//     printf("%p to %p\n", __cfaasm_addr_get_before, __cfaasm_addr_get_after);
-//     printf("%p to %p\n", __cfaasm_addr_set_before, __cfaasm_addr_set_after);
-//     return 0;
-// }
-
 __cfaabi_dbg_debug_do( static thread_local void * last_interrupt = 0; )
 
@@ -237 +166 @@
         // Disable interrupts by incrementing the counter
         void disable_interrupts() {
-                // create a assembler label before
-                // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_disable_before:":::"memory");
-
-                with( __cfaabi_tls.preemption_state ) {
+                with( kernelTLS.preemption_state ) {
                         #if GCC_VERSION > 50000
                         static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
@@ -258 +183 @@
                         verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
                 }
-
-                // create a assembler label after
-                // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_disable_after:":::"memory");
         }
 
@@ -267 +188 @@
         // If counter reaches 0, execute any pending __cfactx_switch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                // create a assembler label before
-                // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_enable_before:":::"memory");
-
-                processor   * proc = __cfaabi_tls.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
+                processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
                 /* paranoid */ verify( proc );
 
-                with( __cfaabi_tls.preemption_state ){
+                with( kernelTLS.preemption_state ){
                         unsigned short prev = disable_count;
                         disable_count -= 1;
@@ -301 +218 @@
                 // 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_enable_after:":::"memory");
         }
 
@@ -310 +223 @@
         // 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;
+                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 ) {
                         #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(kernelTLS.preemption_state.enabled), &kernelTLS.preemption_state.enabled), "Must be lock-free");
                         #endif
                         // Set enabled flag to true
                         // should be atomic to avoid preemption in the middle of the operation.
                         // use memory order RELAXED since there is no inter-thread on this variable requirements
-                        __atomic_store_n(&__cfaabi_tls.preemption_state.enabled, true, __ATOMIC_RELAXED);
+                        __atomic_store_n(&kernelTLS.preemption_state.enabled, true, __ATOMIC_RELAXED);
 
                         // Signal the compiler that a fence is needed but only for signal handlers
                         __atomic_signal_fence(__ATOMIC_RELEASE);
                 }
-
-                // create a assembler label after
-                // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_nopoll_after:":::"memory");
         }
 }
@@ -365 +270 @@
 
 // reserved for future use
-static void timeout( $thread * this ) {
+static void timeout( struct __processor_id_t * id, $thread * this ) {
         #if !defined( __CFA_NO_STATISTICS__ )
-                kernelTLS().this_stats = this->curr_cluster->stats;
+                kernelTLS.this_stats = this->curr_cluster->stats;
         #endif
-        unpark( this );
+        __unpark( id, this );
 }
 
@@ -378 +283 @@
 static inline bool preemption_ready() {
         // Check if preemption is safe
-        bool ready = __cfaabi_tls.preemption_state.enabled && ! __cfaabi_tls.preemption_state.in_progress;
+        bool ready = kernelTLS.preemption_state.enabled && ! kernelTLS.preemption_state.in_progress;
 
         // Adjust the pending flag accordingly
-        __cfaabi_tls.this_processor->pending_preemption = !ready;
+        kernelTLS.this_processor->pending_preemption = !ready;
         return ready;
 }
@@ -395 +300 @@
 
         // Start with preemption disabled until ready
-        __cfaabi_tls.preemption_state.enabled = false;
-        __cfaabi_tls.preemption_state.disable_count = 1;
+        kernelTLS.preemption_state.enabled = false;
+        kernelTLS.preemption_state.disable_count = 1;
 
         // Initialize the event kernel
@@ -454 +359 @@
 // Kernel Signal Handlers
 //=============================================================================================
-struct asm_region {
-        void * before;
-        void * after;
-};
-
-//-----------------------------------------------------------------------------
-// Some assembly required
-#if defined( __i386 )
-        #define __cfaasm_label( label ) \
-                ({ \
-                        struct asm_region region; \
-                        asm( \
-                                "movl $__cfaasm_" #label "_before, %[vb]\n\t" \
-                                "movl $__cfaasm_" #label "_after , %[va]\n\t" \
-                                 : [vb]"=r"(region.before), [vb]"=r"(region.before) \
-                        ); \
-                        region; \
-                });
-#elif defined( __x86_64 )
-        #ifdef __PIC__
-                #define PLT "@PLT"
-        #else
-                #define PLT ""
-        #endif
-        #define __cfaasm_label( label ) \
-                ({ \
-                        struct asm_region region; \
-                        asm( \
-                                "movq $__cfaasm_" #label "_before" PLT ", %[vb]\n\t" \
-                                "movq $__cfaasm_" #label "_after"  PLT ", %[va]\n\t" \
-                                 : [vb]"=r"(region.before), [va]"=r"(region.after) \
-                        ); \
-                        region; \
-                });
-#elif defined( __aarch64__ )
-        #error __cfaasm_label undefined for arm
-#else
-        #error unknown hardware architecture
-#endif
 
 // Context switch signal handler
 // Receives SIGUSR1 signal and causes the current thread to yield
 static void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
-        void * ip = (void *)(cxt->uc_mcontext.CFA_REG_IP);
-        __cfaabi_dbg_debug_do( last_interrupt = ip; )
+        __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.CFA_REG_IP); )
 
         // SKULLDUGGERY: if a thread creates a processor and the immediately deletes it,
@@ -504 +369 @@
         // before the kernel thread has even started running. When that happens, an interrupt
         // with a null 'this_processor' will be caught, just ignore it.
-        if(! __cfaabi_tls.this_processor ) return;
+        if(! kernelTLS.this_processor ) return;
 
         choose(sfp->si_value.sival_int) {
                 case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
-                case PREEMPT_TERMINATE: verify( __atomic_load_n( &__cfaabi_tls.this_processor->do_terminate, __ATOMIC_SEQ_CST ) );
+                case PREEMPT_TERMINATE: verify( __atomic_load_n( &kernelTLS.this_processor->do_terminate, __ATOMIC_SEQ_CST ) );
                 default:
                         abort( "internal error, signal value is %d", sfp->si_value.sival_int );
@@ -516 +381 @@
         if( !preemption_ready() ) { return; }
 
-        struct asm_region region;
-        region = __cfaasm_label( get     ); if( ip >= region.before && ip <= region.after ) return;
-        region = __cfaasm_label( check   ); if( ip >= region.before && ip <= region.after ) return;
-        region = __cfaasm_label( disable ); if( ip >= region.before && ip <= region.after ) return;
-        region = __cfaasm_label( enable  ); if( ip >= region.before && ip <= region.after ) return;
-        region = __cfaasm_label( nopoll  ); if( ip >= region.before && ip <= region.after ) return;
-
-        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p @ %p).\n", __cfaabi_tls.this_processor, __cfaabi_tls.this_thread, (void *)(cxt->uc_mcontext.CFA_REG_IP) );
+        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p @ %p).\n", kernelTLS.this_processor, kernelTLS.this_thread, (void *)(cxt->uc_mcontext.CFA_REG_IP) );
 
         // Sync flag : prevent recursive calls to the signal handler
-        __cfaabi_tls.preemption_state.in_progress = true;
+        kernelTLS.preemption_state.in_progress = true;
 
         // Clear sighandler mask before context switching.
@@ -536 +394 @@
         }
 
+        // TODO: this should go in finish action
         // Clear the in progress flag
-        __cfaabi_tls.preemption_state.in_progress = false;
+        kernelTLS.preemption_state.in_progress = false;
 
         // Preemption can occur here
@@ -554 +413 @@
         id.full_proc = false;
         id.id = doregister(&id);
-        __cfaabi_tls.this_proc_id = &id;
 
         // Block sigalrms to control when they arrive
@@ -600 +458 @@
                         // __cfaabi_dbg_print_safe( "Kernel : Preemption thread tick\n" );
                         lock( event_kernel->lock __cfaabi_dbg_ctx2 );
-                        tick_preemption();
+                        tick_preemption( &id );
                         unlock( event_kernel->lock );
                         break;
@@ -622 +480 @@
 
 void __cfaabi_check_preemption() {
-        bool ready = __preemption_enabled();
+        bool ready = kernelTLS.preemption_state.enabled;
         if(!ready) { abort("Preemption should be ready"); }
 
@@ -645 +503 @@
 #ifdef __CFA_WITH_VERIFY__
 bool __cfaabi_dbg_in_kernel() {
-        return !__preemption_enabled();
+        return !kernelTLS.preemption_state.enabled;
 }
 #endif