Changeset c81ebf9 for src/libcfa

Timestamp:

Jun 6, 2017, 11:45:13 AM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

c5ac6d5

Parents:

7b13aeb

Message:

More work done on preemption in cforall, next step disabling interrupts at the correct places

Location:

src/libcfa/concurrency

Files:

• alarm.c (modified) (3 diffs)
• alarm.h (modified) (3 diffs)
• kernel (modified) (2 diffs)
• kernel.c (modified) (15 diffs)
• kernel_private.h (modified) (1 diff)
• monitor (modified) (1 diff)
• monitor.c (modified) (3 diffs)
• preemption.h (added)
• signal.c (modified) (1 diff)

src/libcfa/concurrency/alarm.c ¶

@@ -15 +15 @@
 //
 
+extern "C" {
+#include <time.h>
+#include <sys/time.h>
+}
+
 #include "alarm.h"
 #include "kernel_private.h"
+#include "preemption.h"
 
-static void register_self( alarm_node_t * this ) {
-        lock( &systemProcessor->alarm_lock );
-        insert( &systemProcessor->alarms, this );
-        unlock( &systemProcessor->alarm_lock );
+//=============================================================================================
+// Clock logic
+//=============================================================================================
+
+__cfa_time_t __kernel_get_time() {
+        timespec curr;
+        clock_gettime( CLOCK_REALTIME, &curr );
+        return ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
 }
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, cfa_time_t alarm, cfa_time_t period = 0 ) {
+void __kernel_set_timer( __cfa_time_t alarm ) {
+        itimerval val;
+        val.it_value.tv_sec = alarm / TIMEGRAN;                 // seconds
+        val.it_value.tv_usec = (alarm % TIMEGRAN) / ( TIMEGRAN / 1_000_000L ); // microseconds
+        val.it_interval.tv_sec = 0;
+        val.it_interval.tv_usec = 0;
+        setitimer( ITIMER_REAL, &val, NULL );
+}
+
+//=============================================================================================
+// Alarm logic
+//=============================================================================================
+
+void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
         this->thrd = thrd;
         this->alarm = alarm;
         this->period = period;
         this->next = 0;
-
-        register_self( this );
+        this->set = false;
+        this->kernel_alarm = false;
 }
 
-void ?{}( alarm_node_t * this, processor   * proc, cfa_time_t alarm, cfa_time_t period = 0 ) {
+void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
         this->proc = proc;
         this->alarm = alarm;
         this->period = period;
         this->next = 0;
+        this->set = false;
+        this->kernel_alarm = true;
+}
 
-        register_self( this );
+void ^?{}( alarm_node_t * this ) {
+        if( this->set ) {
+                unregister_self( this );
+        }
 }
 
@@ -62 +91 @@
 }
 
-void pop( alarm_list_t * this ) {
+alarm_node_t * pop( alarm_list_t * this ) {
         alarm_node_t * head = this->head;
         if( head ) {
@@ -73 +102 @@
         return head;
 }
+
+static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) {
+        assert( it );
+        assert( (*it)->next == n );
+
+        (*it)->next = n->next;
+        if( !n-> next ) {
+                this->tail = it;
+        }
+        n->next = NULL;
+}
+
+static inline void remove( alarm_list_t * this, alarm_node_t * n ) {
+        alarm_node_t ** it = &this->head;
+        while( (*it) && (*it)->next != n ) {
+                it = &(*it)->next;
+        }
+
+        if( *it ) { remove_at( this, n, it ); }
+}
+
+void register_self( alarm_node_t * this ) {
+        disable_interrupts();
+        assert( !systemProcessor->pending_alarm );
+        lock( &systemProcessor->alarm_lock );
+        {
+                insert( &systemProcessor->alarms, this );
+                if( systemProcessor->pending_alarm ) {
+                        tick_preemption();
+                }
+        }
+        unlock( &systemProcessor->alarm_lock );
+        this->set = true;
+        enable_interrupts();
+}
+
+void unregister_self( alarm_node_t * this ) {
+        disable_interrupts();
+        lock( &systemProcessor->alarm_lock );
+        remove( &systemProcessor->alarms, this );
+        unlock( &systemProcessor->alarm_lock );
+        disable_interrupts();
+        this->set = false;
+}

src/libcfa/concurrency/alarm.h ¶

@@ -18 +18 @@
 #define ALARM_H
 
+#include <stdbool.h>
+
 #include "assert"
 
-typedef unsigned long int cfa_time_t;
+typedef unsigned long int __cfa_time_t;
 
 struct thread_desc;
 struct processor;
 
+//=============================================================================================
+// Clock logic
+//=============================================================================================
+
+#define TIMEGRAN 1_000_000_000L                         // nanosecond granularity, except for timeval
+
+__cfa_time_t __kernel_get_time();
+void __kernel_set_timer( __cfa_time_t alarm );
+
+//=============================================================================================
+// Alarm logic
+//=============================================================================================
+
 struct alarm_node_t {
-        cfa_time_t alarm;               // time when alarm goes off
-        cfa_time_t period;      // if > 0 => period of alarm
-        alarm_node_t * next;    // intrusive link list field
+        __cfa_time_t alarm;             // time when alarm goes off
+        __cfa_time_t period;            // if > 0 => period of alarm
+        alarm_node_t * next;            // intrusive link list field
 
         union {
@@ -34 +49 @@
                 processor * proc;               // proc who created event
         };
+
+        bool set                :1;             // whether or not the alarm has be registered
+        bool kernel_alarm       :1;             // true if this is not a user defined alarm
 };
 
 typedef alarm_node_t ** __alarm_it_t;
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, cfa_time_t alarm, cfa_time_t period = 0 );
-void ?{}( alarm_node_t * this, processor   * proc, cfa_time_t alarm, cfa_time_t period = 0 );
+void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
+void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 );
+void ^?{}( alarm_node_t * this );
 
 struct alarm_list_t {
@@ -54 +73 @@
 alarm_node_t * pop( alarm_list_t * this );
 
+void register_self  ( alarm_node_t * this );
+void unregister_self( alarm_node_t * this );
+
 #endif
 

src/libcfa/concurrency/kernel ¶

@@ -28 +28 @@
 //-----------------------------------------------------------------------------
 // Locks
+bool try_lock( spinlock * );
 void lock( spinlock * );
 void unlock( spinlock * );
@@ -85 +86 @@
 
         struct FinishAction finish;
+
+        struct alarm_node_t * preemption_alarm;
+        unsigned int preemption;
+
+        unsigned short disable_preempt_count;
+
+        bool pending_preemption;
 };
 

src/libcfa/concurrency/kernel.c ¶

@@ -36 +36 @@
 //CFA Includes
 #include "libhdr.h"
+#include "preemption.h"
 
 //Private includes
@@ -81 +82 @@
 
 void ?{}( current_stack_info_t * this ) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Ctor 1\n");
         CtxGet( &this->ctx );
         this->base = this->ctx.FP;
@@ -96 +96 @@
 
 void ?{}( coStack_t * this, current_stack_info_t * info) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Ctor 2\n");
         this->size = info->size;
         this->storage = info->storage;
@@ -107 +106 @@
 
 void ?{}( coroutine_desc * this, current_stack_info_t * info) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Ctor 3\n");
         (&this->stack){ info }; 
         this->name = "Main Thread";
@@ -115 +113 @@
 
 void ?{}( thread_desc * this, current_stack_info_t * info) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Ctor 4\n");
         (&this->cor){ info };
 }
@@ -122 +119 @@
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Ctor 5\n");
         (&this->__cor){ "Processor" };
         this->proc = proc;
@@ -129 +125 @@
 
 void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Ctor 6\n");
         (&this->__cor){ info };
         this->proc = proc;
@@ -136 +131 @@
 
 void ?{}(processor * this) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Ctor 7\n");
         this{ systemCluster };
 }
 
 void ?{}(processor * this, cluster * cltr) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Ctor 8\n");
         this->cltr = cltr;
         this->current_coroutine = NULL;
@@ -147 +140 @@
         (&this->terminated){};
         this->is_terminated = false;
+        this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
+        this->disable_preempt_count = 1;                //Start with interrupts disabled
+        this->pending_preemption = false;
 
         start( this );
@@ -157 +154 @@
         (&this->terminated){};
         this->is_terminated = false;
+        this->disable_preempt_count = 0;
+        this->pending_preemption = false;
 
         this->runner = runner;
@@ -164 +163 @@
 
 void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Ctor 9\n");
         (&this->alarms){};
         (&this->alarm_lock){};
+        this->pending_alarm = false;
 
         (&this->proc){ cltr, runner };
@@ -194 +193 @@
 void main(processorCtx_t * runner) {
         processor * this = runner->proc;
+
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
 
-        thread_desc * readyThread = NULL;
-        for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
         {
-                readyThread = nextThread( this->cltr );
-
-                if(readyThread) 
+                // Setup preemption data
+                preemption_scope scope = { this };
+
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
+
+                thread_desc * readyThread = NULL;
+                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
                 {
-                        runThread(this, readyThread);
-
-                        //Some actions need to be taken from the kernel
-                        finishRunning(this);
-
-                        spin_count = 0;
-                } 
-                else 
-                {
-                        spin(this, &spin_count);
-                }               
-        }
-
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p unlocking thread\n", this);
+                        readyThread = nextThread( this->cltr );
+
+                        if(readyThread)
+                        {
+                                runThread(this, readyThread);
+
+                                //Some actions need to be taken from the kernel
+                                finishRunning(this);
+
+                                spin_count = 0;
+                        }
+                        else
+                        {
+                                spin(this, &spin_count);
+                        }
+                }
+
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);
+        }
+
         signal( &this->terminated );
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
@@ -315 +323 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
         
-        // pthread_attr_t attributes;
-        // pthread_attr_init( &attributes );
-
         pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
-
-        // pthread_attr_destroy( &attributes );
 
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);       
@@ -381 +384 @@
         this_processor->finish.thrd_count = thrd_count;
         suspend();
-}
-
-//=============================================================================================
-// Kernel Preemption logic
-//=============================================================================================
-
-#define __CFA_DEFAULT_PREEMPTION__ 10
-
-unsigned int default_preemption() {
-        return __CFA_DEFAULT_PREEMPTION__;
-}
-
-void kernel_start_preemption() {
-
 }
 
@@ -536 +525 @@
 }
 
+bool try_lock( spinlock * this ) {
+        return this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
+}
+
 void lock( spinlock * this ) {
         for ( unsigned int i = 1;; i += 1 ) {

src/libcfa/concurrency/kernel_private.h ¶

@@ -52 +52 @@
         alarm_list_t alarms;
         spinlock alarm_lock;
+
+        bool pending_alarm;
 };
 
 extern cluster * systemCluster;
 extern system_proc_t * systemProcessor;
+extern thread_local processor * this_processor;
+
+static inline void disable_interrupts() {
+        __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, 1, __ATOMIC_SEQ_CST );
+        assert( prev != (unsigned short) -1 );
+}
+
+static inline void enable_interrupts_noRF() {
+        unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+        assert( prev != (unsigned short) 0 );
+}
+
+static inline void enable_interrupts() {
+        unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+        assert( prev != (unsigned short) 0 );
+        if( prev == 1 && this_processor->pending_preemption ) {
+                ScheduleInternal( this_processor->current_thread );
+                this_processor->pending_preemption = false;
+        }
+}
 
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/monitor ¶

@@ -92 +92 @@
 uintptr_t front( condition * this );
 
+struct __acceptable_t {
+        void (*func)(void);
+        unsigned short count;
+        monitor_desc * monitors[1];
+};
+
+void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) );
+
 #endif //MONITOR_H

src/libcfa/concurrency/monitor.c ¶

@@ -212 +212 @@
         ScheduleInternal( locks, count, threads, thread_count );
 
+
         //WE WOKE UP
 
@@ -312 +313 @@
         ScheduleInternal( locks, count, &signallee, 1 );
 
+
+
+
         LIB_DEBUG_PRINT_SAFE( "Back from signal block\n" );
 
@@ -330 +334 @@
         );
         return this->blocked.head->user_info;
+}
+
+//-----------------------------------------------------------------------------
+// Internal scheduling
+void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) ) {
+        // thread_desc * this = this_thread();
+
+        // unsigned short count = this->current_monitor_count;
+        // unsigned int recursions[ count ];            //Save the current recursion levels to restore them later
+        // spinlock *   locks     [ count ];            //We need to pass-in an array of locks to ScheduleInternal
+
+        // lock_all( this->current_monitors, locks, count );
+
+
+
+
+
+        // // // Everything is ready to go to sleep
+        // // ScheduleInternal( locks, count, threads, thread_count );
+
+
+        // //WE WOKE UP
+
+
+        // //We are back, restore the owners and recursions
+        // lock_all( locks, count );
+        // restore_recursion( this->monitors, recursions, count );
+        // unlock_all( locks, count );
 }
 

src/libcfa/concurrency/signal.c ¶

@@ +1 @@
+//                              -*- Mode: CFA -*-
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// signal.c --
+//
+// Author           : Thierry Delisle
+// Created On       : Mon Jun 5 14:20:42 2017
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
+//
+
+#include "preemption.h"
+
+extern "C" {
+#include <signal.h>
+}
+
+#define __CFA_DEFAULT_PREEMPTION__ 10
+
+__attribute__((weak)) unsigned int default_preemption() {
+        return __CFA_DEFAULT_PREEMPTION__;
+}
+
+static void preempt( processor   * this );
+static void timeout( thread_desc * this );
+
+//=============================================================================================
+// Kernel Preemption logic
+//=============================================================================================
+
+void kernel_start_preemption() {
+
+}
+
+void tick_preemption() {
+        alarm_list_t * alarms = &systemProcessor->alarms;
+        __cfa_time_t currtime = __kernel_get_time();
+        while( alarms->head && alarms->head->alarm < currtime ) {
+                alarm_node_t * node = pop(alarms);
+                if( node->kernel_alarm ) {
+                        preempt( node->proc );
+                }
+                else {
+                        timeout( node->thrd );
+                }
+
+                if( node->period > 0 ) {
+                        node->alarm += node->period;
+                        insert( alarms, node );
+                }
+                else {
+                        node->set = false;
+                }
+        }
+
+        if( alarms->head ) {
+                __kernel_set_timer( alarms->head->alarm - currtime );
+        }
+}
+
+void update_preemption( processor * this, __cfa_time_t duration ) {
+        //     assert( THREAD_GETMEM( disableInt ) && THREAD_GETMEM( disableIntCnt ) == 1 );
+        alarm_node_t * alarm = this->preemption_alarm;
+
+        // Alarms need to be enabled
+        if ( duration > 0 && !alarm->set ) {
+                alarm->alarm = __kernel_get_time() + duration;
+                alarm->period = duration;
+                register_self( alarm );
+        }
+        // Zero duraction but alarm is set
+        else if ( duration == 0 && alarm->set ) {
+                unregister_self( alarm );
+                alarm->alarm = 0;
+                alarm->period = 0;
+        }
+        // If alarm is different from previous, change it
+        else if ( duration > 0 && alarm->period != duration ) {
+                unregister_self( alarm );
+                alarm->alarm = __kernel_get_time() + duration;
+                alarm->period = duration;
+                register_self( alarm );
+        }
+}
+
+void ?{}( preemption_scope * this, processor * proc ) {
+        (&this->alarm){ proc };
+        this->proc = proc;
+        this->proc->preemption_alarm = &this->alarm;
+        update_preemption( this->proc, this->proc->preemption );
+}
+
+void ^?{}( preemption_scope * this ) {
+        update_preemption( this->proc, 0 );
+}
+
+//=============================================================================================
+// Kernel Signal logic
+//=============================================================================================
+
+static inline bool preemption_ready() {
+        return this_processor->disable_preempt_count == 0;
+}
+
+static inline void defer_ctxSwitch() {
+        this_processor->pending_preemption = true;
+}
+
+static inline void defer_alarm() {
+        systemProcessor->pending_alarm = true;
+}
+
+void sigHandler_ctxSwitch( __attribute__((unused)) int sig ) {
+        if( preemption_ready() ) {
+                ScheduleInternal( this_processor->current_thread );
+        }
+        else {
+                defer_ctxSwitch();
+        }
+}
+
+void sigHandler_alarm( __attribute__((unused)) int sig ) {
+        if( try_lock( &systemProcessor->alarm_lock ) ) {
+                tick_preemption();
+                unlock( &systemProcessor->alarm_lock );
+        }
+        else {
+                defer_alarm();
+        }
+}
+
+static void preempt( processor * this ) {
+        pthread_kill( this->kernel_thread, SIGUSR1 );
+}
+
+static void timeout( thread_desc * this ) {
+        //TODO : implement waking threads
+}