Changes in libcfa/src/concurrency/kernel.hfa [454f478:431cd4f]

File:

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

libcfa/src/concurrency/kernel.hfa

@@ -28 +28 @@
 }
 
-//-----------------------------------------------------------------------------
-// Underlying Locks
 #ifdef __CFA_WITH_VERIFY__
         extern bool __cfaabi_dbg_in_kernel();
 #endif
 
-extern "C" {
-        char * strerror(int);
-}
-#define CHECKED(x) { int err = x; if( err != 0 ) abort("KERNEL ERROR: Operation \"" #x "\" return error %d - %s\n", err, strerror(err)); }
-
-struct __bin_sem_t {
-        pthread_mutex_t         lock;
-        pthread_cond_t          cond;
-        int                     val;
-};
-
-static inline void ?{}(__bin_sem_t & this) with( this ) {
-        // Create the mutex with error checking
-        pthread_mutexattr_t mattr;
-        pthread_mutexattr_init( &mattr );
-        pthread_mutexattr_settype( &mattr, PTHREAD_MUTEX_ERRORCHECK_NP);
-        pthread_mutex_init(&lock, &mattr);
-
-        pthread_cond_init (&cond, (const pthread_condattr_t *)0p);  // workaround trac#208: cast should not be required
-        val = 0;
-}
-
-static inline void ^?{}(__bin_sem_t & this) with( this ) {
-        CHECKED( pthread_mutex_destroy(&lock) );
-        CHECKED( pthread_cond_destroy (&cond) );
-}
-
-static inline void wait(__bin_sem_t & this) with( this ) {
-        verify(__cfaabi_dbg_in_kernel());
-        CHECKED( pthread_mutex_lock(&lock) );
-                while(val < 1) {
-                        pthread_cond_wait(&cond, &lock);
-                }
-                val -= 1;
-        CHECKED( pthread_mutex_unlock(&lock) );
-}
-
-static inline bool post(__bin_sem_t & this) with( this ) {
-        bool needs_signal = false;
-
-        CHECKED( pthread_mutex_lock(&lock) );
-                if(val < 1) {
-                        val += 1;
-                        pthread_cond_signal(&cond);
-                        needs_signal = true;
-                }
-        CHECKED( pthread_mutex_unlock(&lock) );
-
-        return needs_signal;
-}
-
-#undef CHECKED
-
+//-----------------------------------------------------------------------------
+// I/O
+struct cluster;
+struct $io_context;
+struct $io_arbiter;
+
+struct io_context_params {
+        int num_entries;
+};
+
+void  ?{}(io_context_params & this);
 
 //-----------------------------------------------------------------------------
@@ -95 +51 @@
 struct __processor_id_t {
         unsigned id:24;
-        bool full_proc:1;
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -114 +69 @@
         struct cluster * cltr;
 
+        // Ready Queue state per processor
+        struct {
+                unsigned short its;
+                unsigned short itr;
+                unsigned id;
+                unsigned target;
+                unsigned long long int cutoff;
+        } rdq;
+
         // Set to true to notify the processor should terminate
         volatile bool do_terminate;
@@ -125 +89 @@
         // Handle to pthreads
         pthread_t kernel_thread;
+
+        struct {
+                $io_context * ctx;
+                bool pending;
+                bool dirty;
+        } io;
 
         // Preemption data
@@ -134 +104 @@
 
         // Idle lock (kernel semaphore)
-        __bin_sem_t idle;
+        int idle;
 
         // Termination synchronisation (user semaphore)
@@ -144 +114 @@
         // Link lists fields
         DLISTED_MGD_IMPL_IN(processor)
+
+        // special init fields
+        // This is needed for memcached integration
+        // once memcached experiments are done this should probably be removed
+        // it is not a particularly safe scheme as it can make processors less homogeneous
+        struct {
+                $thread * thrd;
+        } init;
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -159 +137 @@
 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)                        { 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}; }
 
 DLISTED_MGD_IMPL_OUT(processor)
 
 //-----------------------------------------------------------------------------
-// I/O
-struct __io_data;
-
-// IO poller user-thread
-// Not using the "thread" keyword because we want to control
-// more carefully when to start/stop it
-struct $io_ctx_thread {
-        struct __io_data * ring;
-        single_sem sem;
-        volatile bool done;
-        $thread self;
-};
-
-
-struct io_context {
-        $io_ctx_thread thrd;
-};
-
-struct io_context_params {
-        int num_entries;
-        int num_ready;
-        int submit_aff;
-        bool eager_submits:1;
-        bool poller_submits:1;
-        bool poll_submit:1;
-        bool poll_complete:1;
-};
-
-void  ?{}(io_context_params & this);
-
-void  ?{}(io_context & this, struct cluster & cl);
-void  ?{}(io_context & this, struct cluster & cl, const io_context_params & params);
-void ^?{}(io_context & this);
-
-struct io_cancellation {
-        __u64 target;
-};
-
-static inline void  ?{}(io_cancellation & this) { this.target = -1u; }
-static inline void ^?{}(io_cancellation &) {}
-bool cancel(io_cancellation & this);
-
-//-----------------------------------------------------------------------------
 // Cluster Tools
 
-// Intrusives lanes which are used by the relaxed ready queue
+// Intrusives lanes which are used by the ready queue
 struct __attribute__((aligned(128))) __intrusive_lane_t;
 void  ?{}(__intrusive_lane_t & this);
 void ^?{}(__intrusive_lane_t & this);
 
-// Counter used for wether or not the lanes are all empty
-struct __attribute__((aligned(128))) __snzi_node_t;
-struct __snzi_t {
-        unsigned mask;
-        int root;
-        __snzi_node_t * nodes;
-};
-
-void  ?{}( __snzi_t & this, unsigned depth );
-void ^?{}( __snzi_t & this );
+// Aligned timestamps which are used by the relaxed ready queue
+struct __attribute__((aligned(128))) __timestamp_t;
+void  ?{}(__timestamp_t & this);
+void ^?{}(__timestamp_t & this);
 
 //TODO adjust cache size to ARCHITECTURE
 // Structure holding the relaxed ready queue
 struct __ready_queue_t {
-        // Data tracking how many/which lanes are used
-        // Aligned to 128 for cache locality
-        __snzi_t snzi;
-
         // Data tracking the actual lanes
         // On a seperate cacheline from the used struct since
@@ -242 +167 @@
                 __intrusive_lane_t * volatile data;
 
+                // Array of times
+                __timestamp_t * volatile tscs;
+
                 // Number of lanes (empty or not)
                 volatile size_t count;
@@ -251 +179 @@
 
 // Idle Sleep
-struct __cluster_idles {
+struct __cluster_proc_list {
         // Spin lock protecting the queue
         volatile uint64_t lock;
@@ -262 +190 @@
 
         // List of idle processors
-        dlist(processor, processor) list;
+        dlist(processor, processor) idles;
+
+        // List of active processors
+        dlist(processor, processor) actives;
 };
 
@@ -278 +209 @@
 
         // List of idle processors
-        __cluster_idles idles;
+        __cluster_proc_list procs;
 
         // List of threads
@@ -292 +223 @@
 
         struct {
-                io_context * ctxs;
-                unsigned cnt;
+                $io_arbiter * arbiter;
+                io_context_params params;
         } io;