ppc64_events.c

Go to the documentation of this file.

/****************************/
/* THIS IS OPEN SOURCE CODE */
/****************************/
 
/* 
* File:    ppc64_events.c
* Author:  Maynard Johnson
*          maynardj@us.ibm.com
* Mods:    <your name here>
*          <your email address>
*/
 
#include "papi_internal.h"
#include <string.h>
#include "libperfctr.h"
 
hwd_groups_t group_map[MAX_GROUPS] = { {0}
, {0}
, {0}
, {0}
, {0}
};
native_event_entry_t native_table[PAPI_MAX_NATIVE_EVENTS];
 
/* to initialize the native_table */
void
perfctr_initialize_native_table(  )
{
    int i, j;
    memset( native_table, 0,
            PAPI_MAX_NATIVE_EVENTS * sizeof ( native_event_entry_t ) );
    for ( i = 0; i < PAPI_MAX_NATIVE_EVENTS; i++ ) {
        for ( j = 0; j < MAX_COUNTERS; j++ )
            native_table[i].resources.counter_cmd[j] = -1;
    }
}
 
 
/* to setup native_table group value */
void
perfctr_ppc64_setup_gps( int total, ntv_event_group_info_t * group_info )
{
    int i, j, gnum;
 
    for ( i = 0; i < total; i++ ) {
        for ( j = 0; j < MAX_COUNTERS; j++ ) {
            if ( native_table[i].resources.selector & ( 1 << j ) ) {
                for ( gnum = 0; gnum < group_info->maxgroups; gnum++ ) {
                    if ( native_table[i].resources.counter_cmd[j] ==
                         group_info->event_groups[gnum]->events[j] ) {
                        native_table[i].resources.group[gnum / 32] |=
                            1 << ( gnum % 32 );
                    }
                }
            }
        }
    }
 
    for ( gnum = 0; gnum < group_info->maxgroups; gnum++ ) {
        group_map[gnum].mmcr0 = group_info->event_groups[gnum]->mmcr0;
        group_map[gnum].mmcr1L = group_info->event_groups[gnum]->mmcr1L;
        group_map[gnum].mmcr1U = group_info->event_groups[gnum]->mmcr1U;
        group_map[gnum].mmcra = group_info->event_groups[gnum]->mmcra;
        for ( i = 0; i < MAX_COUNTERS; i++ )
            group_map[gnum].counter_cmd[i] =
                group_info->event_groups[gnum]->events[i];
    }
}
 
 
/* to setup native_table values, and return number of entries */
int
perfctr_ppc64_setup_native_table(  )
{
    int pmc, ev, i, j, index;
    /* This is for initialisation-testing of consistency between
       native_name_map and our events file */
    int itemCount = 0;
    index = 0;
    perfctr_initialize_native_table(  );
    ntv_event_info_t *info = perfctr_get_native_evt_info(  );
    if ( info == NULL ) {
        PAPIERROR( EVENT_INFO_FILE_ERROR );
        return PAPI_ECMP;
    }
    ntv_event_t *wevp;
    for ( pmc = 0; pmc < info->maxpmcs; pmc++ ) {
        wevp = info->wev[pmc];
        for ( ev = 0; ev < info->maxevents[pmc]; ev++, wevp++ ) {
            for ( i = 0; i < index; i++ ) {
                if ( strcmp( wevp->symbol, native_table[i].name ) == 0 ) {
                    native_table[i].resources.selector |= 1 << pmc;
                    native_table[i].resources.counter_cmd[pmc] =
                        wevp->event_num;
                    break;
                }
            }
            if ( i == index ) {
                //native_table[i].index=i; 
                native_table[i].resources.selector |= 1 << pmc;
                native_table[i].resources.counter_cmd[pmc] = wevp->event_num;
                native_table[i].name =
                    ( char * ) malloc( strlen( wevp->symbol ) + 1 );
                strcpy( native_table[i].name, wevp->symbol );
                native_table[i].description = wevp->description;
                index++;
                for ( j = 0; j < MAX_NATNAME_MAP_INDEX; j++ ) {
                    /* It appears that here, if I'm right, that the events
                       file entry matches the event from native_name_map, */
                    /* This here check is to ensure that native_name_map in fact
                       has MAX_NATNAME_MAP_INDEX elements, or rather that it never
                       tries to access one that has not been initialised. */
                    if ( native_name_map[j].name == NULL ) {
                        SUBDBG( "native_name_map has a NULL at position %i\n",
                                j );
                        PAPIERROR
                            ( "Inconsistency between events_map file and events header." );
                        return PAPI_EBUG;
                    }
                    if ( strcmp( native_table[i].name, native_name_map[j].name )
                         == 0 ) {
                        native_name_map[j].index = i;
                        itemCount++;
                        break;
                    }
                }
                /* If we never set native_name_map[j], then there is an
                   inconsistency between native_name_map and native_table */
                if ( ( !( j < MAX_NATNAME_MAP_INDEX ) ) ||
                     native_name_map[j].index != i ) {
                    SUBDBG
                        ( "No match found between native_name_map and native_table.  "
                          "Values was %s at position %i in native_table.\n",
                          native_table[i].name, i );
                    PAPIERROR
                        ( "Inconsistency between native_name_map and events file." );
                    return PAPI_EBUG;
                }
            }
        }
    }
    /* given the previous evidence that native_name_map is a superset of
       native_table, ensuring this match in their cardinality shows them to
       be equivalent. */
    if ( itemCount != MAX_NATNAME_MAP_INDEX ) {
        SUBDBG( "%i events found in native_table, but really should be %i\n",
                itemCount, MAX_NATNAME_MAP_INDEX );
        PAPIERROR
            ( "Inconsistent cardinality between native_name_map and events file",
              itemCount, MAX_NATNAME_MAP_INDEX );
        return PAPI_EBUG;
    }
 
    ntv_event_group_info_t *gp_info = perfctr_get_native_group_info(  );
    if ( gp_info == NULL ) {
        perfctr_initialize_native_table(  );
        PAPIERROR( EVENT_INFO_FILE_ERROR );
        return PAPI_ECMP;
    }
 
    perfctr_ppc64_setup_gps( index, gp_info );
    _papi_hwi_system_info.sub_info.num_native_events = index;
 
    return check_native_name(  );
}
 
int
check_native_name(  )
{
    enum native_name foo;
    int itemCount = 0;
    int i;
 
    /* This should ensure that the cardinality of native_name is the same
       as that of native_name_map which may be true iff native_name 
       expresses the same data as native_name_map and there is a 1:1 
       mapping from one onto the other, though there is no guarantee of 
       order. */
    if ( ( NATNAME_GUARD - PAPI_NATIVE_MASK ) != MAX_NATNAME_MAP_INDEX ) {
        SUBDBG( "%i is the number of elements apparently in native_name, "
                "but really should be %i, according to native_name_map.\n",
                ( NATNAME_GUARD - PAPI_NATIVE_MASK ), MAX_NATNAME_MAP_INDEX );
        PAPIERROR
            ( "Inconsistent cardinality between native_name and native_name_map "
              "detected in preliminary check\n" );
        return PAPI_EBUG;
    }
 
    /* The following is sanity checking only.  It attempts to verify some level
       of consistency between native_name and native_name_map and native_table.
       This should imply that native_name is a subset of native_name_map. */
    for ( foo = PAPI_NATIVE_MASK; foo < NATNAME_GUARD; foo++ ) {
        for ( i = 0; i < MAX_NATNAME_MAP_INDEX; i++ ) {
            /* Now, if the event we are on is the native event we seek... */
            if ( ( native_name_map[i].index | PAPI_NATIVE_MASK ) == foo ) {
                itemCount++;
                break;
            }
        }
    }
    if ( itemCount != MAX_NATNAME_MAP_INDEX ) {
        SUBDBG( "Inconsistency between native_name_map and native_name.  "
                "%i events matched, but really should be %i\n", itemCount,
                MAX_NATNAME_MAP_INDEX );
        PAPIERROR
            ( "Inconsistent cardinality between native_name and native_name_map\n" );
        return PAPI_EBUG;
    }
 
    return PAPI_OK;
}
 
static FILE *
open_file( const char *fname )
{
    char *cpu;
    char *dot = ".";
    char *dot_dot = "..";
#ifdef _POWER5p
    cpu = "power5+";
#elif defined(_POWER5)
    cpu = "power5";
#elif defined(_PPC970)
    cpu = "ppc970";
#else
    cpu = "";
#endif
    char *dir = ( char * ) getenv( "PAPI_EVENTFILE_PATH" );
#ifdef PAPI_DATADIR
    if ( dir == NULL ) {
        dir = PAPI_DATADIR;
    }
#endif
    /* If dir is still NULL, assume current dir holds event_data dir */
    if ( dir == NULL )
        dir = dot;
 
    char *relative_pathname = ( char * ) malloc( strlen( "/" ) +
                                                 strlen( "event_data" ) +
                                                 strlen( "/" ) + strlen( cpu ) +
                                                 strlen( "/" ) +
                                                 strlen( fname ) + 1 );
    strcpy( relative_pathname, "/" );
    strcat( relative_pathname, "event_data" );
    strcat( relative_pathname, "/" );
    strcat( relative_pathname, cpu );
    strcat( relative_pathname, "/" );
    strcat( relative_pathname, fname );
    /* Add a little extra space to the malloc for the case where dir = "." since
     * we may be trying dir = ".." later on. */
    char *pathname =
        ( char * ) malloc( strlen( dir ) + strlen( relative_pathname ) + 4 );
    int keep_trying;
    if ( strcmp( dir, dot ) == 0 )
        keep_trying = 2;
    else
        keep_trying = 3;
    FILE *file = NULL;
    while ( file == NULL && keep_trying-- ) {
        strcpy( pathname, dir );
        strcat( pathname, relative_pathname );
        file = fopen( pathname, "r" );
        if ( strcmp( dir, dot ) == 0 ) {
            dir = dot_dot;
        } else {
            dir = dot;
        }
        SUBDBG( "Attempt to open event data file %s %s successful.\n", pathname,
                ( file == NULL ) ? "was not" : "was" );
        memset( pathname, '\0', sizeof ( pathname ) );
    }
 
    free( pathname );
    free( relative_pathname );
    return ( file );
}
 
static ntv_event_t *
copy_buffer( ntv_event_t events[], int maxevents )
{
    ntv_event_t *cur_wev, *start_wev;
    start_wev = ( ntv_event_t * ) malloc( sizeof ( ntv_event_t ) * maxevents );
    cur_wev = start_wev;
 
    int cnt;
    for ( cnt = 0; cnt < maxevents; cnt++, cur_wev++ ) {
        cur_wev->event_num = events[cnt].event_num;
        strcpy( cur_wev->symbol, events[cnt].symbol );
        cur_wev->short_description =
            ( char * ) malloc( strlen( events[cnt].short_description ) );
        strcpy( cur_wev->short_description, events[cnt].short_description );
        cur_wev->description =
            ( char * ) malloc( strlen( events[cnt].description ) );
        strcpy( cur_wev->description, events[cnt].description );
    }
    return start_wev;
}
 
static ntv_event_info_t *
parse_eventfile( FILE * evfile )
{
    int counter = 0, num_events = 0;
    int i, len, cc;
    int event;
    int line_counter_flag = 0;
    char line_data[1024];
    ntv_event_t events[PAPI_MAX_NATIVE_EVENTS];
    ntv_event_info_t *ntv_evt_info =
        ( ntv_event_info_t * ) malloc( sizeof ( ntv_event_info_t ) );
    ntv_evt_info->maxpmcs = 0;
    char data[1024];
    while ( fgets( data, 1022, evfile ) ) {
        if ( feof( evfile ) )
            continue;
        if ( strlen( data ) < 2 )
            continue;
 
        if ( strncmp( data, "$$$$", 4 ) == 0 ) {
            line_counter_flag = 0;
            ntv_evt_info->maxevents[counter - 1] = num_events;
            ntv_evt_info->wev[counter - 1] = copy_buffer( events, num_events );
            ntv_event_t *temp = ntv_evt_info->wev[counter - 1];
            temp++;
        }
        switch ( line_counter_flag ) {
        case 0:
            if ( sscanf( data, "{ counter %u", &counter ) == 1 ) {
                line_counter_flag = 1;
                num_events = 0;
                ntv_evt_info->maxpmcs++;
            }
            break;
        case 1:
            if ( sscanf( data, "#%u", &event ) != 1 ) {
                fprintf( stderr, "EVS file format error 1 (%s)\n", data );
                return NULL;
            }
            if ( event >= PAPI_MAX_NATIVE_EVENTS ) {
                fprintf( stderr, "EVS file format error 1 (%s)\n", data );
                return NULL;
            }
            events[num_events].event_num = event;
            len = strlen( data );
            int symb_found = 0;
            for ( i = cc = 0; i < len; i++ ) {
                if ( data[i] == ',' )
                    cc++;
                if ( cc == 5 && !symb_found ) {
                    strcpy( line_data, &data[i + 1] );
                    int j = 0;
                    while ( line_data[j] != ',' )
                        j++;
                    strncpy( events[num_events].symbol, line_data, j );
                    events[num_events].symbol[j] = 0;
                    symb_found = 1;
                    i += j;
                } else if ( cc == 6 ) {
                    len = strlen( &data[i + 1] );
                    events[num_events].short_description =
                        ( char * ) malloc( len );
                    strcpy( events[num_events].short_description,
                            &data[i + 1] );
                    events[num_events].short_description[len - 1] = 0;
                    break;
                }
            }
            line_counter_flag = 2;
            break;
        case 2:
            line_counter_flag = 3;
            break;
        case 3:
            len = strlen( data );
            events[num_events].description = ( char * ) malloc( len );
            strcpy( events[num_events].description, data );
            events[num_events].description[len - 1] = 0;
            line_counter_flag = 1;
            num_events++;
            break;
        }
    }
    if ( counter == 0 ) {
        free( ntv_evt_info );
        ntv_evt_info = NULL;
    }
    if ( counter == MAX_COUNTERS ) {
        ntv_evt_info->maxevents[counter - 1] = num_events;
        ntv_evt_info->wev[counter - 1] = copy_buffer( events, num_events );
    }
    fclose( evfile );
    return ntv_evt_info;
}
 
static int
any_counter_invalid( int event_id[], int size )
{
    int j;
    for ( j = 0; j < size; j++ ) {
        if ( event_id[j] >= PAPI_MAX_NATIVE_EVENTS )
            return 1;
    }
    return 0;
}
 
static ntv_event_group_info_t *
parse_groupfile( FILE * grp_file )
{
    char data[1024];
    unsigned int mmcr0, mmcr1H, mmcr1L, mmcra;
    int g, state = 0;
    ntv_event_group_info_t *group_info =
        ( ntv_event_group_info_t * )
        malloc( sizeof ( ntv_event_group_info_t ) );
    group_info->maxgroups = 0;
    int event_num[MAX_COUNTERS];
    while ( fgets( data, 1022, grp_file ) ) {
        if ( feof( grp_file ) || ( strlen( data ) < 2 ) )
            continue;
 
        switch ( state ) {
        case 0:
#if defined(_POWER5) || defined(_POWER5p)
            if ( sscanf
                 ( data, "#%u,%u,%u,%u,%u,%u,%u", &g, &event_num[0],
                   &event_num[1], &event_num[2], &event_num[3], &event_num[4],
                   &event_num[5] ) == 7 ) {
                state = 1;
                if ( any_counter_invalid( event_num, 6 ) ) {
                    fprintf( stderr, "ERROR: Maximum events exceeded\n" );
                    return NULL;
                }
            }
#else
            if ( sscanf
                 ( data, "#%u,%u,%u,%u,%u,%u,%u,%u,%u", &g, &event_num[0],
                   &event_num[1], &event_num[2], &event_num[3], &event_num[4],
                   &event_num[5], &event_num[6], &event_num[7] ) == 9 ) {
                state = 1;
                if ( any_counter_invalid( event_num, 8 ) ) {
                    fprintf( stderr, "ERROR: Maximum events exceeded\n" );
                    return NULL;
                }
            }
#endif
            if ( state == 1 ) {
                group_info->event_groups[group_info->maxgroups] =
                    ( event_group_t * ) malloc( sizeof ( event_group_t ) );
                group_info->event_groups[group_info->maxgroups]->group_id = g;
                int j = 0;
                for ( ; j < MAX_COUNTERS; j++ )
                    group_info->event_groups[group_info->maxgroups]->events[j] =
                        event_num[j];
            }
            break;
        case 1:
            // unused hex event codes
            state = 2;
            break;
        case 2:
            /* get mmcr values */
            if ( sscanf( data, "%#x,%#x,%#x,%#x", &mmcr0, &mmcr1H, &mmcr1L, &mmcra )
                 != 4 ) {
                fprintf( stderr, "GPS file format error 1 (%s)\n", data );
                return NULL;
            }
            state = 3;
            group_info->event_groups[group_info->maxgroups]->mmcr0 = mmcr0;
            group_info->event_groups[group_info->maxgroups]->mmcr1L = mmcr1L;
            group_info->event_groups[group_info->maxgroups]->mmcr1U = mmcr1H;
            group_info->event_groups[group_info->maxgroups]->mmcra = mmcra;
            group_info->maxgroups++;
            break;
        case 3:
            // unused group name
            state = 0;
        }
    }
    fclose( grp_file );
    return group_info;
}
 
ntv_event_info_t *
perfctr_get_native_evt_info( void )
{
    ntv_event_info_t *evt_info = NULL;
    FILE *evt_file = open_file( "events" );
    if ( evt_file != NULL ) {
        evt_info = parse_eventfile( evt_file );
    }
    return evt_info;
 
}
 
ntv_event_group_info_t *
perfctr_get_native_group_info( void )
{
    ntv_event_group_info_t *groups = NULL;
    FILE *grp_file = NULL;
    if ( ( grp_file = open_file( "groups" ) ) != NULL ) {
        groups = parse_groupfile( grp_file );
    }
    return groups;
}