Changeset 1756e08

Timestamp:

Sep 29, 2022, 11:33:03 AM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master

Children:

5f9c42b

Parents:

a659b31

Message:

Added some defensive programming to work around parsing bug

Location:

libcfa/src/concurrency

Files:

• alarm.cfa (modified) (5 diffs)
• alarm.hfa (modified) (1 diff)
• io.cfa (modified) (6 diffs)
• io/types.hfa (modified) (1 diff)
• kernel/cluster.cfa (modified) (2 diffs)
• preemption.cfa (modified) (3 diffs)
• ready_queue.cfa (modified) (2 diffs)

libcfa/src/concurrency/alarm.cfa

@@ -55 +55 @@
         this.period  = period;
         this.thrd = thrd;
-        this.timeval = __kernel_get_time() + alarm;
+        this.deadline = __kernel_get_time() + alarm;
         set = false;
         type = User;
@@ -64 +64 @@
         this.period  = period;
         this.proc = proc;
-        this.timeval = __kernel_get_time() + alarm;
+        this.deadline = __kernel_get_time() + alarm;
         set = false;
         type = Kernel;
@@ -72 +72 @@
         this.initial = alarm;
         this.period  = period;
-        this.timeval = __kernel_get_time() + alarm;
+        this.deadline = __kernel_get_time() + alarm;
         set = false;
         type = Callback;
@@ -85 +85 @@
 void insert( alarm_list_t * this, alarm_node_t * n ) {
         alarm_node_t * it = & (*this)`first;
-        while( it && (n->timeval > it->timeval) ) {
+        while( it && (n->deadline > it->deadline) ) {
                 it = & (*it)`next;
         }
@@ -116 +116 @@
 
                 Time curr = __kernel_get_time();
-                __cfadbg_print_safe( preemption, " KERNEL: alarm inserting %p (%lu -> %lu).\n", this, curr.tn, this->timeval.tn );
+                __cfadbg_print_safe( preemption, " KERNEL: alarm inserting %p (%lu -> %lu).\n", this, curr.tn, this->deadline.tn );
                 insert( &alarms, this );
-                __kernel_set_timer( this->timeval - curr);
+                __kernel_set_timer( this->deadline - curr);
                 this->set = true;
         }

libcfa/src/concurrency/alarm.hfa

@@ -57 +57 @@
         };
 
-        Time timeval;           // actual time at which the alarm goes off
+        Time deadline;          // actual time at which the alarm goes off
         enum alarm_type type;   // true if this is not a user defined alarm
         bool set                :1;     // whether or not the alarm has be registered

libcfa/src/concurrency/io.cfa

@@ -206 +206 @@
         }
 
-        bool __cfa_io_drain( processor * proc ) {
+        bool __cfa_io_drain( struct processor * proc ) {
                 bool local = false;
                 bool remote = false;
@@ -273 +273 @@
         }
 
-        bool __cfa_io_flush( processor * proc ) {
+        bool __cfa_io_flush( struct processor * proc ) {
                 /* paranoid */ verify( ! __preemption_enabled() );
                 /* paranoid */ verify( proc );
@@ -353 +353 @@
 
                 disable_interrupts();
-                processor * proc = __cfaabi_tls.this_processor;
+                struct processor * proc = __cfaabi_tls.this_processor;
                 io_context$ * ctx = proc->io.ctx;
                 /* paranoid */ verify( __cfaabi_tls.this_processor );
@@ -433 +433 @@
                 disable_interrupts();
                 __STATS__( true, if(!lazy) io.submit.eagr += 1; )
-                processor * proc = __cfaabi_tls.this_processor;
+                struct processor * proc = __cfaabi_tls.this_processor;
                 io_context$ * ctx = proc->io.ctx;
                 /* paranoid */ verify( __cfaabi_tls.this_processor );
@@ -641 +641 @@
 
         #if defined(CFA_WITH_IO_URING_IDLE)
-                bool __kernel_read(processor * proc, io_future_t & future, iovec & iov, int fd) {
+                bool __kernel_read(struct processor * proc, io_future_t & future, iovec & iov, int fd) {
                         io_context$ * ctx = proc->io.ctx;
                         /* paranoid */ verify( ! __preemption_enabled() );
@@ -692 +692 @@
                 }
 
-                void __cfa_io_idle( processor * proc ) {
+                void __cfa_io_idle( struct processor * proc ) {
                         iovec iov;
                         __atomic_acquire( &proc->io.ctx->cq.lock );

libcfa/src/concurrency/io/types.hfa

@@ -127 +127 @@
         struct __attribute__((aligned(64))) io_context$ {
                 io_arbiter$ * arbiter;
-                processor * proc;
+                struct processor * proc;
 
                 __outstanding_io_queue ext_sq;

libcfa/src/concurrency/kernel/cluster.cfa

@@ -254 +254 @@
 }
 
-static void assign_list(unsigned & valrq, unsigned & valio, dlist(processor) & list, unsigned count) {
-        processor * it = &list`first;
+static void assign_list(unsigned & valrq, unsigned & valio, dlist(struct processor) & list, unsigned count) {
+        struct processor * it = &list`first;
         for(unsigned i = 0; i < count; i++) {
                 /* paranoid */ verifyf( it, "Unexpected null iterator, at index %u of %u\n", i, count);
@@ -278 +278 @@
 
 #if defined(CFA_HAVE_LINUX_IO_URING_H)
-        static void assign_io(io_context$ ** data, size_t count, dlist(processor) & list) {
-                processor * it = &list`first;
+        static void assign_io(io_context$ ** data, size_t count, dlist(struct processor) & list) {
+                struct processor * it = &list`first;
                 while(it) {
                         /* paranoid */ verifyf( it, "Unexpected null iterator\n");

libcfa/src/concurrency/preemption.cfa

@@ -104 +104 @@
 static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) {
         if( ! & (*alarms)`first ) return 0p;                                            // If no alarms return null
-        if( (*alarms)`first.timeval >= currtime ) return 0p;    // If alarms head not expired return null
+        if( (*alarms)`first.deadline >= currtime ) return 0p;   // If alarms head not expired return null
         return pop(alarms);                                                                     // Otherwise just pop head
 }
@@ -140 +140 @@
                 if( period > 0 ) {
                         __cfadbg_print_buffer_local( preemption, " KERNEL: alarm period is %lu.\n", period`ns );
-                        node->timeval = currtime + period;  // Alarm is periodic, add currtime to it (used cached current time)
+                        node->deadline = currtime + period;  // Alarm is periodic, add currtime to it (used cached current time)
                         insert( alarms, node );             // Reinsert the node for the next time it triggers
                 }
@@ -147 +147 @@
         // If there are still alarms pending, reset the timer
         if( & (*alarms)`first ) {
-                Duration delta = (*alarms)`first.timeval - currtime;
+                Duration delta = (*alarms)`first.deadline - currtime;
                 __kernel_set_timer( delta );
         }

libcfa/src/concurrency/ready_queue.cfa

@@ -62 +62 @@
 //-----------------------------------------------------------------------
 __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, unpark_hint hint) with (cltr->sched) {
-        processor * const proc = kernelTLS().this_processor;
+        struct processor * const proc = kernelTLS().this_processor;
         const bool external = (!proc) || (cltr != proc->cltr);
         const bool remote   = hint == UNPARK_REMOTE;
@@ -116 +116 @@
         /* paranoid */ verify( kernelTLS().this_processor->rdq.id < lanes_count );
 
-        processor * const proc = kernelTLS().this_processor;
+        struct processor * const proc = kernelTLS().this_processor;
         unsigned this = proc->rdq.id;
         /* paranoid */ verify( this < lanes_count );