krentel_pthreads_race.c File Reference

Include dependency graph for krentel_pthreads_race.c:

Go to the source code of this file.

Macros
#define	MAX_THREADS   256
#define	EVENT   PAPI_TOT_CYC

Functions
static void	my_handler (int EventSet, void *pc, long long ovec, void *context)
static void	print_rate (long num)
static void	do_cycles (long num, int len)
static void *	my_thread (void *v)
int	main (int argc, char **argv)

Variables
static int	program_time = 5
static int	threshold = 20000000
static int	num_threads = 3
static long	count [MAX_THREADS]
static long	iter [MAX_THREADS]
static struct timeval	last [MAX_THREADS]
static pthread_key_t	key
static struct timeval	start

Macro Definition Documentation

EVENT

#define EVENT   PAPI_TOT_CYC

Definition at line 23 of file krentel_pthreads_race.c.

MAX_THREADS

#define MAX_THREADS   256

Definition at line 13 of file krentel_pthreads_race.c.

Function Documentation

do_cycles()

static void do_cycles ( long  num, int  len  )

static

Definition at line 79 of file krentel_pthreads_race.c.

{
    struct timeval start, now;
    double x, sum;
 
    gettimeofday( &start, NULL );
 
    for ( ;; ) {
        sum = 1.0;
        for ( x = 1.0; x < 250000.0; x += 1.0 )
            sum += x;
        if ( sum < 0.0 )
            printf( "==>>  SUM IS NEGATIVE !!  <<==\n" );
 
        iter[num]++;
 
        gettimeofday( &now, NULL );
        if ( now.tv_sec >= start.tv_sec + len )
            break;
    }
}

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 171 of file krentel_pthreads_race.c.

{
    pthread_t *td = NULL;
    long n;
    int quiet,retval;
 
    /* Set TESTS_QUIET variable */
    quiet=tests_quiet( argc, argv );
 
    if ( argc < 2 || sscanf( argv[1], "%d", &program_time ) < 1 )
        program_time = 6;
    if ( argc < 3 || sscanf( argv[2], "%d", &threshold ) < 1 )
        threshold = 20000000;
    if ( argc < 4 || sscanf( argv[3], "%d", &num_threads ) < 1 )
        num_threads = 32;
 
    td = malloc((num_threads+1) * sizeof(pthread_t));
    if (!td) {
        test_fail( __FILE__, __LINE__, "td malloc failed", 1 );
    }
 
    if (!quiet) {
        printf( "program_time = %d, threshold = %d, num_threads = %d\n\n",
            program_time, threshold, num_threads );
    }
 
    if ( PAPI_library_init( PAPI_VER_CURRENT ) != PAPI_VER_CURRENT )
        test_fail( __FILE__, __LINE__, "PAPI_library_init failed", 1 );
 
    /* Test to be sure we can add events */
    retval = PAPI_query_event( EVENT );
    if (retval!=PAPI_OK) {
        if (!quiet) printf("Trouble finding event\n");
        test_skip(__FILE__,__LINE__,"Event not available",1);
    }
 
    if ( PAPI_thread_init( ( unsigned long ( * )( void ) ) ( pthread_self ) ) !=
         PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_thread_init failed", 1 );
 
    if ( pthread_key_create( &key, NULL ) != 0 )
        test_fail( __FILE__, __LINE__, "pthread key create failed", 1 );
 
    gettimeofday( &start, NULL );
 
    for ( n = 1; n <= num_threads; n++ ) {
        if ( pthread_create( &(td[n]), NULL, my_thread, ( void * ) n ) != 0 )
            test_fail( __FILE__, __LINE__, "pthread create failed", 1 );
    }
 
    my_thread( ( void * ) 0 );
 
    /* wait for all the threads */
    for ( n = 1; n <= num_threads; n++ ) {
        if ( pthread_join( td[n], NULL))
            test_fail( __FILE__, __LINE__, "pthread join failed", 1 );
    }
 
    free(td);
 
    if (!quiet) printf( "done\n" );
 
    test_pass( __FILE__ );
 
    return 0;
}

Here is the call graph for this function:

my_handler()

static void my_handler ( int  EventSet, void *  pc, long long  ovec, void *  context  )

static

Definition at line 38 of file krentel_pthreads_race.c.

{
    ( void ) EventSet;
    ( void ) pc;
    ( void ) ovec;
    ( void ) context;
 
    long num = ( long ) pthread_getspecific( key );
 
    if ( num < 0 || num > num_threads )
        test_fail( __FILE__, __LINE__, "getspecific failed", 1 );
    count[num]++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

my_thread()

static void * my_thread ( void *  v )

static

Definition at line 102 of file krentel_pthreads_race.c.

{
    long num = ( long ) v;
    int n;
    int EventSet = PAPI_NULL;
    int event_code;
    long long value;
 
    int retval;
 
    retval = PAPI_register_thread(  );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_register_thread", retval );
    }
    pthread_setspecific( key, v );
 
    count[num] = 0;
    iter[num] = 0;
    last[num] = start;
 
    retval = PAPI_create_eventset( &EventSet );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_create_eventset failed", retval );
    }
 
    retval = PAPI_event_name_to_code("PAPI_TOT_CYC", &event_code);
    if (retval != PAPI_OK ) {
        if (!TESTS_QUIET) printf("Trouble creating event name\n");
        test_fail( __FILE__, __LINE__, "PAPI_event_name_to_code failed", retval );
    }
 
    retval = PAPI_add_event( EventSet, EVENT );
    if (retval != PAPI_OK ) {
        if (!TESTS_QUIET) printf("Trouble adding event\n");
        test_fail( __FILE__, __LINE__, "PAPI_add_event failed", retval );
    }
 
    if ( PAPI_overflow( EventSet, EVENT, threshold, 0, my_handler ) != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_overflow failed", 1 );
 
    if ( PAPI_start( EventSet ) != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_start failed", 1 );
 
    if (!TESTS_QUIET) printf( "launched timer in thread %ld\n", num );
 
    for ( n = 1; n <= program_time; n++ ) {
        do_cycles( num, 1 );
        print_rate( num );
    }
 
    PAPI_stop( EventSet, &value );
 
        retval = PAPI_overflow( EventSet, EVENT, 0, 0, my_handler);
    if ( retval != PAPI_OK )
            test_fail( __FILE__, __LINE__, "PAPI_overflow failed to reset the overflow handler", retval );
 
    if ( PAPI_remove_event( EventSet, EVENT ) != PAPI_OK ) 
        test_fail( __FILE__, __LINE__, "PAPI_remove_event", 1 );
 
    if ( PAPI_destroy_eventset( &EventSet ) != PAPI_OK ) 
        test_fail( __FILE__, __LINE__, "PAPI_destroy_eventset", 1 );
 
    if ( PAPI_unregister_thread( ) != PAPI_OK ) 
            test_fail( __FILE__, __LINE__, "PAPI_unregister_thread", 1 );
 
    return ( NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_rate()

static void print_rate ( long  num )

static

Definition at line 53 of file krentel_pthreads_race.c.

{
    struct timeval now;
    long st_secs;
    double last_secs;
 
    gettimeofday( &now, NULL );
    st_secs = now.tv_sec - start.tv_sec;
    last_secs = ( double ) ( now.tv_sec - last[num].tv_sec )
        + ( ( double ) ( now.tv_usec - last[num].tv_usec ) ) / 1000000.0;
    if ( last_secs <= 0.001 )
        last_secs = 0.001;
 
    if (!TESTS_QUIET) {
        printf( "[%ld] time = %ld, count = %ld, iter = %ld, "
            "rate = %.1f/Kiter\n",
            num, st_secs, count[num], iter[num],
            ( 1000.0 * ( double ) count[num] ) / ( double ) iter[num] );
    }
 
    count[num] = 0;
    iter[num] = 0;
    last[num] = now;
}

Here is the caller graph for this function:

Variable Documentation

count

long count[MAX_THREADS]

static

Definition at line 29 of file krentel_pthreads_race.c.

iter

long iter[MAX_THREADS]

static

Definition at line 30 of file krentel_pthreads_race.c.

key

pthread_key_t key

static

Definition at line 33 of file krentel_pthreads_race.c.

last

struct timeval last[MAX_THREADS]

static

Definition at line 31 of file krentel_pthreads_race.c.

num_threads

int num_threads = 3

static

Definition at line 27 of file krentel_pthreads_race.c.

program_time

int program_time = 5

static

Definition at line 25 of file krentel_pthreads_race.c.

start

struct timeval start

static

Definition at line 35 of file krentel_pthreads_race.c.

threshold

int threshold = 20000000

static

Definition at line 26 of file krentel_pthreads_race.c.