Changeset 2c88368 for src

Timestamp:

May 22, 2018, 4:46:29 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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, with_gc

Children:

59c034c6, d807ca28

Parents:

a8706fc (diff), a1a17a74 (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:/u/cforall/software/cfa/cfa-cc

Location:

src/libcfa

Files:

• bits/containers.h (modified) (2 diffs)
• concurrency/alarm.c (modified) (3 diffs)
• concurrency/kernel (modified) (1 diff)
• concurrency/kernel.c (modified) (7 diffs)
• concurrency/kernel_private.h (modified) (1 diff)
• concurrency/preemption.c (modified) (7 diffs)
• concurrency/thread.c (modified) (2 diffs)
• time (modified) (3 diffs)

src/libcfa/bits/containers.h

@@ -220 +220 @@
         }
 
-        #define _next .0
-        #define _prev .1
+        #define next 0
+        #define prev 1
         forall(dtype T | sized(T))
         static inline void push_front( __dllist(T) & this, T & node ) with( this ) {
+                verify(__get);
                 if ( head ) {
-                        __get( node )_next = head;
-                        __get( node )_prev = __get( *head )_prev;
+                        __get( node ).next = head;
+                        __get( node ).prev = __get( *head ).prev;
                         // inserted node must be consistent before it is seen
                         // prevent code movement across barrier
                         asm( "" : : : "memory" );
-                        __get( *head )_prev = &node;
-                        T & prev = *__get( node )_prev;
-                        __get( prev )_next = &node;
+                        __get( *head ).prev = &node;
+                        T & _prev = *__get( node ).prev;
+                        __get( _prev ).next = &node;
                 }
                 else {
-                        __get( node )_next = &node;
-                        __get( node )_prev = &node;
+                        __get( node ).next = &node;
+                        __get( node ).prev = &node;
                 }
 
@@ -246 +247 @@
         forall(dtype T | sized(T))
         static inline void remove( __dllist(T) & this, T & node ) with( this ) {
+                verify(__get);
                 if ( &node == head ) {
-                        if ( __get( *head )_next == head ) {
+                        if ( __get( *head ).next == head ) {
                                 head = NULL;
                         }
                         else {
-                                head = __get( *head )_next;
+                                head = __get( *head ).next;
                         }
                 }
-                __get( *__get( node )_next )_prev = __get( node )_prev;
-                __get( *__get( node )_prev )_next = __get( node )_next;
-                __get( node )_next = NULL;
-                __get( node )_prev = NULL;
-        }
-        #undef _next
-        #undef _prev
+                __get( *__get( node ).next ).prev = __get( node ).prev;
+                __get( *__get( node ).prev ).next = __get( node ).next;
+                __get( node ).next = NULL;
+                __get( node ).prev = NULL;
+        }
+        #undef next
+        #undef prev
 #endif
 

src/libcfa/concurrency/alarm.c

@@ -37 +37 @@
 
 void __kernel_set_timer( Duration alarm ) {
+        verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%luns)", alarm.tv);
         setitimer( ITIMER_REAL, &(itimerval){ alarm }, NULL );
 }
@@ -68 +69 @@
 }
 
-__cfaabi_dbg_debug_do( bool validate( alarm_list_t * this ) {
+#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
+bool validate( alarm_list_t * this ) {
         alarm_node_t ** it = &this->head;
         while( (*it) ) {
@@ -75 +77 @@
 
         return it == this->tail;
-})
+}
+#endif
 
 static inline void insert_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t p ) {

src/libcfa/concurrency/kernel

@@ -145 +145 @@
         __dllist_t(struct processor) idles;
 
+        // List of processors
+        __spinlock_t thread_list_lock;
+        __dllist_t(struct thread_desc) threads;
+
         // Link lists fields
         struct {

src/libcfa/concurrency/kernel.c

@@ -49 +49 @@
 thread_desc * mainThread;
 
-struct { __dllist_t(thread_desc) list; __spinlock_t lock; } global_threads ;
 struct { __dllist_t(cluster    ) list; __spinlock_t lock; } global_clusters;
 
 //-----------------------------------------------------------------------------
 // Global state
-
-// volatile thread_local bool preemption_in_progress = 0;
-// volatile thread_local bool preemption_enabled = false;
-// volatile thread_local unsigned short disable_preempt_count = 1;
-
 thread_local struct KernelThreadData kernelTLS = {
         NULL,
@@ -123 +117 @@
         node.next = NULL;
         node.prev = NULL;
-        doregister(this);
+        doregister(curr_cluster, this);
 
         monitors{ &self_mon_p, 1, (fptr_t)0 };
@@ -172 +166 @@
         procs{ __get };
         idles{ __get };
+        threads{ __get };
 
         doregister(this);
@@ -523 +518 @@
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 
-        global_threads. list{ __get };
-        global_threads. lock{};
         global_clusters.list{ __get };
         global_clusters.lock{};
@@ -624 +617 @@
         ^(mainThread){};
 
+        ^(global_clusters.list){};
+        ^(global_clusters.lock){};
+
         __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
 }
@@ -697 +693 @@
         else {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
+                __cfaabi_dbg_bits_write( abort_text, len );
         }
 }
@@ -760 +757 @@
 //-----------------------------------------------------------------------------
 // Global Queues
-void doregister( thread_desc & thrd ) {
-        // lock      ( global_thread.lock );
-        // push_front( global_thread.list, thrd );
-        // unlock    ( global_thread.lock );
-}
-
-void unregister( thread_desc & thrd ) {
-        // lock  ( global_thread.lock );
-        // remove( global_thread.list, thrd );
-        // unlock( global_thread.lock );
-}
-
 void doregister( cluster     & cltr ) {
-        // lock      ( global_cluster.lock );
-        // push_front( global_cluster.list, cltr );
-        // unlock    ( global_cluster.lock );
+        lock      ( global_clusters.lock __cfaabi_dbg_ctx2);
+        push_front( global_clusters.list, cltr );
+        unlock    ( global_clusters.lock );
 }
 
 void unregister( cluster     & cltr ) {
-        // lock  ( global_cluster.lock );
-        // remove( global_cluster.list, cltr );
-        // unlock( global_cluster.lock );
-}
-
+        lock  ( global_clusters.lock __cfaabi_dbg_ctx2);
+        remove( global_clusters.list, cltr );
+        unlock( global_clusters.lock );
+}
+
+void doregister( cluster * cltr, thread_desc & thrd ) {
+        lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
+        push_front(cltr->threads, thrd);
+        unlock    (cltr->thread_list_lock);
+}
+
+void unregister( cluster * cltr, thread_desc & thrd ) {
+        lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
+        remove(cltr->threads, thrd );
+        unlock(cltr->thread_list_lock);
+}
 
 void doregister( cluster * cltr, processor * proc ) {
-        // lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
-        // push_front(cltr->procs, *proc);
-        // unlock    (cltr->proc_list_lock);
+        lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        push_front(cltr->procs, *proc);
+        unlock    (cltr->proc_list_lock);
 }
 
 void unregister( cluster * cltr, processor * proc ) {
-        // lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
-        // remove(cltr->procs, *proc );
-        // unlock(cltr->proc_list_lock);
+        lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        remove(cltr->procs, *proc );
+        unlock(cltr->proc_list_lock);
 }
 

src/libcfa/concurrency/kernel_private.h

@@ -101 +101 @@
 
 
-void doregister( struct thread_desc & thrd );
-void unregister( struct thread_desc & thrd );
+void doregister( struct cluster & cltr );
+void unregister( struct cluster & cltr );
 
-void doregister( struct cluster     & cltr );
-void unregister( struct cluster     & cltr );
+void doregister( struct cluster * cltr, struct thread_desc & thrd );
+void unregister( struct cluster * cltr, struct thread_desc & thrd );
 
 void doregister( struct cluster * cltr, struct processor * proc );

src/libcfa/concurrency/preemption.c

@@ -15 +15 @@
 
 #include "preemption.h"
+#include <assert.h>
 
 extern "C" {
@@ -91 +92 @@
         //Loop throught every thing expired
         while( node = get_expired( alarms, currtime ) ) {
+                // __cfaabi_dbg_print_buffer_decl( " KERNEL: preemption tick.\n" );
 
                 // Check if this is a kernel
@@ -103 +105 @@
                 Duration period = node->period;
                 if( period > 0 ) {
+                        // __cfaabi_dbg_print_buffer_local( " KERNEL: alarm period is %lu.\n", period.tv );
                         node->alarm = 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
@@ -112 +115 @@
 
         // If there are still alarms pending, reset the timer
-        if( alarms->head ) { __kernel_set_timer( alarms->head->alarm - currtime ); }
+        if( alarms->head ) {
+                __cfaabi_dbg_print_buffer_decl( " KERNEL: @%lu(%lu) resetting alarm to %lu.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
+                Duration delta = alarms->head->alarm - currtime;
+                Duration caped = max(delta, 50`us);
+                // itimerval tim  = { caped };
+                // __cfaabi_dbg_print_buffer_local( "    Values are %lu, %lu, %lu %lu.\n", delta.tv, caped.tv, tim.it_value.tv_sec, tim.it_value.tv_usec);
+
+                __kernel_set_timer( caped );
+        }
 }
 
@@ -335 +346 @@
         if( !preemption_ready() ) { return; }
 
-        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", kernelTLS.this_processor, kernelTLS.this_thread );
+        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p @ %p).\n", kernelTLS.this_processor, kernelTLS.this_thread, (void *)(cxt->uc_mcontext.CFA_REG_IP) );
 
         // Sync flag : prevent recursive calls to the signal handler
         kernelTLS.preemption_state.in_progress = true;
 
-        // We are about to CtxSwitch out of the signal handler, let other handlers in
-        signal_unblock( SIGUSR1 );
+        // Clear sighandler mask before context switching.
+        static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" );
+        if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), NULL ) == -1 ) {
+                abort( "internal error, sigprocmask" );
+        }
 
         // TODO: this should go in finish action
@@ -377 +391 @@
                                 case EAGAIN :
                                 case EINTR :
+                                        {__cfaabi_dbg_print_buffer_decl( " KERNEL: Spurious wakeup %d.\n", err );}
                                         continue;
                         case EINVAL :
@@ -424 +439 @@
         sigset_t oldset;
         int ret;
-        ret = sigprocmask(0, NULL, &oldset);
+        ret = pthread_sigmask(0, NULL, &oldset);
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
         ret = sigismember(&oldset, SIGUSR1);
         if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
-
         if(ret == 1) { abort("ERROR SIGUSR1 is disabled"); }
+
+        ret = sigismember(&oldset, SIGALRM);
+        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+        if(ret == 0) { abort("ERROR SIGALRM is enabled"); }
+
+        ret = sigismember(&oldset, SIGTERM);
+        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+        if(ret == 1) { abort("ERROR SIGTERM is disabled"); }
 }
 

src/libcfa/concurrency/thread.c

@@ -42 +42 @@
         node.next = NULL;
         node.prev = NULL;
-        doregister(this);
+        doregister(curr_cluster, this);
 
         monitors{ &self_mon_p, 1, (fptr_t)0 };
@@ -48 +48 @@
 
 void ^?{}(thread_desc& this) with( this ) {
-        unregister(this);
+        unregister(curr_cluster, this);
         ^self_cor{};
 }

src/libcfa/time

@@ -1 @@
-// 
+//
 // Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
-// 
-// time -- 
-// 
+//
+// time --
+//
 // Author           : Peter A. Buhr
 // Created On       : Wed Mar 14 23:18:57 2018
@@ -12 +12 @@
 // Last Modified On : Sat Apr 14 17:48:23 2018
 // Update Count     : 636
-// 
+//
 
 #pragma once
@@ -91 +91 @@
 static inline int64_t ?`w( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
 
+static inline Duration max( Duration lhs, Duration rhs ) { return  (lhs.tv < rhs.tv) ? rhs : lhs;}
+static inline Duration min( Duration lhs, Duration rhs ) { return !(rhs.tv < lhs.tv) ? lhs : rhs;}
+
 
 //######################### C timeval #########################