driver.h File Reference

Include dependency graph for driver.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	USE_ALL_EVENTS   0x0
#define	READ_FROM_FILE   0x1
#define	BENCH_FLOPS   0x01
#define	BENCH_BRANCH   0x02
#define	BENCH_DCACHE_READ   0x04
#define	BENCH_DCACHE_WRITE   0x08
#define	BENCH_ICACHE_READ   0x10
#define	BENCH_VEC   0x20
#define	BENCH_INSTR   0x40

Functions
int	parseArgs (int argc, char **argv, cat_params_t *params)
int	setup_evts (char *inputfile, char ***basenames, int **cards)
unsigned long int	omp_get_thread_num_wrapper ()
int	check_cards (cat_params_t mode, int **indexmemo, char **basenames, int *cards, int ct, int nevts, evstock *data)
void	combine_qualifiers (int n, int pk, int ct, char **list, char *name, char **allevts, int *track, int flag, int *bitmap)
void	trav_evts (evstock *stock, int pk, int *cards, int nevts, int selexnsize, int mode, char **allevts, int *track, int *indexmemo, char **basenames)
int	perm (int n, int k)
int	comb (int n, int k)
void	testbench (char **allevts, int cmbtotal, hw_desc_t *hw_desc, cat_params_t params, int myid, int nprocs)
void	print_usage ()
static int	parse_line (FILE *input, char **key, long long *value)
static void	read_conf_file (char *conf_file, hw_desc_t *hw_desc)
static hw_desc_t *	obtain_hardware_description (char *conf_file_name)

Macro Definition Documentation

BENCH_BRANCH

#define BENCH_BRANCH   0x02

Definition at line 15 of file driver.h.

BENCH_DCACHE_READ

#define BENCH_DCACHE_READ   0x04

Definition at line 16 of file driver.h.

BENCH_DCACHE_WRITE

#define BENCH_DCACHE_WRITE   0x08

Definition at line 17 of file driver.h.

BENCH_FLOPS

#define BENCH_FLOPS   0x01

Definition at line 14 of file driver.h.

BENCH_ICACHE_READ

#define BENCH_ICACHE_READ   0x10

Definition at line 18 of file driver.h.

BENCH_INSTR

#define BENCH_INSTR   0x40

Definition at line 20 of file driver.h.

BENCH_VEC

#define BENCH_VEC   0x20

Definition at line 19 of file driver.h.

READ_FROM_FILE

#define READ_FROM_FILE   0x1

Definition at line 12 of file driver.h.

USE_ALL_EVENTS

#define USE_ALL_EVENTS   0x0

Definition at line 11 of file driver.h.

Function Documentation

check_cards()

int check_cards	(	cat_params_t	mode,
		int **	indexmemo,
		char **	basenames,
		int *	cards,
		int	ct,
		int	nevts,
		evstock *	data
	)

Definition at line 196 of file main.c.

{
    int i, j, minim, n, cmbtotal = 0;
    char *name;
    int mode = params.mode;
    int pk = params.subsetsize;
 
    // User provided a file of events.
    if(READ_FROM_FILE == mode)
    {
        // Compute the total number of qualifier combinations and allocate memory to store them.
        if (NULL == ((*indexmemo) = (int*)malloc(ct*sizeof(int)))) {
            fprintf(stderr, "Failed to allocate memory.\n");
            return 0;
        }
 
        // Find the index in the main stock whose event corresponds to that in the file provided.
        // This simplifies looking up event qualifiers later.
        for(i = 0; i < ct; ++i)
        {
            if(NULL == basenames[i])
            {
                (*indexmemo)[i] = -1;
                cmbtotal -= 1;
                continue;
            }
 
            // j is the index of the event name provided by the user.
            for(j = 0; j < nevts; ++j)
            {
                name = evt_name(data, j);
                if(strcmp(basenames[i], name) == 0)
                {
                    break;
                }
            }
 
            // If the event name provided by the user does not match any of the main event
            // names in the architecture, then it either contains qualifiers or it does not
            // exist.
            if(cards[i] != 0 && j == nevts)
            {
                fprintf(stderr, "The provided event '%s' is either not in the architecture or contains qualifiers.\n" \
                        "If the latter, use '0' in place of the provided '%d'.\n", basenames[i], cards[i]);
                cards[i] = 0;
            }
 
            // If an invalid (negative) qualifier count was given, use zero qualifiers.
            if(cards[i] < 0)
            {
                fprintf(stderr, "The qualifier count (provided for event '%s') cannot be negative.\n", basenames[i]);
                cards[i] = 0;
            }
 
            (*indexmemo)[i] = j;
        }
 
        // Count the total number of events to test.
        for(i = 0; i < ct; ++i)
        {
            // If no qualifiers are used, then just count the event itself.
            if(cards[i] <= 0)
            {
                cmbtotal += 1;
                continue;
            }
 
            // Get the number of qualifiers which belong to the main event.
            if((*indexmemo)[i] != -1)
            {
                n = num_quals(data, (*indexmemo)[i]);
            }
            else
            {
                n = 0;
            }
 
            // If the user specifies to use more qualifiers than are available
            // for the main event, do not use any qualifiers. Otherwise, count
            // the number of combinations of qualifiers for the main event.
            minim = cards[i];
            if(cards[i] > n || cards[i] < 0)
            {
                minim = 0;
            }
            cmbtotal += comb(n, minim);
        }
    }
    // User wants to inspect all events in the architecture.
    else
    {
        for(i = 0; i < nevts; ++i)
        {
            // Get the number of qualifiers which belong to the main event.
            n = num_quals(data, i);
 
            // If the user specifies to use more qualifiers than are available
            // for the main event, do not use any qualifiers. Otherwise, count
            // the number of combinations of qualifiers for the main event.
            minim = pk;
            if(pk > n || pk < 0)
            {
                minim = 0;
            }
            cmbtotal += comb(n, minim);
        }
    }
 
    return cmbtotal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

comb()

int comb	(	int	n,
		int	k
	)

Definition at line 804 of file main.c.

{
    return perm(n, k)/perm(k, k);
}

Here is the call graph for this function:

Here is the caller graph for this function:

combine_qualifiers()

void combine_qualifiers	(	int	n,
		int	pk,
		int	ct,
		char **	list,
		char *	name,
		char **	allevts,
		int *	track,
		int	flag,
		int *	bitmap
	)

Definition at line 585 of file main.c.

{
    int original;
    int counter;
    int i;
 
    // Set flag in the array.
    original = bitmap[ct];
    bitmap[ct] = flag;
 
    // Only make recursive calls if there are more items.
    // Ensure proper cardinality.
    counter = 0;
    for(i = 0; i < n; ++i)
    {
        counter += bitmap[i];
    }    
 
    // Cannot use more qualifiers than are available.
    if(ct+1 < n)
    {
        // Make recursive calls both with and without a given qualifier.
        // Recursion cannot exceed the number of qualifiers specified by
        // the user.
        if(counter < pk)
        {
            combine_qualifiers(n, pk, ct+1, list, name, allevts, track, 1, bitmap); 
        }
        combine_qualifiers(n, pk, ct+1, list, name, allevts, track, 0, bitmap);
    }
    // Qualifier count matches that specified by the user.
    else
    {
        if(counter == pk)
        {
            // Construct the qualifier combination string.
            char* chunk;
            size_t evtsize = strlen(name)+1;
            for(i = 0; i < n; ++i)
            {
                if(bitmap[i] == 1)
                {
                    // Add one to account for the colon in front of the qualifier.
                    evtsize += strlen(list[i])+1;
                }
            }
 
            if (NULL == (chunk = (char*)malloc((evtsize+1)*sizeof(char)))) {
                fprintf(stderr, "Failed to allocate memory.\n");
                return;
            }
 
            strcpy(chunk,name);
            for(i = 0; i < n; ++i)
            {
                if(bitmap[i] == 1)
                {
                    strcat(chunk,":");
                    strcat(chunk,list[i]);
                }
            }
 
            // Add qualifier combination string to the list.
            allevts[*track] = strdup(chunk);
            *track += 1;
 
            free(chunk);
        }
    }
 
    // Undo effect of recursive call to combine other qualifiers.
    bitmap[ct] = original;
 
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

obtain_hardware_description()

static hw_desc_t * obtain_hardware_description ( char *  conf_file_name )

static

omp_get_thread_num_wrapper()

unsigned long int omp_get_thread_num_wrapper

(

)

Definition at line 191 of file main.c.

                                               {
    return omp_get_thread_num();
}

Here is the caller graph for this function:

parse_line()

static int parse_line ( FILE *  input, char **  key, long long *  value  )

static

parseArgs()

int parseArgs	(	int	argc,
		char **	argv,
		cat_params_t *	params
	)

Definition at line 988 of file main.c.

                                                          {
    char *name = argv[0];
    char *tmp = NULL;
    int dirlen = 0;
    int kflag  = 0;
    int inflag = 0;
    FILE *test = NULL;
    int len, status = 0;
 
    params->subsetsize = -1;
 
    // Parse the command line arguments
    while(--argc){
        ++argv;
        if( !strcmp(argv[0],"-h") ){
            print_usage(name);
            return -1;
        }
        if( argc > 1 && !strcmp(argv[0],"-k") ){
            params->subsetsize = atoi(argv[1]);
            if( params->subsetsize < 0 )
            {
                params->subsetsize = 0;
                fprintf(stderr, "Warning: Cannot pass a negative value to -k.\n");
            }
            params->mode = USE_ALL_EVENTS;
            kflag = 1;
            --argc;
            ++argv;
            continue;
        }
        if( argc > 1 && !strcmp(argv[0],"-n") ){
            params->max_iter = atoi(argv[1]);
            --argc;
            ++argv;
            continue;
        }
        if( argc > 1 && !strcmp(argv[0],"-conf") ){
            params->conf_file = argv[1];
            --argc;
            ++argv;
            continue;
        }
        if( argc > 1 && !strcmp(argv[0],"-in") ){
            params->inputfile = argv[1];
            params->mode = READ_FROM_FILE;
            inflag = 1;
            --argc;
            ++argv;
            continue;
        }
        if( argc > 1 && !strcmp(argv[0],"-out") ){
            tmp = argv[1];
            --argc;
            ++argv;
            continue;
        }
        if( !strcmp(argv[0],"-verbose") ){
            params->show_progress = 1;
            continue;
        }
        if( !strcmp(argv[0],"-quick") ){
            params->quick = 1;
            continue;
        }
        if( !strcmp(argv[0],"-branch") ){
            params->bench_type |= BENCH_BRANCH;
            continue;
        }
        if( !strcmp(argv[0],"-dcr") ){
            params->bench_type |= BENCH_DCACHE_READ;
            continue;
        }
        if( !strcmp(argv[0],"-dcw") ){
            params->bench_type |= BENCH_DCACHE_WRITE;
            continue;
        }
        if( !strcmp(argv[0],"-flops") ){
            params->bench_type |= BENCH_FLOPS;
            continue;
        }
        if( !strcmp(argv[0],"-ic") ){
            params->bench_type |= BENCH_ICACHE_READ;
            continue;
        }
        if( !strcmp(argv[0],"-vec") ){
            params->bench_type |= BENCH_VEC;
            continue;
        }
        if( !strcmp(argv[0],"-instr") ){
            params->bench_type |= BENCH_INSTR;
            continue;
        }
 
        print_usage(name);
        return -1;
    }
 
    // MODE INFO: mode 1 uses file; mode 2 uses all native events.
    if(READ_FROM_FILE == params->mode)
    {
        test = fopen(params->inputfile, "r");
        if(test == NULL)
        {
            fprintf(stderr, "Could not open %s. Exiting...\n", params->inputfile);
            return -1;
        }
        fclose(test);
    }
 
    // Make sure user does not specify both modes simultaneously.
    if(kflag == 1 && inflag == 1)
    {
        fprintf(stderr, "Cannot use -k flag with -in flag. Exiting...\n");
        return -1;
    }
 
    // Make sure user specifies mode explicitly.
    if(kflag == 0 && inflag == 0)
    {
        print_usage(name);
        return -1;
    }
 
    // Make sure output path was provided.
    if(tmp == NULL)
    {
        fprintf(stderr, "Output path not provided. Exiting...\n");
        return -1;
    }
 
    // Write output files in the user-specified directory.
    dirlen = strlen(tmp);
    params->outputdir = (char*)malloc((2+dirlen)*sizeof(char));
 
    if (NULL == params->outputdir) {
        fprintf(stderr, "Failed to allocate memory.\n");
        return -1;
    }
 
    len = snprintf( params->outputdir, 2+dirlen, "%s/", tmp);
    if( len < 1+dirlen )
    {
        fprintf(stderr, "Problem with output directory name.\n");
        return -1;
    }
 
    // Make sure files can be written to the provided path.
    status = access(params->outputdir, W_OK);
    if(status != 0)
    {
        fprintf(stderr, "Permission to write files to \"%s\" denied. Make sure the path exists and is writable.\n", tmp);
        return -1;
    }
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

perm()

int perm	(	int	n,
		int	k
	)

Definition at line 789 of file main.c.

{
    int i;
    int prod = 1;
    int diff = n-k;
 
    for(i = n; i > diff; --i)
    {
        prod *= i;
    }
 
    return prod;
}

Here is the caller graph for this function:

print_usage()

void print_usage

(

)

Here is the caller graph for this function:

read_conf_file()

static void read_conf_file ( char *  conf_file, hw_desc_t *  hw_desc  )

static

setup_evts()

int setup_evts	(	char *	inputfile,
		char ***	basenames,
		int **	cards
	)

Definition at line 500 of file main.c.

{
    size_t linelen = 0;
    int cnt = 0, status = 0;
    char *line = NULL, *place;
    FILE *input;
    int evnt_count = 256;
  
    char **names = (char **)calloc(evnt_count, sizeof(char *));
    int *cards = (int *)calloc(evnt_count, sizeof(int));
 
    if (NULL == names || NULL == cards) {
        fprintf(stderr, "Failed to allocate memory.\n");
        return 0;
    }
 
    // Read the base event name and cardinality columns.
    input = fopen(inputfile, "r");
    for(cnt=0; 1; cnt++)
    {
        ssize_t ret_val = getline(&line, &linelen, input);
        if( ret_val < 0 )
            break;
        if( cnt >= evnt_count )
        {
            evnt_count *= 2;
            names = realloc(names, evnt_count*sizeof(char *));
            cards = realloc(cards, evnt_count*sizeof(int));
 
            if (NULL == names || NULL == cards) {
                fprintf(stderr, "Failed to allocate memory.\n");
                return 0;
            }
        }
 
        place = strstr(line, " ");
 
        // If this line was commented, silently ignore it.
        if(strlen(line) > 0 && line[0] == '#') {
            names[cnt] = NULL;
            cards[cnt] = -1;
            cnt--;
 
            free(line);
            line = NULL;
            linelen = 0;
            continue;
        } else if( NULL == place ) {
            fprintf(stderr,"problem with line: '%s'\n",line);
            names[cnt] = NULL;
            cards[cnt] = -1;
            cnt--;
 
            free(line);
            line = NULL;
            linelen = 0;
            continue;
        }
 
        names[cnt] = NULL;
        status = sscanf(line, "%ms %d", &(names[cnt]), &(cards[cnt]) );
 
        // If this line was malformed, ignore it.
        if(2 != status)
        {
            fprintf(stderr,"problem with line: '%s'\n",line);
            names[cnt] = NULL;
            cards[cnt] = -1;
            cnt--;
        }
 
        free(line);
        line = NULL;
        linelen = 0;
    }
    free(line);
    fclose(input);
 
    *basenames = names;
    *evnt_cards = cards;
 
    return cnt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

testbench()

void testbench	(	char **	allevts,
		int	cmbtotal,
		hw_desc_t *	hw_desc,
		cat_params_t	params,
		int	myid,
		int	nprocs
	)

Definition at line 829 of file main.c.

{
    int i;
    int junk=((int)getpid()+123)/456;
    int low = myid*(cmbtotal/nprocs);
    int cap = (myid+1)*(cmbtotal/nprocs);
    int offset = nprocs*(1+cmbtotal/nprocs)-cmbtotal;
 
    // Divide the work as evenly as possible.
    if(myid >= offset) {
        cap += myid-offset+1;
        low += myid-offset;
    }
 
    // Make sure the user provided events and iterate through all events.
    if( 0 == cmbtotal )
    {
        fprintf(stderr, "No events to measure.\n");
        return;
    }
 
    // Run the branch benchmark by default if none are specified.
    if( 0 == params.bench_type )
    {
        params.bench_type |= BENCH_BRANCH;
        fprintf(stderr, "Warning: No benchmark specified. Running 'branch' by default.\n");
    }
 
    /* Benchmark I - Branch*/
    if( params.bench_type & BENCH_BRANCH )
    {
        if(params.show_progress) printf("Branch Benchmarks: ");
 
        for(i = low; i < cap; ++i)
        {
            if(params.show_progress) print_progress((100*i)/cmbtotal);
 
            if( allevts[i] != NULL )
                branch_driver(allevts[i], junk, hw_desc, params.outputdir);
        }
        if(params.show_progress) print_progress(100);
    }
 
    /* Benchmark II - Data Cache Reads*/
    if( params.bench_type & BENCH_DCACHE_READ )
    {
        if ( !params.quick && 0 == myid )
        {
            if(params.show_progress)
            {
                printf("D-Cache Latencies:  0%%\b\b\b\b");
                fflush(stdout);
            }
            d_cache_driver("cat::latencies", params, hw_desc, 1, 0);
            if(params.show_progress) printf("100%%\n");
        }
 
        if(params.show_progress) printf("D-Cache Read Benchmarks: ");
        for(i = low; i < cap; ++i)
        {
            if(params.show_progress) print_progress2((100*i)/cmbtotal);
 
            if( allevts[i] != NULL ) {
                d_cache_driver(allevts[i], params, hw_desc, 0, 0);
            }
        }
        if(params.show_progress) print_progress2(100);
    }
 
    /* Benchmark III - Data Cache Writes*/
    if( params.bench_type & BENCH_DCACHE_WRITE )
    {
        // If the READ benchmark was run, do not recompute the latencies.
        if ( !(params.bench_type & BENCH_DCACHE_READ) && !params.quick)
        {
            if(params.show_progress)
            {
                printf("D-Cache Latencies:  0%%\b\b\b\b");
                fflush(stdout);
            }
            d_cache_driver("cat::latencies", params, hw_desc, 1, 0);
            if(params.show_progress) printf("100%%\n");
        }
 
        if(params.show_progress) printf("D-Cache Write Benchmarks: ");
        for(i = low; i < cap; ++i)
        {
            if(params.show_progress) print_progress2((100*i)/cmbtotal);
 
            if( allevts[i] != NULL ) {
                d_cache_driver(allevts[i], params, hw_desc, 0, 1);
            }
        }
        if(params.show_progress) print_progress2(100);
    }
 
    /* Benchmark IV - FLOPS*/
    if( params.bench_type & BENCH_FLOPS )
    {
        if(params.show_progress) printf("FLOP Benchmarks: ");
 
        for(i = low; i < cap; ++i)
        {
            if(params.show_progress) print_progress((100*i)/cmbtotal);
 
            if( allevts[i] != NULL )
                flops_driver(allevts[i], hw_desc, params.outputdir);
        }
        if(params.show_progress) print_progress(100);
    }
 
    /* Benchmark V - Instruction Cache*/
    if( params.bench_type & BENCH_ICACHE_READ )
    {
        if(params.show_progress) printf("I-Cache Benchmarks: ");
 
        for(i = low; i < cap; ++i)
        {
            if(params.show_progress) print_progress2((100*i)/cmbtotal);
 
            if( allevts[i] != NULL )
                i_cache_driver(allevts[i], junk, hw_desc, params.outputdir, params.show_progress);
        }
        if(params.show_progress) print_progress2(100);
    }
 
    /* Benchmark VI - Vector FLOPS*/
    if( params.bench_type & BENCH_VEC )
    {
        if(params.show_progress) printf("Vector FLOP Benchmarks: ");
 
        for(i = low; i < cap; ++i)
        {
            if(params.show_progress) print_progress((100*i)/cmbtotal);
 
            if( allevts[i] != NULL )
                vec_driver(allevts[i], hw_desc, params.outputdir);
        }
        if(params.show_progress) print_progress(100);
    }
 
    /* Benchmark VII - Instructions*/
    if( params.bench_type & BENCH_INSTR )
    {
        if(params.show_progress) printf("Instruction Benchmarks: ");
 
        for(i = low; i < cap; ++i)
        {
            if(params.show_progress) print_progress((100*i)/cmbtotal);
 
            if( allevts[i] != NULL )
                instr_driver(allevts[i], hw_desc, params.outputdir);
        }
        if(params.show_progress) print_progress(100);
    }
 
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

trav_evts()

void trav_evts	(	evstock *	stock,
		int	pk,
		int *	cards,
		int	nevts,
		int	selexnsize,
		int	mode,
		char **	allevts,
		int *	track,
		int *	indexmemo,
		char **	basenames
	)

Definition at line 662 of file main.c.

{
    int i, j, k, n = 0;
    char** chosen = NULL;
    char* name = NULL;
    int* bitmap = NULL;
 
    // User provided a file of events.
    if(READ_FROM_FILE == mode)
    {
        for(i = 0; i < selexnsize; ++i)
        {
            // Iterate through whole stock. If there are matches, proceed normally using the given cardinalities.
            j = indexmemo[i];
            if( -1 == j )
            {
                allevts[i] = NULL;
                continue;
            }
 
            // Get event's name and qualifier count.
            if(j == nevts)
            {
                // User a provided specific qualifier combination.
                name = basenames[i];
            }
            else
            {
                name = evt_name(stock, j);
                n = num_quals(stock, j);
            }
 
            // Create a list to contain the qualifiers.
            if(cards[i] > 0)
            {
                chosen = (char**)malloc(n*sizeof(char*));
                bitmap = (int*)calloc(n, sizeof(int));    
                
                if (NULL == chosen || NULL == bitmap) {
                    fprintf(stderr, "Failed to allocate memory.\n");
                    return;
                }
 
                // Store the qualifiers for the current event.
                for(k = 0; k < n; ++k)
                {
                    chosen[k] = strdup(stock->evts[j][k]);
                }
            }
 
            // Get combinations of all current event's qualifiers.
            if (n!=0 && cards[i]>0)
            {
                combine_qualifiers(n, cards[i], 0, chosen, name, allevts, track, 0, bitmap);
                combine_qualifiers(n, cards[i], 0, chosen, name, allevts, track, 1, bitmap);
            }
            else
            {
                allevts[*track] = strdup(name);
                *track += 1;
            }
 
            // Free the space back up.
            if(cards[i] > 0)
            {
                for(k = 0; k < n; ++k)
                {
                    free(chosen[k]);
                }
                free(chosen);
                free(bitmap);
            }
        }
    }
    // User wants to inspect all events in the architecture.
    else
    {
        for(i = 0; i < nevts; ++i)
        {
            // Get event's name and qualifier count.
            n = num_quals(stock, i);
            name = evt_name(stock, i);
 
            // Show progress to the user.
            //fprintf(stderr, "CURRENT EVENT: %s (%d/%d)\n", name, (i+1), nevts);
 
            // Create a list to contain the qualifiers.
            chosen = (char**)malloc(n*sizeof(char*));
            bitmap = (int*)calloc(n, sizeof(int));    
 
            if (NULL == chosen || NULL == bitmap) {
                fprintf(stderr, "Failed to allocate memory.\n");
                return;
            }
 
            // Store the qualifiers for the current event.
            for(j = 0; j < n; ++j)
            {
                chosen[j] = strdup(stock->evts[i][j]);
            }
 
            // Get combinations of all current event's qualifiers.
            if (n!=0)
            {
                combine_qualifiers(n, pk, 0, chosen, name, allevts, track, 0, bitmap);
                combine_qualifiers(n, pk, 0, chosen, name, allevts, track, 1, bitmap);
            }
            else
            {
                allevts[*track] = strdup(name);
                *track += 1;
            }
 
            // Free the space back up.
            for(j = 0; j < n; ++j)
            {
                free(chosen[j]);
            }
            free(chosen);
            free(bitmap);
        }
    }
 
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function: