int
_papi_libpfm_init(papi_vector_t *my_vector, int cidx) {
int retval;
unsigned int ncnt;
unsigned int version;
char pmu_name[PAPI_MIN_STR_LEN];
/* The following checks the version of the PFM library
against the version PAPI linked to... */
SUBDBG( "pfm_initialize()\n" );
if ( ( retval = pfm_initialize( ) ) != PFMLIB_SUCCESS ) {
PAPIERROR( "pfm_initialize(): %s", pfm_strerror( retval ) );
return PAPI_ESYS;
}
/* Get the libpfm3 version */
SUBDBG( "pfm_get_version(%p)\n", &version );
if ( pfm_get_version( &version ) != PFMLIB_SUCCESS ) {
PAPIERROR( "pfm_get_version(%p): %s", version, pfm_strerror( retval ) );
return PAPI_ESYS;
}
/* Set the version */
sprintf( my_vector->cmp_info.support_version, "%d.%d",
PFM_VERSION_MAJOR( version ), PFM_VERSION_MINOR( version ) );
/* Complain if the compiled-against version doesn't match current version */
if ( PFM_VERSION_MAJOR( version ) != PFM_VERSION_MAJOR( PFMLIB_VERSION ) ) {
PAPIERROR( "Version mismatch of libpfm: compiled %#x vs. installed %#x\n",
PFM_VERSION_MAJOR( PFMLIB_VERSION ),
PFM_VERSION_MAJOR( version ) );
return PAPI_ESYS;
}
/* Always initialize globals dynamically to handle forks properly. */
_perfmon2_pfm_pmu_type = -1;
/* Opened once for all threads. */
SUBDBG( "pfm_get_pmu_type(%p)\n", &_perfmon2_pfm_pmu_type );
if ( pfm_get_pmu_type( &_perfmon2_pfm_pmu_type ) != PFMLIB_SUCCESS ) {
PAPIERROR( "pfm_get_pmu_type(%p): %s", _perfmon2_pfm_pmu_type,
pfm_strerror( retval ) );
return PAPI_ESYS;
}
pmu_name[0] = '\0';
if ( pfm_get_pmu_name( pmu_name, PAPI_MIN_STR_LEN ) != PFMLIB_SUCCESS ) {
PAPIERROR( "pfm_get_pmu_name(%p,%d): %s", pmu_name, PAPI_MIN_STR_LEN,
pfm_strerror( retval ) );
return PAPI_ESYS;
}
SUBDBG( "PMU is a %s, type %d\n", pmu_name, _perfmon2_pfm_pmu_type );
/* Setup presets */
retval = _papi_load_preset_table( pmu_name, _perfmon2_pfm_pmu_type, cidx );
if ( retval )
return retval;
/* Fill in cmp_info */
SUBDBG( "pfm_get_num_events(%p)\n", &ncnt );
if ( ( retval = pfm_get_num_events( &ncnt ) ) != PFMLIB_SUCCESS ) {
PAPIERROR( "pfm_get_num_events(%p): %s\n", &ncnt,
pfm_strerror( retval ) );
return PAPI_ESYS;
}
SUBDBG( "pfm_get_num_events: %d\n", ncnt );
my_vector->cmp_info.num_native_events = ncnt;
num_native_events = ncnt;
pfm_get_num_counters( ( unsigned int * ) &my_vector->cmp_info.num_cntrs );
SUBDBG( "pfm_get_num_counters: %d\n", my_vector->cmp_info.num_cntrs );
if ( _papi_hwi_system_info.hw_info.vendor == PAPI_VENDOR_INTEL ) {
/* Pentium4 */
if ( _papi_hwi_system_info.hw_info.cpuid_family == 15 ) {
PAPI_NATIVE_EVENT_AND_MASK = 0x000000ff;
PAPI_NATIVE_UMASK_AND_MASK = 0x0fffff00;
PAPI_NATIVE_UMASK_SHIFT = 8;
/* Itanium2 */
} else if ( _papi_hwi_system_info.hw_info.cpuid_family == 31 ||
_papi_hwi_system_info.hw_info.cpuid_family == 32 ) {
PAPI_NATIVE_EVENT_AND_MASK = 0x00000fff;
PAPI_NATIVE_UMASK_AND_MASK = 0x0ffff000;
PAPI_NATIVE_UMASK_SHIFT = 12;
}
}
return PAPI_OK;
}
int
main(int argc, char **argv)
{
pfarg_pmr_t pd[NUM_PMDS];
pfarg_pmr_t pc[NUM_PMCS];
pfarg_pmd_attr_t pa[NUM_PMDS];
smpl_arg_t buf_arg;
pfarg_msg_t msg;
smpl_hdr_t *hdr;
void *buf_addr;
pid_t pid;
int ret, fd, status, npmcs = 0;
check_valid_cpu();
if (argc < 2)
fatal_error("you need to pass a program to sample\n");
memset(pd, 0, sizeof(pd));
memset(pc, 0, sizeof(pc));
memset(&buf_arg, 0, sizeof(buf_arg));
buf_arg.buf_size = getpagesize();
buf_arg.cnt_reset = -SMPL_PERIOD;
/*
* trigger interrupt when reached 90% of buffer
*/
buf_arg.intr_thres = (buf_arg.buf_size/sizeof(smpl_entry_t))*90/100;
fd = pfm_create(PFM_FL_SMPL_FMT, NULL, FMT_NAME, &buf_arg, sizeof(buf_arg));
if (fd == -1) {
if (errno == ENOSYS) {
fatal_error("Your kernel does not have performance monitoring support!\n");
}
fatal_error("cannot create session %s, maybe you do not have the P4/Xeon PEBS sampling format in the kernel.\n Check /sys/kernel/perfmon\n", strerror(errno));
}
/*
* retrieve the virtual address at which the sampling
* buffer has been mapped
*/
buf_addr = mmap(NULL, (size_t)buf_arg.buf_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (buf_addr == MAP_FAILED)
fatal_error("cannot mmap sampling buffer errno %d\n", errno);
printf("session [%d] buffer mapped @%p\n", fd, buf_addr);
hdr = (smpl_hdr_t *)buf_addr;
printf("pebs_base=0x%lx pebs_end=0x%lx index=0x%lx\n"
"intr=0x%lx version=%u.%u\n"
"entry_size=%zu ds_size=%zu\n",
hdr->ds.pebs_buf_base,
hdr->ds.pebs_abs_max,
hdr->ds.pebs_index,
hdr->ds.pebs_intr_thres,
PFM_VERSION_MAJOR(hdr->version),
PFM_VERSION_MINOR(hdr->version),
sizeof(smpl_entry_t),
sizeof(hdr->ds));
if (PFM_VERSION_MAJOR(hdr->version) < 1)
fatal_error("invalid buffer format version\n");
/*
* using the replay_event event
*
* CRU_ESCR2.usr=1
* CRU_ESCR2.event_mask=1 (NBOGUS)
* CRU_ESCR2.event_select=0x9 (replay_event)
*/
pc[npmcs].reg_num = 21;
pc[npmcs].reg_value = (9ULL <<25) | (1ULL<<9) |(1ULL<<2);
npmcs++;
/*
* for PEBS, must use IQ_CCCR4 for thread0
* IQ_CCCR4.escr_select = 5
* IQ_CCCR4.enable= 1
* IQ_CCCR4.active_thread= 3
*
* We must disable 64-bit emulation by the kernel
* on the associated counter when using PEBS. Otherwise
* we received a spurious interrupt for every counter overflow.
*/
pc[npmcs].reg_num = 31;
pc[npmcs].reg_flags = PFM_REGFL_NO_EMUL64;
pc[npmcs].reg_value = (5ULL << 13) | (1ULL<<12) | (3ULL<<16);
npmcs++;
/*
* PEBS_MATRIX_VERT.bit0=1 (1st level cache load miss retired)
*/
pc[npmcs].reg_num = 63;
pc[npmcs].reg_value = 1;
npmcs++;
/*
* PEBS_ENABLE.enable=1 (bit0)
* PEBS_ENABLE.uops=1 (bit 24)
* PEBS_ENABLE.my_thr=1 (bit 25)
*/
pc[npmcs].reg_num = 64;
pc[npmcs].reg_value = (1ULL<<25)|(1ULL<<24) | 1ULL;
npmcs++;
/*
* Must use IQ_CCCR4/IQ_CTR4 with PEBS for thread0
*
* IMPORTANT:
* SMPL_PERIOD MUST not exceed width of HW counter
* because no 64-bit virtualization is done by the
* kernel.
*/
pd[0].reg_num = 8;
pd[0].reg_flags = PFM_REGFL_OVFL_NOTIFY;
pd[0].reg_value = -SMPL_PERIOD;
pa[0].reg_long_reset = -SMPL_PERIOD;
pa[0].reg_short_reset = -SMPL_PERIOD;
/*
* Now program the registers
*/
if (pfm_write(fd, 0, PFM_RW_PMC, pc, npmcs * sizeof(*pc)) == -1)
fatal_error("pfm_writeerror errno %d\n",errno);
if (pfm_write(fd, 0, PFM_RW_PMD_ATTR, pd, sizeof(*pd)) == -1)
fatal_error("pfm_write(PMD) error errno %d\n",errno);
signal(SIGCHLD, SIG_IGN);
/*
* Create the child task
*/
if ((pid=fork()) == -1) fatal_error("Cannot fork process\n");
/*
* In order to get the PFM_END_MSG message, it is important
* to ensure that the child task does not inherit the file
* descriptor of the session. By default, file descriptor
* are inherited during exec(). We explicitely close it
* here. We could have set it up through fcntl(FD_CLOEXEC)
* to achieve the same thing.
*/
if (pid == 0) {
close(fd);
child(argv+1);
}
/*
* wait for the child to exec
*/
waitpid(pid, &status, WUNTRACED);
/*
* process is stopped at this point
*/
if (WIFEXITED(status)) {
warning("task %s [%d] exited already status %d\n", argv[1], pid, WEXITSTATUS(status));
goto terminate_session;
}
/*
* attach the session
*/
if (pfm_attach(fd, 0, pid) == -1)
fatal_error("pfm_attach error errno %d\n",errno);
/*
* start monitoring
*/
if (pfm_set_state(fd, 0, PFM_ST_START) == -1)
fatal_error("pfm_set_state(start) error errno %d\n",errno);
/*
* detach child. Side effect includes
* activation of monitoring.
*/
ptrace(PTRACE_DETACH, pid, NULL, 0);
/*
* core loop
*/
for(;;) {
/*
* wait for overflow/end notification messages
*/
ret = read(fd, &msg, sizeof(msg));
if (ret == -1) {
if(ret == -1 && errno == EINTR) {
warning("read interrupted, retrying\n");
continue;
}
fatal_error("cannot read perfmon msg: %s\n", strerror(errno));
}
switch(msg.type) {
case PFM_MSG_OVFL: /* the sampling buffer is full */
process_smpl_buf(hdr);
/*
* reactivate monitoring once we are done with the samples
*
* Note that this call can fail with EBUSY in non-blocking mode
* as the task may have disappeared while we were processing
* the samples.
*/
if (pfm_set_state(fd, 0, PFM_ST_RESTART) == -1) {
if (errno != EBUSY)
fatal_error("pfm_set_state(restart)_ error errno %d\n",errno);
else
warning("pfm_set_state(restart): task has probably terminated \n");
}
break;
case PFM_MSG_END: /* monitored task terminated */
warning("task terminated\n");
goto terminate_session;
default: fatal_error("unknown message type %d\n", msg.type);
}
}
terminate_session:
/*
* cleanup child
*/
wait4(pid, &status, 0, NULL);
/*
* check for any leftover samples
*/
process_smpl_buf(hdr);
munmap(buf_addr, (size_t)buf_arg.buf_size);
close(fd);
return 0;
}
int
process_smpl_buffer(void)
{
perfmon_smpl_hdr_t *hdr = (perfmon_smpl_hdr_t *)smpl_vaddr;
perfmon_smpl_entry_t *ent;
unsigned long pos;
unsigned long smpl_entry = 0;
pfm_ita2_reg_t *reg, *pmd16;
int i, ret;
/*
* Make sure the kernel uses the format we understand
*/
if (PFM_VERSION_MAJOR(hdr->hdr_version) != PFM_VERSION_MAJOR(PFM_SMPL_VERSION)) {
fatal_error("Perfmon v%u.%u sampling format is not supported\n",
PFM_VERSION_MAJOR(hdr->hdr_version),
PFM_VERSION_MINOR(hdr->hdr_version));
}
pos = (unsigned long)(hdr+1);
/*
* walk through all the entries recored in the buffer
*/
for(i=0; i < hdr->hdr_count; i++) {
ret = 0;
ent = (perfmon_smpl_entry_t *)pos;
/*
* print entry header
*/
safe_printf("Entry %ld PID:%d CPU:%d STAMP:0x%lx IIP:0x%016lx\n",
smpl_entry++,
ent->pid,
ent->cpu,
ent->stamp,
ent->ip);
/*
* point to first recorded register (always contiguous with entry header)
*/
reg = (pfm_ita2_reg_t*)(ent+1);
/*
* in this particular example, we have pmd8-pmd15 has the BTB. We have also
* included pmd16 (BTB index) has part of the registers to record. This trick
* allows us to get the index to decode the sequential order of the BTB.
*
* Recorded registers are always recorded in increasing order. So we know
* that pmd16 is at a fixed offset (+8*sizeof(unsigned long)) from pmd8.
*/
pmd16 = reg+8;
show_btb(reg, pmd16);
/*
* move to next entry
*/
pos += hdr->hdr_entry_size;
}
return 0;
}
int
main(int argc, char **argv)
{
pfmlib_input_param_t inp;
pfmlib_output_param_t outp;
pfmlib_core_input_param_t mod_inp;
pfmlib_options_t pfmlib_options;
pfarg_pmr_t pc[NUM_PMCS];
pfarg_pmd_attr_t pd[NUM_PMDS];
pfarg_sinfo_t sif;
struct pollfd fds;
smpl_arg_t buf_arg;
pfarg_msg_t msg;
smpl_hdr_t *hdr;
void *buf_addr;
uint64_t pebs_size;
pid_t pid;
int ret, fd, type;
unsigned int i;
uint32_t ctx_flags;
if (argc < 2)
fatal_error("you need to pass a program to sample\n");
if (pfm_initialize() != PFMLIB_SUCCESS)
fatal_error("libpfm intialization failed\n");
/*
* check we are on an Intel Core PMU
*/
pfm_get_pmu_type(&type);
if (type != PFMLIB_INTEL_CORE_PMU && type != PFMLIB_INTEL_ATOM_PMU)
fatal_error("This program only works with an Intel Core processor\n");
/*
* pass options to library (optional)
*/
memset(&pfmlib_options, 0, sizeof(pfmlib_options));
pfmlib_options.pfm_debug = 0; /* set to 1 for debug */
pfmlib_options.pfm_verbose = 1; /* set to 1 for verbose */
pfm_set_options(&pfmlib_options);
memset(pd, 0, sizeof(pd));
memset(pc, 0, sizeof(pc));
memset(&inp, 0, sizeof(inp));
memset(&outp, 0, sizeof(outp));
memset(&mod_inp, 0, sizeof(mod_inp));
memset(&sif, 0, sizeof(sif));
memset(&buf_arg, 0, sizeof(buf_arg));
memset(&fds, 0, sizeof(fds));
/*
* search for our sampling event
*/
if (pfm_find_full_event(SMPL_EVENT, &inp.pfp_events[0]) != PFMLIB_SUCCESS)
fatal_error("cannot find sampling event %s\n", SMPL_EVENT);
inp.pfp_event_count = 1;
inp.pfp_dfl_plm = PFM_PLM3;
/*
* important: inform libpfm we do use PEBS
*/
mod_inp.pfp_core_pebs.pebs_used = 1;
/*
* sampling buffer parameters
*/
pebs_size = 3 * getpagesize();
buf_arg.buf_size = pebs_size;
/*
* sampling period cannot use more bits than HW counter can supoprt
*/
buf_arg.cnt_reset = -SMPL_PERIOD;
/*
* We want a system-wide context for sampling
*/
ctx_flags = PFM_FL_SYSTEM_WIDE | PFM_FL_SMPL_FMT;
/*
* trigger notification (interrupt) when reaching the very end of
* the buffer
*/
buf_arg.intr_thres = (pebs_size/sizeof(smpl_entry_t))*90/100;
/*
* we want to measure CPU0, thus we pin ourself to the CPU before invoking
* perfmon. This ensures that the sampling buffer will be allocated on the
* same NUMA node.
*/
ret = pin_cpu(getpid(), 0);
if (ret)
fatal_error("cannot pin on CPU0");
/*
* create session and sampling buffer
*/
fd = pfm_create(ctx_flags, &sif, FMT_NAME, &buf_arg, sizeof(buf_arg));
if (fd == -1) {
if (errno == ENOSYS) {
fatal_error("Your kernel does not have performance monitoring support!\n");
}
fatal_error("cannot create session %s, maybe you do not have the PEBS sampling format in the kernel.\nCheck /sys/kernel/perfmon/formats\n", strerror(errno));
}
/*
* map buffer into our address space
*/
buf_addr = mmap(NULL, (size_t)buf_arg.buf_size, PROT_READ, MAP_PRIVATE, fd, 0);
printf("session [%d] buffer mapped @%p\n", fd, buf_addr);
if (buf_addr == MAP_FAILED)
fatal_error("cannot mmap sampling buffer errno %d\n", errno);
hdr = (smpl_hdr_t *)buf_addr;
printf("pebs_base=0x%llx pebs_end=0x%llx index=0x%llx\n"
"intr=0x%llx version=%u.%u\n"
"entry_size=%zu ds_size=%zu\n",
(unsigned long long)hdr->ds.pebs_buf_base,
(unsigned long long)hdr->ds.pebs_abs_max,
(unsigned long long)hdr->ds.pebs_index,
(unsigned long long)hdr->ds.pebs_intr_thres,
PFM_VERSION_MAJOR(hdr->version),
PFM_VERSION_MINOR(hdr->version),
sizeof(smpl_entry_t),
sizeof(hdr->ds));
if (PFM_VERSION_MAJOR(hdr->version) < 1)
fatal_error("invalid buffer format version\n");
/*
* get which PMC registers are available
*/
detect_unavail_pmu_regs(&sif, &inp.pfp_unavail_pmcs, NULL);
/*
* let libpfm figure out how to assign event onto PMU registers
*/
if (pfm_dispatch_events(&inp, &mod_inp, &outp, NULL) != PFMLIB_SUCCESS)
fatal_error("cannot assign event %s\n", SMPL_EVENT);
/*
* propagate PMC setup from libpfm to perfmon
*/
for (i=0; i < outp.pfp_pmc_count; i++) {
pc[i].reg_num = outp.pfp_pmcs[i].reg_num;
pc[i].reg_value = outp.pfp_pmcs[i].reg_value;
/*
* must disable 64-bit emulation on the PMC0 counter.
* PMC0 is the only counter useable with PEBS. We must disable
* 64-bit emulation to avoid getting interrupts for each
* sampling period, PEBS takes care of this part.
*/
if (pc[i].reg_num == 0)
pc[i].reg_flags = PFM_REGFL_NO_EMUL64;
}
/*
* propagate PMD set from libpfm to perfmon
*/
for (i=0; i < outp.pfp_pmd_count; i++)
pd[i].reg_num = outp.pfp_pmds[i].reg_num;
/*
* setup sampling period for first counter
* we want notification on overflow, i.e., when buffer is full
*/
pd[0].reg_flags = PFM_REGFL_OVFL_NOTIFY;
pd[0].reg_value = -SMPL_PERIOD;
pd[0].reg_long_reset = -SMPL_PERIOD;
pd[0].reg_short_reset = -SMPL_PERIOD;
/*
* Now program the registers
*/
if (pfm_write(fd, 0, PFM_RW_PMC, pc, outp.pfp_pmc_count * sizeof(*pc)) == -1)
fatal_error("pfm_write error errno %d\n",errno);
if (pfm_write(fd, 0, PFM_RW_PMD_ATTR, pd, outp.pfp_pmd_count * sizeof(*pd)) == -1)
fatal_error("pfm_write(PMD) error errno %d\n",errno);
/*
* attach the session to CPU0
*/
if (pfm_attach(fd, 0, 0) == -1)
fatal_error("pfm_attach error errno %d\n",errno);
/*
* Create the child task
*/
signal(SIGCHLD, handler);
if ((pid=fork()) == -1)
fatal_error("Cannot fork process\n");
if (pid == 0) {
/* child does not inherit context file descriptor */
close(fd);
/* if child is too short-lived we may not measure it */
child(argv+1);
}
/*
* start monitoring
*/
if (pfm_set_state(fd, 0, PFM_ST_START) == -1)
fatal_error("pfm_set_state(start) error errno %d\n",errno);
fds.fd = fd;
fds.events = POLLIN;
/*
* core loop
*/
for(;done == 0;) {
/*
* Must use a timeout to avoid a race condition
* with the SIGCHLD signal
*/
ret = poll(&fds, 1, 500);
/*
* if timeout expired, then check done
*/
if (ret == 0)
continue;
if (ret == -1) {
if(ret == -1 && errno == EINTR) {
warning("read interrupted, retrying\n");
continue;
}
fatal_error("poll failed: %s\n", strerror(errno));
}
ret = read(fd, &msg, sizeof(msg));
if (ret == -1)
fatal_error("cannot read perfmon msg: %s\n", strerror(errno));
switch(msg.type) {
case PFM_MSG_OVFL: /* the sampling buffer is full */
process_smpl_buf(hdr);
/*
* reactivate monitoring once we are done with the samples
* in syste-wide, interface guarantees monitoring is active
* upon return from the pfm_restart() syscall
*/
if (pfm_set_state(fd, 0, PFM_ST_RESTART) == -1)
fatal_error("pfm_set_state(restart) error errno %d\n",errno);
break;
default: fatal_error("unknown message type %d\n", msg.type);
}
}
/*
* cleanup child
*/
waitpid(pid, NULL, 0);
/*
* stop monitoring, this is required in order to guarantee that the PEBS buffer
* header is updated with the latest position, such that we see see the final
* samples
*/
if (pfm_set_state(fd, 0, PFM_ST_STOP) == -1)
fatal_error("pfm_set_state(stop) error errno %d\n",errno);
/*
* check for any leftover samples. Must have monitoring stopped
* for this operation to have guarantee it is up to date
*/
process_smpl_buf(hdr);
/*
* close session
*/
close(fd);
/*
* unmap sampling buffer and actually free the perfmon session
*/
munmap(buf_addr, (size_t)buf_arg.buf_size);
return 0;
}