papi_preset.c File Reference

Include dependency graph for papi_preset.c:

Go to the source code of this file.

Macros
#define	PAPI_EVENT_FILE   "papi_events.csv"

Functions
static int	papi_load_derived_events (char *pmu_str, int pmu_type, int cidx, int preset_flag)
int	_papi_hwi_setup_all_presets (hwi_search_t *findem, int cidx)
int	_papi_hwi_cleanup_all_presets (void)
static char *	trim_string (char *in)
static char *	trim_note (char *in)
static int	find_event_index (hwi_presets_t *array, int size, char *tmp)
static FILE *	open_event_table (char *name)
static int	get_event_line (char *line, FILE *table, char **tmp_perfmon_events_table)
static void	update_ops_string (char **formula, int old_index, int new_index)
static void	ops_string_append (hwi_presets_t *results, hwi_presets_t *depends_on, int addition)
static void	ops_string_merge (char **original, char *insertion, int replaces, int start_index)
static int	check_derived_events (char *target, int derived_type, hwi_presets_t *results, hwi_presets_t *search, int search_size, int token_index)
static int	check_native_events (char *target, hwi_presets_t *results)
static int	is_event (char *event_name, int derived_type, hwi_presets_t *results, int token_index)
int	_papi_load_preset_table (char *pmu_str, int pmu_type, int cidx)
static int	priority (char symbol)
static int	push (char symbol)
static char	pop ()
static char *	infix_to_postfix (char *infix)

Variables
hwi_presets_t	user_defined_events []
int	user_defined_events_count
static char *	papi_events_table = NULL
static char	stack [2 *PAPI_HUGE_STR_LEN]
static int	stacktop = -1

Macro Definition Documentation

PAPI_EVENT_FILE

#define PAPI_EVENT_FILE   "papi_events.csv"

Definition at line 151 of file papi_preset.c.

Function Documentation

_papi_hwi_cleanup_all_presets()

int _papi_hwi_cleanup_all_presets

(

void

)

Definition at line 114 of file papi_preset.c.

{
        int preset_index,cidx;
    unsigned int j;

    for ( preset_index = 0; preset_index < PAPI_MAX_PRESET_EVENTS;
          preset_index++ ) {
        if ( _papi_hwi_presets[preset_index].postfix != NULL ) {
           papi_free( _papi_hwi_presets[preset_index].postfix );
           _papi_hwi_presets[preset_index].postfix = NULL;
        }
        if ( _papi_hwi_presets[preset_index].note != NULL ) {
           papi_free( _papi_hwi_presets[preset_index].note );
           _papi_hwi_presets[preset_index].note = NULL;
        }
        for(j=0; j<_papi_hwi_presets[preset_index].count;j++) {
           papi_free(_papi_hwi_presets[preset_index].name[j]);
        }
    }

    for(cidx=0;cidx<papi_num_components;cidx++) {
       _papi_hwd[cidx]->cmp_info.num_preset_events = 0;
    }

#if defined(ITANIUM2) || defined(ITANIUM3)
    /* NOTE: This memory may need to be freed for BG/P builds as well */
    if ( preset_search_map != NULL ) {
        papi_free( preset_search_map );
        preset_search_map = NULL;
    }
#endif

    return PAPI_OK;
}

_papi_hwi_setup_all_presets()

int _papi_hwi_setup_all_presets	(	hwi_search_t *	findem,
		int	cidx
	)

Definition at line 44 of file papi_preset.c.

{
    int i, pnum, did_something = 0;
    unsigned int preset_index, j, k;

    /* dense array of events is terminated with a 0 preset.
       don't do anything if NULL pointer. This allows just notes to be loaded.
       It's also good defensive programming.
     */
    if ( findem != NULL ) {
       for ( pnum = 0; ( pnum < PAPI_MAX_PRESET_EVENTS ) &&
              ( findem[pnum].event_code != 0 ); pnum++ ) {
       /* find the index for the event to be initialized */
       preset_index = ( findem[pnum].event_code & PAPI_PRESET_AND_MASK );
       /* count and set the number of native terms in this event, 
              these items are contiguous.

          PAPI_EVENTS_IN_DERIVED_EVENT is arbitrarily defined in the high 
              level to be a reasonable number of terms to use in a derived 
              event linear expression, currently 8.

          This wastes space for components with less than 8 counters, 
              but keeps the framework independent of the components.

          The 'native' field below is an arbitrary opaque identifier 
              that points to information on an actual native event. 
              It is not an event code itself (whatever that might mean).
          By definition, this value can never == PAPI_NULL.
          - dkt */

       INTDBG( "Counting number of terms for preset index %d, "
                   "search map index %d.\n", preset_index, pnum );
       i = 0;
       j = 0;
       while ( i < PAPI_EVENTS_IN_DERIVED_EVENT ) {
          if ( findem[pnum].native[i] != PAPI_NULL ) {
         j++;
          }
          else if ( j ) {
         break;
          }
          i++;
       }

       INTDBG( "This preset has %d terms.\n", j );
       _papi_hwi_presets[preset_index].count = j;
 
           _papi_hwi_presets[preset_index].derived_int = findem[pnum].derived;
       for(k=0;k<j;k++) {
              _papi_hwi_presets[preset_index].code[k] =
                     findem[pnum].native[k];
       }
       /* preset code list must be PAPI_NULL terminated */
       if (k<PAPI_EVENTS_IN_DERIVED_EVENT) {
              _papi_hwi_presets[preset_index].code[k] = PAPI_NULL;
       }

       _papi_hwi_presets[preset_index].postfix=
                                       papi_strdup(findem[pnum].operation);

       did_something++;
       }
    }

    _papi_hwd[cidx]->cmp_info.num_preset_events += did_something;

    return ( did_something ? PAPI_OK : PAPI_ENOEVNT );
}

_papi_load_preset_table()

int _papi_load_preset_table	(	char *	pmu_str,
		int	pmu_type,
		int	cidx
	)

Definition at line 771 of file papi_preset.c.

                                                                   {
    SUBDBG("ENTER: pmu_str: %s, pmu_type: %d, cidx: %d\n", pmu_str, pmu_type, cidx);

    int retval;

    // go load papi preset events (last argument tells function if we are loading presets or user events)
    retval = papi_load_derived_events(pmu_str, pmu_type, cidx, 1);
    if (retval != PAPI_OK) {
        SUBDBG("EXIT: retval: %d\n", retval);
        return retval;
    }

    // go load the user defined event definitions if any are defined
    retval = papi_load_derived_events(pmu_str, pmu_type, cidx, 0);

    SUBDBG("EXIT: retval: %d\n", retval);
    return retval;
}

Here is the call graph for this function:

check_derived_events()

static int check_derived_events ( char *  target, int  derived_type, hwi_presets_t *  results, hwi_presets_t *  search, int  search_size, int  token_index  )

static

Definition at line 617 of file papi_preset.c.

{
    INTDBG("ENTER: target: %p (%s), results: %p, search: %p, search_size: %d, token_index: %d\n", target, target, results, search, search_size, token_index);
    unsigned int i;
    int j;
    int k;
    int found = 0;

    for (j=0; j < search_size; j++) {
        //  INTDBG("search[%d].symbol: %s, looking for: %s\n", j, search[j].symbol, target);
        if (search[j].symbol == NULL) {
            INTDBG("EXIT: returned: 0\n");
            return 0;
        }

        // if not the event we depend on, just look at next
        if ( strcasecmp( target, search[j].symbol) != 0 ) {
            continue;
        }

        INTDBG("Found a match\n");

        // derived formulas need to be adjusted based on what kind of derived event we are processing
        // the derived type passed to this function is the type of the new event being defined (not the events it is based on)
        // when we get here the formula must be in reverse polish notation (RPN) format
        switch (derived_type) {
            case DERIVED_POSTFIX: {
                // go create a formula to merge the second formula into a spot identified by one of the tokens in
                // the first formula.
                ops_string_merge(&(results->postfix), search[j].postfix, token_index, results->count);
                break;
            }
            case DERIVED_ADD: {
                // the new derived event adds two things together, go handle this target events role in the add
                ops_string_append(results, &search[j], 1);
                break;
            }
            case DERIVED_SUB: {
                // go create a formula to subtract the value generated by the second formula from the value generated by the first formula.
                ops_string_append(results, &search[j], 0);
                break;
            }
                default: {
                INTDBG("Derived type: %d, not currently handled\n", derived_type);
                break;
            }
        }

        // copy event name and code used by the derived event into the results table (place where new derived event is getting created)
        for ( k = 0; k < (int)search[j].count; k++ ) {
//          INTDBG("search[%d]: %p, name[%d]: %s, code[%d]: %#x\n", j, &search[j], k, search[j].name[k], k, search[j].code[k]);
            // if this event is already in the list, just update the formula so that references to this event point to the existing one
            for (i=0 ; i < results->count ; i++) {
                if (results->code[i] == search[j].code[k]) {
                    INTDBG("event: %s, code: %#x, already in results at index: %d\n", search[j].name[k], search[j].code[k], i);
                    // replace all tokens in the formula that refer to index "results->count + found" with a token that refers to index "i".
                    // the index "results->count + found" identifies the index used in the formula for the event we just determined is a duplicate
                    update_ops_string(&(results->postfix), results->count + found, i);
                    found++;
                    break;
                }
            }

            // if we did not find a match, copy native event info into results array
            if (found == 0) {
                // not a duplicate, go ahead and copy into results and bump number of native events in results
                if (search[j].name[k]) {
                    results->name[results->count] = papi_strdup(search[j].name[k]);
                } else {
                    results->name[results->count] = papi_strdup(target);
                }
                results->code[results->count] = search[j].code[k];
                INTDBG("results: %p, name[%d]: %s, code[%d]: %#x\n", results, results->count, results->name[results->count], results->count, results->code[results->count]);

                results->count++;
            }
        }

        INTDBG("EXIT: returned: 1\n");
        return 1;
    }

    INTDBG("EXIT: returned: 0\n");
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_native_events()

static int check_native_events ( char *  target, hwi_presets_t *  results  )

static

Definition at line 704 of file papi_preset.c.

{
    INTDBG("ENTER: target: %p (%s), results: %p\n", target, target, results);
    int ret;

    // find this native events code
    if ( ( ret = _papi_hwi_native_name_to_code( target, (int *)(&results->code[results->count])) ) != PAPI_OK ) {
        INTDBG("EXIT: returned: 0, call to convert name to event code failed with ret: %d\n", ret);
        return 0;
    }

    // if the code returned was 0, return to show it is not a valid native event
    if ( results->code[results->count] == 0 ) {
        INTDBG( "EXIT: returned: 0, event code not found\n");
        return 0;
    }

    // if this native event is not for component 0, return to show it can not be used in derived events
    // it should be possible to create derived events for other components as long as all events in the derived event are associated with the same component
    if ( _papi_hwi_component_index(results->code[results->count]) != 0 ) {
        INTDBG( "EXIT: returned: 0, new event not associated with component 0 (current limitation with derived events)\n");
        return 0;
    }

    //    found = 1;
    INTDBG("\tFound a native event %s\n", target);
    results->name[results->count++] = papi_strdup(target);

    INTDBG( "EXIT: returned: 1\n");
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_event_index()

static int find_event_index ( hwi_presets_t *  array, int  size, char *  tmp  )

inlinestatic

Definition at line 225 of file papi_preset.c.

                                                            {
    SUBDBG("ENTER: array: %p, size: %d, tmp: %s\n", array, size, tmp);
    int i;
    for (i = 0; i < size; i++) {
        if (array[i].symbol == NULL) {
            array[i].symbol = papi_strdup(tmp);
            SUBDBG("EXIT: i: %d\n", i);
            return i;
        }
        if (strcasecmp(tmp, array[i].symbol) == 0) {
            SUBDBG("EXIT: i: %d\n", i);
            return i;
        }
    }
    SUBDBG("EXIT: PAPI_EINVAL\n");
    return PAPI_EINVAL;
}

Here is the caller graph for this function:

get_event_line()

static int get_event_line ( char *  line, FILE *  table, char **  tmp_perfmon_events_table  )

static

Definition at line 273 of file papi_preset.c.

{
    int i;

    if ( table ) {
        if ( fgets( line, LINE_MAX, table ) == NULL)
        return 0;

        i = ( int ) strlen( line );
        if (i == 0)
        return 0;
        if ( line[i-1] == '\n' )
        line[i-1] = '\0';
        return 1;
    } else {
        for ( i = 0;
              **tmp_perfmon_events_table && **tmp_perfmon_events_table != '\n';
              i++, ( *tmp_perfmon_events_table )++ )
            line[i] = **tmp_perfmon_events_table;
        if (i == 0)
            return 0;
        if ( **tmp_perfmon_events_table && **tmp_perfmon_events_table == '\n' ) {
            ( *tmp_perfmon_events_table )++;
        }
        line[i] = '\0';
        return 1;
    }
}

Here is the caller graph for this function:

infix_to_postfix()

static char* infix_to_postfix ( char *  infix )

static

Definition at line 839 of file papi_preset.c.

                                {
    INTDBG("ENTER: in: %s, size: %zu\n", infix, strlen(infix));
    static char postfix[2*PAPI_HUGE_STR_LEN];   // output
        unsigned int index;
        int postfixlen;
        char token;
        if ( strlen(infix) > PAPI_HUGE_STR_LEN ) 
            PAPIERROR("A infix string (probably in user-defined presets) is too big (max allowed %d): %s", PAPI_HUGE_STR_LEN, infix );

        // initialize stack
    memset(stack, 0, 2*PAPI_HUGE_STR_LEN);
    stacktop = -1; 
    push('#'); 
        stacktop = 0; // after initialization of stack to #
        /* initialize output string */
    memset(postfix,0,2*PAPI_HUGE_STR_LEN);
        postfixlen = 0;

    for( index=0; index<strlen(infix); index++ ) {
                token = infix[index];
                INTDBG("INTDBG: in: %s, length: %zu, index: %d token %c\n", infix, strlen( infix ), index, token);
        switch( token ) {
        case '(':
            push( token );
            break;
        case ')':
                        if (postfix[postfixlen-1]!='|') postfix[postfixlen++] = '|';
                        while ( stack[stacktop] != '(' ) {
                                postfix[postfixlen++] = pop();
                                postfix[postfixlen++] = '|';
                        }
                        token = pop();  /* pop the '(' character */
            break;
        case '+':
        case '-':
        case '*':
        case '/':
        case '%':
        case '^':       /* if an operator */
                        if (postfix[postfixlen-1]!='|') postfix[postfixlen++] = '|';
                        while ( priority(stack[stacktop]) > priority(token) ) {
                                postfix[postfixlen++] = pop();
                                postfix[postfixlen++] = '|';
                        }
                        push( token ); /* save current operator */
                        break;
        default: // if alphanumeric character which is not parenthesis or an operator
                        postfix[postfixlen++] = token;
            break;
        } // end switch symbol
    } // end while

        /* Write any remaining operators */
        if (postfix[postfixlen-1]!='|') postfix[postfixlen++] = '|';
        while ( stacktop>0 ) {
                postfix[postfixlen++] = pop();
                postfix[postfixlen++] = '|';
        }
        postfix[postfixlen++] = '\0';
    stacktop = -1; 

    INTDBG("EXIT: postfix: %s, size: %zu\n", postfix, strlen(postfix));
    return (postfix);
} // end infix_to_postfix

Here is the call graph for this function:

Here is the caller graph for this function:

is_event()

static int is_event ( char *  event_name, int  derived_type, hwi_presets_t *  results, int  token_index  )

static

Definition at line 739 of file papi_preset.c.

                                                                                      {
    INTDBG("ENTER: event_name: %p (%s), derived_type: %d, results: %p, token_index: %d\n", event_name, event_name, derived_type, results, token_index);

    /* check if its a preset event */
    if ( check_derived_events(event_name, derived_type, results, &_papi_hwi_presets[0], PAPI_MAX_PRESET_EVENTS, token_index) ) {
        INTDBG("EXIT: found preset event\n");
        return 1;
    }

    /* check if its a user defined event */
    if ( check_derived_events(event_name, derived_type, results, user_defined_events, user_defined_events_count, token_index) ) {
        INTDBG("EXIT: found user event\n");
        return 1;
    }

    /* check if its a native event */
    if ( check_native_events(event_name, results) ) {
        INTDBG("EXIT: found native event\n");
        return 1;
    }

    INTDBG("EXIT: event not found\n");
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

open_event_table()

static FILE* open_event_table ( char *  name )

static

Definition at line 246 of file papi_preset.c.

{
    FILE *table;

    SUBDBG( "Opening %s\n", name );
    table = fopen( name, "r" );
    if ( table == NULL ) {
        SUBDBG( "Open %s failed, trying ./%s.\n", 
            name, PAPI_EVENT_FILE );
        sprintf( name, "%s", PAPI_EVENT_FILE );
        table = fopen( name, "r" );
    }
    if ( table == NULL ) {
        SUBDBG( "Open ./%s failed, trying ../%s.\n", 
            name, PAPI_EVENT_FILE );
        sprintf( name, "../%s", PAPI_EVENT_FILE );
        table = fopen( name, "r" );
    }
    if ( table ) {
        SUBDBG( "Open %s succeeded.\n", name );
    }
    return table;
}

Here is the caller graph for this function:

ops_string_append()

static void ops_string_append ( hwi_presets_t *  results, hwi_presets_t *  depends_on, int  addition  )

static

Definition at line 363 of file papi_preset.c.

                                                                                   {
    INTDBG("ENTER: results: %p, depends_on: %p, addition %d\n", results, depends_on, addition);

    int i;
    int second_event = 0;
    char newFormula[PAPI_MIN_STR_LEN] = "";
    char work[20];

    // if our results already have a formula, start with what was collected so far
    // this should only happens when processing the second event of a new derived add
    if (results->postfix != NULL) {
        INTDBG("Event %s has existing formula %s\n", results->symbol, results->postfix);
        // get the existing formula
        strncat(newFormula, results->postfix, sizeof(newFormula)-1);
        newFormula[sizeof(newFormula)-1] = '\0';
        second_event = 1;
    }

    // process based on what kind of event the one we depend on is
    switch (depends_on->derived_int) {
        case DERIVED_POSTFIX: {
            // the event we depend on has a formula, append it our new events formula

            // if event we depend on does not have a formula, report error
            if (depends_on->postfix == NULL) {
                INTDBG("Event %s is of type DERIVED_POSTFIX but is missing operation string\n", depends_on->symbol);
                return;
            }

            // may need to renumber the native event index values in the depends on event formula before putting it into new derived event
            char *temp = papi_strdup(depends_on->postfix);

            // If this is not the first event of the new derived add, need to adjust native event index values in formula.
            // At this time we assume that all the native events in the second events formula are unique for the new event
            // and just bump the indexes by the number of events already known to the new event.  Later when we add the events
            // to the native event list for this new derived event, we will check to see if the native events are already known
            // to the new derived event and if so adjust the indexes again.
            if (second_event) {
                for ( i=depends_on->count-1 ; i>=0 ; i--) {
                    update_ops_string(&temp, i, results->count + i);
                }
            }

            // append the existing formula from the event we depend on (but get rid of last '|' character)
            strncat(newFormula, temp, sizeof(newFormula)-1);
            newFormula[sizeof(newFormula)-1] = '\0';
            papi_free (temp);
            break;
        }
        case DERIVED_ADD: {
            // the event we depend on has no formula, create a formula for our new event to add together the depends_on native event values

            // build a formula for this add event
            sprintf(work, "N%d|N%d|+|", results->count, results->count + 1);
            strcat(newFormula, work);
            break;
        }
        case DERIVED_SUB: {
            // the event we depend on has no formula, create a formula for our new event to subtract the depends_on native event values

            // build a formula for this subtract event
            sprintf(work, "N%d|N%d|-|", results->count, results->count + 1);
            strcat(newFormula, work);
            break;
        }
        case NOT_DERIVED: {
            // the event we depend on has no formula and is itself only based on one native event, create a formula for our new event to include this native event

            // build a formula for this subtract event
            sprintf(work, "N%d|", results->count);
            strcat(newFormula, work);
            break;
        }
        default: {
            // the event we depend on has unsupported derived type, put out some debug and give up
            INTDBG("Event %s depends on event %s which has an unsupported derived type of %d\n", results->symbol, depends_on->symbol, depends_on->derived_int);
            return;
        }
    }

    // if this was the second event, append to the formula an operation to add or subtract the results of the two events
    if (second_event) {
        if (addition != 0) {
            strcat(newFormula, "+|");
        } else {
            strcat(newFormula, "-|");
        }
        // also change the new derived events type to show it has a formula now
        results->derived_int = DERIVED_POSTFIX;
    }

    // we need to free the existing space (created by malloc and we need to create a new one)
    papi_free (results->postfix);
    results->postfix = papi_strdup(newFormula);
    INTDBG("EXIT: newFormula: %s\n", newFormula);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ops_string_merge()

static void ops_string_merge ( char **  original, char *  insertion, int  replaces, int  start_index  )

static

Definition at line 464 of file papi_preset.c.

                                                                                  {
    INTDBG("ENTER: original: %p, *original: %s, insertion: %s, replaces: %d, start_index: %d\n", original, *original, insertion, replaces, start_index);

    int orig_len=0;
    int ins_len=0;
    char *subtoken;
    char *workBuf;
    char *workPtr;
    char *tok_save_ptr=NULL;
    char *newOriginal;
    char *newInsertion;
    char *newFormula;
    int insert_events;

    if (*original != NULL) {
        orig_len = strlen(*original);
    }
    if (insertion != NULL) {
        ins_len = strlen(insertion);
    }
    newFormula = papi_calloc (orig_len + ins_len + 40, 1);

    // if insertion formula is not provided, then the original formula remains basically unchanged.
    if (insertion == NULL) {
        // if the original formula has a leading '|' then get rid of it
        workPtr = *original;
        if (workPtr[0] == '|') {
            strcpy(newFormula, &workPtr[1]);
        } else {
            strcpy(newFormula, workPtr);
        }
        // formula fields are always malloced space so free the previous one
        papi_free (*original);
        *original = newFormula;
        INTDBG("EXIT: newFormula: %s\n", *original);
        return;
    }

    // renumber the token numbers in the insertion formula
    // also count how many native events are used in this formula
    insert_events = 0;
    newInsertion = papi_calloc(ins_len+20, 1);
    workBuf = papi_calloc(ins_len+10, 1);
    workPtr = papi_strdup(insertion);
    subtoken = strtok_r(workPtr, "|", &tok_save_ptr);
    while ( subtoken != NULL) {
//      INTDBG("subtoken: %s, newInsertion: %s\n", subtoken, newInsertion);
        if ((subtoken[0] == 'N')  &&  (isdigit(subtoken[1]))) {
            insert_events++;
            int val = atoi(&subtoken[1]);
            val += start_index;
            subtoken[1] = '\0';
            sprintf (workBuf, "N%d", val);
        } else {
            strcpy(workBuf, subtoken);
        }
        strcat (newInsertion, workBuf);
        strcat (newInsertion, "|");
        subtoken = strtok_r(NULL, "|", &tok_save_ptr);
    }
    papi_free (workBuf);
    papi_free (workPtr);
    INTDBG("newInsertion: %s\n", newInsertion);

    // if original formula is not provided, then the updated insertion formula becomes the new formula
    // but we still had to renumber the native event tokens in case another native event was put into the list first
    if (*original == NULL) {
        *original = papi_strdup(newInsertion);
        INTDBG("EXIT: newFormula: %s\n", newInsertion);
        papi_free (newInsertion);
        papi_free (newFormula);
        return;
    }

    // if token to replace not valid, return null  (do we also need to check an upper bound ???)
    if ((replaces < 0)) {
        papi_free (newInsertion);
        papi_free (newFormula);
        INTDBG("EXIT: Invalid value for token in original formula to be replaced\n");
        return;
    }

    // renumber the token numbers in the original formula
    // tokens with an index greater than the replaces token need to be incremented by number of events in insertion formula-1
    newOriginal = papi_calloc (orig_len+20, 1);
    workBuf = papi_calloc(orig_len+10, 1);
    workPtr = papi_strdup(*original);

    subtoken = strtok_r(workPtr, "|", &tok_save_ptr);
    while ( subtoken != NULL) {
//      INTDBG("subtoken: %s, newOriginal: %s\n", subtoken, newOriginal);
        // prime the work area with the next token, then see if we need to change it
        strcpy(workBuf, subtoken);
        if ((subtoken[0] == 'N')  &&  (isdigit(subtoken[1]))) {
            int val = atoi(&subtoken[1]);
            if (val > replaces) {
                val += insert_events-1;
                subtoken[1] = '\0';
                sprintf (workBuf, "N%d", val);
            }
        }
        // put the work buffer into the new original formula
        strcat (newOriginal, workBuf);
        strcat (newOriginal, "|");
        subtoken = strtok_r(NULL, "|", &tok_save_ptr);
    }
    papi_free (workBuf);
    papi_free (workPtr);
    INTDBG("newOriginal: %s\n", newOriginal);

    // replace the specified "replace" tokens in the new original formula with the new insertion formula
    newFormula[0] = '\0';
    workPtr = newOriginal;
    subtoken = strtok_r(workPtr, "|", &tok_save_ptr);
    while ( subtoken != NULL) {
//      INTDBG("subtoken: %s, newFormula: %s\n", subtoken, newFormula);
        // if this is the token we want to replace with the insertion string, do it now
        if ((subtoken[0] == 'N')  &&  (isdigit(subtoken[1]))  &&  (replaces == atoi(&subtoken[1]))) {
            // copy updated insertion string into the original string (replacing this token)
            strcat(newFormula, newInsertion);
        } else {
            // copy this part of the original formula into the new formula
            strcat(newFormula, subtoken);
            strcat(newFormula, "|");
        }
        subtoken = strtok_r(NULL, "|", &tok_save_ptr);
    }
    papi_free (newInsertion);
    papi_free (workPtr);

    // formula fields are always malloced space so free the previous one
    papi_free (*original);
    *original = newFormula;
    INTDBG("EXIT: newFormula: %s\n", newFormula);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

papi_load_derived_events()

static int papi_load_derived_events ( char *  pmu_str, int  pmu_type, int  cidx, int  preset_flag  )

static

Definition at line 947 of file papi_preset.c.

                                                                                  {
    SUBDBG( "ENTER: pmu_str: %s, pmu_type: %d, cidx: %d, preset_flag: %d\n", pmu_str, pmu_type, cidx, preset_flag);

    char pmu_name[PAPI_MIN_STR_LEN];
    char line[LINE_MAX];
    char name[PATH_MAX] = "builtin papi_events_table";
    char *event_file_path=NULL;
    char *event_table_ptr=NULL;
    int event_type_bits = 0;
    char *tmpn;
    char *tok_save_ptr=NULL;
    FILE *event_file = NULL;
    hwi_presets_t *results=NULL;
    int result_size = 0;
    int *event_count = NULL;
    int invalid_event;
    int line_no = 0;  /* count of lines read from event definition input */
    int derived = 0;
    int res_idx = 0;  /* index into results array for where to store next event */
    int preset = 0;
    int get_events = 0; /* only process derived events after CPU type they apply to is identified      */
    int found_events = 0; /* flag to track if event definitions (PRESETS) are found since last CPU declaration */
#ifdef PAPI_DATADIR
        char path[PATH_MAX];
#endif


    if (preset_flag) {
        /* try the environment variable first */
        if ((tmpn = getenv("PAPI_CSV_EVENT_FILE")) && (strlen(tmpn) > 0)) {
            event_file_path = tmpn;
        }
        /* if no valid environment variable, look for built-in table */
        else if (papi_events_table) {
            event_table_ptr = papi_events_table;
        }
        /* if no env var and no built-in, search for default file */
        else {
#ifdef PAPI_DATADIR
            sprintf( path, "%s/%s", PAPI_DATADIR, PAPI_EVENT_FILE );
            event_file_path = path;
#else
            event_file_path = PAPI_EVENT_FILE;
#endif
        }
        event_type_bits = PAPI_PRESET_MASK;
        results = &_papi_hwi_presets[0];
        result_size = PAPI_MAX_PRESET_EVENTS;
        event_count = &_papi_hwd[cidx]->cmp_info.num_preset_events;
    } else {
        if ((event_file_path = getenv( "PAPI_USER_EVENTS_FILE" )) == NULL ) {
            SUBDBG("EXIT: User event definition file not provided.\n");
            return PAPI_OK;
        }

        event_type_bits = PAPI_UE_MASK;
        results = &user_defined_events[0];
        result_size = PAPI_MAX_USER_EVENTS;
        event_count = &user_defined_events_count;
    }

    // if we have an event file pathname, open it and read event definitions from the file
    if (event_file_path != NULL) {
        if ((event_file = open_event_table(event_file_path)) == NULL) {
            // if file open fails, return an error
            SUBDBG("EXIT: Event file open failed.\n");
            return PAPI_ESYS;
        }
        strncpy(name, event_file_path, sizeof(name)-1);
        name[sizeof(name)-1] = '\0';
    } else if (event_table_ptr == NULL) {
        // if we do not have a path name or table pointer, return an error
        SUBDBG("EXIT: Both event_file_path and event_table_ptr are NULL.\n");
        return PAPI_ESYS;
    }

    /* copy the pmu identifier, stripping commas if found */
    tmpn = pmu_name;
    while (*pmu_str) {
        if (*pmu_str != ',')
            *tmpn++ = *pmu_str;
        pmu_str++;
    }
    *tmpn = '\0';

    /* at this point we have either a valid file pointer or built-in table pointer */
    while (get_event_line(line, event_file, &event_table_ptr)) {
        char *t;
        int i;

        // increment number of lines we have read
        line_no++;

        t = trim_string(strtok_r(line, ",", &tok_save_ptr));

        /* Skip blank lines */
        if ((t == NULL) || (strlen(t) == 0))
            continue;

        /* Skip comments */
        if (t[0] == '#') {
            continue;
        }

        if (strcasecmp(t, "CPU") == 0) {
            if (get_events != 0 && found_events != 0) {
                SUBDBG( "Ending event scanning at line %d of %s.\n", line_no, name);
                get_events = 0;
                found_events = 0;
            }

            t = trim_string(strtok_r(NULL, ",", &tok_save_ptr));
            if ((t == NULL) || (strlen(t) == 0)) {
                PAPIERROR("Expected name after CPU token at line %d of %s -- ignoring", line_no, name);
                continue;
            }

            if (strcasecmp(t, pmu_name) == 0) {
                int type;

                SUBDBG( "Process events for PMU %s found at line %d of %s.\n", t, line_no, name);

                t = trim_string(strtok_r(NULL, ",", &tok_save_ptr));
                if ((t == NULL) || (strlen(t) == 0)) {
                    SUBDBG("No additional qualifier found, matching on string.\n");
                    get_events = 1;
                } else if ((sscanf(t, "%d", &type) == 1) && (type == pmu_type)) {
                    SUBDBG( "Found CPU %s type %d at line %d of %s.\n", pmu_name, type, line_no, name);
                    get_events = 1;
                } else {
                    SUBDBG( "Additional qualifier match failed %d vs %d.\n", pmu_type, type);
                }
            }
            continue;
        }

        if ((strcasecmp(t, "PRESET") == 0)  || (strcasecmp(t, "EVENT") == 0)) {

            if (get_events == 0)
                continue;

            found_events = 1;
            t = trim_string(strtok_r(NULL, ",", &tok_save_ptr));

            if ((t == NULL) || (strlen(t) == 0)) {
                PAPIERROR("Expected name after PRESET token at line %d of %s -- ignoring", line_no, name);
                continue;
            }

            SUBDBG( "Examining event %s\n", t);

            // see if this event already exists in the results array, if not already known it sets up event in unused entry
            if ((res_idx = find_event_index (results, result_size, t)) < 0) {
                PAPIERROR("No room left for event %s -- ignoring", t);
                continue;
            }

            // add the proper event bits (preset or user defined bits)
            preset = res_idx | event_type_bits;
            (void) preset;

            SUBDBG( "Use event code: %#x for %s\n", preset, t);

            t = trim_string(strtok_r(NULL, ",", &tok_save_ptr));
            if ((t == NULL) || (strlen(t) == 0)) {
                // got an error, make this entry unused
                if (results[res_idx].symbol != NULL){
                    papi_free (results[res_idx].symbol);
                    results[res_idx].symbol = NULL;
                }
                PAPIERROR("Expected derived type after PRESET token at line %d of %s -- ignoring", line_no, name);
                continue;
            }

            if (_papi_hwi_derived_type(t, &derived) != PAPI_OK) {
                // got an error, make this entry unused
                if (results[res_idx].symbol != NULL){
                    papi_free (results[res_idx].symbol);
                    results[res_idx].symbol = NULL;
                }
                PAPIERROR("Invalid derived name %s after PRESET token at line %d of %s -- ignoring", t, line_no, name);
                continue;
            }

            /****************************************/
            /* Have an event, let's start assigning */
            /****************************************/

            SUBDBG( "Adding event: %s, code: %#x, derived: %d results[%d]: %p.\n", t, preset, derived, res_idx, &results[res_idx]);

            /* results[res_idx].event_code = preset; */
            results[res_idx].derived_int = derived;

            /* Derived support starts here */
            /* Special handling for postfix and infix */
            if ((derived == DERIVED_POSTFIX)  || (derived == DERIVED_INFIX)) {
                t = trim_string(strtok_r(NULL, ",", &tok_save_ptr));
                if ((t == NULL) || (strlen(t) == 0)) {
                    // got an error, make this entry unused
                    if (results[res_idx].symbol != NULL){
                        papi_free (results[res_idx].symbol);
                        results[res_idx].symbol = NULL;
                    }
                    PAPIERROR("Expected Operation string after derived type DERIVED_POSTFIX or DERIVED_INFIX at line %d of %s -- ignoring", line_no, name);
                    continue;
                }

                // if it is an algebraic formula, we need to convert it to postfix
                if (derived == DERIVED_INFIX) {
                    SUBDBG( "Converting InFix operations %s\n", t);
                    t = infix_to_postfix( t );
                    results[res_idx].derived_int = DERIVED_POSTFIX;
                }

                SUBDBG( "Saving PostFix operations %s\n", t);
                results[res_idx].postfix = papi_strdup(t);
            }

            /* All derived terms collected here */
            i = 0;
            invalid_event = 0;
            results[res_idx].count = 0;
            do {
                t = trim_string(strtok_r(NULL, ",", &tok_save_ptr));
                if ((t == NULL) || (strlen(t) == 0))
                    break;
                if (strcasecmp(t, "NOTE") == 0)
                    break;
                if (strcasecmp(t, "LDESC") == 0)
                    break;
                if (strcasecmp(t, "SDESC") == 0)
                    break;

                SUBDBG( "Adding term (%d) %s to derived event %#x, current native event count: %d.\n", i, t, preset, results[res_idx].count);

                // show that we do not have an event code yet (the component may create one and update this info)
                // this also clears any values left over from a previous call
                _papi_hwi_set_papi_event_code(-1, -1);

                // make sure that this term in the derived event is a valid event name
                // this call replaces preset and user event names with the equivalent native events in our results table
                // it also updates formulas for derived events so that they refer to the correct native event index
                if (is_event(t, results[res_idx].derived_int, &results[res_idx], i) == 0) {
                    invalid_event = 1;
                    PAPIERROR("Missing event %s, used in derived event %s", t, results[res_idx].symbol);
                    break;
                }

                i++;
            } while (results[res_idx].count < PAPI_EVENTS_IN_DERIVED_EVENT);

            /* preset code list must be PAPI_NULL terminated */
            if (i < PAPI_EVENTS_IN_DERIVED_EVENT) {
                results[res_idx].code[results[res_idx].count] = PAPI_NULL;
            }

            if (invalid_event) {
                // got an error, make this entry unused
                    // preset table is statically allocated, user defined is dynamic
                unsigned int j;
                for (j = 0; j < results[res_idx].count; j++){
                    if (results[res_idx].name[j] != NULL){
                        papi_free( results[res_idx].name[j] );
                        results[res_idx].name[j] = NULL;
                    }
                }

                if (!preset_flag){
                    if(results[res_idx].symbol != NULL){
                        papi_free (results[res_idx].symbol);
                        results[res_idx].symbol = NULL;
                    }
                }

                continue;
            }

            /* End of derived support */

            // if we did not find any terms to base this derived event on, report error
            if (i == 0) {
                // got an error, make this entry unused
                if (!preset_flag){
                    if(results[res_idx].symbol != NULL){
                        papi_free (results[res_idx].symbol);
                        results[res_idx].symbol = NULL;
                    }
                }
                PAPIERROR("Expected PFM event after DERIVED token at line %d of %s -- ignoring", line_no, name);
                continue;
            }

            if (i == PAPI_EVENTS_IN_DERIVED_EVENT) {
                t = trim_string(strtok_r(NULL, ",", &tok_save_ptr));
            }

            // if something was provided following the list of events to be used by the operation, process it
            if ( t!= NULL  && strlen(t) > 0 ) {
                do {
                    // save the field name
                    char *fptr = papi_strdup(t);

                    // get the value to be used with this field
                    t = trim_note(strtok_r(NULL, ",", &tok_save_ptr));
                    if ( t== NULL  || strlen(t) == 0 ) {
                        papi_free(fptr);
                        break;
                    }

                    // Handle optional short descriptions, long descriptions and notes
                    if (strcasecmp(fptr, "SDESC") == 0) {
                        results[res_idx].short_descr = papi_strdup(t);
                    }
                    if (strcasecmp(fptr, "LDESC") == 0) {
                        results[res_idx].long_descr = papi_strdup(t);
                    }
                    if (strcasecmp(fptr, "NOTE") == 0) {
                        results[res_idx].note = papi_strdup(t);
                    }

                    SUBDBG( "Found %s (%s) on line %d\n", fptr, t, line_no);
                    papi_free (fptr);

                    // look for another field name
                    t = trim_string(strtok_r(NULL, ",", &tok_save_ptr));
                    if ( t== NULL  || strlen(t) == 0 ) {
                        break;
                    }
                } while (t != NULL);
            }
            (*event_count)++;
            continue;
        }

        PAPIERROR("Unrecognized token %s at line %d of %s -- ignoring", t, line_no, name);
    }

    if (event_file) {
        fclose(event_file);
    }

    SUBDBG("EXIT: Done processing derived event file.\n");
    return PAPI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pop()

static char pop ( )

static

Definition at line 826 of file papi_preset.c.

           {
  if( stacktop < 0 ) {
    INTDBG("stack underflow converting algebraic expression\n" );
    return '\0';  //***TODO: Figure out how to exit gracefully
  } // end if empty
  return( stack[stacktop--] );
} // end pop

Here is the caller graph for this function:

priority()

static int priority ( char  symbol )

static

Definition at line 796 of file papi_preset.c.

                            {
        switch( symbol ) {
        case '@':
                return -1;
        case '(':
                return 0;
    case '+':
    case '-':
                return 1;
    case '*':
    case '/':
    case '%':
        return 2;
    default :
        return 0;
    } // end switch symbol
} // end priority

Here is the caller graph for this function:

push()

static int push ( char  symbol )

static

Definition at line 815 of file papi_preset.c.

                        {
  if (stacktop >= 2*PAPI_HUGE_STR_LEN - 1) {
    INTDBG("stack overflow converting algebraic expression (%d,%c)\n", stacktop,symbol );
    return -1;  //***TODO: Figure out how to exit gracefully
  } // end if stacktop>MAX
  stack[++stacktop] = symbol;
  return 0;
} // end push

Here is the caller graph for this function:

trim_note()

static char* trim_note ( char *  in )

inlinestatic

Definition at line 197 of file papi_preset.c.

{
    int len;
    char *note, start, end;

    note = trim_string( in );
    if ( note != NULL ) {
                len = ( int ) strlen( note );
        if ( len > 0 ) {
            if ( ispunct( *note ) ) {
                start = *note;
                end = note[len - 1];
                if ( ( start == end )
                     || ( ( start == '(' ) && ( end == ')' ) )
                     || ( ( start == '<' ) && ( end == '>' ) )
                     || ( ( start == '{' ) && ( end == '}' ) )
                     || ( ( start == '[' ) && ( end == ']' ) ) ) {
                    note[len - 1] = '\0';
                    *note = '\0';
                    note++;
                }
            }
        }
    }
    return note;
}

Here is the call graph for this function:

Here is the caller graph for this function:

trim_string()

static char* trim_string ( char *  in )

inlinestatic

Definition at line 157 of file papi_preset.c.

{
    int len, i = 0;
    char *start = in;

    if ( in == NULL )
        return ( in );
    len = ( int ) strlen( in );
    if ( len == 0 )
        return ( in );

    /* Trim left */
    while ( i < len ) {
        if ( isblank( in[i] ) ) {
            in[i] = '\0';
            start++;
        } else
            break;
        i++;
    }

    /* Trim right */
    i = ( int ) strlen( start ) - 1;
    while ( i >= 0 ) {
        if ( isblank( start[i] ) )
            start[i] = '\0';
        else
            break;
        i--;
    }
    return ( start );
}

Here is the caller graph for this function:

update_ops_string()

static void update_ops_string ( char **  formula, int  old_index, int  new_index  )

static

Definition at line 304 of file papi_preset.c.

                                                                {
    INTDBG("ENTER:   *formula: %s, old_index: %d, new_index: %d\n", *formula?*formula:"NULL", old_index, new_index);

    int cur_index;
    char *newFormula;
    char *subtoken;
    char *tok_save_ptr=NULL;

    // if formula is null just return
    if (*formula == NULL) {
        INTDBG("EXIT: Null pointer to formula passed in\n");
        return;
    }

    // get some space for the new formula we are going to create
    newFormula = papi_calloc(strlen(*formula) + 20, 1);

    // replace the specified "replace" tokens in the new original formula with the new insertion formula
    newFormula[0] = '\0';
    subtoken = strtok_r(*formula, "|", &tok_save_ptr);
    while ( subtoken != NULL) {
//      INTDBG("subtoken: %s, newFormula: %s\n", subtoken, newFormula);
        char work[10];
        // if this is the token we want to replace with the new token index, do it now
        if ((subtoken[0] == 'N')  &&  (isdigit(subtoken[1]))) {
            cur_index = atoi(&subtoken[1]);
            // if matches old index, use the new one
            if (cur_index == old_index) {
                sprintf (work, "N%d", new_index);
                strcat (newFormula, work);
            } else if (cur_index > old_index) {
                // current token greater than old index, make it one less than what it was
                sprintf (work, "N%d", cur_index-1);
                strcat (newFormula, work);
            } else {
                // current token less than old index, copy this part of the original formula into the new formula
                strcat(newFormula, subtoken);
            }
        } else {
            // copy this part of the original formula into the new formula
            strcat(newFormula, subtoken);
        }
        strcat (newFormula, "|");
        subtoken = strtok_r(NULL, "|", &tok_save_ptr);
    }
    papi_free (*formula);
    *formula = newFormula;

    INTDBG("EXIT: newFormula: %s\n", newFormula);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

papi_events_table

char* papi_events_table = NULL

static

Definition at line 768 of file papi_preset.c.

stack

char stack[2 *PAPI_HUGE_STR_LEN]

static

Definition at line 791 of file papi_preset.c.

stacktop

int stacktop = -1

static

Definition at line 792 of file papi_preset.c.

user_defined_events

hwi_presets_t user_defined_events[]

Definition at line 59 of file papi_internal.c.

user_defined_events_count

int user_defined_events_count

Definition at line 60 of file papi_internal.c.