Include dependency graph for perfctr-ppc64.c:

Defines
#define	PERFCTR_CPU_NAME perfctr_cpu_name
#define	PERFCTR_CPU_NRCTRS perfctr_cpu_nrctrs
Functions
static void	clear_unused_pmcsel_bits (hwd_control_state_t *cntrl)
static int	set_domain (hwd_control_state_t *cntrl, unsigned int domain)
void	print_control (const struct perfctr_cpu_control *control)
int	setup_ppc64_presets (int cputype)
int	_papi_hwd_init_control_state (hwd_control_state_t *ptr)
static int	do_counter_allocation (ppc64_reg_alloc_t *event_list, int size)
int	_papi_hwd_allocate_registers (EventSetInfo_t *ESI)
int	_papi_hwd_update_control_state (hwd_control_state_t this_state, NativeInfo_t native, int count, hwd_context_t *context)
int	_papi_hwd_start (hwd_context_t ctx, hwd_control_state_t state)
int	_papi_hwd_stop (hwd_context_t ctx, hwd_control_state_t state)
int	_papi_hwd_read (hwd_context_t ctx, hwd_control_state_t spc, long long **dp, int flags)
int	_papi_hwd_reset (hwd_context_t ctx, hwd_control_state_t cntrl)
int	_papi_hwd_shutdown (hwd_context_t *ctx)
static void	swap_events (EventSetInfo_t ESI, struct hwd_pmc_control contr, int cntr1, int cntr2)
int	_papi_hwd_set_overflow (EventSetInfo_t *ESI, int EventIndex, int threshold)
int	_papi_hwd_set_profile (EventSetInfo_t *ESI, int EventIndex, int threshold)
int	_papi_hwd_stop_profiling (ThreadInfo_t master, EventSetInfo_t ESI)
int	_papi_hwd_set_domain (hwd_control_state_t *cntrl, int domain)
char *	_papi_hwd_ntv_code_to_name (unsigned int EventCode)
int	_papi_hwd_ntv_code_to_bits (unsigned int EventCode, hwd_register_t *bits)
static void	copy_value (unsigned int val, char nam, char names, unsigned int *values, int len)
char *	_papi_hwd_ntv_code_to_descr (unsigned int EventCode)
int	_papi_hwd_ntv_enum_events (unsigned int *EventCode, int modifier)
int	ppc64_setup_vector_table (papi_vectors_t *vtable)
Variables
static hwi_search_t	preset_name_map_PPC64 [PAPI_MAX_PRESET_EVENTS]
hwi_search_t *	preset_search_map
unsigned long long	pmc_sel_mask [NUM_COUNTER_MASKS]
papi_mdi_t	_papi_hwi_system_info
papi_svector_t	_ppc64_vector_table []

Define Documentation

#define PERFCTR_CPU_NAME perfctr_cpu_name

Definition at line 24 of file perfctr-ppc64.c.

#define PERFCTR_CPU_NRCTRS perfctr_cpu_nrctrs

Definition at line 25 of file perfctr-ppc64.c.

Function Documentation

int _papi_hwd_allocate_registers ( EventSetInfo_t * ESI )

Definition at line 327 of file perfctr-ppc64.c.

{
    hwd_control_state_t *this_state = &ESI->machdep;
    int i, j, natNum, index;
    ppc64_reg_alloc_t event_list[MAX_COUNTERS];
    int group;

    /* not yet successfully mapped, but have enough slots for events */

    /* Initialize the local structure needed 
       for counter allocation and optimization. */
    natNum = ESI->NativeCount;
    for ( i = 0; i < natNum; i++ ) {
        event_list[i].ra_position = -1;
        for ( j = 0; j < MAX_COUNTERS; j++ ) {
            if ( ( index =
                   native_name_map[ESI->NativeInfoArray[i].
                                   ni_event & PAPI_NATIVE_AND_MASK].index ) <
                 0 )
                return PAPI_ECNFLCT;
            event_list[i].ra_counter_cmd[j] =
                native_table[index].resources.counter_cmd[j];
        }
        for ( j = 0; j < GROUP_INTS; j++ ) {
            if ( ( index =
                   native_name_map[ESI->NativeInfoArray[i].
                                   ni_event & PAPI_NATIVE_AND_MASK].index ) <
                 0 )
                return PAPI_ECNFLCT;
            event_list[i].ra_group[j] = native_table[index].resources.group[j];
        }
    }
    if ( ( group = do_counter_allocation( event_list, natNum ) ) >= 0 ) {   /* successfully mapped */
        /* copy counter allocations info back into NativeInfoArray */
        this_state->group_id = group;
        for ( i = 0; i < natNum; i++ ) {
//         ESI->NativeInfoArray[i].ni_position = event_list[i].ra_position;
            this_state->control.cpu_control.pmc_map[i] =
                event_list[i].ra_position;
            ESI->NativeInfoArray[i].ni_position = i;
        }
        /* update the control structure based on the NativeInfoArray */
        SUBDBG( "Group ID: %d\n", group );

        return PAPI_OK;
    } else {
        return PAPI_ECNFLCT;
    }
}

Here is the call graph for this function:

int _papi_hwd_init_control_state ( hwd_control_state_t * ptr )

Definition at line 261 of file perfctr-ppc64.c.

{
    int i = 0;
    for ( i = 0; i < _papi_hwi_system_info.sub_info.num_cntrs; i++ ) {
        ptr->control.cpu_control.pmc_map[i] = i;
    }
    ptr->control.cpu_control.tsc_on = 1;
    set_domain( ptr, _papi_hwi_system_info.sub_info.default_domain );
    return ( PAPI_OK );
}

Here is the call graph for this function:

int _papi_hwd_ntv_code_to_bits	(	unsigned int	EventCode,
		hwd_register_t *	bits
	)

Definition at line 651 of file perfctr-ppc64.c.

{
    if ( ( EventCode & PAPI_NATIVE_AND_MASK ) >=
         _papi_hwi_system_info.sub_info.num_native_events ) {
        return ( PAPI_ENOEVNT );
    }

    memcpy( bits,
            &native_table[native_name_map[EventCode & PAPI_NATIVE_AND_MASK].
                          index].resources, sizeof ( hwd_register_t ) );
    return ( PAPI_OK );
}

char* _papi_hwd_ntv_code_to_descr ( unsigned int EventCode )

Definition at line 675 of file perfctr-ppc64.c.

{
    if ( ( EventCode & PAPI_NATIVE_AND_MASK ) >=
         _papi_hwi_system_info.sub_info.num_native_events ) {
        return "\0";
    }
    return ( native_table
             [native_name_map[EventCode & PAPI_NATIVE_AND_MASK].index].
             description );
}

char* _papi_hwd_ntv_code_to_name ( unsigned int EventCode )

Definition at line 642 of file perfctr-ppc64.c.

{
    if ( ( EventCode & PAPI_NATIVE_AND_MASK ) >=
         _papi_hwi_system_info.sub_info.num_native_events )
        return ( '\0' );     // return a null string for invalid events
    return ( native_name_map[EventCode & PAPI_NATIVE_AND_MASK].name );
}

int _papi_hwd_ntv_enum_events	(	unsigned int *	EventCode,
		int	modifier
	)

Definition at line 687 of file perfctr-ppc64.c.

{
    if ( modifier == PAPI_ENUM_EVENTS ) {
        int index = *EventCode & PAPI_NATIVE_AND_MASK;
        if ( index + 1 == MAX_NATNAME_MAP_INDEX ) {
            return ( PAPI_ENOEVNT );
        } else {
            *EventCode = *EventCode + 1;
            return ( PAPI_OK );
        }
    } else if ( modifier == PAPI_PWR4_ENUM_GROUPS ) {
/* Use this modifier for all supported PPC64 processors. */
        unsigned int group = ( *EventCode & 0x00FF0000 ) >> 16;
        int index = *EventCode & 0x000001FF;
        int i;
        unsigned int tmpg;

        *EventCode = *EventCode & 0xFF00FFFF;
        for ( i = 0; i < GROUP_INTS; i++ ) {
            tmpg = native_table[index].resources.group[i];
            if ( group != 0 ) {
                while ( ( ffs( tmpg ) + i * 32 ) <= group && tmpg != 0 )
                    tmpg = tmpg ^ ( 1 << ( ffs( tmpg ) - 1 ) );
            }
            if ( tmpg != 0 ) {
                group = ffs( tmpg ) + i * 32;
                *EventCode = *EventCode | ( group << 16 );
                return ( PAPI_OK );
            }
        }
        if ( index + 1 == MAX_NATNAME_MAP_INDEX ) {
            return ( PAPI_ENOEVNT );
        }
        *EventCode = *EventCode + 1;
        return ( PAPI_OK );
    } else
        return ( PAPI_EINVAL );
}

int _papi_hwd_read	(	hwd_context_t *	ctx,
		hwd_control_state_t *	spc,
		long long **	dp,
		int	flags
	)

Definition at line 452 of file perfctr-ppc64.c.

{
    if ( flags & PAPI_PAUSED ) {
        vperfctr_read_state( ctx->perfctr, &spc->state, NULL );
    } else {
        SUBDBG( "vperfctr_read_ctrs\n" );
        if ( spc->rvperfctr != NULL ) {
            rvperfctr_read_ctrs( spc->rvperfctr, &spc->state );
        } else {
            vperfctr_read_ctrs( ctx->perfctr, &spc->state );
        }
    }

    *dp = ( long long * ) spc->state.pmc;
#ifdef DEBUG
    {
        if ( ISLEVEL( DEBUG_SUBSTRATE ) ) {
            int i;
            for ( i = 0;
                  i <
                  spc->control.cpu_control.nractrs +
                  spc->control.cpu_control.nrictrs; i++ ) {
                SUBDBG( "raw val hardware index %d is %lld\n", i,
                        ( long long ) spc->state.pmc[i] );
            }
        }
    }
#endif
    return ( PAPI_OK );
}

int _papi_hwd_reset	(	hwd_context_t *	ctx,
		hwd_control_state_t *	cntrl
	)

Definition at line 486 of file perfctr-ppc64.c.

{
    return ( _papi_hwd_start( ctx, cntrl ) );
}

Here is the call graph for this function:

int _papi_hwd_set_domain	(	hwd_control_state_t *	cntrl,
		int	domain
	)

Definition at line 635 of file perfctr-ppc64.c.

{
    return set_domain( cntrl, domain );
}

Here is the call graph for this function:

int _papi_hwd_set_overflow	(	EventSetInfo_t *	ESI,
		int	EventIndex,
		int	threshold
	)

Definition at line 549 of file perfctr-ppc64.c.

{
    hwd_control_state_t *this_state = &ESI->machdep;
    struct hwd_pmc_control *contr = &this_state->control;
    int i, ncntrs, nricntrs = 0, nracntrs = 0, retval = 0;

    OVFDBG( "EventIndex=%d, threshold = %d\n", EventIndex, threshold );

    /* The correct event to overflow is EventIndex */
    ncntrs = _papi_hwi_system_info.sub_info.num_cntrs;
    i = ESI->EventInfoArray[EventIndex].pos[0];
    if ( i >= ncntrs ) {
        OVFDBG( "Selector id (%d) larger than ncntrs (%d)\n", i, ncntrs );
        return PAPI_EINVAL;
    }
    if ( threshold != 0 ) {  /* Set an overflow threshold */
        if ( ESI->EventInfoArray[EventIndex].derived ) {
            OVFDBG( "Can't overflow on a derived event.\n" );
            return PAPI_EINVAL;
        }

        if ( ( retval =
               _papi_hwi_start_signal( _papi_hwi_system_info.sub_info.
                                       hardware_intr_sig,
                                       NEED_CONTEXT ) ) != PAPI_OK )
            return ( retval );

        contr->cpu_control.ireset[i] = PMC_OVFL - threshold;
        nricntrs = ++contr->cpu_control.nrictrs;
        nracntrs = --contr->cpu_control.nractrs;
        contr->si_signo = _papi_hwi_system_info.sub_info.hardware_intr_sig;
        contr->cpu_control.ppc64.mmcr0 |= PERF_INT_ENABLE;

        /* move this event to the bottom part of the list if needed */
        if ( i < nracntrs )
            swap_events( ESI, contr, i, nracntrs );

        OVFDBG( "Modified event set\n" );
    } else {
        if ( contr->cpu_control.ppc64.mmcr0 & PERF_INT_ENABLE ) {
            contr->cpu_control.ireset[i] = 0;
            nricntrs = --contr->cpu_control.nrictrs;
            nracntrs = ++contr->cpu_control.nractrs;
            if ( !nricntrs )
                contr->cpu_control.ppc64.mmcr0 &= ( ~PERF_INT_ENABLE );
        }
        /* move this event to the top part of the list if needed */
        if ( i >= nracntrs )
            swap_events( ESI, contr, i, nracntrs - 1 );
        if ( !nricntrs )
            contr->si_signo = 0;

        OVFDBG( "Modified event set\n" );

        retval =
            _papi_hwi_stop_signal( _papi_hwi_system_info.sub_info.
                                   hardware_intr_sig );
    }
#ifdef DEBUG
    print_control( &contr->cpu_control );
#endif
    OVFDBG( "%s:%d: Hardware overflow is still experimental.\n", __FILE__,
            __LINE__ );
    OVFDBG( "End of call. Exit code: %d\n", retval );

    return ( retval );
}

Here is the call graph for this function:

int _papi_hwd_set_profile	(	EventSetInfo_t *	ESI,
		int	EventIndex,
		int	threshold
	)

Definition at line 620 of file perfctr-ppc64.c.

{
    /* This function is not used and shouldn't be called. */
    return PAPI_ECMP;
}

int _papi_hwd_shutdown ( hwd_context_t * ctx )

Definition at line 495 of file perfctr-ppc64.c.

{
    int retval = vperfctr_unlink( ctx->perfctr );
    SUBDBG( "_papi_hwd_shutdown vperfctr_unlink(%p) = %d\n", ctx->perfctr,
            retval );
    vperfctr_close( ctx->perfctr );
    SUBDBG( "_papi_hwd_shutdown vperfctr_close(%p)\n", ctx->perfctr );
    memset( ctx, 0x0, sizeof ( hwd_context_t ) );

    if ( retval )
        return ( PAPI_ESYS );
    return ( PAPI_OK );
}

int _papi_hwd_start	(	hwd_context_t *	ctx,
		hwd_control_state_t *	state
	)

Definition at line 410 of file perfctr-ppc64.c.

{
    int error;
/*   clear_unused_pmcsel_bits(this_state);   moved to update_control_state */
#ifdef DEBUG
    print_control( &state->control.cpu_control );
#endif
    if ( state->rvperfctr != NULL ) {
        if ( ( error =
               rvperfctr_control( state->rvperfctr, &state->control ) ) < 0 ) {
            SUBDBG( "rvperfctr_control returns: %d\n", error );
            PAPIERROR( RCNTRL_ERROR );
            return ( PAPI_ESYS );
        }
        return ( PAPI_OK );
    }
    if ( ( error = vperfctr_control( ctx->perfctr, &state->control ) ) < 0 ) {
        SUBDBG( "vperfctr_control returns: %d\n", error );
        PAPIERROR( VCNTRL_ERROR );
        return ( PAPI_ESYS );
    }
    return ( PAPI_OK );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int _papi_hwd_stop	(	hwd_context_t *	ctx,
		hwd_control_state_t *	state
	)

Definition at line 435 of file perfctr-ppc64.c.

{
    if ( state->rvperfctr != NULL ) {
        if ( rvperfctr_stop( ( struct rvperfctr * ) ctx->perfctr ) < 0 ) {
            PAPIERROR( RCNTRL_ERROR );
            return ( PAPI_ESYS );
        }
        return ( PAPI_OK );
    }
    if ( vperfctr_stop( ctx->perfctr ) < 0 ) {
        PAPIERROR( VCNTRL_ERROR );
        return ( PAPI_ESYS );
    }
    return ( PAPI_OK );
}

Here is the call graph for this function:

int _papi_hwd_stop_profiling	(	ThreadInfo_t *	master,
		EventSetInfo_t *	ESI
	)

Definition at line 628 of file perfctr-ppc64.c.

{
    ESI->profile.overflowcount = 0;
    return PAPI_OK;
}

int _papi_hwd_update_control_state	(	hwd_control_state_t *	this_state,
		NativeInfo_t *	native,
		int	count,
		hwd_context_t *	context
	)

Definition at line 381 of file perfctr-ppc64.c.

{


    this_state->control.cpu_control.nractrs =
        count - this_state->control.cpu_control.nrictrs;
    // save control state
    unsigned int save_mmcr0_ctlbits =
        PERF_CONTROL_MASK & this_state->control.cpu_control.ppc64.mmcr0;

    this_state->control.cpu_control.ppc64.mmcr0 =
        group_map[this_state->group_id].mmcr0 | save_mmcr0_ctlbits;

    unsigned long long mmcr1 =
        ( ( unsigned long long ) group_map[this_state->group_id].mmcr1U ) << 32;
    mmcr1 += group_map[this_state->group_id].mmcr1L;
    this_state->control.cpu_control.ppc64.mmcr1 = mmcr1;

    this_state->control.cpu_control.ppc64.mmcra =
        group_map[this_state->group_id].mmcra;

    clear_unused_pmcsel_bits( this_state );
    return PAPI_OK;
}

Here is the call graph for this function:

static void clear_unused_pmcsel_bits ( hwd_control_state_t * cntrl ) [static]

Definition at line 147 of file perfctr-ppc64.c.

{
    struct perfctr_cpu_control *cpu_ctl = &cntrl->control.cpu_control;
    int i;
    int num_used_counters = cpu_ctl->nractrs + cpu_ctl->nrictrs;
    unsigned int used_counters = 0x0;
    for ( i = 0; i < num_used_counters; i++ ) {
        used_counters |= 1 << cpu_ctl->pmc_map[i];
    }
#if defined(_POWER5) || defined(_POWER5p)
    int freeze_pmc5_pmc6 = 0;          /* for Power5 use only */
#endif

    for ( i = 0; i < MAX_COUNTERS; i++ ) {
        unsigned int active_counter = ( ( 1 << i ) & used_counters );
        if ( !active_counter ) {
#if defined(_POWER5) || defined(_POWER5p)
            if ( i > 3 )
                freeze_pmc5_pmc6++;
            else
                cpu_ctl->ppc64.mmcr1 &= pmc_sel_mask[i];
#else
            if ( i < 2 ) {
                cpu_ctl->ppc64.mmcr0 &= pmc_sel_mask[i];
            } else {
                cpu_ctl->ppc64.mmcr1 &= pmc_sel_mask[i];
                if ( i == ( MAX_COUNTERS - 1 ) )
                    cpu_ctl->ppc64.mmcra &= pmc_sel_mask[NUM_COUNTER_MASKS - 1];
            }
#endif
        }
    }
#if defined(_POWER5) || defined(_POWER5p)
    if ( freeze_pmc5_pmc6 == 2 )
        cpu_ctl->ppc64.mmcr0 |= PMC5_PMC6_FREEZE;
#endif
}

Here is the caller graph for this function:

static void copy_value	(	unsigned int	val,
		char *	nam,
		char *	names,
		unsigned int *	values,
		int	len
	)		`[static]`

Definition at line 665 of file perfctr-ppc64.c.

{
    *values = val;
    strncpy( names, nam, len );
    names[len - 1] = 0;
}

static int do_counter_allocation	(	ppc64_reg_alloc_t *	event_list,
		int	size
	)		`[static]`

Definition at line 288 of file perfctr-ppc64.c.

{
    int i, j, group = -1;
    unsigned int map[GROUP_INTS];

    for ( i = 0; i < GROUP_INTS; i++ ) {
        map[i] = event_list[0].ra_group[i];
    }

    for ( i = 1; i < size; i++ ) {
        for ( j = 0; j < GROUP_INTS; j++ )
            map[j] &= event_list[i].ra_group[j];
    }

    for ( i = 0; i < GROUP_INTS; i++ ) {
        if ( map[i] ) {
            group = ffs( map[i] ) - 1 + i * 32;
            break;
        }
    }

    if ( group < 0 )
        return group;        /* allocation fail */
    else {
        for ( i = 0; i < size; i++ ) {
            for ( j = 0; j < MAX_COUNTERS; j++ ) {
                if ( event_list[i].ra_counter_cmd[j] >= 0
                     && event_list[i].ra_counter_cmd[j] ==
                     group_map[group].counter_cmd[j] )
                    event_list[i].ra_position = j;
            }
        }
        return group;
    }
}

Here is the caller graph for this function:

int ppc64_setup_vector_table ( papi_vectors_t * vtable )

Definition at line 754 of file perfctr-ppc64.c.

{
    int retval = PAPI_OK;
    retval = _papi_hwi_setup_vector_table( vtable, _ppc64_vector_table );
}

void print_control ( const struct perfctr_cpu_control * control )

Definition at line 226 of file perfctr-ppc64.c.

{
    unsigned int i;

    SUBDBG( "Control used:\n" );
    SUBDBG( "tsc_on\t\t\t%u\n", control->tsc_on );
    SUBDBG( "nractrs\t\t\t%u\n", control->nractrs );
    SUBDBG( "nrictrs\t\t\t%u\n", control->nrictrs );
    SUBDBG( "mmcr0\t\t\t0x%X\n", control->ppc64.mmcr0 );
    SUBDBG( "mmcr1\t\t\t0x%llX\n",
            ( unsigned long long ) control->ppc64.mmcr1 );
    SUBDBG( "mmcra\t\t\t0x%X\n", control->ppc64.mmcra );

    for ( i = 0; i < ( control->nractrs + control->nrictrs ); ++i ) {
        SUBDBG( "pmc_map[%u]\t\t%u\n", i, control->pmc_map[i] );
        if ( control->ireset[i] ) {
            SUBDBG( "ireset[%d]\t%X\n", i, control->ireset[i] );
        }
    }

}

static int set_domain	(	hwd_control_state_t *	cntrl,
		unsigned int	domain
	)		`[static]`

Definition at line 185 of file perfctr-ppc64.c.

{
    int did = 0;

    /* A bit setting of '0' indicates "count this context".
     * Start off by turning off counting for all contexts; 
     * then, selectively re-enable.
     */
    cntrl->control.cpu_control.ppc64.mmcr0 |=
        PERF_USER | PERF_KERNEL | PERF_HYPERVISOR;
    if ( domain & PAPI_DOM_USER ) {
        cntrl->control.cpu_control.ppc64.mmcr0 |= PERF_USER;
        cntrl->control.cpu_control.ppc64.mmcr0 ^= PERF_USER;
        did = 1;
    }
    if ( domain & PAPI_DOM_KERNEL ) {
        cntrl->control.cpu_control.ppc64.mmcr0 |= PERF_KERNEL;
        cntrl->control.cpu_control.ppc64.mmcr0 ^= PERF_KERNEL;
        did = 1;
    }
    if ( domain & PAPI_DOM_SUPERVISOR ) {
        cntrl->control.cpu_control.ppc64.mmcr0 |= PERF_HYPERVISOR;
        cntrl->control.cpu_control.ppc64.mmcr0 ^= PERF_HYPERVISOR;
        did = 1;
    }

    if ( did ) {
        return ( PAPI_OK );
    } else {
        return ( PAPI_EINVAL );
    }

}

Here is the caller graph for this function:

int setup_ppc64_presets ( int cputype )

Definition at line 253 of file perfctr-ppc64.c.

{
    preset_search_map = preset_name_map_PPC64;
    return ( _papi_hwi_setup_all_presets( preset_search_map, NULL ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void swap_events	(	EventSetInfo_t *	ESI,
		struct hwd_pmc_control *	contr,
		int	cntr1,
		int	cntr2
	)		`[static]`

Definition at line 518 of file perfctr-ppc64.c.

{
    unsigned int ui;
    int si, i, j;

    for ( i = 0; i < ESI->NativeCount; i++ ) {
        if ( ESI->NativeInfoArray[i].ni_position == cntr1 )
            ESI->NativeInfoArray[i].ni_position = cntr2;
        else if ( ESI->NativeInfoArray[i].ni_position == cntr2 )
            ESI->NativeInfoArray[i].ni_position = cntr1;
    }
    for ( i = 0; i < ESI->NumberOfEvents; i++ ) {
        for ( j = 0; ESI->EventInfoArray[i].pos[j] >= 0; j++ ) {
            if ( ESI->EventInfoArray[i].pos[j] == cntr1 )
                ESI->EventInfoArray[i].pos[j] = cntr2;
            else if ( ESI->EventInfoArray[i].pos[j] == cntr2 )
                ESI->EventInfoArray[i].pos[j] = cntr1;
        }
    }
    ui = contr->cpu_control.pmc_map[cntr1];
    contr->cpu_control.pmc_map[cntr1] = contr->cpu_control.pmc_map[cntr2];
    contr->cpu_control.pmc_map[cntr2] = ui;

    si = contr->cpu_control.ireset[cntr1];
    contr->cpu_control.ireset[cntr1] = contr->cpu_control.ireset[cntr2];
    contr->cpu_control.ireset[cntr2] = si;
}

Here is the caller graph for this function:

Variable Documentation

papi_mdi_t _papi_hwi_system_info

Definition at line 57 of file papi_internal.c.

papi_svector_t _ppc64_vector_table[]

Initial value:

 {
    {( void ( * )(  ) ) _papi_hwd_init_control_state,
     VEC_PAPI_HWD_INIT_CONTROL_STATE},
    {( void ( * )(  ) ) _papi_hwd_allocate_registers,
     VEC_PAPI_HWD_ALLOCATE_REGISTERS},
    {( void ( * )(  ) ) _papi_hwd_update_control_state,
     VEC_PAPI_HWD_UPDATE_CONTROL_STATE},
    {( void ( * )(  ) ) _papi_hwd_start, VEC_PAPI_HWD_START},
    {( void ( * )(  ) ) _papi_hwd_stop, VEC_PAPI_HWD_STOP},
    {( void ( * )(  ) ) _papi_hwd_read, VEC_PAPI_HWD_READ},
    {( void ( * )(  ) ) _papi_hwd_reset, VEC_PAPI_HWD_RESET},
    {( void ( * )(  ) ) _papi_hwd_shutdown, VEC_PAPI_HWD_SHUTDOWN},
    {( void ( * )(  ) ) _papi_hwd_set_overflow, VEC_PAPI_HWD_SET_OVERFLOW},
    {( void ( * )(  ) ) _papi_hwd_set_profile, VEC_PAPI_HWD_SET_PROFILE},
    {( void ( * )(  ) ) _papi_hwd_stop_profiling, VEC_PAPI_HWD_STOP_PROFILING},
    {( void ( * )(  ) ) _papi_hwd_set_domain, VEC_PAPI_HWD_SET_DOMAIN},
    {( void ( * )(  ) ) *_papi_hwd_ntv_code_to_name,
     VEC_PAPI_HWD_NTV_CODE_TO_NAME},
    {( void ( * )(  ) ) _papi_hwd_ntv_code_to_bits,
     VEC_PAPI_HWD_NTV_CODE_TO_BITS},
    {( void ( * )(  ) ) *_papi_hwd_ntv_code_to_descr,
     VEC_PAPI_HWD_NTV_CODE_TO_DESCR},
    {( void ( * )(  ) ) *_papi_hwd_ntv_enum_events,
     VEC_PAPI_HWD_NTV_ENUM_EVENTS},
    {NULL, VEC_PAPI_END}
}

Definition at line 726 of file perfctr-ppc64.c.

unsigned long long pmc_sel_mask[NUM_COUNTER_MASKS]

Initial value:

 {
    PMC1_SEL_MASK,
    PMC2_SEL_MASK,
    PMC3_SEL_MASK,
    PMC4_SEL_MASK,
    PMC5_SEL_MASK,
    PMC6_SEL_MASK,
    PMC7_SEL_MASK,
    PMC8_SEL_MASK,
    PMC8a_SEL_MASK
}

Definition at line 133 of file perfctr-ppc64.c.

hwi_search_t preset_name_map_PPC64[PAPI_MAX_PRESET_EVENTS] [static]

Definition at line 28 of file perfctr-ppc64.c.

hwi_search_t* preset_search_map

Definition at line 123 of file perfctr-ppc64.c.

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation