papi_vector.c

Go to the documentation of this file.

/*
 * File:    papi_vector.c
 * Author:  Kevin London
 *          london@cs.utk.edu
 * Mods:    Haihang You
 *         you@cs.utk.edu
 * Mods:    <Your name here>
 *          <Your email here>
 */
 
#include "papi.h"
#include "papi_internal.h"
#include "papi_vector.h"
#include "papi_memory.h"
 
#include <string.h>
 
#ifdef _AIX
 
/* needed because the get_virt_usec() code uses a hardware context */
/* which is a pmapi definition on AIX.                             */
#include <pmapi.h>
#endif
 
 
void
_vectors_error(  )
{
    SUBDBG( "function is not implemented in the component!\n" );
    exit( PAPI_ECMP );
}
 
int
vec_int_ok_dummy(  )
{
    return PAPI_OK;
}
 
int
vec_int_one_dummy(  )
{
    return 1;
}
 
int
vec_int_dummy(  )
{
    return PAPI_ECMP;
}
 
void *
vec_void_star_dummy(  )
{
    return NULL;
}
 
void
vec_void_dummy(  )
{
    return;
}
 
long long
vec_long_long_dummy(  )
{
    return PAPI_ECMP;
}
 
long long
vec_long_long_context_dummy( hwd_context_t *ignored )
{
        (void) ignored;
 
    return PAPI_ECMP;
}
 
char *
vec_char_star_dummy(  )
{
    return NULL;
}
 
long
vec_long_dummy(  )
{
    return PAPI_ECMP;
}
 
long long vec_virt_cycles(void)
{
  return ((long long) _papi_os_vector.get_virt_usec() * 
      _papi_hwi_system_info.hw_info.cpu_max_mhz);
}
 
long long vec_real_nsec_dummy(void)
{
  return ((long long) _papi_os_vector.get_real_usec() * 1000);
 
}
 
long long vec_virt_nsec_dummy(void)
{
  return ((long long) _papi_os_vector.get_virt_usec() * 1000);
 
}
 
 
int
_papi_hwi_innoculate_vector( papi_vector_t * v )
{
    if ( !v )
        return ( PAPI_EINVAL );
 
    /* component function pointers */
    if ( !v->dispatch_timer )
        v->dispatch_timer =
            ( void ( * )( int, hwd_siginfo_t *, void * ) ) vec_void_dummy;
    if ( !v->get_overflow_address )
        v->get_overflow_address =
            ( void *( * )( int, char *, int ) ) vec_void_star_dummy;
    if ( !v->start )
        v->start = ( int ( * )( hwd_context_t *, hwd_control_state_t * ) )
            vec_int_dummy;
    if ( !v->stop )
        v->stop = ( int ( * )( hwd_context_t *, hwd_control_state_t * ) )
            vec_int_dummy;
    if ( !v->read )
        v->read = ( int ( * )
                    ( hwd_context_t *, hwd_control_state_t *, long long **,
                      int ) ) vec_int_dummy;
    if ( !v->reset )
        v->reset = ( int ( * )( hwd_context_t *, hwd_control_state_t * ) )
            vec_int_dummy;
    if ( !v->write )
        v->write =
            ( int ( * )( hwd_context_t *, hwd_control_state_t *, long long[] ) )
            vec_int_dummy;
    if ( !v->cleanup_eventset ) 
        v->cleanup_eventset = ( int ( * )( hwd_control_state_t * ) ) vec_int_ok_dummy;
    if ( !v->stop_profiling )
        v->stop_profiling =
            ( int ( * )( ThreadInfo_t *, EventSetInfo_t * ) ) vec_int_dummy;
    if ( !v->init_component )
        v->init_component = ( int ( * )( int ) ) vec_int_ok_dummy;
    if ( !v->init_thread )
        v->init_thread = ( int ( * )( hwd_context_t * ) ) vec_int_ok_dummy;
    if ( !v->init_control_state )
        v->init_control_state =
            ( int ( * )( hwd_control_state_t * ptr ) ) vec_int_dummy;
    if ( !v->update_control_state )
        v->update_control_state = ( int ( * )
                                    ( hwd_control_state_t *, NativeInfo_t *,
                                      int, hwd_context_t * ) ) vec_int_dummy;
    if ( !v->ctl )
        v->ctl = ( int ( * )( hwd_context_t *, int, _papi_int_option_t * ) )
            vec_int_dummy;
    if ( !v->set_overflow )
        v->set_overflow =
            ( int ( * )( EventSetInfo_t *, int, int ) ) vec_int_dummy;
    if ( !v->set_profile )
        v->set_profile =
            ( int ( * )( EventSetInfo_t *, int, int ) ) vec_int_dummy;
 
    if ( !v->set_domain )
        v->set_domain =
            ( int ( * )( hwd_control_state_t *, int ) ) vec_int_dummy;
    if ( !v->ntv_enum_events )
        v->ntv_enum_events = ( int ( * )( unsigned int *, int ) ) vec_int_dummy;
    if ( !v->ntv_name_to_code )
        v->ntv_name_to_code =
            ( int ( * )( const char *, unsigned int * ) ) vec_int_dummy;
    if ( !v->ntv_code_to_name )
        v->ntv_code_to_name =
            ( int ( * )( unsigned int, char *, int ) ) vec_int_dummy;
    if ( !v->ntv_code_to_descr )
        v->ntv_code_to_descr =
            ( int ( * )( unsigned int, char *, int ) ) vec_int_ok_dummy;
    if ( !v->ntv_code_to_bits )
        v->ntv_code_to_bits =
            ( int ( * )( unsigned int, hwd_register_t * ) ) vec_int_dummy;
    if ( !v->ntv_code_to_info )
        v->ntv_code_to_info =
            ( int ( * )( unsigned int, PAPI_event_info_t * ) ) vec_int_dummy;
 
    if ( !v->allocate_registers )
        v->allocate_registers =
            ( int ( * )( EventSetInfo_t * ) ) vec_int_ok_dummy;
 
    if ( !v->shutdown_thread )
        v->shutdown_thread = ( int ( * )( hwd_context_t * ) ) vec_int_dummy;
    if ( !v->shutdown_component )
        v->shutdown_component = ( int ( * )( void ) ) vec_int_ok_dummy;
    if ( !v->user )
        v->user = ( int ( * )( int, void *, void * ) ) vec_int_dummy;
    return PAPI_OK;
}
 
 
int
_papi_hwi_innoculate_os_vector( papi_os_vector_t * v )
{
    if ( !v )
        return ( PAPI_EINVAL );
 
    if ( !v->get_real_cycles )
        v->get_real_cycles = vec_long_long_dummy;
    if ( !v->get_real_usec )
        v->get_real_usec = vec_long_long_dummy;
    if ( !v->get_real_nsec )
        v->get_real_nsec = vec_real_nsec_dummy;
    if ( !v->get_virt_cycles )
        v->get_virt_cycles = vec_virt_cycles;
    if ( !v->get_virt_usec )
        v->get_virt_usec = vec_long_long_dummy;
    if ( !v->get_virt_nsec )
        v->get_virt_nsec = vec_virt_nsec_dummy;
 
    if ( !v->update_shlib_info )
        v->update_shlib_info = ( int ( * )( papi_mdi_t * ) ) vec_int_dummy;
    if ( !v->get_system_info )
        v->get_system_info = ( int ( * )(  ) ) vec_int_dummy;
 
    if ( !v->get_memory_info )
        v->get_memory_info =
            ( int ( * )( PAPI_hw_info_t *, int ) ) vec_int_dummy;
 
    if ( !v->get_dmem_info )
        v->get_dmem_info = ( int ( * )( PAPI_dmem_info_t * ) ) vec_int_dummy;
 
    return PAPI_OK;
}
 
/* not used?  debug only? */
#if 0
static void *
vector_find_dummy( void *func, char **buf )
{
    void *ptr = NULL;
 
    if ( vec_int_ok_dummy == ( int ( * )(  ) ) func ) {
        ptr = ( void * ) vec_int_ok_dummy;
        if ( buf != NULL )
            *buf = papi_strdup( "vec_int_ok_dummy" );
    } else if ( vec_int_one_dummy == ( int ( * )(  ) ) func ) {
        ptr = ( void * ) vec_int_one_dummy;
        if ( buf != NULL )
            *buf = papi_strdup( "vec_int_one_dummy" );
    } else if ( vec_int_dummy == ( int ( * )(  ) ) func ) {
        ptr = ( void * ) vec_int_dummy;
        if ( buf != NULL )
            *buf = papi_strdup( "vec_int_dummy" );
    } else if ( vec_void_dummy == ( void ( * )(  ) ) func ) {
        ptr = ( void * ) vec_void_dummy;
        if ( buf != NULL )
            *buf = papi_strdup( "vec_void_dummy" );
    } else if ( vec_void_star_dummy == ( void *( * )(  ) ) func ) {
        ptr = ( void * ) vec_void_star_dummy;
        if ( buf != NULL )
            *buf = papi_strdup( "vec_void_star_dummy" );
    } else if ( vec_long_long_dummy == ( long long ( * )(  ) ) func ) {
        ptr = ( void * ) vec_long_long_dummy;
        if ( buf != NULL )
            *buf = papi_strdup( "vec_long_long_dummy" );
    } else if ( vec_char_star_dummy == ( char *( * )(  ) ) func ) {
        ptr = ( void * ) vec_char_star_dummy;
        *buf = papi_strdup( "vec_char_star_dummy" );
    } else if ( vec_long_dummy == ( long ( * )(  ) ) func ) {
        ptr = ( void * ) vec_long_dummy;
        if ( buf != NULL )
            *buf = papi_strdup( "vec_long_dummy" );
    } else {
        ptr = NULL;
    }
    return ( ptr );
}
 
 
static void
vector_print_routine( void *func, char *fname, int pfunc )
{
    void *ptr = NULL;
    char *buf = NULL;
 
    ptr = vector_find_dummy( func, &buf );
    if ( ptr ) {
        printf( "DUMMY: %s is mapped to %s.\n",
                fname, buf );
        papi_free( buf );
    } else if ( ( !ptr && pfunc ) )
        printf( "function: %s is mapped to %p.\n",
                fname, func );
}
 
static void
vector_print_table( papi_vector_t * v, int print_func )
{
 
    if ( !v )
        return;
 
    vector_print_routine( ( void * ) v->dispatch_timer,
                          "_papi_hwd_dispatch_timer", print_func );
    vector_print_routine( ( void * ) v->get_overflow_address,
                          "_papi_hwd_get_overflow_address", print_func );
    vector_print_routine( ( void * ) v->start, "_papi_hwd_start", print_func );
    vector_print_routine( ( void * ) v->stop, "_papi_hwd_stop", print_func );
    vector_print_routine( ( void * ) v->read, "_papi_hwd_read", print_func );
    vector_print_routine( ( void * ) v->reset, "_papi_hwd_reset", print_func );
    vector_print_routine( ( void * ) v->write, "_papi_hwd_write", print_func );
    vector_print_routine( ( void * ) v->cleanup_eventset, 
                          "_papi_hwd_cleanup_eventset", print_func );
 
    vector_print_routine( ( void * ) v->stop_profiling,
                          "_papi_hwd_stop_profiling", print_func );
    vector_print_routine( ( void * ) v->init_component,
                          "_papi_hwd_init_component", print_func );
    vector_print_routine( ( void * ) v->init_thread, "_papi_hwd_init_thread", print_func );
    vector_print_routine( ( void * ) v->init_control_state,
                          "_papi_hwd_init_control_state", print_func );
    vector_print_routine( ( void * ) v->ctl, "_papi_hwd_ctl", print_func );
    vector_print_routine( ( void * ) v->set_overflow, "_papi_hwd_set_overflow",
                          print_func );
    vector_print_routine( ( void * ) v->set_profile, "_papi_hwd_set_profile",
                          print_func );
    vector_print_routine( ( void * ) v->set_domain, "_papi_hwd_set_domain",
                          print_func );
    vector_print_routine( ( void * ) v->ntv_enum_events,
                          "_papi_hwd_ntv_enum_events", print_func );
    vector_print_routine( ( void * ) v->ntv_name_to_code,
                          "_papi_hwd_ntv_name_to_code", print_func );
    vector_print_routine( ( void * ) v->ntv_code_to_name,
                          "_papi_hwd_ntv_code_to_name", print_func );
    vector_print_routine( ( void * ) v->ntv_code_to_descr,
                          "_papi_hwd_ntv_code_to_descr", print_func );
    vector_print_routine( ( void * ) v->ntv_code_to_bits,
                          "_papi_hwd_ntv_code_to_bits", print_func );
    vector_print_routine( ( void * ) v->ntv_code_to_info,
                          "_papi_hwd_ntv_code_to_info", print_func );
 
    vector_print_routine( ( void * ) v->allocate_registers,
                          "_papi_hwd_allocate_registers", print_func );
 
    vector_print_routine( ( void * ) v->shutdown_thread, "_papi_hwd_shutdown_thread",
                          print_func );
    vector_print_routine( ( void * ) v->shutdown_component,
                          "_papi_hwd_shutdown_component", print_func );
    vector_print_routine( ( void * ) v->user, "_papi_hwd_user", print_func );
}
 
#endif