extras.c

Go to the documentation of this file.

/****************************/
/* THIS IS OPEN SOURCE CODE */
/****************************/

/* 
* File:    extras.c
* Author:  Philip Mucci
*          mucci@cs.utk.edu
* Mods:    dan terpstra
*          terpstra@cs.utk.edu
* Mods:    Haihang You
*          you@cs.utk.edu
* Mods:    Kevin London
*          london@cs.utk.edu
* Mods:    Maynard Johnson
*          maynardj@us.ibm.com
*/

/* This file contains portable routines to do things that we wish the
vendors did in the kernel extensions or performance libraries. */

#include "papi.h"
#include "papi_internal.h"
#include "papi_vector.h"
#include "papi_memory.h"
#include "extras.h"
#include "threads.h"

#if (!defined(HAVE_FFSLL) || defined(__bgp__))
int ffsll( long long lli );
#else
#include <string.h>
#endif

/****************/
/* BEGIN LOCALS */
/****************/

static unsigned int _rnum = DEADBEEF;

/**************/
/* END LOCALS */
/**************/

inline_static unsigned short
random_ushort( void )
{
    return ( unsigned short ) ( _rnum = 1664525 * _rnum + 1013904223 );
}


/* compute the amount by which to increment the bucket.
   value is the current value of the bucket
   this routine is used by all three profiling cases
   it is inlined for speed
*/
inline_static int
profil_increment( long long value,
                  int flags, long long excess, long long threshold )
{
    int increment = 1;

    if ( flags == PAPI_PROFIL_POSIX ) {
        return ( 1 );
    }

    if ( flags & PAPI_PROFIL_RANDOM ) {
        if ( random_ushort(  ) <= ( USHRT_MAX / 4 ) )
            return ( 0 );
    }

    if ( flags & PAPI_PROFIL_COMPRESS ) {
        /* We're likely to ignore the sample if buf[address] gets big. */
        if ( random_ushort(  ) < value ) {
            return ( 0 );
        }
    }

    if ( flags & PAPI_PROFIL_WEIGHTED ) {   /* Increment is between 1 and 255 */
        if ( excess <= ( long long ) 1 )
            increment = 1;
        else if ( excess > threshold )
            increment = 255;
        else {
            threshold = threshold / ( long long ) 255;
            increment = ( int ) ( excess / threshold );
        }
    }
    return ( increment );
}


static void
posix_profil( caddr_t address, PAPI_sprofil_t * prof,
              int flags, long long excess, long long threshold )
{
    unsigned short *buf16;
    unsigned int *buf32;
    unsigned long long *buf64;
    unsigned long indx;
    unsigned long long lloffset;

    /* SPECIAL CASE: if starting address is 0 and scale factor is 2
       then all counts go into first bin.
     */
    if ( ( prof->pr_off == 0 ) && ( prof->pr_scale == 0x2 ) )
        indx = 0;
    else {
        /* compute the profile buffer offset by:
           - subtracting the profiling base address from the pc address
           - multiplying by the scaling factor
           - dividing by max scale (65536, or 2^^16) 
           - dividing by implicit 2 (2^^1 for a total of 2^^17), for even addresses
           NOTE: 131072 is a valid scale value. It produces byte resolution of addresses
         */
        lloffset =
            ( unsigned long long ) ( ( address - prof->pr_off ) *
                                     prof->pr_scale );
        indx = ( unsigned long ) ( lloffset >> 17 );
    }

    /* confirm addresses within specified range */
    if ( address >= prof->pr_off ) {
        /* test first for 16-bit buckets; this should be the fast case */
        if ( flags & PAPI_PROFIL_BUCKET_16 ) {
            if ( ( indx * sizeof ( short ) ) < prof->pr_size ) {
                buf16 = (unsigned short *) prof->pr_base;
                buf16[indx] =
                    ( unsigned short ) ( ( unsigned short ) buf16[indx] +
                                         profil_increment( buf16[indx], flags,
                                                           excess,
                                                           threshold ) );
                PRFDBG( "posix_profil_16() bucket %lu = %u\n", indx,
                        buf16[indx] );
            }
        }
        /* next, look for the 32-bit case */
        else if ( flags & PAPI_PROFIL_BUCKET_32 ) {
            if ( ( indx * sizeof ( int ) ) < prof->pr_size ) {
                buf32 = (unsigned int *) prof->pr_base;
                buf32[indx] = ( unsigned int ) buf32[indx] +
                    ( unsigned int ) profil_increment( buf32[indx], flags,
                                                       excess, threshold );
                PRFDBG( "posix_profil_32() bucket %lu = %u\n", indx,
                        buf32[indx] );
            }
        }
        /* finally, fall through to the 64-bit case */
        else {
            if ( ( indx * sizeof ( long long ) ) < prof->pr_size ) {
                buf64 = (unsigned long long *) prof->pr_base;
                buf64[indx] = ( unsigned long long ) buf64[indx] +
                    ( unsigned long long ) profil_increment( ( long long )
                                                             buf64[indx], flags,
                                                             excess,
                                                             threshold );
                PRFDBG( "posix_profil_64() bucket %lu = %lld\n", indx,
                        buf64[indx] );
            }
        }
    }
}

void
_papi_hwi_dispatch_profile( EventSetInfo_t * ESI, caddr_t pc,
                            long long over, int profile_index )
{
    EventSetProfileInfo_t *profile = &ESI->profile;
    PAPI_sprofil_t *sprof;
    caddr_t offset = 0;
    caddr_t best_offset = 0;
    int count;
    int best_index = -1;
    int i;

    PRFDBG( "handled IP %p\n", pc );

    sprof = profile->prof[profile_index];
    count = profile->count[profile_index];

    for ( i = 0; i < count; i++ ) {
        offset = sprof[i].pr_off;
        if ( ( offset < pc ) && ( offset > best_offset ) ) {
            best_index = i;
            best_offset = offset;
        }
    }

    if ( best_index == -1 )
        best_index = 0;

    posix_profil( pc, &sprof[best_index], profile->flags, over,
                  profile->threshold[profile_index] );
}

/* if isHardware is true, then the processor is using hardware overflow,
   else it is using software overflow. Use this parameter instead of 
   _papi_hwi_system_info.supports_hw_overflow is in CRAY some processors
   may use hardware overflow, some may use software overflow.

   overflow_bit: if the component can get the overflow bit when overflow
                 occurs, then this should be passed by the component;

   If both genOverflowBit and isHardwareSupport are true, that means
     the component doesn't know how to get the overflow bit from the
     kernel directly, so we generate the overflow bit in this function 
    since this function can access the ESI->overflow struct;
   (The component can only set genOverflowBit parameter to true if the
     hardware doesn't support multiple hardware overflow. If the
     component supports multiple hardware overflow and you don't know how 
     to get the overflow bit, then I don't know how to deal with this 
     situation).
*/

int
_papi_hwi_dispatch_overflow_signal( void *papiContext, caddr_t address,
                   int *isHardware, long long overflow_bit,
                   int genOverflowBit, ThreadInfo_t ** t,
                   int cidx )
{
    int retval, event_counter, i, overflow_flag, pos;
    int papi_index, j;
    int profile_index = 0;
    long long overflow_vector;

    long long temp[_papi_hwd[cidx]->cmp_info.num_cntrs], over;
    long long latest = 0;
    ThreadInfo_t *thread;
    EventSetInfo_t *ESI;
    _papi_hwi_context_t *ctx = ( _papi_hwi_context_t * ) papiContext;

    OVFDBG( "enter\n" );

    if ( *t )
        thread = *t;
    else
        *t = thread = _papi_hwi_lookup_thread( 0 );

    if ( thread != NULL ) {
        ESI = thread->running_eventset[cidx];

        if ( ( ESI == NULL ) || ( ( ESI->state & PAPI_OVERFLOWING ) == 0 ) ) {
            OVFDBG( "Either no eventset or eventset not set to overflow.\n" );
#ifdef ANY_THREAD_GETS_SIGNAL
            _papi_hwi_broadcast_signal( thread->tid );
#endif
            return ( PAPI_OK );
        }

        if ( ESI->CmpIdx != cidx )
            return ( PAPI_ENOCMP );

        if ( ESI->master != thread ) {
            PAPIERROR
                ( "eventset->thread %#lx vs. current thread %#lx mismatch",
                  ESI->master, thread );
            return ( PAPI_EBUG );
        }

        if ( isHardware ) {
            if ( ESI->overflow.flags & PAPI_OVERFLOW_HARDWARE ) {
                ESI->state |= PAPI_PAUSED;
                *isHardware = 1;
            } else
                *isHardware = 0;
        }
        /* Get the latest counter value */
        event_counter = ESI->overflow.event_counter;

        overflow_flag = 0;
        overflow_vector = 0;

        if ( !( ESI->overflow.flags & PAPI_OVERFLOW_HARDWARE ) ) {
            retval = _papi_hwi_read( thread->context[cidx], ESI, ESI->sw_stop );
            if ( retval < PAPI_OK )
                return ( retval );
            for ( i = 0; i < event_counter; i++ ) {
                papi_index = ESI->overflow.EventIndex[i];
                latest = ESI->sw_stop[papi_index];
                temp[i] = -1;

                if ( latest >= ( long long ) ESI->overflow.deadline[i] ) {
                    OVFDBG
                        ( "dispatch_overflow() latest %lld, deadline %lld, threshold %d\n",
                          latest, ESI->overflow.deadline[i],
                          ESI->overflow.threshold[i] );
                    pos = ESI->EventInfoArray[papi_index].pos[0];
                    overflow_vector ^= ( long long ) 1 << pos;
                    temp[i] = latest - ESI->overflow.deadline[i];
                    overflow_flag = 1;
                    /* adjust the deadline */
                    ESI->overflow.deadline[i] =
                        latest + ESI->overflow.threshold[i];
                }
            }
        } else if ( genOverflowBit ) {
            /* we had assumed the overflow event can't be derived event */
            papi_index = ESI->overflow.EventIndex[0];

            /* suppose the pos is the same as the counter number
             * (this is not true in Itanium, but itanium doesn't 
             * need us to generate the overflow bit
             */
            pos = ESI->EventInfoArray[papi_index].pos[0];
            overflow_vector = ( long long ) 1 << pos;
        } else
            overflow_vector = overflow_bit;

        if ( ( ESI->overflow.flags & PAPI_OVERFLOW_HARDWARE ) || overflow_flag ) {
            if ( ESI->state & PAPI_PROFILING ) {
                int k = 0;
                while ( overflow_vector ) {
                    i = ffsll( overflow_vector ) - 1;
                    for ( j = 0; j < event_counter; j++ ) {
                        papi_index = ESI->overflow.EventIndex[j];
                        /* This loop is here ONLY because Pentium 4 can have tagged *
                         * events that contain more than one counter without being  *
                         * derived. You've gotta scan all terms to make sure you    *
                         * find the one to profile. */
                        for ( k = 0, pos = 0; k < PAPI_EVENTS_IN_DERIVED_EVENT && pos >= 0;
                              k++ ) {
                            pos = ESI->EventInfoArray[papi_index].pos[k];
                            if ( i == pos ) {
                                profile_index = j;
                                goto foundit;
                            }
                        }
                    }
                    if ( j == event_counter ) {
                        PAPIERROR
                            ( "BUG! overflow_vector is 0, dropping interrupt" );
                        return ( PAPI_EBUG );
                    }

                  foundit:
                    if ( ( ESI->overflow.flags & PAPI_OVERFLOW_HARDWARE ) )
                        over = 0;
                    else
                        over = temp[profile_index];
                    _papi_hwi_dispatch_profile( ESI, address, over,
                                                profile_index );
                    overflow_vector ^= ( long long ) 1 << i;
                }
                /* do not use overflow_vector after this place */
            } else {
                ESI->overflow.handler( ESI->EventSetIndex, ( void * ) address,
                                       overflow_vector, ctx->ucontext );
            }
        }
        ESI->state &= ~( PAPI_PAUSED );
    }
#ifdef ANY_THREAD_GETS_SIGNAL
    else {
        OVFDBG( "I haven't been noticed by PAPI before\n" );
        _papi_hwi_broadcast_signal( ( *_papi_hwi_thread_id_fn ) (  ) );
    }
#endif
    return ( PAPI_OK );
}

#include <sys/time.h>
#include <errno.h>
#include <string.h>

int _papi_hwi_using_signal[PAPI_NSIG];

int
_papi_hwi_start_timer( int timer, int signal, int ns )
{
    struct itimerval value;
    int us = ns / 1000;

    if ( us == 0 )
        us = 1;

#ifdef ANY_THREAD_GETS_SIGNAL
    _papi_hwi_lock( INTERNAL_LOCK );
    if ( ( _papi_hwi_using_signal[signal] - 1 ) ) {
        INTDBG( "itimer already installed\n" );
        _papi_hwi_unlock( INTERNAL_LOCK );
        return ( PAPI_OK );
    }
    _papi_hwi_unlock( INTERNAL_LOCK );
#else
    ( void ) signal;         /*unused */
#endif

    value.it_interval.tv_sec = 0;
    value.it_interval.tv_usec = us;
    value.it_value.tv_sec = 0;
    value.it_value.tv_usec = us;

    INTDBG( "Installing itimer %d, with %d us interval\n", timer, us );
    if ( setitimer( timer, &value, NULL ) < 0 ) {
        PAPIERROR( "setitimer errno %d", errno );
        return ( PAPI_ESYS );
    }

    return ( PAPI_OK );
}

int
_papi_hwi_start_signal( int signal, int need_context, int cidx )
{
    struct sigaction action;

    _papi_hwi_lock( INTERNAL_LOCK );
    _papi_hwi_using_signal[signal]++;
    if ( _papi_hwi_using_signal[signal] - 1 ) {
        INTDBG( "_papi_hwi_using_signal is now %d\n",
                _papi_hwi_using_signal[signal] );
        _papi_hwi_unlock( INTERNAL_LOCK );
        return ( PAPI_OK );
    }

    memset( &action, 0x00, sizeof ( struct sigaction ) );
    action.sa_flags = SA_RESTART;
    action.sa_sigaction =
        ( void ( * )( int, siginfo_t *, void * ) ) _papi_hwd[cidx]->
        dispatch_timer;
    if ( need_context )
#if (defined(_BGL) /*|| defined (__bgp__)*/)
        action.sa_flags |= SIGPWR;
#else
        action.sa_flags |= SA_SIGINFO;
#endif

    INTDBG( "installing signal handler\n" );
    if ( sigaction( signal, &action, NULL ) < 0 ) {
        PAPIERROR( "sigaction errno %d", errno );
        _papi_hwi_unlock( INTERNAL_LOCK );
        return ( PAPI_ESYS );
    }

    INTDBG( "_papi_hwi_using_signal[%d] is now %d.\n", signal,
            _papi_hwi_using_signal[signal] );
    _papi_hwi_unlock( INTERNAL_LOCK );

    return ( PAPI_OK );
}

int
_papi_hwi_stop_signal( int signal )
{
    _papi_hwi_lock( INTERNAL_LOCK );
    if ( --_papi_hwi_using_signal[signal] == 0 ) {
        INTDBG( "removing signal handler\n" );
        if ( sigaction( signal, NULL, NULL ) == -1 ) {
            PAPIERROR( "sigaction errno %d", errno );
            _papi_hwi_unlock( INTERNAL_LOCK );
            return ( PAPI_ESYS );
        }
    }

    INTDBG( "_papi_hwi_using_signal[%d] is now %d\n", signal,
            _papi_hwi_using_signal[signal] );
    _papi_hwi_unlock( INTERNAL_LOCK );

    return ( PAPI_OK );
}

int
_papi_hwi_stop_timer( int timer, int signal )
{
    struct itimerval value;

#ifdef ANY_THREAD_GETS_SIGNAL
    _papi_hwi_lock( INTERNAL_LOCK );
    if ( _papi_hwi_using_signal[signal] > 1 ) {
        INTDBG( "itimer in use by another thread\n" );
        _papi_hwi_unlock( INTERNAL_LOCK );
        return ( PAPI_OK );
    }
    _papi_hwi_unlock( INTERNAL_LOCK );
#else
    ( void ) signal;         /*unused */
#endif

    value.it_interval.tv_sec = 0;
    value.it_interval.tv_usec = 0;
    value.it_value.tv_sec = 0;
    value.it_value.tv_usec = 0;

    INTDBG( "turning off timer\n" );
    if ( setitimer( timer, &value, NULL ) == -1 ) {
        PAPIERROR( "setitimer errno %d", errno );
        return PAPI_ESYS;
    }

    return PAPI_OK;
}



#if (!defined(HAVE_FFSLL) || defined(__bgp__))
/* find the first set bit in long long */

int
ffsll( long long lli )
{
    int i, num, t, tmpint, len;

    num = sizeof ( long long ) / sizeof ( int );
    if ( num == 1 )
        return ( ffs( ( int ) lli ) );
    len = sizeof ( int ) * CHAR_BIT;

    for ( i = 0; i < num; i++ ) {
        tmpint = ( int ) ( ( ( lli >> len ) << len ) ^ lli );

        t = ffs( tmpint );
        if ( t ) {
            return ( t + i * len );
        }
        lli = lli >> len;
    }
    return PAPI_OK;
}
#endif