Changeset e0f93e0

Timestamp:

Jul 30, 2020, 2:57:36 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

f00b26d4

Parents:

22ddade

Message:

Added single_sem type, which effectively extends park/unpark logic for cases where extra unparks would have been acceptable.

File:

• libcfa/src/bits/locks.hfa (modified) (1 diff)

libcfa/src/bits/locks.hfa

@@ -164 +164 @@
 
         #undef CHECKED
+
+        struct $thread;
+        extern void park( __cfaabi_dbg_ctx_param );
+        extern void unpark( struct $thread * this __cfaabi_dbg_ctx_param2 );
+        static inline struct $thread * active_thread ();
+
+        // Semaphore which only supports a single thread
+        struct single_sem {
+                struct $thread * volatile ptr;
+        };
+
+        static inline {
+                void  ?{}(single_sem & this) {
+                        this.ptr = 0p;
+                }
+
+                void ^?{}(single_sem & this) {}
+
+                bool wait(single_sem & this) {
+                        for() {
+                                struct $thread * expected = this.ptr;
+                                if(expected == 1p) {
+                                        if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                                return false;
+                                        }
+                                }
+                                else {
+                                        /* paranoid */ verify( expected == 0p );
+                                        if(__atomic_compare_exchange_n(&this.ptr, &expected, active_thread(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                                park( __cfaabi_dbg_ctx );
+                                                return true;
+                                        }
+                                }
+
+                        }
+                }
+
+                bool post(single_sem & this) {
+                        for() {
+                                struct $thread * expected = this.ptr;
+                                if(expected == 1p) return false;
+                                if(expected == 0p) {
+                                        if(__atomic_compare_exchange_n(&this.ptr, &expected, 1p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                                return false;
+                                        }
+                                }
+                                else {
+                                        if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                                unpark( expected __cfaabi_dbg_ctx2 );
+                                                return true;
+                                        }
+                                }
+                        }
+                }
+        }
 #endif