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

File:

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

libcfa/src/concurrency/kernel_private.hfa

@@ -77 +77 @@
 //-----------------------------------------------------------------------------
 // I/O
-$io_arbiter * create(void);
-void destroy($io_arbiter *);
+void ^?{}(io_context & this, bool );
 
 //=======================================================================
 // Cluster lock API
 //=======================================================================
+// 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));
+
 // Lock-Free registering/unregistering of threads
 // Register a processor to a given cluster and get its unique id in return
-void register_proc_id( struct __processor_id_t * );
+unsigned doregister( struct __processor_id_t * proc );
 
 // Unregister a processor from a given cluster using its id, getting back the original pointer
-void unregister_proc_id( struct __processor_id_t * proc );
+void     unregister( struct __processor_id_t * proc );
+
+//-----------------------------------------------------------------------
+// Cluster idle lock/unlock
+static inline void lock(__cluster_idles & this) {
+        for() {
+                uint64_t l = this.lock;
+                if(
+                        (0 == (l % 2))
+                        && __atomic_compare_exchange_n(&this.lock, &l, l + 1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
+                ) return;
+                Pause();
+        }
+}
+
+static inline void unlock(__cluster_idles & this) {
+        /* paranoid */ verify( 1 == (this.lock % 2) );
+        __atomic_fetch_add( &this.lock, 1, __ATOMIC_SEQ_CST );
+}
 
 //=======================================================================
@@ -116 +151 @@
         __atomic_store_n(ll, (bool)false, __ATOMIC_RELEASE);
 }
-
-// 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));
 
 //-----------------------------------------------------------------------
@@ -229 +246 @@
 void ready_mutate_unlock( uint_fast32_t /* value returned by lock */ );
 
-//-----------------------------------------------------------------------
-// Lock-Free registering/unregistering of threads
-// Register a processor to a given cluster and get its unique id in return
-// For convenience, also acquires the lock
-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( struct __processor_id_t * proc, uint_fast32_t last_s ) {
-        ready_mutate_unlock( last_s );
-        unregister_proc_id( proc );
-}
-
-//-----------------------------------------------------------------------
-// Cluster idle lock/unlock
-static inline void lock(__cluster_proc_list & this) {
-        /* paranoid */ verify( ! __preemption_enabled() );
-
-        // Start by locking the global RWlock so that we know no-one is
-        // adding/removing processors while we mess with the idle lock
-        ready_schedule_lock();
-
-        // Simple counting lock, acquired, acquired by incrementing the counter
-        // to an odd number
-        for() {
-                uint64_t l = this.lock;
-                if(
-                        (0 == (l % 2))
-                        && __atomic_compare_exchange_n(&this.lock, &l, l + 1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
-                ) return;
-                Pause();
-        }
-
-        /* paranoid */ verify( ! __preemption_enabled() );
-}
-
-static inline void unlock(__cluster_proc_list & this) {
-        /* paranoid */ verify( ! __preemption_enabled() );
-
-        /* paranoid */ verify( 1 == (this.lock % 2) );
-        // Simple couting lock, release by incrementing to an even number
-        __atomic_fetch_add( &this.lock, 1, __ATOMIC_SEQ_CST );
-
-        // Release the global lock, which we acquired when locking
-        ready_schedule_unlock();
-
-        /* paranoid */ verify( ! __preemption_enabled() );
-}
-
 //=======================================================================
 // Ready-Queue API
+//-----------------------------------------------------------------------
+// pop thread from the ready queue of a cluster
+// returns 0p if empty
+__attribute__((hot)) bool query(struct cluster * cltr);
+
 //-----------------------------------------------------------------------
 // push thread onto a ready queue for a cluster
 // returns true if the list was previously empty, false otherwise
-__attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd);
-
-//-----------------------------------------------------------------------
-// pop thread from the local queues of a cluster
+__attribute__((hot)) bool push(struct cluster * cltr, struct $thread * thrd);
+
+//-----------------------------------------------------------------------
+// pop thread from the ready queue of a cluster
 // returns 0p if empty
 // May return 0p spuriously
-__attribute__((hot)) struct $thread * pop_fast(struct cluster * cltr);
-
-//-----------------------------------------------------------------------
-// pop thread from any ready queue of a cluster
-// returns 0p if empty
-// May return 0p spuriously
-__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr);
-
-//-----------------------------------------------------------------------
-// search all ready queues of a cluster for any thread
+__attribute__((hot)) struct $thread * pop(struct cluster * cltr);
+
+//-----------------------------------------------------------------------
+// pop thread from the ready queue of a cluster
 // returns 0p if empty
 // guaranteed to find any threads added before this call
-__attribute__((hot)) struct $thread * pop_search(struct cluster * cltr);
+__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr);
+
+//-----------------------------------------------------------------------
+// remove thread from the ready queue of a cluster
+// returns bool if it wasn't found
+bool remove_head(struct cluster * cltr, struct $thread * thrd);
 
 //-----------------------------------------------------------------------
 // Increase the width of the ready queue (number of lanes) by 4
-void ready_queue_grow  (struct cluster * cltr);
+void ready_queue_grow  (struct cluster * cltr, int target);
 
 //-----------------------------------------------------------------------
 // Decrease the width of the ready queue (number of lanes) by 4
-void ready_queue_shrink(struct cluster * cltr);
+void ready_queue_shrink(struct cluster * cltr, int target);