Changeset b1e68d03 for src/libcfa

Timestamp:

Nov 2, 2017, 11:45:03 AM (8 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, resolv-new, with_gc

Children:

4f748c5

Parents:

85d340d (diff), 0dc954b (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/algorithms.h (added)
• concurrency/kernel.c (modified) (1 diff)
• concurrency/monitor.c (modified) (19 diffs)
• concurrency/preemption.c (modified) (2 diffs)
• interpose.c (modified) (1 diff)
• libhdr/libdebug.c (modified) (6 diffs)
• libhdr/libdebug.h (modified) (3 diffs)
• stdlib (modified) (3 diffs)
• stdlib.c (modified) (2 diffs)

src/libcfa/concurrency/kernel.c

@@ -548 +548 @@
 
         int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
-        __lib_debug_write( STDERR_FILENO, abort_text, len );
+        __lib_debug_write( abort_text, len );
 
         if ( thrd != this_coroutine ) {
                 len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
-                __lib_debug_write( STDERR_FILENO, abort_text, len );
+                __lib_debug_write( abort_text, len );
         }
         else {
-                __lib_debug_write( STDERR_FILENO, ".\n", 2 );
+                __lib_debug_write( ".\n", 2 );
         }
 }

src/libcfa/concurrency/monitor.c

@@ -21 +21 @@
 #include "kernel_private.h"
 
+#include "bits/algorithms.h"
+
 //-----------------------------------------------------------------------------
 // Forward declarations
@@ -95 +97 @@
                 else if( this->owner == thrd) {
                         // We already have the monitor, just note how many times we took it
-                        verify( this->recursion > 0 );
                         this->recursion += 1;
 
@@ -207 +208 @@
                 // it means we don't need to do anything
                 if( this->recursion != 0) {
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  recursion still %d\n", this->recursion);
                         unlock( &this->lock );
                         return;
@@ -291 +293 @@
 
         // Sort monitors based on address -> TODO use a sort specialized for small numbers
-        qsort(this.m, count);
+        __libcfa_small_sort(this.m, count);
 
         // Save previous thread context
@@ -492 +494 @@
         set_owner( monitors, count, signallee );
 
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", this, signallee );
+
         //Everything is ready to go to sleep
         BlockInternal( locks, count, &signallee, 1 );
@@ -498 +502 @@
         // WE WOKE UP
 
+
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :   signal_block returned\n" );
 
         //We are back, restore the masks and recursions
@@ -536 +542 @@
         short actual_count = aggregate( mon_storage, mask );
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (short)max);
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (short)max);
 
         if(actual_count == 0) return;
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : waitfor internal proceeding\n");
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n");
 
         // Create storage for monitor context
@@ -556 +562 @@
                         *mask.accepted = index;
                         if( mask.clauses[index].is_dtor ) {
-                                LIB_DEBUG_PRINT_SAFE("Kernel : dtor already there\n");
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");
                                 verifyf( mask.clauses[index].size == 1        , "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
@@ -568 +574 @@
                         }
                         else {
-                                LIB_DEBUG_PRINT_SAFE("Kernel : thread present, baton-passing\n");
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, baton-passing\n");
 
                                 // Create the node specific to this wait operation
@@ -576 +582 @@
                                 monitor_save;
 
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :  baton of %d monitors : ", count );
+                                #ifdef __CFA_DEBUG_PRINT__
+                                        for( int i = 0; i < count; i++) {
+                                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
+                                        }
+                                #endif
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n");
+
                                 // Set the owners to be the next thread
                                 set_owner( monitors, count, next );
@@ -585 +599 @@
                                 monitor_restore;
 
-                                LIB_DEBUG_PRINT_SAFE("Kernel : thread present, returned\n");
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n");
                         }
 
-                        LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
+                        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
 
                         return;
@@ -596 +610 @@
 
         if( duration == 0 ) {
-                LIB_DEBUG_PRINT_SAFE("Kernel : non-blocking, exiting\n");
+                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n");
 
                 unlock_all( locks, count );
 
-                LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
+                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
                 return;
         }
@@ -607 +621 @@
         verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : blocking waitfor\n");
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n");
 
         // Create the node specific to this wait operation
@@ -629 +643 @@
         monitor_restore;
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : exiting\n");
-
-        LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n");
+
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
 }
 
@@ -648 +662 @@
 
 static inline void set_owner( monitor_desc ** monitors, short count, thread_desc * owner ) {
-        for( int i = 0; i < count; i++ ) {
-                set_owner( monitors[i], owner );
+        monitors[0]->owner     = owner;
+        monitors[0]->recursion = 1;
+        for( int i = 1; i < count; i++ ) {
+                monitors[i]->owner     = owner;
+                monitors[i]->recursion = 0;
         }
 }
@@ -667 +684 @@
 static inline thread_desc * next_thread( monitor_desc * this ) {
         //Check the signaller stack
+        LIB_DEBUG_PRINT_SAFE("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
         __condition_criterion_t * urgent = pop( &this->signal_stack );
         if( urgent ) {
@@ -718 +736 @@
         for(int i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
+                LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
                 push( &criteria[i].target->signal_stack, &criteria[i] );
         }
@@ -788 +807 @@
         }
 
-        // LIB_DEBUG_PRINT_SAFE( "Runing %i\n", ready2run );
+        LIB_DEBUG_PRINT_SAFE( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
         return ready2run ? node->waiting_thread : NULL;
 }
@@ -856 +875 @@
         short size = 0;
         for( int i = 0; i < mask.size; i++ ) {
+                __libcfa_small_sort( mask.clauses[i].list, mask.clauses[i].size );
                 for( int j = 0; j < mask.clauses[i].size; j++) {
                         insert_unique( storage, size, mask.clauses[i].list[j] );
                 }
         }
-        qsort( storage, size );
+        // TODO insertion sort instead of this
+        __libcfa_small_sort( storage, size );
         return size;
 }

src/libcfa/concurrency/preemption.c

@@ -380 +380 @@
 
         if ( sigaction( sig, &act, NULL ) == -1 ) {
-                LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO,
+                LIB_DEBUG_PRINT_BUFFER_DECL(
                         " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
                         sig, handler, flags, errno, strerror( errno )
@@ -397 +397 @@
 
         if ( sigaction( sig, &act, NULL ) == -1 ) {
-                LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO,
+                LIB_DEBUG_PRINT_BUFFER_DECL(
                         " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
                         sig, errno, strerror( errno )

src/libcfa/interpose.c

@@ -127 +127 @@
                         va_end( args );
 
-                        __lib_debug_write( STDERR_FILENO, abort_text, len );
-                        __lib_debug_write( STDERR_FILENO, "\n", 1 );
+                        __lib_debug_write( abort_text, len );
+                        __lib_debug_write( "\n", 1 );
                 }
 
                 len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld)\n", (long int)getpid() ); // use UNIX pid (versus getPid)
-                __lib_debug_write( STDERR_FILENO, abort_text, len );
+                __lib_debug_write( abort_text, len );
 
 

src/libcfa/libhdr/libdebug.c

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu Mar 30 12:30:01 2017
-// Last Modified By : 
-// Last Modified On : 
+// Last Modified By :
+// Last Modified On :
 // Update Count     : 0
 //
@@ -28 +28 @@
 extern "C" {
 
-        void __lib_debug_write( int fd, const char *in_buffer, int len ) {
+        void __lib_debug_write( const char *in_buffer, int len ) {
                 // ensure all data is written
-                for ( int count = 0, retcode; count < len; count += retcode ) { 
+                for ( int count = 0, retcode; count < len; count += retcode ) {
                         in_buffer += count;
 
                         for ( ;; ) {
-                                retcode = write( fd, in_buffer, len - count );
+                                retcode = write( STDERR_FILENO, in_buffer, len - count );
 
                                 // not a timer interrupt ?
-                                if ( retcode != -1 || errno != EINTR ) break; 
+                                if ( retcode != -1 || errno != EINTR ) break;
                         }
 
@@ -52 +52 @@
                 va_start( args, fmt );
                 __lib_debug_acquire();
-                
+
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
-                __lib_debug_write( STDERR_FILENO, buffer, len );
+                __lib_debug_write( buffer, len );
 
                 __lib_debug_release();
@@ -64 +64 @@
 
                 va_start( args, fmt );
-                
+
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
-                __lib_debug_write( STDERR_FILENO, buffer, len );
+                __lib_debug_write( buffer, len );
 
                 va_end( args );
@@ -73 +73 @@
         void __lib_debug_print_vararg( const char fmt[], va_list args ) {
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
-                __lib_debug_write( STDERR_FILENO, buffer, len );
+                __lib_debug_write( buffer, len );
         }
 
@@ -80 +80 @@
 
                 va_start( args, fmt );
-                
+
                 int len = vsnprintf( in_buffer, in_buffer_size, fmt, args );
-                __lib_debug_write( STDERR_FILENO, in_buffer, len );
+                __lib_debug_write( in_buffer, len );
 
                 va_end( args );

src/libcfa/libhdr/libdebug.h

@@ -44 +44 @@
 extern "C" {
 #endif
-      #include <stdarg.h>
+        #include <stdarg.h>
+        #include <stdio.h>
 
-      extern void __lib_debug_write( int fd, const char *buffer, int len );
+      extern void __lib_debug_write( const char *buffer, int len );
       extern void __lib_debug_acquire();
       extern void __lib_debug_release();
@@ -58 +59 @@
 
 #ifdef __CFA_DEBUG_PRINT__
-        #define LIB_DEBUG_WRITE( fd, buffer, len )     __lib_debug_write( fd, buffer, len )
+        #define LIB_DEBUG_WRITE( buffer, len )         __lib_debug_write( buffer, len )
         #define LIB_DEBUG_ACQUIRE()                    __lib_debug_acquire()
         #define LIB_DEBUG_RELEASE()                    __lib_debug_release()
@@ -64 +65 @@
         #define LIB_DEBUG_PRINT_NOLOCK(...)            __lib_debug_print_nolock (__VA_ARGS__)
         #define LIB_DEBUG_PRINT_BUFFER(...)            __lib_debug_print_buffer (__VA_ARGS__)
-        #define LIB_DEBUG_PRINT_BUFFER_DECL(fd, ...)   char text[256]; int len = snprintf( text, 256, __VA_ARGS__ ); __lib_debug_write( fd, text, len );
-        #define LIB_DEBUG_PRINT_BUFFER_LOCAL(fd, ...)  len = snprintf( text, 256, __VA_ARGS__ ); __lib_debug_write( fd, text, len );
+        #define LIB_DEBUG_PRINT_BUFFER_DECL(...)       char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __lib_debug_write( __dbg_text, __dbg_len );
+        #define LIB_DEBUG_PRINT_BUFFER_LOCAL(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __lib_debug_write( __dbg_text, __dbg_len );
 #else
         #define LIB_DEBUG_WRITE(...)               ((void)0)

src/libcfa/stdlib

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 23 20:29:47 2017
-// Update Count     : 224
+// Last Modified On : Tue Oct 31 13:47:24 2017
+// Update Count     : 245
 //
 
@@ -27 +27 @@
 // allocation, non-array types
 static inline forall( dtype T | sized(T) ) T * malloc( void ) {
-        //printf( "X1\n" );
+        // printf( "* malloc\n" );
         return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
 } // malloc
+
+// static inline forall( dtype T | sized(T) ) T & malloc( void ) {
+//      int & p = *(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+//      printf( "& malloc %p\n", &p );
+//      return p;
+// //   return (T &)*(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+// } // malloc
 
 extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine
@@ -206 +213 @@
 //---------------------------------------
 
-void rand48seed( long int s );
-char rand48( void );
-int rand48( void );
-unsigned int rand48( void );
-long int rand48( void );
-unsigned long int rand48( void );
-float rand48( void );
-double rand48( void );
-float _Complex rand48( void );
-double _Complex rand48( void );
-long double _Complex rand48( void );
+void random_seed( long int s );
+char random( void );
+char random( char l, char u );
+int random( void );
+unsigned int random( void );
+unsigned int random( unsigned int u );
+unsigned int random( unsigned int l, unsigned int u );
+//long int random( void );
+unsigned long int random( void );
+unsigned long int random( unsigned long int u );
+unsigned long int random( unsigned long int l, unsigned long int u );
+float random( void );
+double random( void );
+float _Complex random( void );
+double _Complex random( void );
+long double _Complex random( void );
 
 //---------------------------------------

src/libcfa/stdlib.c

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 23 20:30:44 2017
-// Update Count     : 292
+// Last Modified On : Mon Oct 30 22:43:02 2017
+// Update Count     : 297
 //
 
@@ -275 +275 @@
 //---------------------------------------
 
-void rand48seed( long int s ) { srand48( s ); }
-char rand48( void ) { return mrand48(); }
-int rand48( void ) { return mrand48(); }
-unsigned int rand48( void ) { return lrand48(); }
-long int rand48( void ) { return mrand48(); }
-unsigned long int rand48( void ) { return lrand48(); }
-float rand48( void ) { return (float)drand48(); }               // otherwise float uses lrand48
-double rand48( void ) { return drand48(); }
-float _Complex rand48( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
-double _Complex rand48( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
-long double _Complex rand48( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
+void random_seed( long int s ) { srand48( s ); }
+char random( void ) { return mrand48(); }
+char random( char l, char u ) { return lrand48() % (u - l) + l; }
+int random( void ) { return mrand48(); }
+unsigned int random( void ) { return lrand48(); }
+unsigned int random( unsigned int u ) { return lrand48() % u; }
+unsigned int random( unsigned int l, unsigned int u ) { return lrand48() % (u - l) + l; }
+//long int random( void ) { return mrand48(); }
+unsigned long int random( void ) { return lrand48(); }
+unsigned long int random( unsigned long int u ) { return lrand48() % u; }
+unsigned long int random( unsigned long int l, unsigned long int u ) { return lrand48() % (u - l) + l; }
+float random( void ) { return (float)drand48(); }               // otherwise float uses lrand48
+double random( void ) { return drand48(); }
+float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
+double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
+long double _Complex random( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
 
 //---------------------------------------