Changes in libcfa/src/concurrency/kernel.hfa [dca5802:e3fea42]

File:

• libcfa/src/concurrency/kernel.hfa (modified) (6 diffs)

libcfa/src/concurrency/kernel.hfa

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec  4 07:54:51 2019
-// Update Count     : 18
+// Last Modified On : Tue Feb  4 12:29:26 2020
+// Update Count     : 22
 //
 
@@ -107 +107 @@
         // Cluster from which to get threads
         struct cluster * cltr;
-        unsigned int id;
 
         // Name of the processor
@@ -151 +150 @@
 };
 
-void  ?{}(processor & this, const char * name, struct cluster & cltr);
+void  ?{}(processor & this, const char name[], struct cluster & cltr);
 void ^?{}(processor & this);
 
 static inline void  ?{}(processor & this)                    { this{ "Anonymous Processor", *mainCluster}; }
 static inline void  ?{}(processor & this, struct cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
-static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
+static inline void  ?{}(processor & this, const char name[]) { this{name, *mainCluster }; }
 
 static inline [processor *&, processor *& ] __get( processor & this ) {
         return this.node.[next, prev];
 }
-
-
-//-----------------------------------------------------------------------------
-// Cluster Tools
-
-// Cells use by the reader writer lock
-// while not generic it only relies on a opaque pointer
-struct __processor_id;
-
-// Reader-Writer lock protecting the ready-queue
-// while this lock is mostly generic some aspects
-// have been hard-coded to for the ready-queue for
-// simplicity and performance
-struct __clusterRWLock_t {
-        // total cachelines allocated
-        unsigned int max;
-
-        // cachelines currently in use
-        volatile unsigned int alloc;
-
-        // cachelines ready to itereate over
-        // (!= to alloc when thread is in second half of doregister)
-        volatile unsigned int ready;
-
-        // writer lock
-        volatile bool lock;
-
-        // data pointer
-        __processor_id * data;
-};
-
-void  ?{}(__clusterRWLock_t & this);
-void ^?{}(__clusterRWLock_t & this);
-
-// Intrusives lanes which are used by the relaxed ready queue
-struct __attribute__((aligned(128))) __intrusive_lane_t {
-        // spin lock protecting the queue
-        volatile bool lock;
-
-        // anchor for the head and the tail of the queue
-        struct __sentinel_t {
-                // Link lists fields
-                // instrusive link field for threads
-                // must be exactly as in thread_desc
-                __thread_desc_link link;
-        } before, after;
-
-#if defined(__CFA_WITH_VERIFY__)
-        // id of last processor to acquire the lock
-        // needed only to check for mutual exclusion violations
-        unsigned int last_id;
-
-        // number of items on this list
-        // needed only to check for deadlocks
-        unsigned int count;
-#endif
-
-        // Optional statistic counters
-        #if !defined(__CFA_NO_SCHED_STATS__)
-                struct __attribute__((aligned(64))) {
-                        // difference between number of push and pops
-                        ssize_t diff;
-
-                        // total number of pushes and pops
-                        size_t  push;
-                        size_t  pop ;
-                } stat;
-        #endif
-};
-
-void  ?{}(__intrusive_lane_t & this);
-void ^?{}(__intrusive_lane_t & this);
-
-typedef unsigned long long __cfa_readyQ_mask_t;
-
-// enum {
-//      __cfa_ready_queue_mask_size = (64 - sizeof(size_t)) / sizeof(size_t),
-//      __cfa_max_ready_queues = __cfa_ready_queue_mask_size * 8 * sizeof(size_t)
-// };
-
-#define __cfa_lane_mask_size ((64 - sizeof(size_t)) / sizeof(__cfa_readyQ_mask_t))
-#define __cfa_max_lanes (__cfa_lane_mask_size * 8 * sizeof(__cfa_readyQ_mask_t))
-
-//TODO adjust cache size to ARCHITECTURE
-// Structure holding the relaxed ready queue
-struct __attribute__((aligned(128))) __ready_queue_t {
-        // Data tracking how many/which lanes are used
-        // Aligned to 128 for cache locality
-        struct {
-                // number of non-empty lanes
-                volatile size_t count;
-
-                // bit mask, set bits indentify which lanes are non-empty
-                volatile __cfa_readyQ_mask_t mask[ __cfa_lane_mask_size ];
-        } used;
-
-        // Data tracking the actual lanes
-        // On a seperate cacheline from the used struct since
-        // used can change on each push/pop but this data
-        // only changes on shrink/grow
-        struct __attribute__((aligned(64))) {
-                // Arary of lanes
-                __intrusive_lane_t * volatile data;
-
-                // Number of lanes (empty or not)
-                volatile size_t count;
-        } lanes;
-
-        // Statistics
-        #if !defined(__CFA_NO_STATISTICS__)
-                __attribute__((aligned(64))) struct {
-                        struct {
-                                // Push statistic
-                                struct {
-                                        // number of attemps at pushing something
-                                        volatile size_t attempt;
-
-                                        // number of successes at pushing
-                                        volatile size_t success;
-                                } push;
-
-                                // Pop statistic
-                                struct {
-                                        // number of reads of the mask
-                                        // picking an empty __cfa_readyQ_mask_t counts here
-                                        // but not as an attempt
-                                        volatile size_t maskrds;
-
-                                        // number of attemps at poping something
-                                        volatile size_t attempt;
-
-                                        // number of successes at poping
-                                        volatile size_t success;
-                                } pop;
-                        } pick;
-
-                        // stats on the "used" struct of the queue
-                        // tracks average number of queues that are not empty
-                        // when pushing / poping
-                        struct {
-                                volatile size_t value;
-                                volatile size_t count;
-                        } used;
-                } global_stats;
-
-        #endif
-};
-
-void  ?{}(__ready_queue_t & this);
-void ^?{}(__ready_queue_t & this);
 
 //-----------------------------------------------------------------------------
@@ -316 +165 @@
 struct cluster {
         // Ready queue locks
-        __clusterRWLock_t ready_lock;
+        __spinlock_t ready_queue_lock;
 
         // Ready queue for threads
-        __ready_queue_t ready_queue;
+        __queue_t(thread_desc) ready_queue;
 
         // Name of the cluster
@@ -329 +178 @@
         // List of processors
         __spinlock_t proc_list_lock;
+        __dllist_t(struct processor) procs;
         __dllist_t(struct processor) idles;
+        unsigned int nprocessors;
 
         // List of threads
@@ -344 +195 @@
 extern Duration default_preemption();
 
-void ?{} (cluster & this, const char * name, Duration preemption_rate);
+void ?{} (cluster & this, const char name[], Duration preemption_rate);
 void ^?{}(cluster & this);
 
 static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
 static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
-static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
+static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
 
 static inline [cluster *&, cluster *& ] __get( cluster & this ) {