pfmlib_gen_powerpc.c File Reference

Include dependency graph for pfmlib_gen_powerpc.c:

Go to the source code of this file.

Macros
#define	_GNU_SOURCE   /* for getline */
#define	FIRST_POWER_PMU   PFMLIB_PPC970_PMU

Functions
static int	get_num_event_counters ()
static int	get_num_control_regs ()
static const unsigned long long *	get_group_vector (int event)
static int	get_event_id (int event, int counter)
static char *	get_event_name (int event)
static char *	get_long_desc (int event)
static int	get_group_event_id (int group, int counter)
static unsigned long long	get_mmcr0 (int group)
static unsigned long long	get_mmcr1 (int group)
static unsigned long long	get_mmcra (int group)
static int	pfm_gen_powerpc_get_event_code (unsigned int event, unsigned int pmd, int *code)
static char *	pfm_gen_powerpc_get_event_name (unsigned int event)
static char *	pfm_gen_powerpc_get_event_mask_name (unsigned int event, unsigned int mask)
static void	pfm_gen_powerpc_get_event_counters (unsigned int event, pfmlib_regmask_t *counters)
static unsigned int	pfm_gen_powerpc_get_num_event_masks (unsigned int event)
static void	remove_group (unsigned long long *group_vec, int group)
static void	intersect_groups (unsigned long long *result, const unsigned long long *operand)
static int	first_group (unsigned long long *group_vec)
static int	pfm_gen_powerpc_dispatch_events (pfmlib_input_param_t *input, void *model_input, pfmlib_output_param_t *output, void *model_output)
static int	pfm_gen_powerpc_pmu_detect (void)
static void	pfm_gen_powerpc_get_impl_pmcs (pfmlib_regmask_t *impl_pmcs)
static void	pfm_gen_powerpc_get_impl_pmds (pfmlib_regmask_t *impl_pmds)
static void	pfm_gen_powerpc_get_impl_counters (pfmlib_regmask_t *impl_counters)
static void	pfm_gen_powerpc_get_hw_counter_width (unsigned int *width)
static int	pfm_gen_powerpc_get_event_desc (unsigned int event, char **desc)
static int	pfm_gen_powerpc_get_event_mask_desc (unsigned int event, unsigned int mask, char **desc)
static int	pfm_gen_powerpc_get_event_mask_code (unsigned int event, unsigned int mask, unsigned int *code)
static int	pfm_gen_powerpc_get_cycle_event (pfmlib_event_t *e)
static int	pfm_gen_powerpc_get_inst_retired (pfmlib_event_t *e)

Variables
static const int	num_group_vec []
static const int	event_count []
unsigned *	pmd_priv_vec
static unsigned long long	mmcr0_fc5_6_mask
static unsigned long long *	mmcr0_counter_mask
static unsigned long long *	mmcr1_counter_mask
static unsigned long long *	mmcr0_counter_off_val
static unsigned long long *	mmcr1_counter_off_val
static const pme_power_entry_t *	pe
static const pmg_power_group_t *	groups
static unsigned	gq_pmd_priv_vec [8]
static unsigned	gr_pmd_priv_vec [6]
static unsigned	gs_pmd_priv_vec [6]
static unsigned long long	power4_mmcr0_counter_mask [POWER4_NUM_EVENT_COUNTERS]
static unsigned long long	power4_mmcr1_counter_mask [POWER4_NUM_EVENT_COUNTERS]
static unsigned long long	power4_mmcr0_counter_off_val [POWER4_NUM_EVENT_COUNTERS]
static unsigned long long	power4_mmcr1_counter_off_val [POWER4_NUM_EVENT_COUNTERS]
static unsigned long long	ppc970_mmcr0_counter_off_val [POWER4_NUM_EVENT_COUNTERS]
static unsigned long long	ppc970_mmcr1_counter_off_val [POWER4_NUM_EVENT_COUNTERS]
static unsigned long long	power5_mmcr0_counter_mask [POWER5_NUM_EVENT_COUNTERS]
static unsigned long long	power5_mmcr1_counter_mask [POWER5_NUM_EVENT_COUNTERS]
static unsigned long long	power5_mmcr0_counter_off_val [POWER5_NUM_EVENT_COUNTERS]
static unsigned long long	power5_mmcr1_counter_off_val [POWER5_NUM_EVENT_COUNTERS]
pfm_pmu_support_t	gen_powerpc_support

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE   /* for getline */

Definition at line 29 of file pfmlib_gen_powerpc.c.

FIRST_POWER_PMU

#define FIRST_POWER_PMU   PFMLIB_PPC970_PMU

Definition at line 59 of file pfmlib_gen_powerpc.c.

Function Documentation

first_group()

static int first_group ( unsigned long long *  group_vec )

static

Definition at line 213 of file pfmlib_gen_powerpc.c.

{
        int i, bit;
 
        for (i = 0; i < num_group_vec[gen_powerpc_support.pmu_type - FIRST_POWER_PMU]; i++) {
                bit = ffsll(group_vec[i]);
                if (bit) {
                        return (bit - 1) + (i * 64);
                }
        }
        /* There were no groups */
        return -1;
}

Here is the caller graph for this function:

get_event_id()

static int get_event_id ( int  event, int  counter  )

inlinestatic

Definition at line 103 of file pfmlib_gen_powerpc.c.

                                                       {
    return pe[event].pme_event_ids[counter];
}

Here is the caller graph for this function:

get_event_name()

static char * get_event_name ( int  event )

inlinestatic

Definition at line 107 of file pfmlib_gen_powerpc.c.

                                              {
    return pe[event].pme_name;
}

Here is the caller graph for this function:

get_group_event_id()

static int get_group_event_id ( int  group, int  counter  )

inlinestatic

Definition at line 115 of file pfmlib_gen_powerpc.c.

                                                             {
    return groups[group].pmg_event_ids[counter];
}

Here is the caller graph for this function:

get_group_vector()

static const unsigned long long * get_group_vector ( int  event )

inlinestatic

Definition at line 99 of file pfmlib_gen_powerpc.c.

                                                                    {
    return pe[event].pme_group_vector;
}

Here is the caller graph for this function:

get_long_desc()

static char * get_long_desc ( int  event )

inlinestatic

Definition at line 111 of file pfmlib_gen_powerpc.c.

                                             {
    return pe[event].pme_long_desc;
}

Here is the caller graph for this function:

get_mmcr0()

static unsigned long long get_mmcr0 ( int  group )

inlinestatic

Definition at line 119 of file pfmlib_gen_powerpc.c.

                                                      {
    return groups[group].pmg_mmcr0;
}

Here is the caller graph for this function:

get_mmcr1()

static unsigned long long get_mmcr1 ( int  group )

inlinestatic

Definition at line 123 of file pfmlib_gen_powerpc.c.

                                                      {
    return groups[group].pmg_mmcr1;
}

Here is the caller graph for this function:

get_mmcra()

static unsigned long long get_mmcra ( int  group )

inlinestatic

Definition at line 127 of file pfmlib_gen_powerpc.c.

                                                      {
    return groups[group].pmg_mmcra;
}

Here is the caller graph for this function:

get_num_control_regs()

static int get_num_control_regs ( )

inlinestatic

Definition at line 95 of file pfmlib_gen_powerpc.c.

                                         {
    return gen_powerpc_support.pmc_count;
}

Here is the caller graph for this function:

get_num_event_counters()

static int get_num_event_counters ( )

inlinestatic

Definition at line 91 of file pfmlib_gen_powerpc.c.

                                           {
    return gen_powerpc_support.pmd_count;
}

Here is the caller graph for this function:

intersect_groups()

static void intersect_groups ( unsigned long long *  result, const unsigned long long *  operand  )

static

Definition at line 204 of file pfmlib_gen_powerpc.c.

{
        int i;
 
        for (i = 0; i < num_group_vec[gen_powerpc_support.pmu_type - FIRST_POWER_PMU]; i++) {
                result[i] &= operand[i];
        }
}

Here is the caller graph for this function:

pfm_gen_powerpc_dispatch_events()

static int pfm_gen_powerpc_dispatch_events ( pfmlib_input_param_t *  input, void *  model_input, pfmlib_output_param_t *  output, void *  model_output  )

static

pfm_gen_powerpc_dispatch_events

Examine each desired event specified in "input" and find an appropriate set of PMCs and PMDs to count them.

Definition at line 364 of file pfmlib_gen_powerpc.c.

{
    /* model_input and model_output are unused on POWER */
 
    int i, j, group;
    int counters_used = 0;
    unsigned long long mmcr0_val, mmcr1_val;
    unsigned long long group_vector[num_group_vec[gen_powerpc_support.pmu_type - FIRST_POWER_PMU]];
    unsigned int plm;
 
    plm  = (input->pfp_events[0].plm != 0) ? input->pfp_events[0].plm : input->pfp_dfl_plm;
 
        /*
         * Verify that all of the privilege level masks are identical, as
         * we cannot have mixed levels on POWER
         */
 
    for (i = 1; i < input->pfp_event_count; i++) {
        if (input->pfp_events[i].plm == 0) {
            /* it's ok if the default is the same as plm */
            if (plm != input->pfp_dfl_plm) 
                return PFMLIB_ERR_NOASSIGN;
        } else {
            if (plm != input->pfp_events[i].plm)
                return PFMLIB_ERR_NOASSIGN;
        }
    }
 
    /* start by setting all of the groups as available */
    memset(group_vector, 0xff, sizeof(unsigned long long) * num_group_vec[gen_powerpc_support.pmu_type - FIRST_POWER_PMU]);
 
    for (i = 0; i < input->pfp_event_count; i++) {
        mmcr0_val |= mmcr0_counter_off_val[i];  
        intersect_groups(group_vector, get_group_vector(input->pfp_events[i].event));
        mmcr1_val |= mmcr1_counter_off_val[i];  
    }
    group = first_group(group_vector);
    while (group != -1) {
        /* find out if the the privilege levels are compatible with each counter */
        for (i = 0; i < input->pfp_event_count; i++) {
            /* find event counter in group */
            for (j = 0; j < get_num_event_counters(); j++) {
                if (get_event_id(input->pfp_events[i].event,j) == get_group_event_id(group, j)) {
                    /* found counter */
                    if (input->pfp_events[i].plm != 0) {
                        if (! (pmd_priv_vec[j] & (1 << input->pfp_events[0].plm))) {
                            remove_group(group_vector, group);
                            group = first_group(group_vector);
                            goto try_next_group;
                        }
                    } else {
                        if (! (pmd_priv_vec[j] & (1 << input->pfp_dfl_plm))) {
                            remove_group(group_vector, group);
                            group = first_group(group_vector);
                            goto try_next_group;
                        }
                    }
                    /* We located this counter and its privilege checks out ok. */
                    counters_used |= (1 << j);
                    output->pfp_pmds[i].reg_value = 0;
                    output->pfp_pmds[i].reg_addr = 0;
                    output->pfp_pmds[i].reg_alt_addr = 0;
                    output->pfp_pmds[i].reg_num = j + 1;
                    output->pfp_pmds[i].reg_reserved1 = 0;
                    output->pfp_pmd_count = i + 1;
 
                    /* Find the next counter */
                    break;
                }
            }
            if (j == get_num_event_counters()) {
                printf ("libpfm: Internal error.  Unable to find counter in group.\n");
            }
        }
                /*
                 * Success!  We found a group (group) that meets the
                 * privilege constraints
                 */
        break; 
try_next_group: ;
    }
    if (group == -1)
        /* We did not find a group that meets the constraints */
        return PFMLIB_ERR_NOASSIGN;
 
    /* We now have a group that meets the constraints */
 
    mmcr0_val = get_mmcr0(group);
    mmcr1_val = get_mmcr1(group);
    for (i = 0; i < get_num_event_counters(); i++) {
        if (! (counters_used & (1 << i))) { 
            /*
             * This counter is not used, so set that
             * selector to its off value.
             */
            mmcr0_val &= ~mmcr0_counter_mask[i];    
            mmcr0_val |= mmcr0_counter_off_val[i];  
            mmcr1_val &= ~mmcr1_counter_mask[i];    
            mmcr1_val |= mmcr1_counter_off_val[i];  
        }
    }
    /*
     * As a special case for PMC5 and PMC6 on POWER5/5+, freeze these
     * two counters if neither are used.  Note that the
     * mmcr0_fc5_6_mask is zero for all processors except POWER5/5+
     */
    if ((counters_used & ((1 << (5 - 1)) | (1 << (6 - 1)))) == 0)
        mmcr0_val |= mmcr0_fc5_6_mask;
 
        /*
         * Enable counter "exception on negative" and performance monitor
         * exceptions
         */
    mmcr0_val |= MMCR0_PMXE | MMCR0_PMC1CE | MMCR0_PMCjCE;
 
    /* Start with the counters frozen in every state, then selectively
           enable them */
 
    mmcr0_val |= MMCR0_FCP | MMCR0_FCS | MMCR0_FCHV;
 
    if (plm & PFM_PLM3) {
        /* user */
        mmcr0_val &= ~MMCR0_FCP;
    }
    if (plm & PFM_PLM0) {
        /* kernel */
        mmcr0_val &= ~MMCR0_FCS;
    }
    if (plm & PFM_PLM1) {
        /* hypervisor */
        mmcr0_val &= ~MMCR0_FCHV;
    }
        /* PFM_PLM2 is not supported */
 
    output->pfp_pmcs[0].reg_value = mmcr0_val;
    output->pfp_pmcs[0].reg_addr = 0;
    output->pfp_pmcs[0].reg_alt_addr = 0;
    output->pfp_pmcs[0].reg_num = 0;
    output->pfp_pmcs[0].reg_reserved1 = 0;
 
    output->pfp_pmcs[1].reg_value = mmcr1_val;
    output->pfp_pmcs[1].reg_addr = 0;
    output->pfp_pmcs[1].reg_alt_addr = 0;
    output->pfp_pmcs[1].reg_num = 1;
    output->pfp_pmcs[1].reg_reserved1 = 0;
 
    output->pfp_pmcs[2].reg_value = get_mmcra(group);
    output->pfp_pmcs[2].reg_addr = 0;
    output->pfp_pmcs[2].reg_alt_addr = 0;
    output->pfp_pmcs[2].reg_num = 2;
    output->pfp_pmcs[2].reg_reserved1 = 0;
 
    /* We always use the same number of control regs */
    output->pfp_pmc_count = get_num_control_regs();
 
    return PFMLIB_SUCCESS;
}

Here is the call graph for this function:

pfm_gen_powerpc_get_cycle_event()

static int pfm_gen_powerpc_get_cycle_event ( pfmlib_event_t *  e )

static

Definition at line 761 of file pfmlib_gen_powerpc.c.

{
    switch (gen_powerpc_support.pmu_type) {
    case PFMLIB_PPC970_PMU:
        e->event = PPC970_PME_PM_CYC;
        break;
    case PFMLIB_PPC970MP_PMU:
        e->event = PPC970MP_PME_PM_CYC;
        break;
    case PFMLIB_POWER4_PMU:
        e->event = POWER4_PME_PM_CYC;
        break;
    case PFMLIB_POWER5_PMU:
        e->event = POWER5_PME_PM_CYC;
        break;
    case PFMLIB_POWER5p_PMU:
        e->event = POWER5p_PME_PM_RUN_CYC;
        break;
    case PFMLIB_POWER6_PMU:
        e->event = POWER6_PME_PM_RUN_CYC;
        break;
    case PFMLIB_POWER7_PMU:
        e->event = POWER7_PME_PM_RUN_CYC;
        break;
    default:
        /* perhaps gen_powerpc_suport.pmu_type wasn't initialized? */
        return PFMLIB_ERR_NOINIT;
    }
    e->num_masks = 0;
    e->unit_masks[0] = 0;
    return PFMLIB_SUCCESS;
 
}

pfm_gen_powerpc_get_event_code()

static int pfm_gen_powerpc_get_event_code ( unsigned int  event, unsigned int  pmd, int *  code  )

static

pfm_gen_powerpc_get_event_code

Return the event-select value for the specified event as needed for the specified PMD counter.

Definition at line 138 of file pfmlib_gen_powerpc.c.

{
    if (event < event_count[gen_powerpc_support.pmu_type - FIRST_POWER_PMU]) {
        *code = pe[event].pme_code;
        return PFMLIB_SUCCESS;
    } else
        return PFMLIB_ERR_INVAL;
}

pfm_gen_powerpc_get_event_counters()

static void pfm_gen_powerpc_get_event_counters ( unsigned int  event, pfmlib_regmask_t *  counters  )

static

pfm_gen_powerpc_get_event_counters

Fill in the 'counters' bitmask with all possible PMDs that could be used to count the specified event.

Definition at line 175 of file pfmlib_gen_powerpc.c.

{
    int i;
 
    counters->bits[0] = 0;  
    for (i = 0; i < get_num_event_counters(); i++) {
        if (get_event_id(event, i) != -1) {
            counters->bits[0] |= (1 << i);
        }
    }
}

Here is the call graph for this function:

pfm_gen_powerpc_get_event_desc()

static int pfm_gen_powerpc_get_event_desc ( unsigned int  event, char **  desc  )

static

pfm_gen_powerpc_get_event_desc

Return the description for the specified event (if it has one).

Definition at line 735 of file pfmlib_gen_powerpc.c.

{
    *desc = strdup(get_long_desc(event));
    return 0;
}

Here is the call graph for this function:

pfm_gen_powerpc_get_event_mask_code()

static int pfm_gen_powerpc_get_event_mask_code ( unsigned int  event, unsigned int  mask, unsigned int *  code  )

static

Definition at line 753 of file pfmlib_gen_powerpc.c.

{
    *code = 0;
    return 0;
}

pfm_gen_powerpc_get_event_mask_desc()

static int pfm_gen_powerpc_get_event_mask_desc ( unsigned int  event, unsigned int  mask, char **  desc  )

static

pfm_gen_powerpc_get_event_mask_desc

Return the description for the specified event-mask (if it has one).

Definition at line 746 of file pfmlib_gen_powerpc.c.

{
    *desc = strdup("");
    return 0;
}

pfm_gen_powerpc_get_event_mask_name()

static char * pfm_gen_powerpc_get_event_mask_name ( unsigned int  event, unsigned int  mask  )

static

pfm_gen_powerpc_get_event_mask_name

Return the name of the specified event-mask.

Definition at line 164 of file pfmlib_gen_powerpc.c.

{
    return "";
}

pfm_gen_powerpc_get_event_name()

static char * pfm_gen_powerpc_get_event_name ( unsigned int  event )

static

pfm_gen_powerpc_get_event_name

Return the name of the specified event.

Definition at line 154 of file pfmlib_gen_powerpc.c.

{
    return get_event_name(event);
}

Here is the call graph for this function:

pfm_gen_powerpc_get_hw_counter_width()

static void pfm_gen_powerpc_get_hw_counter_width ( unsigned int *  width )

static

pfm_gen_powerpc_get_hw_counter_width

Return the number of usable bits in the PMD counters.

Definition at line 725 of file pfmlib_gen_powerpc.c.

{
    *width = 64;
}

pfm_gen_powerpc_get_impl_counters()

static void pfm_gen_powerpc_get_impl_counters ( pfmlib_regmask_t *  impl_counters )

static

pfm_gen_powerpc_get_impl_counters

Set the appropriate bit in the impl_counters bitmask for each counter that's available on power4.

For now, all PMDs are counters, so just call get_impl_pmds().

Definition at line 715 of file pfmlib_gen_powerpc.c.

{
    pfm_gen_powerpc_get_impl_pmds(impl_counters);
}

Here is the call graph for this function:

pfm_gen_powerpc_get_impl_pmcs()

static void pfm_gen_powerpc_get_impl_pmcs ( pfmlib_regmask_t *  impl_pmcs )

static

pfm_gen_powerpc_get_impl_pmcs

Set the appropriate bit in the impl_pmcs bitmask for each PMC that's available on power4.

Definition at line 690 of file pfmlib_gen_powerpc.c.

{
        impl_pmcs->bits[0] = (0xffffffff >> (32 - get_num_control_regs()));
}

Here is the call graph for this function:

pfm_gen_powerpc_get_impl_pmds()

static void pfm_gen_powerpc_get_impl_pmds ( pfmlib_regmask_t *  impl_pmds )

static

pfm_gen_powerpc_get_impl_pmds

Set the appropriate bit in the impl_pmcs bitmask for each PMD that's available.

Definition at line 702 of file pfmlib_gen_powerpc.c.

{
        impl_pmds->bits[0] = (0xffffffff >> (32 - get_num_event_counters()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfm_gen_powerpc_get_inst_retired()

static int pfm_gen_powerpc_get_inst_retired ( pfmlib_event_t *  e )

static

Definition at line 796 of file pfmlib_gen_powerpc.c.

{
    switch (gen_powerpc_support.pmu_type) {
    case PFMLIB_PPC970_PMU:
        e->event = PPC970_PME_PM_INST_CMPL;
        break;
    case PFMLIB_PPC970MP_PMU:
        e->event = PPC970MP_PME_PM_INST_CMPL;
        break;
    case PFMLIB_POWER4_PMU:
        e->event = POWER4_PME_PM_INST_CMPL;
        break;
    case PFMLIB_POWER5_PMU:
        e->event = POWER5_PME_PM_INST_CMPL;
        break;
    case PFMLIB_POWER5p_PMU:
        e->event = POWER5p_PME_PM_INST_CMPL;
        break;
    case PFMLIB_POWER6_PMU:
        e->event = POWER6_PME_PM_INST_CMPL;
        break;
    case PFMLIB_POWER7_PMU:
        e->event = POWER7_PME_PM_INST_CMPL;
        break;
    default:
        /* perhaps gen_powerpc_suport.pmu_type wasn't initialized? */
        return PFMLIB_ERR_NOINIT;
    }
    e->num_masks = 0;
    e->unit_masks[0] = 0;
    return 0;
}

pfm_gen_powerpc_get_num_event_masks()

static unsigned int pfm_gen_powerpc_get_num_event_masks ( unsigned int  event )

static

pfm_gen_powerpc_get_num_event_masks

Count the number of available event-masks for the specified event.

Definition at line 193 of file pfmlib_gen_powerpc.c.

{
        /* POWER arch doesn't use event masks */
    return 0;
}

pfm_gen_powerpc_pmu_detect()

static int pfm_gen_powerpc_pmu_detect ( void  )

static

pfm_gen_powerpc_pmu_detect

Determine which POWER processor, if any, we are running on. These should be defined in more recent versions of /usr/include/asm-ppc64/reg.h. It isn't pretty to have these here, but maybe we can remove them someday.

Definition at line 541 of file pfmlib_gen_powerpc.c.

{
    if (__is_processor(PV_970) || __is_processor(PV_970FX) || __is_processor(PV_970GX)) {
        gen_powerpc_support.pmu_type = PFMLIB_PPC970_PMU;          
        gen_powerpc_support.pmu_name = "PPC970";          
        gen_powerpc_support.pme_count = PPC970_PME_EVENT_COUNT;
        gen_powerpc_support.pmd_count = PPC970_NUM_EVENT_COUNTERS;
        gen_powerpc_support.pmc_count = PPC970_NUM_CONTROL_REGS;
        gen_powerpc_support.num_cnt = PPC970_NUM_EVENT_COUNTERS;
        mmcr0_fc5_6_mask = 0;
        mmcr0_counter_mask = power4_mmcr0_counter_mask;
        mmcr1_counter_mask = power4_mmcr1_counter_mask;
        mmcr0_counter_off_val = ppc970_mmcr0_counter_off_val;
        mmcr1_counter_off_val = ppc970_mmcr1_counter_off_val;
        pmd_priv_vec = gq_pmd_priv_vec;
        pe = ppc970_pe;
        groups = ppc970_groups;
        return PFMLIB_SUCCESS;
    }
    if (__is_processor(PV_970MP)) {
        gen_powerpc_support.pmu_type = PFMLIB_PPC970MP_PMU;          
        gen_powerpc_support.pmu_name = "PPC970MP";          
        gen_powerpc_support.pme_count = PPC970MP_PME_EVENT_COUNT;
        gen_powerpc_support.pmd_count = PPC970MP_NUM_EVENT_COUNTERS;
        gen_powerpc_support.pmc_count = PPC970MP_NUM_CONTROL_REGS;
        gen_powerpc_support.num_cnt = PPC970MP_NUM_EVENT_COUNTERS;
        mmcr0_fc5_6_mask = 0;
        mmcr0_counter_mask = power4_mmcr0_counter_mask;
        mmcr1_counter_mask = power4_mmcr1_counter_mask;
        mmcr0_counter_off_val = ppc970_mmcr0_counter_off_val;
        mmcr1_counter_off_val = ppc970_mmcr1_counter_off_val;
        pmd_priv_vec = gq_pmd_priv_vec;
        pe = ppc970mp_pe;
        groups = ppc970mp_groups;
        return PFMLIB_SUCCESS;
    }
    if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p)) {
        gen_powerpc_support.pmu_type = PFMLIB_PPC970_PMU;          
        gen_powerpc_support.pmu_name = "POWER4";          
        gen_powerpc_support.pme_count = POWER4_PME_EVENT_COUNT;
        gen_powerpc_support.pmd_count = POWER4_NUM_EVENT_COUNTERS;
        gen_powerpc_support.pmc_count = POWER4_NUM_CONTROL_REGS;
        gen_powerpc_support.num_cnt = POWER4_NUM_EVENT_COUNTERS;
        mmcr0_fc5_6_mask = 0;
        mmcr0_counter_mask = power4_mmcr0_counter_mask;
        mmcr1_counter_mask = power4_mmcr1_counter_mask;
        mmcr0_counter_off_val = ppc970_mmcr0_counter_off_val;
        mmcr1_counter_off_val = ppc970_mmcr1_counter_off_val;
        mmcr0_counter_off_val = power4_mmcr0_counter_off_val;
        mmcr1_counter_off_val = power4_mmcr1_counter_off_val;
        pmd_priv_vec = gq_pmd_priv_vec;
        pe = power4_pe;
        groups = power4_groups;
        return PFMLIB_SUCCESS;
    }
    if (__is_processor(PV_POWER5)) {
        gen_powerpc_support.pmu_type = PFMLIB_POWER5_PMU;          
        gen_powerpc_support.pmu_name = "POWER5";          
        gen_powerpc_support.pme_count = POWER5_PME_EVENT_COUNT;
        gen_powerpc_support.pmd_count = POWER5_NUM_EVENT_COUNTERS;
        gen_powerpc_support.pmc_count = POWER5_NUM_CONTROL_REGS;
        gen_powerpc_support.num_cnt = POWER5_NUM_EVENT_COUNTERS;
        mmcr0_fc5_6_mask = MMCR0_FC5_6;
        mmcr0_counter_off_val = ppc970_mmcr0_counter_off_val;
        mmcr1_counter_off_val = ppc970_mmcr1_counter_off_val;
        mmcr0_counter_mask = power5_mmcr0_counter_mask;
        mmcr1_counter_mask = power5_mmcr1_counter_mask;
        mmcr0_counter_off_val = power5_mmcr0_counter_off_val;
        mmcr1_counter_off_val = power5_mmcr1_counter_off_val;
        pmd_priv_vec = gr_pmd_priv_vec;
        pe = power5_pe;
        groups = power5_groups;
        return PFMLIB_SUCCESS;
    }
    if (__is_processor(PV_POWER5p)) {
        gen_powerpc_support.pmu_type = PFMLIB_POWER5p_PMU;          
        gen_powerpc_support.pmu_name = "POWER5+";          
        gen_powerpc_support.pme_count = POWER5p_PME_EVENT_COUNT;
        gen_powerpc_support.pmd_count = POWER5p_NUM_EVENT_COUNTERS;
        gen_powerpc_support.pmc_count = POWER5p_NUM_CONTROL_REGS;
        mmcr0_counter_off_val = power4_mmcr0_counter_off_val;
        mmcr1_counter_off_val = power4_mmcr1_counter_off_val;
        gen_powerpc_support.num_cnt = POWER5p_NUM_EVENT_COUNTERS;
        mmcr0_counter_mask = power5_mmcr0_counter_mask;
        mmcr1_counter_mask = power5_mmcr1_counter_mask;
        mmcr0_counter_off_val = power5_mmcr0_counter_off_val;
        mmcr1_counter_off_val = power5_mmcr1_counter_off_val;
        if (PVR_VER(mfspr(SPRN_PVR)) >= 0x300) {
            /* this is a newer, GS model POWER5+ */
            mmcr0_fc5_6_mask = 0;
            pmd_priv_vec = gs_pmd_priv_vec;
        } else {
            mmcr0_fc5_6_mask = MMCR0_FC5_6;
            pmd_priv_vec = gr_pmd_priv_vec;
        }
        mmcr0_counter_off_val = power5_mmcr0_counter_off_val;
        mmcr1_counter_off_val = power5_mmcr1_counter_off_val;
        pe = power5p_pe;
        groups = power5p_groups;
        return PFMLIB_SUCCESS;
    }
    if (__is_processor(PV_POWER6)) {
        gen_powerpc_support.pmu_type = PFMLIB_POWER6_PMU;          
        gen_powerpc_support.pmu_name = "POWER6";          
        gen_powerpc_support.pme_count = POWER6_PME_EVENT_COUNT;
        gen_powerpc_support.pmd_count = POWER6_NUM_EVENT_COUNTERS;
        gen_powerpc_support.pmc_count = POWER6_NUM_CONTROL_REGS;
        gen_powerpc_support.num_cnt = POWER6_NUM_EVENT_COUNTERS;
        mmcr0_fc5_6_mask = 0;
        mmcr0_counter_mask = power5_mmcr0_counter_mask;
        mmcr1_counter_mask = power5_mmcr1_counter_mask;
        mmcr0_counter_off_val = power5_mmcr0_counter_off_val;
        mmcr1_counter_off_val = power5_mmcr1_counter_off_val;
        mmcr0_counter_off_val = power5_mmcr0_counter_off_val;
        mmcr1_counter_off_val = power5_mmcr1_counter_off_val;
        pmd_priv_vec = gs_pmd_priv_vec;
        pe = power6_pe;
        groups = power6_groups;
        return PFMLIB_SUCCESS;
    }
    if (__is_processor(PV_POWER7)) {
        gen_powerpc_support.pmu_type = PFMLIB_POWER7_PMU;
        gen_powerpc_support.pmu_name = "POWER7";
        gen_powerpc_support.pme_count = POWER7_PME_EVENT_COUNT;
        gen_powerpc_support.pmd_count = POWER7_NUM_EVENT_COUNTERS;
        gen_powerpc_support.pmc_count = POWER7_NUM_CONTROL_REGS;
        gen_powerpc_support.num_cnt = POWER7_NUM_EVENT_COUNTERS;
        mmcr0_fc5_6_mask = 0;
        mmcr0_counter_mask = power5_mmcr0_counter_mask;
        mmcr1_counter_mask = power5_mmcr1_counter_mask;
        mmcr0_counter_off_val = power5_mmcr0_counter_off_val;
        mmcr1_counter_off_val = power5_mmcr1_counter_off_val;
        mmcr0_counter_off_val = power5_mmcr0_counter_off_val;
        mmcr1_counter_off_val = power5_mmcr1_counter_off_val;
        pmd_priv_vec = gr_pmd_priv_vec;
        pe = power7_pe;
        groups = power7_groups;
        return PFMLIB_SUCCESS;
    }
 
    return PFMLIB_ERR_NOTSUPP;
}

remove_group()

static void remove_group ( unsigned long long *  group_vec, int  group  )

static

Definition at line 199 of file pfmlib_gen_powerpc.c.

{
        group_vec[group / 64] &= ~(1ULL << (group % 64));
}

Here is the caller graph for this function:

Variable Documentation

event_count

const int event_count[]

static

Initial value:

= {
    [PFMLIB_PPC970_PMU - FIRST_POWER_PMU] = PPC970_PME_EVENT_COUNT,
    [PFMLIB_PPC970MP_PMU - FIRST_POWER_PMU] = PPC970MP_PME_EVENT_COUNT,
    [PFMLIB_POWER5_PMU - FIRST_POWER_PMU] = POWER5_PME_EVENT_COUNT,
    [PFMLIB_POWER5p_PMU - FIRST_POWER_PMU] = POWER5p_PME_EVENT_COUNT,
    [PFMLIB_POWER6_PMU - FIRST_POWER_PMU] = POWER6_PME_EVENT_COUNT,
    [PFMLIB_POWER7_PMU - FIRST_POWER_PMU] = POWER7_PME_EVENT_COUNT
}

Definition at line 71 of file pfmlib_gen_powerpc.c.

gen_powerpc_support

pfm_pmu_support_t gen_powerpc_support

Initial value:

= {
    
    .pmu_name       = NULL,
    .pmu_type       = PFMLIB_UNKNOWN_PMU,
    .pme_count      = 0,
    .pmd_count      = 0,
    .pmc_count      = 0,
    .num_cnt        = 0,
 
    .get_event_code     = pfm_gen_powerpc_get_event_code,
    .get_event_name     = pfm_gen_powerpc_get_event_name,
    .get_event_mask_name    = pfm_gen_powerpc_get_event_mask_name,
    .get_event_counters = pfm_gen_powerpc_get_event_counters,
    .get_num_event_masks    = pfm_gen_powerpc_get_num_event_masks,
    .dispatch_events    = pfm_gen_powerpc_dispatch_events,
    .pmu_detect     = pfm_gen_powerpc_pmu_detect,
    .get_impl_pmcs      = pfm_gen_powerpc_get_impl_pmcs,
    .get_impl_pmds      = pfm_gen_powerpc_get_impl_pmds,
    .get_impl_counters  = pfm_gen_powerpc_get_impl_counters,
    .get_hw_counter_width   = pfm_gen_powerpc_get_hw_counter_width,
    .get_event_desc         = pfm_gen_powerpc_get_event_desc,
    .get_event_mask_desc    = pfm_gen_powerpc_get_event_mask_desc,
    .get_event_mask_code    = pfm_gen_powerpc_get_event_mask_code,
    .get_cycle_event    = pfm_gen_powerpc_get_cycle_event,
    .get_inst_retired_event = pfm_gen_powerpc_get_inst_retired
}

gen_powerpc_support

Definition at line 832 of file pfmlib_gen_powerpc.c.

gq_pmd_priv_vec

unsigned gq_pmd_priv_vec[8]

static

Initial value:

= {
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0f0e
}

Definition at line 228 of file pfmlib_gen_powerpc.c.

gr_pmd_priv_vec

unsigned gr_pmd_priv_vec[6]

static

Initial value:

= {
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0f0e,
}

Definition at line 239 of file pfmlib_gen_powerpc.c.

groups

const pmg_power_group_t* groups

static

Definition at line 89 of file pfmlib_gen_powerpc.c.

gs_pmd_priv_vec

unsigned gs_pmd_priv_vec[6]

static

Initial value:

= {
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0f0e,
    0x0800,
    0x0800,
}

Definition at line 248 of file pfmlib_gen_powerpc.c.

mmcr0_counter_mask

unsigned long long* mmcr0_counter_mask

static

Definition at line 83 of file pfmlib_gen_powerpc.c.

mmcr0_counter_off_val

unsigned long long* mmcr0_counter_off_val

static

Definition at line 85 of file pfmlib_gen_powerpc.c.

mmcr0_fc5_6_mask

unsigned long long mmcr0_fc5_6_mask

static

Definition at line 82 of file pfmlib_gen_powerpc.c.

mmcr1_counter_mask

unsigned long long* mmcr1_counter_mask

static

Definition at line 84 of file pfmlib_gen_powerpc.c.

mmcr1_counter_off_val

unsigned long long* mmcr1_counter_off_val

static

Definition at line 86 of file pfmlib_gen_powerpc.c.

num_group_vec

const int num_group_vec[]

static

Initial value:

= {
    [PFMLIB_PPC970_PMU - FIRST_POWER_PMU] = PPC970_NUM_GROUP_VEC,
    [PFMLIB_PPC970MP_PMU - FIRST_POWER_PMU] = PPC970MP_NUM_GROUP_VEC,
    [PFMLIB_POWER4_PMU - FIRST_POWER_PMU] = POWER4_NUM_GROUP_VEC,
    [PFMLIB_POWER5_PMU - FIRST_POWER_PMU] = POWER5_NUM_GROUP_VEC,
    [PFMLIB_POWER5p_PMU - FIRST_POWER_PMU] = POWER5p_NUM_GROUP_VEC,
    [PFMLIB_POWER6_PMU - FIRST_POWER_PMU] = POWER6_NUM_GROUP_VEC,
    [PFMLIB_POWER7_PMU - FIRST_POWER_PMU] = POWER7_NUM_GROUP_VEC
}

Definition at line 61 of file pfmlib_gen_powerpc.c.

pe

const pme_power_entry_t* pe

static

Definition at line 88 of file pfmlib_gen_powerpc.c.

pmd_priv_vec

unsigned* pmd_priv_vec

Definition at line 80 of file pfmlib_gen_powerpc.c.

power4_mmcr0_counter_mask

unsigned long long power4_mmcr0_counter_mask[POWER4_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0x1fUL << (63 - 55), 
    0x1fUL << (63 - 62), 
    0,
    0,
    0,
    0,
    0,
    0
}

Definition at line 258 of file pfmlib_gen_powerpc.c.

power4_mmcr0_counter_off_val

unsigned long long power4_mmcr0_counter_off_val[POWER4_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0, 
    0, 
    0,
    0,
    0,
    0,
    0,
    0
}

Definition at line 279 of file pfmlib_gen_powerpc.c.

power4_mmcr1_counter_mask

unsigned long long power4_mmcr1_counter_mask[POWER4_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0,
    0,
    0x1fUL << (63 - 36), 
    0x1fUL << (63 - 41), 
    0x1fUL << (63 - 46), 
    0x1fUL << (63 - 51), 
    0x1fUL << (63 - 56), 
    0x1fUL << (63 - 61)  
}

Definition at line 268 of file pfmlib_gen_powerpc.c.

power4_mmcr1_counter_off_val

unsigned long long power4_mmcr1_counter_off_val[POWER4_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0,
    0,
    0, 
    0, 
    0, 
    0, 
    0, 
    0  
}

Definition at line 289 of file pfmlib_gen_powerpc.c.

power5_mmcr0_counter_mask

unsigned long long power5_mmcr0_counter_mask[POWER5_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0,
    0,
    0,
    0,
    0,
    0
}

Definition at line 322 of file pfmlib_gen_powerpc.c.

power5_mmcr0_counter_off_val

unsigned long long power5_mmcr0_counter_off_val[POWER5_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0,
    0,
    0,
    0,
    0,
    0
}

Definition at line 339 of file pfmlib_gen_powerpc.c.

power5_mmcr1_counter_mask

unsigned long long power5_mmcr1_counter_mask[POWER5_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0xffUL << (63 - 39), 
    0xffUL << (63 - 47), 
    0xffUL << (63 - 55), 
    0xffUL << (63 - 63), 
    0,
    0
}

Definition at line 330 of file pfmlib_gen_powerpc.c.

power5_mmcr1_counter_off_val

unsigned long long power5_mmcr1_counter_off_val[POWER5_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0, 
    0, 
    0, 
    0, 
    0,
    0
}

Definition at line 348 of file pfmlib_gen_powerpc.c.

ppc970_mmcr0_counter_off_val

unsigned long long ppc970_mmcr0_counter_off_val[POWER4_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0x8UL << (63 - 55), 
    0x8UL << (63 - 62), 
    0,
    0,
    0,
    0,
    0,
    0
}

Definition at line 300 of file pfmlib_gen_powerpc.c.

ppc970_mmcr1_counter_off_val

unsigned long long ppc970_mmcr1_counter_off_val[POWER4_NUM_EVENT_COUNTERS]

static

Initial value:

= {
    0,
    0,
    0x8UL << (63 - 36), 
    0x8UL << (63 - 41), 
    0x8UL << (63 - 46), 
    0x8UL << (63 - 51), 
    0x8UL << (63 - 56), 
    0x8UL << (63 - 61)  
}

Definition at line 310 of file pfmlib_gen_powerpc.c.