Changeset a362f97 for src/libcfa/concurrency/kernel

Timestamp:

Jan 27, 2017, 3:27:34 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

c0aa336

Parents:

6acb935 (diff), 0a86a30 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

File:

• src/libcfa/concurrency/kernel (modified) (1 diff)

src/libcfa/concurrency/kernel

@@ -20 +20 @@
 #include <stdbool.h>
 
+#include "invoke.h"
+
+extern "C" {
+#include <pthread.h>
+}
+
+//-----------------------------------------------------------------------------
+// Cluster
+struct cluster {
+        simple_thread_list ready_queue;
+        pthread_spinlock_t lock;
+};
+
+void ?{}(cluster * this);
+void ^?{}(cluster * this);
+
+//-----------------------------------------------------------------------------
+// Processor
 struct processor {
-        struct proc_coroutine * cor;
-        unsigned int thread_index;
-        unsigned int thread_count;
-        struct thread_h * threads[10];
-        bool terminated;
+        struct processorCtx_t * ctx;
+        cluster * cltr;
+        coroutine * current_coroutine;
+        thread * current_thread;
+        pthread_t kernel_thread;
+        simple_lock lock;
+        volatile bool terminated;
 };
 
 void ?{}(processor * this);
+void ?{}(processor * this, cluster * cltr);
 void ^?{}(processor * this);
 
-void scheduler_add( struct thread_h * thrd );
-void scheduler_remove( struct thread_h * thrd );
-void kernel_run( void );
+
+//-----------------------------------------------------------------------------
+// Locks
+
+void ?{}(simple_lock * this);
+void ^?{}(simple_lock * this);
+
+void lock( simple_lock * );
+void unlock( simple_lock * );
+
+struct pthread_spinlock_guard {
+        pthread_spinlock_t * lock;
+};
+
+static inline void ?{}( pthread_spinlock_guard * this, pthread_spinlock_t * lock ) {
+        this->lock = lock;
+        pthread_spin_lock( this->lock );
+}
+
+static inline void ^?{}( pthread_spinlock_guard * this ) {
+        pthread_spin_unlock( this->lock );
+}
+
+// //Simple spinlock implementation from 
+// //http://stackoverflow.com/questions/1383363/is-my-spin-lock-implementation-correct-and-optimal
+// //Not optimal but correct
+// #define VOL 
+
+// struct simple_spinlock {
+//      VOL int lock;
+// };
+
+// extern VOL int __sync_lock_test_and_set( VOL int *, VOL int);
+// extern void __sync_synchronize();
+
+// static inline void lock( simple_spinlock * this ) {
+//     while (__sync_lock_test_and_set(&this->lock, 1)) {
+//         // Do nothing. This GCC builtin instruction
+//         // ensures memory barrier.
+//     }
+// }
+
+// static inline void unlock( simple_spinlock * this ) {
+//     __sync_synchronize(); // Memory barrier.
+//     this->lock = 0;
+// }
 
 #endif //KERNEL_H