Include dependency graph for timing_kernels.h:

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

Macros
#define	N_1 p = (uintptr_t )p;

#define	N_2 N_1 N_1

#define	N_16 N_2 N_2 N_2 N_2 N_2 N_2 N_2 N_2

#define	N_128 N_16 N_16 N_16 N_16 N_16 N_16 N_16 N_16

#define	NW_1 {p_prime = p; p = p_prime ^ 0x1; p = (uintptr_t *)(p_prime & (~0x1));}

#define	NW_2 NW_1 NW_1

#define	NW_16 NW_2 NW_2 NW_2 NW_2 NW_2 NW_2 NW_2 NW_2

#define	NW_128 NW_16 NW_16 NW_16 NW_16 NW_16 NW_16 NW_16 NW_16

#define	CACHE_READ_ONLY 0x0

#define	CACHE_READ_WRITE 0x1

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 detect_size, int mode, int ONT)

void	error_handler (int e, int line)

Macro Definition Documentation

◆ CACHE_READ_ONLY

#define CACHE_READ_ONLY 0x0

Definition at line 27 of file timing_kernels.h.

◆ CACHE_READ_WRITE

#define CACHE_READ_WRITE 0x1

Definition at line 28 of file timing_kernels.h.

◆ N_1

#define N_1 p = (uintptr_t *)*p;

Definition at line 8 of file timing_kernels.h.

◆ N_128

#define N_128 N_16 N_16 N_16 N_16 N_16 N_16 N_16 N_16

Definition at line 11 of file timing_kernels.h.

◆ N_16

#define N_16 N_2 N_2 N_2 N_2 N_2 N_2 N_2 N_2

Definition at line 10 of file timing_kernels.h.

◆ N_2

#define N_2 N_1 N_1

Definition at line 9 of file timing_kernels.h.

◆ NW_1

#define NW_1 {p_prime = *p; *p = p_prime ^ 0x1; p = (uintptr_t *)(p_prime & (~0x1));}

Definition at line 22 of file timing_kernels.h.

◆ NW_128

#define NW_128 NW_16 NW_16 NW_16 NW_16 NW_16 NW_16 NW_16 NW_16

Definition at line 25 of file timing_kernels.h.

◆ NW_16

#define NW_16 NW_2 NW_2 NW_2 NW_2 NW_2 NW_2 NW_2 NW_2

Definition at line 24 of file timing_kernels.h.

◆ NW_2

#define NW_2 NW_1 NW_1

Definition at line 23 of file timing_kernels.h.

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	detect_size,
		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: