Changes in libcfa/src/concurrency/locks.cfa [e84ab3d:43784ac]

File:

• libcfa/src/concurrency/locks.cfa (modified) (14 diffs)

libcfa/src/concurrency/locks.cfa

@@ -28 +28 @@
 forall(L & | is_blocking_lock(L)) {
         struct info_thread {
-                // used to put info_thread on a dl queue
-                inline dlink(info_thread(L));
+                // used to put info_thread on a dl queue (aka sequence)
+                inline Seqable;
 
                 // waiting thread
-                struct thread$ * t;
+                struct $thread * t;
 
                 // shadow field
@@ -43 +43 @@
                 bool signalled;
         };
-        P9_EMBEDDED( info_thread(L), dlink(info_thread(L)) )
-
-        void ?{}( info_thread(L) & this, thread$ * t, uintptr_t info, L * l ) {
+
+        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info, L * l ) {
+                ((Seqable &) this){};
                 this.t = t;
                 this.info = info;
@@ -52 +52 @@
 
         void ^?{}( info_thread(L) & this ) {}
+
+        info_thread(L) *& Back( info_thread(L) * this ) {
+                return (info_thread(L) *)Back( (Seqable *)this );
+        }
+
+        info_thread(L) *& Next( info_thread(L) * this ) {
+                return (info_thread(L) *)Next( (Colable *)this );
+        }
 }
 
@@ -71 +79 @@
 void lock( blocking_lock & this ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
-        thread$ * thrd = active_thread();
+        $thread * thrd = active_thread();
 
         // single acquisition lock is held by current thread
@@ -78 +86 @@
         // lock is held by some other thread
         if ( owner != 0p && owner != thrd ) {
-                insert_last( blocked_threads, *thrd );
+                addTail( blocked_threads, *thrd );
                 wait_count++;
                 unlock( lock );
@@ -117 +125 @@
 
 void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
-        thread$ * t = &try_pop_front( blocked_threads );
+        $thread * t = &dropHead( blocked_threads );
         owner = t;
         recursion_count = ( t ? 1 : 0 );
@@ -142 +150 @@
 }
 
-void on_notify( blocking_lock & this, thread$ * t ) with( this ) {
+void on_notify( blocking_lock & this, $thread * t ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
         // lock held
         if ( owner != 0p ) {
-                insert_last( blocked_threads, *t );
+                addTail( blocked_threads, *t );
                 wait_count++;
                 unlock( lock );
@@ -199 +207 @@
                 //      may still be called after a thread has been removed from the queue but
                 //      before the alarm is unregistered
-                if ( (*info_thd)`isListed ) {   // is thread on queue
+                if ( listed(info_thd) ) {       // is thread on queue
                         info_thd->signalled = false;
                         // remove this thread O(1)
-                        remove( *info_thd );
+                        remove( cond->blocked_threads, *info_thd );
                         cond->count--;
                         if( info_thd->lock ) {
@@ -247 +255 @@
         bool notify_one( condition_variable(L) & this ) with( this ) {
                 lock( lock __cfaabi_dbg_ctx2 );
-                bool ret = ! blocked_threads`isEmpty;
-                process_popped(this, try_pop_front( blocked_threads ));
+                bool ret = !empty(blocked_threads);
+                process_popped(this, dropHead( blocked_threads ));
                 unlock( lock );
                 return ret;
@@ -255 +263 @@
         bool notify_all( condition_variable(L) & this ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
-                bool ret = ! blocked_threads`isEmpty;
-                while( ! blocked_threads`isEmpty ) {
-                        process_popped(this, try_pop_front( blocked_threads ));
+                bool ret = !empty(blocked_threads);
+                while( !empty(blocked_threads) ) {
+                        process_popped(this, dropHead( blocked_threads ));
                 }
                 unlock( lock );
@@ -264 +272 @@
 
         uintptr_t front( condition_variable(L) & this ) with(this) {
-                return blocked_threads`isEmpty ? NULL : blocked_threads`first.info;
+                return empty(blocked_threads) ? NULL : head(blocked_threads).info;
         }
 
         bool empty( condition_variable(L) & this ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
-                bool ret = blocked_threads`isEmpty;
+                bool ret = empty(blocked_threads);
                 unlock( lock );
                 return ret;
@@ -278 +286 @@
         size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
                 // add info_thread to waiting queue
-                insert_last( blocked_threads, *i );
+                addTail( blocked_threads, *i );
                 count++;
                 size_t recursion_count = 0;
@@ -366 +374 @@
 }
 
-thread$ * V (semaphore & this, const bool doUnpark ) with( this ) {
-        thread$ * thrd = 0p;
+$thread * V (semaphore & this, const bool doUnpark ) with( this ) {
+        $thread * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;
@@ -384 +392 @@
 
 bool V(semaphore & this) with( this ) {
-        thread$ * thrd = V(this, true);
+        $thread * thrd = V(this, true);
         return thrd != 0p;
 }
 
 bool V(semaphore & this, unsigned diff) with( this ) {
-        thread$ * thrd = 0p;
+        $thread * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         int release = max(-count, (int)diff);