Changes in src/libcfa/concurrency/preemption.c [13073be:a83ffa4]

File:

• src/libcfa/concurrency/preemption.c (modified) (4 diffs)

src/libcfa/concurrency/preemption.c

@@ -161 +161 @@
         void disable_interrupts() {
                 with( kernelTLS.preemption_state ) {
-                        static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
-
-                        // Set enabled flag to false
-                        // should be atomic to avoid preemption in the middle of the operation.
-                        // use memory order RELAXED since there is no inter-thread on this variable requirements
-                        __atomic_store_n(&enabled, false, __ATOMIC_RELAXED);
-
-                        // Signal the compiler that a fence is needed but only for signal handlers
-                        __atomic_signal_fence(__ATOMIC_ACQUIRE);
-
+                        enabled = false;
                         __attribute__((unused)) unsigned short new_val = disable_count + 1;
                         disable_count = new_val;
@@ -180 +171 @@
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
-                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic store
+                processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic add
+                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic add
 
                 with( kernelTLS.preemption_state ){
@@ -190 +181 @@
                         // Check if we need to prempt the thread because an interrupt was missed
                         if( prev == 1 ) {
-                                static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
-
-                                // Set enabled flag to true
-                                // should be atomic to avoid preemption in the middle of the operation.
-                                // use memory order RELAXED since there is no inter-thread on this variable requirements
-                                __atomic_store_n(&enabled, true, __ATOMIC_RELAXED);
-
-                                // Signal the compiler that a fence is needed but only for signal handlers
-                                __atomic_signal_fence(__ATOMIC_RELEASE);
+                                enabled = true;
                                 if( proc->pending_preemption ) {
                                         proc->pending_preemption = false;
@@ -217 +200 @@
                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
-                        static_assert(__atomic_always_lock_free(sizeof(kernelTLS.preemption_state.enabled), &kernelTLS.preemption_state.enabled), "Must be lock-free");
-                        // Set enabled flag to true
-                        // should be atomic to avoid preemption in the middle of the operation.
-                        // use memory order RELAXED since there is no inter-thread on this variable requirements
-                        __atomic_store_n(&kernelTLS.preemption_state.enabled, true, __ATOMIC_RELAXED);
-
-                        // Signal the compiler that a fence is needed but only for signal handlers
-                        __atomic_signal_fence(__ATOMIC_RELEASE);
+                        kernelTLS.preemption_state.enabled = true;
                 }
         }