data_range.c File Reference

Include dependency graph for data_range.c:

Go to the source code of this file.

Macros
#define	NUM   16384

Functions
static void	init_array (void)
static int	do_malloc_work (long loop)
static int	do_static_work (long loop)
static void	measure_load_store (caddr_t start, caddr_t end)
static void	measure_event (int index, PAPI_option_t *option)
int	main (int argc, char **argv)

Variables
int *	parray1
int *	parray2
int *	parray3
int	array1 [NUM]
int	array2 [NUM]
int	array3 [NUM]
char	event_name [2][PAPI_MAX_STR_LEN]
int	PAPI_event [2]
int	EventSet = PAPI_NULL

Macro Definition Documentation

NUM

#define NUM   16384

Definition at line 19 of file data_range.c.

Function Documentation

do_malloc_work()

static int do_malloc_work ( long  loop )

static

Definition at line 243 of file data_range.c.

{
    int i;
    int sum = 0;

    for ( i = 0; i < loop; i++ ) {
        parray1[i] = i;
        sum += parray1[i];
    }

    for ( i = 0; i < loop; i++ ) {
        parray2[i] = i;
        sum += parray2[i];
    }

    for ( i = 0; i < loop; i++ ) {
        parray3[i] = i;
        sum += parray3[i];
    }

    return sum;
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_static_work()

static int do_static_work ( long  loop )

static

Definition at line 219 of file data_range.c.

{
    int i;
    int sum = 0;

    for ( i = 0; i < loop; i++ ) {
        array1[i] = i;
        sum += array1[i];
    }

    for ( i = 0; i < loop; i++ ) {
        array2[i] = i;
        sum += array2[i];
    }

    for ( i = 0; i < loop; i++ ) {
        array3[i] = i;
        sum += array3[i];
    }

    return sum;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_array()

static void init_array ( void  )

static

Definition at line 199 of file data_range.c.

{
    parray1 = ( int * ) malloc( NUM * sizeof ( int ) );
    if ( parray1 == NULL )
        test_fail( __FILE__, __LINE__, "No memory available!\n", 0 );
    memset( parray1, 0x0, NUM * sizeof ( int ) );

    parray2 = ( int * ) malloc( NUM * sizeof ( int ) );
    if ( parray2 == NULL )
        test_fail( __FILE__, __LINE__, "No memory available!\n", 0 );
    memset( parray2, 0x0, NUM * sizeof ( int ) );

    parray3 = ( int * ) malloc( NUM * sizeof ( int ) );
    if ( parray3 == NULL )
        test_fail( __FILE__, __LINE__, "No memory available!\n", 0 );
    memset( parray3, 0x0, NUM * sizeof ( int ) );

}

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 34 of file data_range.c.

{
    int retval;
    const PAPI_exe_info_t *prginfo = NULL;
    const PAPI_hw_info_t *hw_info;

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

#if !defined(ITANIUM2) && !defined(ITANIUM3)
    test_skip( __FILE__, __LINE__, "Currently only works on itanium2", 0 );
    exit( 1 );
#endif

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

    init_array(  );
    printf( "Malloc'd array  pointers: %p   %p   %p\n", &parray1, &parray2,
            &parray3 );
    printf( "Malloc'd array addresses: %p   %p   %p\n", parray1, parray2,
            parray3 );
    printf( "Static   array addresses: %p   %p   %p\n", &array1, &array2,
            &array3 );

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

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

    hw_info = PAPI_get_hardware_info(  );
    if ( hw_info == NULL )
        test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 );

    prginfo = PAPI_get_executable_info(  );
    if ( prginfo == NULL )
        test_fail( __FILE__, __LINE__, "PAPI_get_executable_info", 1 );

#if defined(linux) && defined(__ia64__)
    sprintf( event_name[0], "loads_retired" );
    sprintf( event_name[1], "stores_retired" );
    PAPI_event_name_to_code( event_name[0], &PAPI_event[0] );
    PAPI_event_name_to_code( event_name[1], &PAPI_event[1] );
#else
    test_skip( __FILE__, __LINE__, "only works for Itanium", PAPI_ENOSUPP );
#endif

    if ( ( retval = PAPI_create_eventset( &EventSet ) ) != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );

    retval = PAPI_cleanup_eventset( EventSet );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_cleanup_eventset", retval );

    retval = PAPI_assign_eventset_component( EventSet, 0 );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_assign_eventset_component",
                   retval );

/***************************************************************************************/
    printf
        ( "\n\nMeasure loads and stores on the pointers to the allocated arrays\n" );
    printf( "Expected loads: %d; Expected stores: 0\n", NUM * 2 );
    printf
        ( "These loads result from accessing the pointers to compute array addresses.\n" );
    printf
        ( "They will likely disappear with higher levels of optimization.\n" );

    measure_load_store( ( caddr_t ) & parray1, ( caddr_t ) ( &parray1 + 1 ) );
    measure_load_store( ( caddr_t ) & parray2, ( caddr_t ) ( &parray2 + 1 ) );
    measure_load_store( ( caddr_t ) & parray3, ( caddr_t ) ( &parray3 + 1 ) );
/***************************************************************************************/
    printf
        ( "\n\nMeasure loads and stores on the allocated arrays themselves\n" );
    printf( "Expected loads: %d; Expected stores: %d\n", NUM, NUM );

    measure_load_store( ( caddr_t ) parray1, ( caddr_t ) ( parray1 + NUM ) );
    measure_load_store( ( caddr_t ) parray2, ( caddr_t ) ( parray2 + NUM ) );
    measure_load_store( ( caddr_t ) parray3, ( caddr_t ) ( parray3 + NUM ) );
/***************************************************************************************/
    printf( "\n\nMeasure loads and stores on the static arrays\n" );
    printf
        ( "These values will differ from the expected values by the size of the offsets.\n" );
    printf( "Expected loads: %d; Expected stores: %d\n", NUM, NUM );

    measure_load_store( ( caddr_t ) array1, ( caddr_t ) ( array1 + NUM ) );
    measure_load_store( ( caddr_t ) array2, ( caddr_t ) ( array2 + NUM ) );
    measure_load_store( ( caddr_t ) array3, ( caddr_t ) ( array3 + NUM ) );
/***************************************************************************************/

    retval = PAPI_destroy_eventset( &EventSet );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_destroy", retval );

    free( parray1 );
    free( parray2 );
    free( parray3 );

    test_pass( __FILE__ );

    return 0;

}

Here is the call graph for this function:

measure_event()

static void measure_event ( int  index, PAPI_option_t *  option  )

static

Definition at line 158 of file data_range.c.

{
    int retval;
    long long value;

    if ( ( retval = PAPI_add_event( EventSet, PAPI_event[index] ) ) != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_add_event", retval );

    if ( index == 0 ) {
/*      if ((retval = PAPI_get_opt(PAPI_DATA_ADDRESS, option)) != PAPI_OK)
          test_fail(__FILE__, __LINE__, "PAPI_get_opt(PAPI_DATA_ADDRESS)", retval);
*/
        printf
            ( "Requested Start Address: %p; Start Offset: %#5x; Actual Start Address: %p\n",
              option->addr.start, option->addr.start_off,
              option->addr.start - option->addr.start_off );
        printf
            ( "Requested End   Address: %p; End   Offset: %#5x; Actual End   Address: %p\n",
              option->addr.end, option->addr.end_off,
              option->addr.end + option->addr.end_off );
    }

    retval = PAPI_start( EventSet );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_start", retval );
    }
    do_malloc_work( NUM );
    do_static_work( NUM );
    retval = PAPI_stop( EventSet, &value );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
    }

    printf( "%s:  %lld\n", event_name[index], value );

    if ( ( retval =
           PAPI_remove_event( EventSet, PAPI_event[index] ) ) != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_remove_event", retval );
}

Here is the call graph for this function:

Here is the caller graph for this function:

measure_load_store()

static void measure_load_store ( caddr_t  start, caddr_t  end  )

static

Definition at line 139 of file data_range.c.

{
    PAPI_option_t option;
    int retval;

    /* set up the optional address structure for starting and ending data addresses */
    option.addr.eventset = EventSet;
    option.addr.start = start;
    option.addr.end = end;

    if ( ( retval = PAPI_set_opt( PAPI_DATA_ADDRESS, &option ) ) != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_set_opt(PAPI_DATA_ADDRESS)",
                   retval );

    measure_event( 0, &option );
    measure_event( 1, &option );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

array1

int array1[NUM]

Definition at line 28 of file data_range.c.

array2

int array2[NUM]

Definition at line 28 of file data_range.c.

array3

int array3[NUM]

Definition at line 28 of file data_range.c.

event_name

char event_name[2][PAPI_MAX_STR_LEN]

Definition at line 29 of file data_range.c.

EventSet

int EventSet = PAPI_NULL

Definition at line 31 of file data_range.c.

PAPI_event

int PAPI_event[2]

Definition at line 30 of file data_range.c.

parray1

int* parray1

Definition at line 27 of file data_range.c.

parray2

int * parray2

Definition at line 27 of file data_range.c.

parray3

int * parray3

Definition at line 27 of file data_range.c.