31#include <sys/utsname.h>
61#define OBSOLETE_WORKAROUNDS 0
64#define PERF_EVENTS_OPENED 0x01
65#define PERF_EVENTS_RUNNING 0x02
70#define HANDLE_STRING_ERROR {fprintf(stderr,"%s:%i unexpected string function error.\n",__FILE__,__LINE__); exit(-1);}
85#if defined(__powerpc__)
86#define PAPI_REFRESH_VALUE 0
88#define PAPI_REFRESH_VALUE 1
93#if (OBSOLETE_WORKAROUNDS==1)
101processor_supported(
int vendor,
int family) {
106 PAPIERROR(
"Pentium 4 not supported on kernels before 2.6.35");
184#if (OBSOLETE_WORKAROUNDS==1)
199#if (OBSOLETE_WORKAROUNDS==1)
233 ret = fcntl(fd,
F_SETOWN_EX, (
unsigned long)&fown_ex );
236 PAPIERROR(
"cannot fcntl(F_SETOWN_EX) on %d: %s",
237 fd, strerror(
errno ) );
251 unsigned int format = 0;
255 format |= PERF_FORMAT_TOTAL_TIME_ENABLED;
256 format |= PERF_FORMAT_TOTAL_TIME_RUNNING;
263 format |= PERF_FORMAT_GROUP;
267 SUBDBG(
"multiplex: %d, inherit: %d, group_leader: %d, format: %#x\n",
286 memset(&attr, 0 ,
sizeof(attr));
287 attr.
config = PERF_COUNT_HW_INSTRUCTIONS;
291 PAPIERROR(
"Couldn't open hw_instructions in exclude_guest=0 test");
297 memset(&attr, 0 ,
sizeof(attr));
298 attr.
config = PERF_COUNT_HW_INSTRUCTIONS;
299 attr.exclude_guest=1;
307 PAPIERROR(
"Couldn't open hw_instructions in exclude_guest=1 test");
326 pid_t
pid,
int cpu,
int group_fd,
unsigned long int flags) {
338 SUBDBG(
"sys_perf_event_open(hw_event: %p, pid: %d, cpu: %d, "
339 "group_fd: %d, flags: %lx\n",
340 hw_event,
pid, cpu, group_fd, flags);
342 SUBDBG(
" size: %d\n",hw_event->size);
343 SUBDBG(
" config: %"PRIx64
" (%"PRIu64
")\n",
345 SUBDBG(
" sample_period: %"PRIu64
"\n",hw_event->sample_period);
346 SUBDBG(
" sample_type: %"PRIu64
"\n",hw_event->sample_type);
347 SUBDBG(
" read_format: %"PRIu64
"\n",hw_event->read_format);
348 SUBDBG(
" disabled: %d\n",hw_event->disabled);
349 SUBDBG(
" inherit: %d\n",hw_event->inherit);
350 SUBDBG(
" pinned: %d\n",hw_event->pinned);
351 SUBDBG(
" exclusive: %d\n",hw_event->exclusive);
352 SUBDBG(
" exclude_user: %d\n",hw_event->exclude_user);
353 SUBDBG(
" exclude_kernel: %d\n",hw_event->exclude_kernel);
354 SUBDBG(
" exclude_hv: %d\n",hw_event->exclude_hv);
355 SUBDBG(
" exclude_idle: %d\n",hw_event->exclude_idle);
356 SUBDBG(
" mmap: %d\n",hw_event->mmap);
357 SUBDBG(
" comm: %d\n",hw_event->comm);
358 SUBDBG(
" freq: %d\n",hw_event->freq);
359 SUBDBG(
" inherit_stat: %d\n",hw_event->inherit_stat);
360 SUBDBG(
" enable_on_exec: %d\n",hw_event->enable_on_exec);
361 SUBDBG(
" task: %d\n",hw_event->task);
362 SUBDBG(
" watermark: %d\n",hw_event->watermark);
363 SUBDBG(
" precise_ip: %d\n",hw_event->precise_ip);
364 SUBDBG(
" mmap_data: %d\n",hw_event->mmap_data);
365 SUBDBG(
" sample_id_all: %d\n",hw_event->sample_id_all);
366 SUBDBG(
" exclude_host: %d\n",hw_event->exclude_host);
367 SUBDBG(
" exclude_guest: %d\n",hw_event->exclude_guest);
368 SUBDBG(
" exclude_callchain_kernel: %d\n",
369 hw_event->exclude_callchain_kernel);
370 SUBDBG(
" exclude_callchain_user: %d\n",
371 hw_event->exclude_callchain_user);
372 SUBDBG(
" wakeup_events: %"PRIx32
" (%"PRIu32
")\n",
373 hw_event->wakeup_events, hw_event->wakeup_events);
374 SUBDBG(
" bp_type: %"PRIx32
" (%"PRIu32
")\n",
375 hw_event->bp_type, hw_event->bp_type);
376 SUBDBG(
" config1: %"PRIx64
" (%"PRIu64
")\n",
377 hw_event->config1, hw_event->config1);
378 SUBDBG(
" config2: %"PRIx64
" (%"PRIu64
")\n",
379 hw_event->config2, hw_event->config2);
380 SUBDBG(
" branch_sample_type: %"PRIx64
" (%"PRIu64
")\n",
381 hw_event->branch_sample_type, hw_event->branch_sample_type);
382 SUBDBG(
" sample_regs_user: %"PRIx64
" (%"PRIu64
")\n",
383 hw_event->sample_regs_user, hw_event->sample_regs_user);
384 SUBDBG(
" sample_stack_user: %"PRIx32
" (%"PRIu32
")\n",
385 hw_event->sample_stack_user, hw_event->sample_stack_user);
395 switch(perf_event_error) {
440 unsigned int cpu_num,
442 unsigned int granularity,
452 memset(&attr,
'\0',
sizeof(attr));
458 attr.
config = PERF_COUNT_HW_INSTRUCTIONS;
465 attr.exclude_user = 1;
468 attr.exclude_kernel = 1;
477 SUBDBG(
"Calling sys_perf_event_open() from check_permissions\n");
483 SUBDBG(
"sys_perf_event_open returned error. Linux says, %s",
500#define READ_BUFFER_SIZE (3 + (2 * PERF_EVENT_MAX_MPX_COUNTERS))
515 int i,group_leader_fd;
523 if (group_leader_fd==-1) group_leader_fd=ctl->
events[idx].
event_fd;
526 retval = ioctl( group_leader_fd, PERF_EVENT_IOC_ENABLE, NULL );
528 PAPIERROR(
"ioctl(PERF_EVENT_IOC_ENABLE) failed");
533 retval = ioctl(group_leader_fd, PERF_EVENT_IOC_DISABLE, NULL );
535 PAPIERROR(
"ioctl(PERF_EVENT_IOC_DISABLE) failed" );
540 cnt =
read( group_leader_fd, papi_pe_buffer,
sizeof(papi_pe_buffer));
542 SUBDBG(
"read returned an error! Should never happen.\n" );
568 for(
i = 0;
i < idx;
i++) {
571 PAPIERROR(
"ioctl(PERF_EVENT_IOC_RESET) #%d/%d %d "
592 ret = fcntl( fd, F_SETFL, O_ASYNC | O_NONBLOCK );
594 PAPIERROR (
"fcntl(%d, F_SETFL, O_ASYNC | O_NONBLOCK) "
595 "returned error: %s", fd, strerror(
errno ) );
607 ret=fcntl(fd, F_SETFD, FD_CLOEXEC);
621 PAPIERROR(
"cannot fcntl(F_SETSIG,%d) on %d: %s",
638 buf_addr = mmap( NULL,
640 PROT_READ | PROT_WRITE,
654 if ( buf_addr == MAP_FAILED ) {
655 SUBDBG(
"mmap(NULL,%d,%d,%d,%d,0): %s",
657 PROT_READ | PROT_WRITE,
659 fd, strerror(
errno ) );
666 PAPIERROR(
"Can't mmap, disabling fast_counter_read\n");
672 SUBDBG(
"Sample buffer for fd %d is located at %p\n", fd, buf_addr );
675 ctl->
events[evt_idx].
mmap_buf = (
struct perf_counter_mmap_page *) buf_addr;
688 hw_event->config1=0x2;
735 SUBDBG(
"Disabling exclude_guest in event %d\n",
i);
744#if defined(__aarch64__)
757#if defined(__aarch64__)
786 SUBDBG(
"sys_perf_event_open returned error "
787 "on event #%d. Error: %s\n",
791 goto open_pe_cleanup;
794 SUBDBG (
"sys_perf_event_open: tid: %ld, cpu_num: %d,"
795 " group_leader/fd: %d, event_fd: %d,"
796 " read_format: %"PRIu64
"\n",
817 goto open_pe_cleanup;
877 goto open_pe_cleanup;
906 int munmap_error=0,close_error=0;
910 PAPIERROR(
"munmap and num pages is zero");
914 PAPIERROR(
"munmap of fd = %d returned error: %s",
917 event->mmap_buf=NULL;
922 PAPIERROR(
"close of fd = %d returned error: %s",
927 event->event_opened=0;
929 if ((close_error || munmap_error)) {
942 int events_not_opened=0;
946 SUBDBG(
"Closing without stopping first\n");
976 if (ctl->
num_events!=(num_closed+events_not_opened)) {
978 "Closed %d Not Opened: %d Expected %d",
979 num_closed,events_not_opened,ctl->
num_events);
986 ctx->
state &= ~PERF_EVENTS_OPENED;
1012 SUBDBG(
"old control domain %d, new domain %d\n", pe_ctl->
domain,domain);
1068 PERF_EVENT_IOC_RESET, NULL );
1074 PERF_EVENT_IOC_RESET, NULL );
1077 PAPIERROR(
"ioctl(%d, PERF_EVENT_IOC_RESET, NULL) "
1078 "returned error, Linux says: %s",
1080 strerror(
errno ) );
1127 long long **
events,
int flags )
1131 SUBDBG(
"ENTER: ctx: %p, ctl: %p, events: %p, flags: %#x\n",
1132 ctx, ctl,
events, flags);
1136 ( void ) papi_pe_buffer;
1139 unsigned long long count, enabled = 0, running = 0, adjusted;
1150 if (
count==0xffffffffffffffffULL) {
1155 if (enabled == running) {
1158 else if (enabled && running) {
1159 adjusted = (enabled * 128LL) / running;
1160 adjusted = adjusted *
count;
1161 adjusted = adjusted / 128LL;
1165 SUBDBG(
"perf_event kernel bug(?) count, enabled, "
1166 "running: %lld, %lld, %lld\n",
1167 papi_pe_buffer[0],enabled,running);
1189 long long tot_time_running, tot_time_enabled, scale;
1198 sizeof ( papi_pe_buffer ) );
1206 if (ret<(
signed)(3*
sizeof(
long long))) {
1211 SUBDBG(
"read: fd: %2d, tid: %ld, cpu: %d, ret: %d\n",
1214 SUBDBG(
"read: %lld %lld %lld\n",
1219 tot_time_enabled = papi_pe_buffer[1];
1220 tot_time_running = papi_pe_buffer[2];
1222 SUBDBG(
"count[%d] = (papi_pe_buffer[%d] %lld * "
1223 "tot_time_enabled %lld) / "
1224 "tot_time_running %lld\n",
1225 i, 0,papi_pe_buffer[0],
1226 tot_time_enabled,tot_time_running);
1228 if (tot_time_running == tot_time_enabled) {
1230 pe_ctl->
counts[
i] = papi_pe_buffer[0];
1231 }
else if (tot_time_running && tot_time_enabled) {
1235 scale = (tot_time_enabled * 100LL) / tot_time_running;
1236 scale = scale * papi_pe_buffer[0];
1237 scale = scale / 100LL;
1241 SUBDBG(
"perf_event kernel bug(?) count, enabled, "
1242 "running: %lld, %lld, %lld\n",
1243 papi_pe_buffer[0],tot_time_enabled,
1246 pe_ctl->
counts[
i] = papi_pe_buffer[0];
1266 sizeof ( papi_pe_buffer ) );
1274 if (ret!=
sizeof(
long long)) {
1276 PAPIERROR(
"read: fd: %2d, tid: %ld, cpu: %d, ret: %d",
1282 SUBDBG(
"read: fd: %2d, tid: %ld, cpu: %d, ret: %d\n",
1285 SUBDBG(
"read: %lld\n",papi_pe_buffer[0]);
1287 pe_ctl->
counts[
i] = papi_pe_buffer[0];
1296 long long **
events,
int flags )
1298 SUBDBG(
"ENTER: ctx: %p, ctl: %p, events: %p, flags: %#x\n",
1299 ctx, ctl,
events, flags);
1340 PAPIERROR(
"Was expecting group leader");
1345 sizeof ( papi_pe_buffer ) );
1355 if (ret<(
signed)((1+pe_ctl->
num_events)*
sizeof(
long long))) {
1360 SUBDBG(
"read: fd: %2d, tid: %ld, cpu: %d, ret: %d\n",
1364 for(j=0;j<ret/8;j++) {
1365 SUBDBG(
"read %d: %lld\n",j,papi_pe_buffer[j]);
1370 PAPIERROR(
"Error! Wrong number of events");
1376 pe_ctl->
counts[
i] = papi_pe_buffer[1+
i];
1388#if (OBSOLETE_WORKAROUNDS==1)
1396 long long **
events,
int flags )
1410 PERF_EVENT_IOC_DISABLE, NULL );
1412 PAPIERROR(
"ioctl(PERF_EVENT_IOC_DISABLE) "
1413 "returned an error: ", strerror(
errno ));
1430 PERF_EVENT_IOC_ENABLE, NULL );
1433 PAPIERROR(
"ioctl(PERF_EVENT_IOC_ENABLE) returned an error: ",
1452 int did_something = 0;
1466 SUBDBG(
"ioctl(enable): fd: %d\n",
1469 PERF_EVENT_IOC_ENABLE, NULL) ;
1477 PAPIERROR(
"ioctl(PERF_EVENT_IOC_ENABLE) failed");
1485 if (!did_something) {
1486 PAPIERROR(
"Did not enable any counters");
1500 SUBDBG(
"ENTER: ctx: %p, ctl: %p\n", ctx, ctl);
1511 PERF_EVENT_IOC_DISABLE, NULL);
1513 PAPIERROR(
"ioctl(%d, PERF_EVENT_IOC_DISABLE, NULL) "
1514 "returned error, Linux says: %s",
1521 pe_ctx->
state &= ~PERF_EVENTS_RUNNING;
1544 SUBDBG(
"ENTER: ctl: %p, native: %p, count: %d, ctx: %p\n",
1549 int skipped_events=0;
1562 SUBDBG(
"EXIT: Called with count == 0\n" );
1572 SUBDBG(
"papi_event_code: %#x known by papi but not by the component\n",
native[
i].ni_papi_code);
1576 if (ntv_idx == -1) {
1587 SUBDBG(
"papi_event_code: %#x not found in native event tables\n",
native[
i].ni_papi_code);
1593 SUBDBG(
"ntv_evt: %p\n", ntv_evt);
1598 memcpy (&pe_ctl->
events[
i].
attr, &ntv_evt->
attr,
sizeof(perf_event_attr_t));
1605 if ((aName == NULL) || (strstr(aName,
":u=") == NULL)) {
1609 if ((aName == NULL) || (strstr(aName,
":k=") == NULL)) {
1644 SUBDBG(
"&native[%d]: %p, ni_papi_code: %#x, ni_event: %#x, ni_position: %d, ni_owners: %d\n",
1649 if (
count <= skipped_events) {
1650 SUBDBG(
"EXIT: No events to count, they all contained invalid umasks\n");
1659 SUBDBG(
"EXIT: open_pe_events returned: %d\n", ret);
1664 SUBDBG(
"EXIT: PAPI_OK\n" );
1887 char *ntv_name,
int len)
1896 char *ntv_descr,
int len)
1918 unsigned int *native_index,
int *profile_index )
1920 int pos, esi_index,
count;
1926 if ( pos == evt_idx ) {
1927 *profile_index =
count;
1931 SUBDBG(
"Native event %d is at profile index %d, flags %d\n",
1932 *native_index, *profile_index, *flags );
1936 PAPIERROR(
"wrong count: %d vs. ESI->profile.event_counter %d",
1946 int ret, flags, profile_index;
1947 unsigned native_index;
1951 &flags, &native_index, &profile_index );
1956 ctl= (*thr)->running_eventset[
cidx]->ctl_state;
1973 int found_evt_idx = -1, fd = info->si_fd;
1981 PAPIERROR(
"thread == NULL in _papi_pe_dispatch_timer for fd %d!", fd );
1985 if (
thread->running_eventset[
cidx] == NULL ) {
1986 PAPIERROR(
"thread->running_eventset == NULL in "
1987 "_papi_pe_dispatch_timer for fd %d!",fd );
1991 if (
thread->running_eventset[
cidx]->overflow.flags == 0 ) {
1992 PAPIERROR(
"thread->running_eventset->overflow.flags == 0 in "
1993 "_papi_pe_dispatch_timer for fd %d!", fd );
1997 hw_context.
si = info;
2000 if (
thread->running_eventset[
cidx]->overflow.flags &
2009 if (
thread->running_eventset[
cidx]->overflow.flags !=
2011 PAPIERROR(
"thread->running_eventset->overflow.flags "
2012 "is set to something other than "
2013 "PAPI_OVERFLOW_HARDWARE or "
2014 "PAPI_OVERFLOW_FORCE_SW for fd %d (%#x)",
2016 thread->running_eventset[
cidx]->overflow.flags);
2020 ctl=
thread->running_eventset[
cidx]->ctl_state;
2030 if ( found_evt_idx == -1 ) {
2031 PAPIERROR(
"Unable to find fd %d among the open event fds "
2032 "_papi_hwi_dispatch_timer!", fd );
2036 if (ioctl( fd, PERF_EVENT_IOC_DISABLE, NULL ) == -1 ) {
2037 PAPIERROR(
"ioctl(PERF_EVENT_IOC_DISABLE) failed");
2041 !(
thread->running_eventset[
cidx]->profile.flags &
2049 unsigned char *data = ((
unsigned char*)
pe->mmap_buf) + getpagesize( );
2066 PAPIERROR(
"Attempting to access memory "
2067 "which may be inaccessable" );
2070 ip = *( uint64_t * ) ( data + ( ( head - 8 ) &
pe->mask ) );
2103 (
vptr_t ) (
unsigned long ) ip,
2104 NULL, ( 1 << found_evt_idx ), 0,
2139 PAPIERROR(
"process_smpl_buf returned error %d", ret );
2154 SUBDBG(
"ENTER: ESI: %p, EventIndex: %d, threshold: %d\n",
2159 int i, evt_idx, found_non_zero_sample_period = 0,
retval =
PAPI_OK;
2169 SUBDBG(
"Attempting to set overflow for index %d (%d) of EventSet %d\n",
2173 SUBDBG(
"EXIT: evt_idx: %d\n", evt_idx);
2180 ( ctl->
events[evt_idx].
attr.sample_period == 0 ) ) {
2181 SUBDBG(
"EXIT: PAPI_EINVAL, Tried to clear "
2182 "sample threshold when it was not set\n");
2199 ctl->
events[evt_idx].
attr.sample_type = PERF_SAMPLE_IP;
2207 found_non_zero_sample_period = 1;
2212 if ( found_non_zero_sample_period ) {
2221 SUBDBG(
"Call to _papi_hwi_start_signal "
2222 "returned: %d\n",
retval);
2233 SUBDBG(
"Call to _papi_hwi_stop_signal "
2234 "returned: %d\n",
retval);
2279 ctl->
events[evt_idx].
attr.sample_type &= ~PERF_SAMPLE_IP;
2310 if ( ret !=
PAPI_OK )
return ret;
2333#if defined(__aarch64__)
2335static int _pe_detect_arm64_access(
void) {
2338 int perf_user_access;
2341 fff=fopen(
"/proc/sys/kernel/perf_user_access",
"r");
2348 retval=fscanf(
fff,
"%d",&perf_user_access);
2349 if (
retval!=1) fprintf(
stderr,
"Error reading /proc/sys/kernel/perf_user_access\n");
2352 return perf_user_access;
2360 int fd,rdpmc_exists=1;
2362 struct perf_event_mmap_page *our_mmap;
2363 int page_size=getpagesize();
2364#if defined(__aarch64__)
2368#if defined(__i386__) || defined (__x86_64__) || defined(__aarch64__)
2380#if defined(__aarch64__)
2382 retval = _pe_detect_arm64_access();
2391 pe.type=PERF_TYPE_HARDWARE;
2393 pe.config=PERF_COUNT_HW_INSTRUCTIONS;
2394#if defined(__aarch64__)
2397 pe.exclude_kernel=1;
2407 SUBDBG(
"FAILED perf_event_open trying to detect rdpmc support");
2412 addr=mmap(NULL, page_size, PROT_READ, MAP_SHARED,fd,0);
2413 if (addr == MAP_FAILED) {
2414 SUBDBG(
"FAILED mmap trying to detect rdpmc support");
2420 our_mmap=(
struct perf_event_mmap_page *)addr;
2423 if (our_mmap->cap_usr_rdpmc!=0) {
2426 else if ((!our_mmap->cap_bit0_is_deprecated) && (our_mmap->cap_bit0)) {
2437 munmap(addr,page_size);
2440 return rdpmc_exists;
2457 fff=fopen(
"/proc/sys/kernel/perf_event_paranoid",
"r");
2470 retval=fscanf(
fff,
"%d",¶noid_level);
2471 if (
retval!=1) fprintf(
stderr,
"Error reading paranoid level\n");
2474 if (paranoid_level==3) {
2481 if ((paranoid_level==2) && (getuid()!=0)) {
2482 SUBDBG(
"/proc/sys/kernel/perf_event_paranoid prohibits kernel counts");
2490#if (OBSOLETE_WORKAROUNDS==1)
2515 fprintf(
stderr,
"warning, your processor is unsupported\n");
2521 if (bug_sync_read()) {
2522 component->
read = _pe_read_bug_sync;
2549#if (OBSOLETE_WORKAROUNDS==1)
2579#if (USE_PERFEVENT_RDPMC==1)
2606 "Error libpfm4 memory allocation",
2612 "Error libpfm4 no PMUs found",
2618 "Error libpfm4 no default PMU found",
2624 "Error libpfm4 too many default PMUs found",
2630 "Error loading preset events",
2636 "Unknown libpfm4 related error",
2650 SUBDBG(
"The Linux nmi_watchdog is using one of the performance "
2651 "counters, reducing the total number available.\n");
2672 .
name =
"perf_event",
2673 .short_name =
"perf",
2675 .description =
"Linux perf_event CPU counters",
2683 .kernel_profile = 1,
2686 .fast_virtual_timer = 0,
2688 .attach_must_ptrace = 1,
2693 .kernel_multiplex = 1,
2703 .reg_value =
sizeof (
int ),
2704 .reg_alloc =
sizeof (
int ),
#define GET_OVERFLOW_ADDRESS(ctx)
PAPI_os_info_t _papi_os_info
static int set_default_domain(EventSetInfo_t *zero, int domain)
ssize_t read(int fd, void *buf, size_t count)
Initialize the libpfm4 code.
Shutdown any initialization done by the libpfm4 code.
Initialize the libpfm4 code.
Take an event code and convert it to a description.
Take an event code and convert it to a name.
Walk through all events in a pre-defined order.
Take an event name and convert it to an event code.
Shutdown any initialization done by the libpfm4 code.
struct papi_vectors * _papi_hwd[]
static pid_t mygettid(void)
#define PAPI_INSTR_ADDRESS
#define PAPI_PROFIL_INST_EAR
#define PAPI_VENDOR_ARM_ARM
#define PAPI_DOM_SUPERVISOR
#define PAPI_VENDOR_INTEL
#define PAPI_OVERFLOW_FORCE_SW
#define PAPI_DATA_ADDRESS
#define PAPI_OVERFLOW_HARDWARE
#define PAPI_PROFIL_FORCE_SW
#define PAPI_PROFIL_RANDOM
#define PAPI_PROFIL_DATA_EAR
#define PAPI_DEF_ITIMER_NS
char events[MAX_EVENTS][BUFSIZ]
int _linux_detect_nmi_watchdog()
#define LINUX_VERSION(a, b, c)
#define PAPI_NATIVE_AND_MASK
Return codes and api definitions.
#define SUBDBG(format, args...)
int fclose(FILE *__stream)
void PAPIERROR(char *format,...)
int _papi_hwi_get_ntv_idx(unsigned int papi_evt_code)
int _pe_libpfm4_ntv_code_to_info(unsigned int EventCode, PAPI_event_info_t *info, struct native_event_table_t *event_table)
static int close_pe_events(pe_context_t *ctx, pe_control_t *ctl)
static int _pe_rdpmc_read(hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int _pe_init_thread(hwd_context_t *hwd_ctx)
static int _pe_shutdown_thread(hwd_context_t *ctx)
static int _pe_set_profile(EventSetInfo_t *ESI, int EventIndex, int threshold)
static int _pe_set_domain(hwd_control_state_t *ctl, int domain)
static int _pe_detect_rdpmc(void)
void check_exclude_guest(void)
static int _pe_set_overflow(EventSetInfo_t *ESI, int EventIndex, int threshold)
papi_vector_t _perf_event_vector
static int _pe_shutdown_component(void)
static int configure_fd_for_sampling(pe_control_t *ctl, int evt_idx)
static int _pe_ctl(hwd_context_t *ctx, int code, _papi_int_option_t *option)
static void arm64_request_user_access(struct perf_event_attr *hw_event)
static int process_smpl_buf(int evt_idx, ThreadInfo_t **thr, int cidx)
#define PERF_EVENTS_OPENED
static int bug_format_group(void)
static int _pe_init_component(int cidx)
static int _pe_handle_paranoid(papi_vector_t *component)
static int _pe_read(hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int _pe_ntv_code_to_info(unsigned int EventCode, PAPI_event_info_t *info)
static int _pe_read_nogroup(pe_control_t *pe_ctl)
static int _pe_start(hwd_context_t *ctx, hwd_control_state_t *ctl)
struct native_event_table_t perf_native_event_table
static int _pe_reset(hwd_context_t *ctx, hwd_control_state_t *ctl)
static int fcntl_setown_fd(int fd)
static int check_permissions(unsigned long tid, unsigned int cpu_num, unsigned int domain, unsigned int granularity, unsigned int multiplex, unsigned int inherit)
static int _pe_stop(hwd_context_t *ctx, hwd_control_state_t *ctl)
static int _pe_stop_profiling(ThreadInfo_t *thread, EventSetInfo_t *ESI)
static void _pe_dispatch_timer(int n, hwd_siginfo_t *info, void *uc)
static int _pe_read_multiplexed(pe_control_t *pe_ctl)
static void perf_event_dump_attr(struct perf_event_attr *hw_event, pid_t pid, int cpu, int group_fd, unsigned long int flags)
static int _pe_ntv_name_to_code(const char *name, unsigned int *event_code)
static int check_scheduability(pe_context_t *ctx, pe_control_t *ctl, int idx)
static int map_perf_event_errors_to_papi(int perf_event_error)
static int close_event(pe_event_info_t *event)
static int _pe_ntv_enum_events(unsigned int *PapiEventCode, int modifier)
static int _pe_update_control_state(hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int pe_vendor_fixups(papi_vector_t *vector)
static int open_pe_events(pe_context_t *ctx, pe_control_t *ctl)
static int _pe_init_control_state(hwd_control_state_t *ctl)
static int exclude_guest_unsupported
static int _pe_ntv_code_to_descr(unsigned int EventCode, char *ntv_descr, int len)
static unsigned int get_read_format(unsigned int multiplex, unsigned int inherit, int format_group)
#define PAPI_REFRESH_VALUE
static int set_up_mmap(pe_control_t *ctl, int evt_idx)
#define PERF_EVENTS_RUNNING
static int _pe_ntv_code_to_name(unsigned int EventCode, char *ntv_name, int len)
static int _pe_write(hwd_context_t *ctx, hwd_control_state_t *ctl, long long *from)
static int find_profile_index(EventSetInfo_t *ESI, int evt_idx, int *flags, unsigned int *native_index, int *profile_index)
#define HANDLE_STRING_ERROR
#define PERF_EVENT_MAX_MPX_COUNTERS
static uint64_t mmap_read_head(pe_event_info_t *pe)
static long sys_perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu, int group_fd, unsigned long flags)
static unsigned long long mmap_read_reset_count(void *addr __attribute__((unused)))
static void mmap_write_tail(pe_event_info_t *pe, uint64_t tail)
static unsigned long long mmap_read_self(void *addr __attribute__((unused)), int user_reset_flag __attribute__((unused)), unsigned long long reset __attribute__((unused)), unsigned long long *en __attribute__((unused)), unsigned long long *ru __attribute__((unused)))
static void mmap_read(int cidx, ThreadInfo_t **thr, pe_event_info_t *pe, int profile_index)
papi_mdi_t _papi_hwi_system_info
static int set_irange(hwd_context_t *ctx, hwd_control_state_t *current_state, _papi_int_option_t *option)
static int set_drange(hwd_context_t *ctx, hwd_control_state_t *current_state, _papi_int_option_t *option)
static const pme_power_entry_t * pe
int pos[PAPI_EVENTS_IN_DERIVED_EVENT]
EventSetProfileInfo_t profile
struct _ThreadInfo * master
EventInfo_t * EventInfoArray
hwd_control_state_t * ctl_state
NativeInfo_t * NativeInfoArray
EventSetOverflowInfo_t overflow
unsigned int fast_counter_read
unsigned int kernel_multiplex
char name[PAPI_MAX_STR_LEN]
char disabled_reason[PAPI_HUGE_STR_LEN]
unsigned int fast_real_timer
char model_string[PAPI_MAX_STR_LEN]
hwd_ucontext_t * ucontext
struct native_event_t * native_events
PAPI_component_info_t cmp_info
int(* read)(hwd_context_t *, hwd_control_state_t *, long long **, int)
struct native_event_table_t * event_table
long long reset_counts[PERF_EVENT_MAX_MPX_COUNTERS]
unsigned int overflow_signal
long long counts[PERF_EVENT_MAX_MPX_COUNTERS]
pe_event_info_t events[PERF_EVENT_MAX_MPX_COUNTERS]
struct perf_event_attr attr
#define PAPI_MAX_SW_MPX_EVENTS
inline_static ThreadInfo_t * _papi_hwi_lookup_thread(int custom_tid)
_papi_int_domain_t domain
_papi_int_multiplex_t multiplex
_papi_int_granularity_t granularity
_papi_int_attach_t attach
_papi_int_inherit_t inherit
_papi_int_addr_range_t address_range