Changeset 4c925cd for libcfa/src/concurrency

Timestamp:

Aug 14, 2020, 11:40:04 AM (5 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:

5715d43, fa5e0112

Parents:

309d814 (diff), badd22f (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 plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

libcfa/src/concurrency

Files:

• invoke.h (modified) (3 diffs)
• kernel/startup.cfa (modified) (2 diffs)
• ready_queue.cfa (modified) (6 diffs)
• ready_subqueue.hfa (modified) (4 diffs)

libcfa/src/concurrency/invoke.h

@@ -26 +26 @@
 #ifndef _INVOKE_H_
 #define _INVOKE_H_
+
+        struct __cfaehm_try_resume_node;
+        struct __cfaehm_base_exception_t;
+        struct exception_context_t {
+                struct __cfaehm_try_resume_node * top_resume;
+                struct __cfaehm_base_exception_t * current_exception;
+        };
 
         struct __stack_context_t {
@@ -51 +58 @@
                 // base of stack
                 void * base;
+
+                // Information for exception handling.
+                struct exception_context_t exception_context;
         };
 
@@ -84 +94 @@
         };
 
-        static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); }
+        static inline struct __stack_t * __get_stack( struct $coroutine * cor ) {
+                return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2));
+        }
 
         // struct which calls the monitor is accepting

libcfa/src/concurrency/kernel/startup.cfa

@@ -516 +516 @@
         ( this.terminated ){ 0 };
         ( this.runner ){};
-        init( this, name, _cltr );
+
+        disable_interrupts();
+                init( this, name, _cltr );
+        enable_interrupts( __cfaabi_dbg_ctx );
 
         __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
@@ -540 +543 @@
         free( this.stack );
 
-        deinit( this );
+        disable_interrupts();
+                deinit( this );
+        enable_interrupts( __cfaabi_dbg_ctx );
 }
 

libcfa/src/concurrency/ready_queue.cfa

@@ -150 +150 @@
 //  queues or removing them.
 uint_fast32_t ready_mutate_lock( void ) with(*__scheduler_lock) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
         // Step 1 : lock global lock
         // It is needed to avoid processors that register mid Critical-Section
@@ -164 +166 @@
         }
 
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         return s;
 }
 
 void ready_mutate_unlock( uint_fast32_t last_s ) with(*__scheduler_lock) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
         // Step 1 : release local locks
         // This must be done while the global lock is held to avoid
@@ -182 +187 @@
         /*paranoid*/ assert(true == lock);
         __atomic_store_n(&lock, (bool)false, __ATOMIC_RELEASE);
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 }
 
@@ -419 +426 @@
         // Actually pop the list
         struct $thread * thrd;
-        bool emptied;
-        [thrd, emptied] = pop(lane);
+        thrd = pop(lane);
 
         /* paranoid */ verify(thrd);
@@ -457 +463 @@
                         if(head(lane)->link.next == thrd) {
                                 $thread * pthrd;
-                                bool emptied;
-                                [pthrd, emptied] = pop(lane);
+                                pthrd = pop(lane);
 
                                 /* paranoid */ verify( pthrd == thrd );
@@ -608 +613 @@
                         while(!is_empty(lanes.data[idx])) {
                                 struct $thread * thrd;
-                                __attribute__((unused)) bool _;
-                                [thrd, _] = pop(lanes.data[idx]);
+                                thrd = pop(lanes.data[idx]);
 
                                 push(cltr, thrd);

libcfa/src/concurrency/ready_subqueue.hfa

@@ -144 +144 @@
 // returns popped
 // returns true of lane was empty before push, false otherwise
-[$thread *, bool] pop(__intrusive_lane_t & this) {
+$thread * pop(__intrusive_lane_t & this) {
         /* paranoid */ verify(this.lock);
         /* paranoid */ verify(this.before.link.ts != 0ul);
@@ -162 +162 @@
         head->link.next = next;
         next->link.prev = head;
-        node->link.[next, prev] = 0p;
+        node->link.next = 0p;
+        node->link.prev = 0p;
 
         // Update head time stamp
@@ -180 +181 @@
                 /* paranoid */ verify(tail(this)->link.prev == head(this));
                 /* paranoid */ verify(head(this)->link.next == tail(this));
-                return [node, true];
+                return node;
         }
         else {
@@ -187 +188 @@
                 /* paranoid */ verify(head(this)->link.next != tail(this));
                 /* paranoid */ verify(this.before.link.ts != 0);
-                return [node, false];
+                return node;
         }
 }