ctests/locks_pthreads.c File Reference

Include dependency graph for ctests/locks_pthreads.c:

Go to the source code of this file.

Macros
#define	MAX_THREADS   256
#define	APPR_TOTAL_ITER   1000000

Functions
void	lockloop (int iters, volatile long long *mycount)
void *	Slave (void *arg)
int	main (int argc, char **argv)

Variables
volatile long long	count = 0
volatile long long	tmpcount = 0
volatile long long	thread_iter = 0
static int	quiet =0

Macro Definition Documentation

APPR_TOTAL_ITER

#define APPR_TOTAL_ITER   1000000

Definition at line 7 of file ctests/locks_pthreads.c.

MAX_THREADS

#define MAX_THREADS   256

Definition at line 6 of file ctests/locks_pthreads.c.

Function Documentation

lockloop()

void lockloop	(	int	iters,
		volatile long long *	mycount
	)

Definition at line 25 of file ctests/locks_pthreads.c.

{
    int i;
    for ( i = 0; i < iters; i++ ) {
        PAPI_lock( PAPI_USR1_LOCK );
        *mycount = *mycount + 1;
        PAPI_unlock( PAPI_USR1_LOCK );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 53 of file ctests/locks_pthreads.c.

{
    pthread_t slaves[MAX_THREADS];
    int rc, i, nthr;
    int retval;
    const PAPI_hw_info_t *hwinfo = NULL;

    /* Set TESTS_QUIET variable */
    quiet = tests_quiet( argc, argv );

    retval = PAPI_library_init( PAPI_VER_CURRENT );
    if (retval != PAPI_VER_CURRENT ) {
        test_fail( __FILE__, __LINE__, "PAPI_library_init", retval );
    }

    hwinfo = PAPI_get_hardware_info(  );
    if (hwinfo == NULL ) {
        test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 );
    }

    retval = PAPI_thread_init((unsigned long (*)(void)) ( pthread_self ) );
    if ( retval != PAPI_OK ) {
        if ( retval == PAPI_ECMP ) {
            test_skip( __FILE__, __LINE__,
                "PAPI_thread_init", retval );
        }
        else {
            test_fail( __FILE__, __LINE__,
                "PAPI_thread_init", retval );
        }
    }

    if ( hwinfo->ncpu > MAX_THREADS ) {
        nthr = MAX_THREADS;
    }
    else {
        nthr = hwinfo->ncpu;
    }

    /* Scale the per thread work to keep the serial runtime about the same. */
    thread_iter = APPR_TOTAL_ITER/sqrt(nthr);

    if (!quiet) {
        printf( "Creating %d threads, %lld lock/unlock\n",
            nthr , thread_iter);
    }

    for ( i = 0; i < nthr; i++ ) {
        rc = pthread_create( &slaves[i], NULL, Slave, NULL );
        if ( rc ) {
            retval = PAPI_ESYS;
            test_fail( __FILE__, __LINE__,
                "pthread_create", retval );
        }
    }

    for ( i = 0; i < nthr; i++ ) {
        pthread_join( slaves[i], NULL );
    }

    if (!quiet) {
        printf( "Expected: %lld Received: %lld\n",
            ( long long ) nthr * thread_iter,
            count );
    }

    if ( nthr * thread_iter != count ) {
        test_fail( __FILE__, __LINE__, "Thread Locks", 1 );
    }

    test_pass( __FILE__ );

    return 0;

}

Here is the call graph for this function:

Slave()

void* Slave

(

void *

arg

)

Definition at line 36 of file ctests/locks_pthreads.c.

{
    long long duration;

    duration = PAPI_get_real_usec(  );
    lockloop( thread_iter, &count );
    duration = PAPI_get_real_usec(  ) - duration;

    if (!quiet) {
        printf("%f lock/unlocks per us\n",
            (float)thread_iter/(float)duration);
    }
    pthread_exit( arg );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

count

volatile long long count = 0

Definition at line 18 of file ctests/locks_pthreads.c.

quiet

int quiet =0

static

Definition at line 22 of file ctests/locks_pthreads.c.

thread_iter

volatile long long thread_iter = 0

Definition at line 20 of file ctests/locks_pthreads.c.

tmpcount

volatile long long tmpcount = 0

Definition at line 19 of file ctests/locks_pthreads.c.