timing_kernels.c File Reference

Include dependency graph for timing_kernels.c:

Go to the source code of this file.

Functions
run_output_t	probeBufferSize (long long active_buf_len, long long line_size, float pageCountPerBlock, int pattern, uintptr_t **v, uintptr_t *rslt, int latency_only, int mode, int ONT)
void	error_handler (int e, int line)

Variables
volatile double	x
volatile double	y
int	is_core
char *	eventname = NULL

Function Documentation

error_handler()

void error_handler	(	int	e,
		int	line
	)

Definition at line 195 of file timing_kernels.c.

                                   {
    int idx;
    const char *errors[26] = {
                              "No error",
                              "Invalid argument",
                              "Insufficient memory",
                              "A System/C library call failed",
                              "Not supported by component",
                              "Access to the counters was lost or interrupted",
                              "Internal error, please send mail to the developers",
                              "Event does not exist",
                              "Event exists, but cannot be counted due to counter resource limitations",
                              "EventSet is currently not running",
                              "EventSet is currently counting",
                              "No such EventSet Available",
                              "Event in argument is not a valid preset",
                              "Hardware does not support performance counters",
                              "Unknown error code",
                              "Permission level does not permit operation",
                              "PAPI hasn't been initialized yet",
                              "Component Index isn't set",
                              "Not supported",
                              "Not implemented",
                              "Buffer size exceeded",
                              "EventSet domain is not supported for the operation",
                              "Invalid or missing event attributes",
                              "Too many events or attributes",
                              "Bad combination of features",
                              "Component containing event is disabled"
    };
 
    idx = -e;
    if(idx >= 26 || idx < 0 )
        idx = 15;
 
    if( NULL != eventname )
        fprintf(stderr,"\nError \"%s\" occured at line %d when processing event %s.\n", errors[idx], line, eventname);
    else
        fprintf(stderr,"\nError \"%s\" occured at line %d.\n", errors[idx], line);
 
}

Here is the caller graph for this function:

probeBufferSize()

run_output_t probeBufferSize	(	long long	active_buf_len,
		long long	line_size,
		float	pageCountPerBlock,
		int	pattern,
		uintptr_t **	v,
		uintptr_t *	rslt,
		int	latency_only,
		int	mode,
		int	ONT
	)

Definition at line 17 of file timing_kernels.c.

                                                                                                                                                                                      {
    int _papi_eventset = PAPI_NULL;
    int retval, buffer = 0, status = 0;
    int error_line = -1, error_type = PAPI_OK;
    register uintptr_t *p = NULL;
    register uintptr_t p_prime;
    long long count, pageSize, blockSize;
    long long int counter[ONT];
    run_output_t out;
    out.status = 0;
 
    assert( sizeof(int) >= 4 );
 
    x = (double)*rslt;
    x = floor(1.3*x/(1.4*x+1.8));
    y = x*3.97;
    if( x > 0 || y > 0 )
        printf("WARNING: x=%lf y=%lf\n",x,y);
 
    // Make no fewer accesses than we would for a buffer of size 128KB.
    long long countMax;
    long long unsigned threshold = 128*1024;
    if( active_buf_len*sizeof(uintptr_t) > threshold )
        countMax = 64LL*((long long)(active_buf_len/line_size));
    else
        countMax = 64LL*((long long)(threshold/line_size));
 
    // Get the size of a page of memory.
    pageSize = sysconf(_SC_PAGESIZE)/sizeof(uintptr_t);
    if( pageSize <= 0 ){
        fprintf(stderr,"Cannot determine pagesize, sysconf() returned an error code.\n");
        out.status = -1;
        return out;
    }
 
    // Compute the size of a block in the pointer chain and create the pointer chain.
    blockSize = (long long)(pageCountPerBlock*(float)pageSize);
    #pragma omp parallel reduction(+:status) default(shared)
    {
        int idx = omp_get_thread_num();
 
        status += prepareArray(v[idx], active_buf_len, line_size, blockSize, pattern);
    }
 
    // Start of threaded benchmark.
    #pragma omp parallel private(p,count,retval) reduction(+:buffer) reduction(+:status) firstprivate(_papi_eventset) default(shared)
    {
        int idx = omp_get_thread_num();
        int thdStatus = 0;
        double divisor = 1.0;
        double time1=0, time2=0, dt, factor;
 
        // Initialize the result to a value indicating an error.
        // If no error occurs, it will be overwritten.
        if ( !latency_only ) {
            out.counter[idx] = -1;
        }
 
        // We will use "p" even after the epilogue, so let's set
        // it here in case an error occurs.
        p = &v[idx][0];
        count = countMax;
 
        if ( !latency_only && (is_core || 0 == idx) ) {
            retval = PAPI_create_eventset( &_papi_eventset );
            if (retval != PAPI_OK ){
                error_type = retval;
                error_line = __LINE__;
                thdStatus = -1;
                // If we can't measure events, no need to run the kernel.
                goto skip_epilogue;
            }
 
            retval = PAPI_add_named_event( _papi_eventset, eventname );
            if (retval != PAPI_OK ){
                error_type = retval;
                error_line = __LINE__;
                thdStatus = -1;
                // If we can't measure events, no need to run the kernel.
                goto clean_up;
            }
 
            // Start the counters.
            retval = PAPI_start(_papi_eventset);
            if ( PAPI_OK != retval ) {
                error_type = retval;
                error_line = __LINE__;
                thdStatus = -1;
                // If we can't measure events, no need to run the kernel.
                goto clean_up;
            }
        }
 
        // Start the actual test.
 
        // Micro-kernel for memory reading.
        if( CACHE_READ_ONLY == mode || latency_only )
        {
            if( latency_only ) time1 = getticks();
            while(count > 0){
                N_128;
                count -= 128;
            }
            if( latency_only ) time2 = getticks();
        }
        // Micro-kernel for memory writing.
        else
        {
            while(count > 0){
                NW_128;
                count -= 128;
            }
        }
 
        if ( !latency_only && (is_core || 0 == idx) ) {
            // Stop the counters.
            retval = PAPI_stop(_papi_eventset, &counter[idx]);
            if ( PAPI_OK != retval ) {
                error_type = retval;
                error_line = __LINE__;
                thdStatus = -1;
                goto clean_up;
            }
 
            // Get the average event count per access in pointer chase.
            // If it is not a core event, get average count per thread.
            divisor = 1.0*countMax;
            if( !is_core && 0 == idx )
                divisor *= ONT;
 
            out.counter[idx] = (1.0*counter[idx])/divisor;
 
clean_up:
            retval = PAPI_cleanup_eventset(_papi_eventset);
            if (retval != PAPI_OK ){
                error_type = retval;
                error_line = __LINE__;
                thdStatus = -1;
            }
 
            retval = PAPI_destroy_eventset(&_papi_eventset);
            if (retval != PAPI_OK ){
                error_type = retval;
                error_line = __LINE__;
                thdStatus = -1;
            }
 
        }else{
            // Compute the duration of the pointer chase.
            dt = elapsed(time2, time1);
 
            // Convert time into nanoseconds.
            factor = 1000.0;
 
            // Number of accesses per pointer chase.
            factor /= (1.0*countMax);
 
            // Get the average nanoseconds per access.
            out.dt[idx] = dt*factor;
        }
 
skip_epilogue:
        buffer += (uintptr_t)p+(uintptr_t)(x+y);
        status += thdStatus;
    }
 
    // Get the collective status.
    if(status < 0) {
        error_handler(error_type, error_line);
        out.status = -1;
    }
 
    // Prevent compiler optimization.
    *rslt = buffer;
 
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

eventname

char* eventname = NULL

Definition at line 15 of file timing_kernels.c.

is_core

int is_core

extern

Definition at line 15 of file dcache.c.

x

volatile double x

Definition at line 12 of file timing_kernels.c.

y

volatile double y

Definition at line 12 of file timing_kernels.c.