Changeset 6a5be52 for src/libcfa


Ignore:
Timestamp:
Oct 27, 2017, 5:54:56 PM (7 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:
af0c8da
Parents:
9f0b975
Message:

Modified waitfor to sort monitors

Location:
src/libcfa
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/concurrency/kernel.c

    r9f0b975 r6a5be52  
    548548
    549549        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
    550         __lib_debug_write( STDERR_FILENO, abort_text, len );
     550        __lib_debug_write( abort_text, len );
    551551
    552552        if ( thrd != this_coroutine ) {
    553553                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
    554                 __lib_debug_write( STDERR_FILENO, abort_text, len );
     554                __lib_debug_write( abort_text, len );
    555555        }
    556556        else {
    557                 __lib_debug_write( STDERR_FILENO, ".\n", 2 );
     557                __lib_debug_write( ".\n", 2 );
    558558        }
    559559}

  • src/libcfa/concurrency/monitor.c

    r9f0b975 r6a5be52  
    9595                else if( this->owner == thrd) {
    9696                        // We already have the monitor, just note how many times we took it
    97                         verify( this->recursion > 0 );
    9897                        this->recursion += 1;
    9998
    … …  
    207206                // it means we don't need to do anything
    208207                if( this->recursion != 0) {
     208                        LIB_DEBUG_PRINT_SAFE("Kernel :  recursion still %d\n", this->recursion);
    209209                        unlock( &this->lock );
    210210                        return;
    … …  
    536536        short actual_count = aggregate( mon_storage, mask );
    537537
    538         LIB_DEBUG_PRINT_SAFE("Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (short)max);
     538        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (short)max);
    539539
    540540        if(actual_count == 0) return;
    541541
    542         LIB_DEBUG_PRINT_SAFE("Kernel : waitfor internal proceeding\n");
     542        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n");
    543543
    544544        // Create storage for monitor context
    … …  
    556556                        *mask.accepted = index;
    557557                        if( mask.clauses[index].is_dtor ) {
    558                                 LIB_DEBUG_PRINT_SAFE("Kernel : dtor already there\n");
     558                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");
    559559                                verifyf( mask.clauses[index].size == 1        , "ERROR: Accepted dtor has more than 1 mutex parameter." );
    560560
    … …  
    568568                        }
    569569                        else {
    570                                 LIB_DEBUG_PRINT_SAFE("Kernel : thread present, baton-passing\n");
     570                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, baton-passing\n");
    571571
    572572                                // Create the node specific to this wait operation
    … …  
    576576                                monitor_save;
    577577
     578                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :  baton of %d monitors : ", count );
     579                                #ifdef __CFA_DEBUG_PRINT__
     580                                        for( int i = 0; i < count; i++) {
     581                                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
     582                                        }
     583                                #endif
     584                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n");
     585
    578586                                // Set the owners to be the next thread
    579587                                set_owner( monitors, count, next );
    … …  
    585593                                monitor_restore;
    586594
    587                                 LIB_DEBUG_PRINT_SAFE("Kernel : thread present, returned\n");
     595                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n");
    588596                        }
    589597
    590                         LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
     598                        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
    591599
    592600                        return;
    … …  
    596604
    597605        if( duration == 0 ) {
    598                 LIB_DEBUG_PRINT_SAFE("Kernel : non-blocking, exiting\n");
     606                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n");
    599607
    600608                unlock_all( locks, count );
    601609
    602                 LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
     610                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
    603611                return;
    604612        }
    … …  
    607615        verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
    608616
    609         LIB_DEBUG_PRINT_SAFE("Kernel : blocking waitfor\n");
     617        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n");
    610618
    611619        // Create the node specific to this wait operation
    … …  
    629637        monitor_restore;
    630638
    631         LIB_DEBUG_PRINT_SAFE("Kernel : exiting\n");
    632 
    633         LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
     639        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n");
     640
     641        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
    634642}
    635643
    … …  
    648656
    649657static inline void set_owner( monitor_desc ** monitors, short count, thread_desc * owner ) {
    650         for( int i = 0; i < count; i++ ) {
    651                 set_owner( monitors[i], owner );
     658        monitors[0]->owner     = owner;
     659        monitors[0]->recursion = 1;
     660        for( int i = 1; i < count; i++ ) {
     661                monitors[i]->owner     = owner;
     662                monitors[i]->recursion = 0;
    652663        }
    653664}
    … …  
    667678static inline thread_desc * next_thread( monitor_desc * this ) {
    668679        //Check the signaller stack
     680        LIB_DEBUG_PRINT_SAFE("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
    669681        __condition_criterion_t * urgent = pop( &this->signal_stack );
    670682        if( urgent ) {
    … …  
    718730        for(int i = 0; i < count; i++) {
    719731                (criteria[i]){ monitors[i], waiter };
     732                LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
    720733                push( &criteria[i].target->signal_stack, &criteria[i] );
    721734        }
    … …  
    788801        }
    789802
    790         // LIB_DEBUG_PRINT_SAFE( "Runing %i\n", ready2run );
     803        LIB_DEBUG_PRINT_SAFE( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
    791804        return ready2run ? node->waiting_thread : NULL;
    792805}
    … …  
    856869        short size = 0;
    857870        for( int i = 0; i < mask.size; i++ ) {
     871                qsort( mask.clauses[i].list, mask.clauses[i].size );
    858872                for( int j = 0; j < mask.clauses[i].size; j++) {
    859873                        insert_unique( storage, size, mask.clauses[i].list[j] );
    860874                }
    861875        }
     876        // TODO insertion sort instead of this
    862877        qsort( storage, size );
    863878        return size;

  • src/libcfa/concurrency/preemption.c

    r9f0b975 r6a5be52  
    380380
    381381        if ( sigaction( sig, &act, NULL ) == -1 ) {
    382                 LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO,
     382                LIB_DEBUG_PRINT_BUFFER_DECL(
    383383                        " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
    384384                        sig, handler, flags, errno, strerror( errno )
    … …  
    397397
    398398        if ( sigaction( sig, &act, NULL ) == -1 ) {
    399                 LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO,
     399                LIB_DEBUG_PRINT_BUFFER_DECL(
    400400                        " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
    401401                        sig, errno, strerror( errno )

  • src/libcfa/interpose.c

    r9f0b975 r6a5be52  
    127127                        va_end( args );
    128128
    129                         __lib_debug_write( STDERR_FILENO, abort_text, len );
    130                         __lib_debug_write( STDERR_FILENO, "\n", 1 );
     129                        __lib_debug_write( abort_text, len );
     130                        __lib_debug_write( "\n", 1 );
    131131                }
    132132
    133133                len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld)\n", (long int)getpid() ); // use UNIX pid (versus getPid)
    134                 __lib_debug_write( STDERR_FILENO, abort_text, len );
     134                __lib_debug_write( abort_text, len );
    135135
    136136

  • src/libcfa/libhdr/libdebug.c

    r9f0b975 r6a5be52  
    99// Author           : Thierry Delisle
    1010// Created On       : Thu Mar 30 12:30:01 2017
    11 // Last Modified By : 
    12 // Last Modified On : 
     11// Last Modified By :
     12// Last Modified On :
    1313// Update Count     : 0
    1414//
    … …  
    2828extern "C" {
    2929
    30         void __lib_debug_write( int fd, const char *in_buffer, int len ) {
     30        void __lib_debug_write( const char *in_buffer, int len ) {
    3131                // ensure all data is written
    32                 for ( int count = 0, retcode; count < len; count += retcode ) { 
     32                for ( int count = 0, retcode; count < len; count += retcode ) {
    3333                        in_buffer += count;
    3434
    3535                        for ( ;; ) {
    36                                 retcode = write( fd, in_buffer, len - count );
     36                                retcode = write( STDERR_FILENO, in_buffer, len - count );
    3737
    3838                                // not a timer interrupt ?
    39                                 if ( retcode != -1 || errno != EINTR ) break; 
     39                                if ( retcode != -1 || errno != EINTR ) break;
    4040                        }
    4141
    … …  
    5252                va_start( args, fmt );
    5353                __lib_debug_acquire();
    54                
     54
    5555                int len = vsnprintf( buffer, buffer_size, fmt, args );
    56                 __lib_debug_write( STDERR_FILENO, buffer, len );
     56                __lib_debug_write( buffer, len );
    5757
    5858                __lib_debug_release();
    … …  
    6464
    6565                va_start( args, fmt );
    66                
     66
    6767                int len = vsnprintf( buffer, buffer_size, fmt, args );
    68                 __lib_debug_write( STDERR_FILENO, buffer, len );
     68                __lib_debug_write( buffer, len );
    6969
    7070                va_end( args );
    … …  
    7373        void __lib_debug_print_vararg( const char fmt[], va_list args ) {
    7474                int len = vsnprintf( buffer, buffer_size, fmt, args );
    75                 __lib_debug_write( STDERR_FILENO, buffer, len );
     75                __lib_debug_write( buffer, len );
    7676        }
    7777
    … …  
    8080
    8181                va_start( args, fmt );
    82                
     82
    8383                int len = vsnprintf( in_buffer, in_buffer_size, fmt, args );
    84                 __lib_debug_write( STDERR_FILENO, in_buffer, len );
     84                __lib_debug_write( in_buffer, len );
    8585
    8686                va_end( args );

  • src/libcfa/libhdr/libdebug.h

    r9f0b975 r6a5be52  
    4444extern "C" {
    4545#endif
    46       #include <stdarg.h>
     46        #include <stdarg.h>
     47        #include <stdio.h>
    4748
    48       extern void __lib_debug_write( int fd, const char *buffer, int len );
     49      extern void __lib_debug_write( const char *buffer, int len );
    4950      extern void __lib_debug_acquire();
    5051      extern void __lib_debug_release();
    … …  
    5859
    5960#ifdef __CFA_DEBUG_PRINT__
    60         #define LIB_DEBUG_WRITE( fd, buffer, len )     __lib_debug_write( fd, buffer, len )
     61        #define LIB_DEBUG_WRITE( buffer, len )         __lib_debug_write( buffer, len )
    6162        #define LIB_DEBUG_ACQUIRE()                    __lib_debug_acquire()
    6263        #define LIB_DEBUG_RELEASE()                    __lib_debug_release()
    … …  
    6465        #define LIB_DEBUG_PRINT_NOLOCK(...)            __lib_debug_print_nolock (__VA_ARGS__)
    6566        #define LIB_DEBUG_PRINT_BUFFER(...)            __lib_debug_print_buffer (__VA_ARGS__)
    66         #define LIB_DEBUG_PRINT_BUFFER_DECL(fd, ...)   char text[256]; int len = snprintf( text, 256, __VA_ARGS__ ); __lib_debug_write( fd, text, len );
    67         #define LIB_DEBUG_PRINT_BUFFER_LOCAL(fd, ...)  len = snprintf( text, 256, __VA_ARGS__ ); __lib_debug_write( fd, text, len );
     67        #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 );
     68        #define LIB_DEBUG_PRINT_BUFFER_LOCAL(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __lib_debug_write( __dbg_text, __dbg_len );
    6869#else
    6970        #define LIB_DEBUG_WRITE(...)               ((void)0)
Note: See TracChangeset for help on using the changeset viewer.