Changes in libcfa/src/concurrency/kernel_private.hfa [c993b15:fc59df78]

File:

• libcfa/src/concurrency/kernel_private.hfa (modified) (9 diffs)

libcfa/src/concurrency/kernel_private.hfa

@@ -25 +25 @@
 // Scheduler
 
+struct __attribute__((aligned(128))) __scheduler_lock_id_t;
 
 extern "C" {
         void disable_interrupts() OPTIONAL_THREAD;
-        void enable_interrupts( bool poll = true );
-}
-
-void schedule_thread$( $thread * ) __attribute__((nonnull (1)));
+        void enable_interrupts_noPoll();
+        void enable_interrupts( __cfaabi_dbg_ctx_param );
+}
+
+void __schedule_thread( $thread * )
+#if defined(NDEBUG) || (!defined(__CFA_DEBUG__) && !defined(__CFA_VERIFY__))
+        __attribute__((nonnull (1)))
+#endif
+;
 
 extern bool __preemption_enabled();
@@ -79 +85 @@
 // Lock-Free registering/unregistering of threads
 // Register a processor to a given cluster and get its unique id in return
-unsigned register_proc_id( void );
+void register_proc_id( struct __processor_id_t * );
 
 // Unregister a processor from a given cluster using its id, getting back the original pointer
-void unregister_proc_id( unsigned );
+void unregister_proc_id( struct __processor_id_t * proc );
 
 //=======================================================================
@@ -111 +117 @@
 }
 
-
-
-
+// Cells use by the reader writer lock
+// while not generic it only relies on a opaque pointer
+struct __attribute__((aligned(128))) __scheduler_lock_id_t {
+        // Spin lock used as the underlying lock
+        volatile bool lock;
+
+        // Handle pointing to the proc owning this cell
+        // Used for allocating cells and debugging
+        __processor_id_t * volatile handle;
+
+        #ifdef __CFA_WITH_VERIFY__
+                // Debug, check if this is owned for reading
+                bool owned;
+        #endif
+};
+
+static_assert( sizeof(struct __scheduler_lock_id_t) <= __alignof(struct __scheduler_lock_id_t));
 
 //-----------------------------------------------------------------------
@@ -132 +152 @@
 
         // writer lock
-        volatile bool write_lock;
+        volatile bool lock;
 
         // data pointer
-        volatile bool * volatile * data;
+        __scheduler_lock_id_t * data;
 };
 
@@ -148 +168 @@
 static inline void ready_schedule_lock(void) with(*__scheduler_lock) {
         /* paranoid */ verify( ! __preemption_enabled() );
-        /* paranoid */ verify( ! kernelTLS().in_sched_lock );
-        /* paranoid */ verify( data[kernelTLS().sched_id] == &kernelTLS().sched_lock );
-        /* paranoid */ verify( !kernelTLS().this_processor || kernelTLS().this_processor->unique_id == kernelTLS().sched_id );
+        /* paranoid */ verify( kernelTLS().this_proc_id );
+
+        unsigned iproc = kernelTLS().this_proc_id->id;
+        /*paranoid*/ verify(data[iproc].handle == kernelTLS().this_proc_id);
+        /*paranoid*/ verify(iproc < ready);
 
         // Step 1 : make sure no writer are in the middle of the critical section
-        while(__atomic_load_n(&write_lock, (int)__ATOMIC_RELAXED))
+        while(__atomic_load_n(&lock, (int)__ATOMIC_RELAXED))
                 Pause();
 
@@ -162 +184 @@
 
         // Step 2 : acquire our local lock
-        __atomic_acquire( &kernelTLS().sched_lock );
-        /*paranoid*/ verify(kernelTLS().sched_lock);
+        __atomic_acquire( &data[iproc].lock );
+        /*paranoid*/ verify(data[iproc].lock);
 
         #ifdef __CFA_WITH_VERIFY__
                 // Debug, check if this is owned for reading
-                kernelTLS().in_sched_lock = true;
+                data[iproc].owned = true;
         #endif
 }
@@ -173 +195 @@
 static inline void ready_schedule_unlock(void) with(*__scheduler_lock) {
         /* paranoid */ verify( ! __preemption_enabled() );
-        /* paranoid */ verify( data[kernelTLS().sched_id] == &kernelTLS().sched_lock );
-        /* paranoid */ verify( !kernelTLS().this_processor || kernelTLS().this_processor->unique_id == kernelTLS().sched_id );
-        /* paranoid */ verify( kernelTLS().sched_lock );
-        /* paranoid */ verify( kernelTLS().in_sched_lock );
+        /* paranoid */ verify( kernelTLS().this_proc_id );
+
+        unsigned iproc = kernelTLS().this_proc_id->id;
+        /*paranoid*/ verify(data[iproc].handle == kernelTLS().this_proc_id);
+        /*paranoid*/ verify(iproc < ready);
+        /*paranoid*/ verify(data[iproc].lock);
+        /*paranoid*/ verify(data[iproc].owned);
         #ifdef __CFA_WITH_VERIFY__
                 // Debug, check if this is owned for reading
-                kernelTLS().in_sched_lock = false;
+                data[iproc].owned = false;
         #endif
-        __atomic_unlock(&kernelTLS().sched_lock);
+        __atomic_unlock(&data[iproc].lock);
 }
 
@@ -187 +212 @@
         static inline bool ready_schedule_islocked(void) {
                 /* paranoid */ verify( ! __preemption_enabled() );
-                /* paranoid */ verify( (!kernelTLS().in_sched_lock) || kernelTLS().sched_lock );
-                return kernelTLS().sched_lock;
+                /*paranoid*/ verify( kernelTLS().this_proc_id );
+                __processor_id_t * proc = kernelTLS().this_proc_id;
+                return __scheduler_lock->data[proc->id].owned;
         }
 
         static inline bool ready_mutate_islocked() {
-                return __scheduler_lock->write_lock;
+                return __scheduler_lock->lock;
         }
 #endif
@@ -207 +233 @@
 // Register a processor to a given cluster and get its unique id in return
 // For convenience, also acquires the lock
-static inline [unsigned, uint_fast32_t] ready_mutate_register() {
-        unsigned id = register_proc_id();
-        uint_fast32_t last = ready_mutate_lock();
-        return [id, last];
+static inline uint_fast32_t ready_mutate_register( struct __processor_id_t * proc ) {
+        register_proc_id( proc );
+        return ready_mutate_lock();
 }
 
 // Unregister a processor from a given cluster using its id, getting back the original pointer
 // assumes the lock is acquired
-static inline void ready_mutate_unregister( unsigned id, uint_fast32_t last_s ) {
+static inline void ready_mutate_unregister( struct __processor_id_t * proc, uint_fast32_t last_s ) {
         ready_mutate_unlock( last_s );
-        unregister_proc_id( id );
+        unregister_proc_id( proc );
 }