linux-L2unit.c File Reference

This file has the source code for a component that enables PAPI-C to access hardware monitoring counters for BG/Q through the bgpm library. More...

Include dependency graph for linux-L2unit.c:

Go to the source code of this file.

Functions
void	user_signal_handler_L2UNIT (int hEvtSet, uint64_t address, uint64_t ovfVector, const ucontext_t *pContext)
int	L2UNIT_init_thread (hwd_context_t *ctx)
int	L2UNIT_init_component (int cidx)
int	L2UNIT_init_control_state (hwd_control_state_t *ptr)
int	L2UNIT_start (hwd_context_t *ctx, hwd_control_state_t *ptr)
int	L2UNIT_stop (hwd_context_t *ctx, hwd_control_state_t *ptr)
int	L2UNIT_read (hwd_context_t *ctx, hwd_control_state_t *ptr, long_long **events, int flags)
int	L2UNIT_shutdown_thread (hwd_context_t *ctx)
int	L2UNIT_set_overflow (EventSetInfo_t *ESI, int EventIndex, int threshold)
int	L2UNIT_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
int	L2UNIT_cleanup_eventset (hwd_control_state_t *ctrl)
int	L2UNIT_update_control_state (hwd_control_state_t *ptr, NativeInfo_t *native, int count, hwd_context_t *ctx)
int	L2UNIT_set_domain (hwd_control_state_t *cntrl, int domain)
int	L2UNIT_reset (hwd_context_t *ctx, hwd_control_state_t *ptr)
int	L2UNIT_ntv_enum_events (unsigned int *EventCode, int modifier)
int	L2UNIT_ntv_name_to_code (const char *name, unsigned int *event_code)
int	L2UNIT_ntv_code_to_name (unsigned int EventCode, char *name, int len)
int	L2UNIT_ntv_code_to_descr (unsigned int EventCode, char *name, int len)
int	L2UNIT_ntv_code_to_bits (unsigned int EventCode, hwd_register_t *bits)

Variables
papi_vector_t	_L2unit_vector

Detailed Description

Author

Heike Jagode jagod.nosp@m.e@ee.nosp@m.cs.ut.nosp@m.k.ed.nosp@m.u Mods: < your name here > < your email address > BGPM / L2unit component

Tested version of bgpm (early access)

Definition in file linux-L2unit.c.

Function Documentation

L2UNIT_cleanup_eventset()

int L2UNIT_cleanup_eventset

(

hwd_control_state_t *

ctrl

)

Definition at line 386 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_cleanup_eventset\n" );
#endif
    int retval;

    L2UNIT_control_state_t * this_state = ( L2UNIT_control_state_t * ) ctrl;
    
    // create a new empty bgpm eventset
    // reason: bgpm doesn't permit to remove events from an eventset; 
    // hence we delete the old eventset and create a new one
    retval = _common_deleteRecreate( &this_state->EventGroup ); 
    if ( retval < 0 ) return retval;

    // set overflow flag to OFF (0)
    this_state->overflow = 0;
    this_state->overflow_count = 0;
    // set BGPM eventGroup flag back to NOT applied yet (0)
    this_state->bgpm_eventset_applied = 0;
    
    return ( PAPI_OK );
}

Here is the call graph for this function:

L2UNIT_ctl()

int L2UNIT_ctl	(	hwd_context_t *	ctx,
		int	code,
		_papi_int_option_t *	option
	)

Definition at line 368 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_ctl\n" );
#endif
    
    ( void ) ctx;
    ( void ) code;
    ( void ) option;
    return ( PAPI_OK );
}

L2UNIT_init_component()

int L2UNIT_init_component

(

int

cidx

)

Definition at line 52 of file linux-L2unit.c.

{ 
#ifdef DEBUG_BGQ
    printf( "L2UNIT_init_component\n" );
#endif
    
    _L2unit_vector.cmp_info.CmpIdx = cidx;
#ifdef DEBUG_BGQ
    printf( "L2UNIT_init_component cidx = %d\n", cidx );
#endif
    
    return ( PAPI_OK );
}

L2UNIT_init_control_state()

int L2UNIT_init_control_state

(

hwd_control_state_t *

ptr

)

Definition at line 72 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_init_control_state\n" );
#endif
    int retval;

    L2UNIT_control_state_t * this_state = ( L2UNIT_control_state_t * ) ptr;
    
    this_state->EventGroup = Bgpm_CreateEventSet();
    retval = _check_BGPM_error( this_state->EventGroup, "Bgpm_CreateEventSet" );
    if ( retval < 0 ) return retval;

    // initialize overflow flag to OFF (0)
    this_state->overflow = 0;
    this_state->overflow_count = 0;
    // initialized BGPM eventGroup flag to NOT applied yet (0)
    this_state->bgpm_eventset_applied = 0;

    return PAPI_OK;
}

Here is the call graph for this function:

L2UNIT_init_thread()

int L2UNIT_init_thread

(

hwd_context_t *

ctx

)

Definition at line 36 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_init_thread\n" );
#endif
    
    ( void ) ctx;
    return PAPI_OK;
}

L2UNIT_ntv_code_to_bits()

int L2UNIT_ntv_code_to_bits	(	unsigned int	EventCode,
		hwd_register_t *	bits
	)

Definition at line 659 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_ntv_code_to_bits\n" );
#endif
    ( void ) EventCode;
    ( void ) bits;
    return ( PAPI_OK );
}

L2UNIT_ntv_code_to_descr()

int L2UNIT_ntv_code_to_descr	(	unsigned int	EventCode,
		char *	name,
		int	len
	)

Definition at line 638 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    //printf( "L2UNIT_ntv_code_to_descr\n" );
#endif
    int retval, index;
    
    index = ( EventCode ) + OFFSET;
    
    retval = Bgpm_GetLongDesc( index, name, &len );
    retval = _check_BGPM_error( retval, "Bgpm_GetLongDesc" );                        
    if ( retval < 0 ) return retval;

    return ( PAPI_OK );
}

Here is the call graph for this function:

L2UNIT_ntv_code_to_name()

int L2UNIT_ntv_code_to_name	(	unsigned int	EventCode,
		char *	name,
		int	len
	)

Definition at line 609 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    //printf( "L2UNIT_ntv_code_to_name\n" );
#endif
    int index;
    
    index = ( EventCode ) + OFFSET;

    if ( index >= MAX_COUNTERS )
        return PAPI_ENOEVNT;

    strncpy( name, Bgpm_GetEventIdLabel( index ), len );
    
    if ( name == NULL ) {
#ifdef DEBUG_BGPM
        printf ("Error: ret value is NULL for BGPM API function Bgpm_GetEventIdLabel.\n" );
#endif
        return PAPI_ENOEVNT;
    }
    
    return ( PAPI_OK );
}

L2UNIT_ntv_enum_events()

int L2UNIT_ntv_enum_events	(	unsigned int *	EventCode,
		int	modifier
	)

Definition at line 543 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    //printf( "L2UNIT_ntv_enum_events, EventCode = %#x\n", *EventCode );
#endif

    switch ( modifier ) {
    case PAPI_ENUM_FIRST:
        *EventCode = 0;

        return ( PAPI_OK );
        break;

    case PAPI_ENUM_EVENTS:
    {
        int index = ( *EventCode ) + OFFSET;

        if ( index < L2UNIT_MAX_EVENTS ) {
            *EventCode = *EventCode + 1;
            return ( PAPI_OK );
        } else
            return ( PAPI_ENOEVNT );

        break;
    }
    default:
        return ( PAPI_EINVAL );
    }
    return ( PAPI_EINVAL );
}

L2UNIT_ntv_name_to_code()

int L2UNIT_ntv_name_to_code	(	const char *	name,
		unsigned int *	event_code
	)

Definition at line 579 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_ntv_name_to_code\n" );
#endif
    int ret;
    
    /* Return event id matching a given event label string */
    ret = Bgpm_GetEventIdFromLabel ( name );
    
    if ( ret <= 0 ) {
#ifdef DEBUG_BGPM
        printf ("Error: ret value is %d for BGPM API function '%s'.\n",
                ret, "Bgpm_GetEventIdFromLabel" );
#endif
        return PAPI_ENOEVNT;
    }
    else if ( ret < OFFSET || ret > L2UNIT_MAX_EVENTS ) // not a L2Unit event
        return PAPI_ENOEVNT;
    else
        *event_code = ( ret - OFFSET );

    return PAPI_OK;
}

L2UNIT_read()

int L2UNIT_read	(	hwd_context_t *	ctx,
		hwd_control_state_t *	ptr,
		long_long **	events,
		int	flags
	)

Definition at line 150 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_read\n" );
#endif
    ( void ) ctx;
    ( void ) flags;
    int i, numEvts;
    L2UNIT_control_state_t * this_state = ( L2UNIT_control_state_t * ) ptr;
    
    numEvts = Bgpm_NumEvents( this_state->EventGroup );
    if ( numEvts == 0 ) {
#ifdef DEBUG_BGPM
        printf ("Error: ret value is %d for BGPM API function Bgpm_NumEvents.\n", numEvts );
#endif
        //return ( EXIT_FAILURE );
    }

    for ( i = 0; i < numEvts; i++ )
        this_state->counters[i] = _common_getEventValue( i, this_state->EventGroup );
    
    *events = this_state->counters;
    
    return ( PAPI_OK );
}

Here is the call graph for this function:

L2UNIT_reset()

int L2UNIT_reset	(	hwd_context_t *	ctx,
		hwd_control_state_t *	ptr
	)

Definition at line 514 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_reset\n" );
#endif
    ( void ) ctx;
    int retval;
    L2UNIT_control_state_t * this_state = ( L2UNIT_control_state_t * ) ptr;

    /* we can't simply call Bgpm_Reset() since PAPI doesn't have the 
     restriction that an EventSet has to be stopped before resetting is
     possible. However, BGPM does have this restriction. 
     Hence we need to stop, reset and start */
    retval = Bgpm_Stop( this_state->EventGroup );
    retval = _check_BGPM_error( retval, "Bgpm_Stop" );
    if ( retval < 0 ) return retval;

    retval = Bgpm_ResetStart( this_state->EventGroup );
    retval = _check_BGPM_error( retval, "Bgpm_ResetStart" );
    if ( retval < 0 ) return retval;

    return ( PAPI_OK );
}

Here is the call graph for this function:

L2UNIT_set_domain()

int L2UNIT_set_domain	(	hwd_control_state_t *	cntrl,
		int	domain
	)

Definition at line 486 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_set_domain\n" );
#endif
    int found = 0;
    ( void ) cntrl;

    if ( PAPI_DOM_USER & domain )
        found = 1;

    if ( PAPI_DOM_KERNEL & domain )
        found = 1;

    if ( PAPI_DOM_OTHER & domain )
        found = 1;

    if ( !found )
        return ( PAPI_EINVAL );

    return ( PAPI_OK );
}

L2UNIT_set_overflow()

int L2UNIT_set_overflow	(	EventSetInfo_t *	ESI,
		int	EventIndex,
		int	threshold
	)

Definition at line 290 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf("BEGIN L2UNIT_set_overflow\n");
#endif
    L2UNIT_control_state_t * this_state = ( L2UNIT_control_state_t * ) ESI->ctl_state;
    int retval;
    int evt_idx;
    
    /*
     * In case an BGPM eventGroup HAS BEEN applied or attached before
     * overflow is set, delete the eventGroup and create an new empty one,
     * and rebuild as it was prior to deletion
     */
#ifdef DEBUG_BGQ
    printf( "L2UNIT_set_overflow: bgpm_eventset_applied = %d, threshold = %d\n",
           this_state->bgpm_eventset_applied, threshold );
#endif  
    if ( 1 == this_state->bgpm_eventset_applied && 0 != threshold ) {
        retval = _common_deleteRecreate( &this_state->EventGroup );
        if ( retval < 0 ) return retval;
        retval = _common_rebuildEventgroup( this_state->count,
                                  this_state->EventGroup_local,
                                  &this_state->EventGroup );
        if ( retval < 0 ) return retval;

        /* set BGPM eventGroup flag back to NOT applied yet (0) 
         * because the eventGroup has been recreated from scratch */
        this_state->bgpm_eventset_applied = 0;
    }
        
    evt_idx = ESI->EventInfoArray[EventIndex].pos[0];
    SUBDBG( "Hardware counter %d (vs %d) used in overflow, threshold %d\n",
           evt_idx, EventIndex, threshold );
#ifdef DEBUG_BGQ
    printf( "Hardware counter %d (vs %d) used in overflow, threshold %d\n",
           evt_idx, EventIndex, threshold );
#endif
    /* If this counter isn't set to overflow, it's an error */
    if ( threshold == 0 ) {
        /* Remove the signal handler */
        retval = _papi_hwi_stop_signal( _L2unit_vector.cmp_info.hardware_intr_sig );
        if ( retval != PAPI_OK )
            return ( retval );
    }
    else {
        this_state->overflow = 1;
        this_state->overflow_count++;
        this_state->overflow_list[this_state->overflow_count-1].threshold = threshold;
        this_state->overflow_list[this_state->overflow_count-1].EventIndex = evt_idx;
        
#ifdef DEBUG_BGQ
        printf( "L2UNIT_set_overflow: Enable the signal handler\n" );
#endif
        /* Enable the signal handler */
        retval = _papi_hwi_start_signal( _L2unit_vector.cmp_info.hardware_intr_sig, 
                                        NEED_CONTEXT, 
                                        _L2unit_vector.cmp_info.CmpIdx );
        if ( retval != PAPI_OK )
            return ( retval );

        retval = _common_set_overflow_BGPM( this_state->EventGroup,
                                  this_state->overflow_list[this_state->overflow_count-1].EventIndex,
                                  this_state->overflow_list[this_state->overflow_count-1].threshold,
                                  user_signal_handler_L2UNIT );
        if ( retval < 0 ) return retval;
    }
    
    return ( PAPI_OK );
}

Here is the call graph for this function:

L2UNIT_shutdown_thread()

int L2UNIT_shutdown_thread

(

hwd_context_t *

ctx

)

Definition at line 182 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_shutdown_thread\n" );
#endif
    
    ( void ) ctx;
    return ( PAPI_OK );
}

L2UNIT_start()

int L2UNIT_start	(	hwd_context_t *	ctx,
		hwd_control_state_t *	ptr
	)

Definition at line 99 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_start\n" );
#endif
    ( void ) ctx;
    int retval;
    L2UNIT_control_state_t * this_state = ( L2UNIT_control_state_t * ) ptr;
    
    retval = Bgpm_Apply( this_state->EventGroup ); 
    retval = _check_BGPM_error( retval, "Bgpm_Apply" );
    if ( retval < 0 ) return retval;

    // set flag to 1: BGPM eventGroup HAS BEEN applied
    this_state->bgpm_eventset_applied = 1;

    /* Bgpm_Apply() does an implicit reset; 
     hence no need to use Bgpm_ResetStart */
    retval = Bgpm_Start( this_state->EventGroup );
    retval = _check_BGPM_error( retval, "Bgpm_Start" );
    if ( retval < 0 ) return retval;

    return ( PAPI_OK );
}

Here is the call graph for this function:

L2UNIT_stop()

int L2UNIT_stop	(	hwd_context_t *	ctx,
		hwd_control_state_t *	ptr
	)

Definition at line 129 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_stop\n" );
#endif
    ( void ) ctx;
    int retval;
    L2UNIT_control_state_t * this_state = ( L2UNIT_control_state_t * ) ptr;
    
    retval = Bgpm_Stop( this_state->EventGroup );
    retval = _check_BGPM_error( retval, "Bgpm_Stop" );
    if ( retval < 0 ) return retval;

    return ( PAPI_OK );
}

Here is the call graph for this function:

L2UNIT_update_control_state()

int L2UNIT_update_control_state	(	hwd_control_state_t *	ptr,
		NativeInfo_t *	native,
		int	count,
		hwd_context_t *	ctx
	)

Definition at line 415 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "L2UNIT_update_control_state: count = %d\n", count );
#endif  
    
    ( void ) ctx;
    int retval, index, i, k;
    L2UNIT_control_state_t * this_state = ( L2UNIT_control_state_t * ) ptr;
    
    // Delete and re-create BGPM eventset
    retval = _common_deleteRecreate( &this_state->EventGroup );
    if ( retval < 0 ) return retval;

#ifdef DEBUG_BGQ
    printf( "L2UNIT_update_control_state: EventGroup=%d, overflow = %d\n",
           this_state->EventGroup, this_state->overflow );
#endif
    
    
    // otherwise, add the events to the eventset
    for ( i = 0; i < count; i++ ) {
        index = ( native[i].ni_event ) + OFFSET;
        
        native[i].ni_position = i;
        
#ifdef DEBUG_BGQ
        printf("L2UNIT_update_control_state: ADD event: i = %d, index = %d\n", i, index );
#endif
        
        this_state->EventGroup_local[i] = index;

        
        /* Add events to the BGPM eventGroup */
        retval = Bgpm_AddEvent( this_state->EventGroup, index );
        retval = _check_BGPM_error( retval, "Bgpm_AddEvent" );
        if ( retval < 0 ) return retval;
    }
    
    // store how many events we added to an EventSet
    this_state->count = count;

    // since update_control_state trashes overflow settings, this puts things
    // back into balance for BGPM
    if ( 1 == this_state->overflow ) {
        for ( k = 0; k < this_state->overflow_count; k++ ) {
            retval = _common_set_overflow_BGPM( this_state->EventGroup,
                                      this_state->overflow_list[k].EventIndex,
                                      this_state->overflow_list[k].threshold,
                                      user_signal_handler_L2UNIT );
            if ( retval < 0 ) return retval;
        }
    }
    
    return ( PAPI_OK );
}

Here is the call graph for this function:

user_signal_handler_L2UNIT()

void user_signal_handler_L2UNIT	(	int	hEvtSet,
		uint64_t	address,
		uint64_t	ovfVector,
		const ucontext_t *	pContext
	)

Definition at line 202 of file linux-L2unit.c.

{
#ifdef DEBUG_BGQ
    printf( "user_signal_handler_L2UNIT\n" );
#endif
    ( void ) address;
    int retval;
    unsigned i;
    int isHardware = 1;
    int cidx = _L2unit_vector.cmp_info.CmpIdx;
    long_long overflow_bit = 0;
    caddr_t address1;
    _papi_hwi_context_t ctx;
    ctx.ucontext = ( hwd_ucontext_t * ) pContext;
    ThreadInfo_t *thread = _papi_hwi_lookup_thread( 0 );
    EventSetInfo_t *ESI;
    ESI = thread->running_eventset[cidx];
    // Get the indices of all events which have overflowed.
    unsigned ovfIdxs[BGPM_MAX_OVERFLOW_EVENTS];
    unsigned len = BGPM_MAX_OVERFLOW_EVENTS;
    
    retval = Bgpm_GetOverflowEventIndices( hEvtSet, ovfVector, ovfIdxs, &len );
    if ( retval < 0 ) {
#ifdef DEBUG_BGPM
        printf ( "Error: ret value is %d for BGPM API function Bgpm_GetOverflowEventIndices.\n",
                 retval );
#endif
        return;
    }
    
    if ( thread == NULL ) {
        PAPIERROR( "thread == NULL in user_signal_handler!" );
        return;
    }
    
    if ( ESI == NULL ) {
        PAPIERROR( "ESI == NULL in user_signal_handler!");
        return;
    }
    
    if ( ESI->overflow.flags == 0 ) {
        PAPIERROR( "ESI->overflow.flags == 0 in user_signal_handler!");
        return;
    }
    
    for ( i = 0; i < len; i++ ) {
        uint64_t hProf;
        Bgpm_GetEventUser1( hEvtSet, ovfIdxs[i], &hProf );
        if ( hProf ) {
            overflow_bit ^= 1 << ovfIdxs[i];
            break;
        }
        
    }
    
    if ( ESI->overflow.flags & PAPI_OVERFLOW_FORCE_SW ) {
#ifdef DEBUG_BGQ
        printf("OVERFLOW_SOFTWARE\n");
#endif
        address1 = GET_OVERFLOW_ADDRESS( ctx );
        _papi_hwi_dispatch_overflow_signal( ( void * ) &ctx, address1, NULL, 0, 0, &thread, cidx );
        return;
    }
    else if ( ESI->overflow.flags & PAPI_OVERFLOW_HARDWARE ) {
#ifdef DEBUG_BGQ
        printf("OVERFLOW_HARDWARE\n");
#endif
        address1 = GET_OVERFLOW_ADDRESS( ctx );
        _papi_hwi_dispatch_overflow_signal( ( void * ) &ctx, address1, &isHardware, overflow_bit, 0, &thread, cidx );
    }
    else {
#ifdef DEBUG_BGQ
        printf("OVERFLOW_NONE\n");
#endif
        PAPIERROR( "ESI->overflow.flags is set to something other than PAPI_OVERFLOW_HARDWARE or PAPI_OVERFLOW_FORCE_SW (%#x)", thread->running_eventset[cidx]->overflow.flags);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_L2unit_vector

papi_vector_t _L2unit_vector

Definition at line 23 of file linux-L2unit.c.