Changes in libcfa/src/concurrency/kernel.hfa [92e7631:d4e68a6]

File:

• libcfa/src/concurrency/kernel.hfa (modified) (13 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 : Tue Feb  4 12:29:26 2020
-// Update Count     : 22
+// Last Modified On : Sat Jun 22 11:39:17 2019
+// Update Count     : 16
 //
 
@@ -20 +20 @@
 #include "invoke.h"
 #include "time_t.hfa"
-#include "coroutine.hfa"
 
 extern "C" {
@@ -32 +31 @@
         __spinlock_t lock;
         int count;
-        __queue_t($thread) waiting;
+        __queue_t(thread_desc) waiting;
 };
 
@@ -38 +37 @@
 void ^?{}(semaphore & this);
 void   P (semaphore & this);
-bool   V (semaphore & this);
+void   V (semaphore & this);
 
 
@@ -44 +43 @@
 // Processor
 extern struct cluster * mainCluster;
+
+enum FinishOpCode { No_Action, Release, Schedule, Release_Schedule, Release_Multi, Release_Multi_Schedule, Callback };
+
+typedef void (*__finish_callback_fptr_t)(void);
+
+//TODO use union, many of these fields are mutually exclusive (i.e. MULTI vs NOMULTI)
+struct FinishAction {
+        FinishOpCode action_code;
+        /*
+        // Union of possible actions
+        union {
+                // Option 1 : locks and threads
+                struct {
+                        // 1 thread or N thread
+                        union {
+                                thread_desc * thrd;
+                                struct {
+                                        thread_desc ** thrds;
+                                        unsigned short thrd_count;
+                                };
+                        };
+                        // 1 lock or N lock
+                        union {
+                                __spinlock_t * lock;
+                                struct {
+                                        __spinlock_t ** locks;
+                                        unsigned short lock_count;
+                                };
+                        };
+                };
+                // Option 2 : action pointer
+                __finish_callback_fptr_t callback;
+        };
+        /*/
+        thread_desc * thrd;
+        thread_desc ** thrds;
+        unsigned short thrd_count;
+        __spinlock_t * lock;
+        __spinlock_t ** locks;
+        unsigned short lock_count;
+        __finish_callback_fptr_t callback;
+        //*/
+};
+static inline void ?{}(FinishAction & this) {
+        this.action_code = No_Action;
+        this.thrd = NULL;
+        this.lock = NULL;
+}
+static inline void ^?{}(FinishAction &) {}
 
 // Processor
@@ -67 +115 @@
         // RunThread data
         // Action to do after a thread is ran
-        $thread * destroyer;
+        struct FinishAction finish;
 
         // Preemption data
@@ -76 +124 @@
         bool pending_preemption;
 
-        // Idle lock (kernel semaphore)
-        __bin_sem_t idle;
+        // Idle lock
+        __bin_sem_t idleLock;
 
         // Termination
@@ -83 +131 @@
         volatile bool do_terminate;
 
-        // Termination synchronisation (user semaphore)
+        // Termination synchronisation
         semaphore terminated;
-
-        // pthread Stack
-        void * stack;
 
         // Link lists fields
@@ -101 +146 @@
 };
 
-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 [processor *&, processor *& ] __get( processor & this ) __attribute__((const)) { return this.node.[next, prev]; }
+static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
+
+static inline [processor *&, processor *& ] __get( processor & this ) {
+        return this.node.[next, prev];
+}
 
 //-----------------------------------------------------------------------------
@@ -117 +164 @@
 
         // Ready queue for threads
-        __queue_t($thread) ready_queue;
+        __queue_t(thread_desc) ready_queue;
 
         // Name of the cluster
@@ -126 +173 @@
 
         // List of processors
-        __spinlock_t idle_lock;
+        __spinlock_t proc_list_lock;
         __dllist_t(struct processor) procs;
         __dllist_t(struct processor) idles;
@@ -133 +180 @@
         // List of threads
         __spinlock_t thread_list_lock;
-        __dllist_t(struct $thread) threads;
+        __dllist_t(struct thread_desc) threads;
         unsigned int nthreads;
 
@@ -144 +191 @@
 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 [cluster *&, cluster *& ] __get( cluster & this ) __attribute__((const)) { return this.node.[next, prev]; }
+static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
+
+static inline [cluster *&, cluster *& ] __get( cluster & this ) {
+        return this.node.[next, prev];
+}
 
 static inline struct processor * active_processor() { return TL_GET( this_processor ); } // UNSAFE