/*
* self_count.c - example of a simple self monitoring using mmapped page
*
* Copyright (c) 2009 Google, Inc
* Contributed by Stephane Eranian <eranian@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of libpfm, a performance monitoring support library for
* applications on Linux.
*/
#include <sys/types.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <err.h>
#include "perf_util.h"
static const char *gen_events[]={
"cycles",
NULL
};
static volatile int quit;
void sig_handler(int n)
{
quit = 1;
}
#if defined(__x86_64__) || defined(__i386__)
#ifdef __x86_64__
#define DECLARE_ARGS(val, low, high) unsigned low, high
#define EAX_EDX_VAL(val, low, high) ((low) | ((uint64_t )(high) << 32))
#define EAX_EDX_ARGS(val, low, high) "a" (low), "d" (high)
#define EAX_EDX_RET(val, low, high) "=a" (low), "=d" (high)
#else
#define DECLARE_ARGS(val, low, high) unsigned long long val
#define EAX_EDX_VAL(val, low, high) (val)
#define EAX_EDX_ARGS(val, low, high) "A" (val)
#define EAX_EDX_RET(val, low, high) "=A" (val)
#endif
#define barrier() __asm__ __volatile__("": : :"memory")
static inline int rdpmc(struct perf_event_mmap_page *hdr, uint64_t *value)
{
int counter = hdr->index - 1;
DECLARE_ARGS(val, low, high);
if (counter < 0)
return -1;
asm volatile("rdpmc" : EAX_EDX_RET(val, low, high) : "c" (counter));
*value = EAX_EDX_VAL(val, low, high);
return 0;
}
#else
/*
* Default barrier macro.
* Given this is architecture specific, it must be defined when
* libpfm is ported to new architecture. The default macro below
* simply does nothing.
*/
#define barrier() {}
/*
* Default function to read counter directly from user level mode.
* Given this is architecture specific, it must be defined when
* libpfm is ported to new architecture. The default routine below
* simply fails and the caller falls backs to syscall.
*/
static inline int rdpmc(struct perf_event_mmap_page *hdr, uint64_t *value)
{
int counter = hdr->index - 1;
if (counter < 0)
return -1;
printf("your architecture does not have a way to read counters from user mode\n");
return -1;
}
#endif
/*
* our test code (function cannot be made static otherwise it is optimized away)
*/
unsigned long
fib(unsigned long n)
{
if (n == 0)
return 0;
if (n == 1)
return 2;
return fib(n-1)+fib(n-2);
}
uint64_t
read_count(perf_event_desc_t *fds)
{
struct perf_event_mmap_page *hdr;
uint64_t values[3];
uint64_t count = 0;
uint32_t width;
unsigned int seq;
ssize_t ret;
int idx = -1;
hdr = fds->buf;
width = hdr->pmc_width;
do {
seq = hdr->lock;
barrier();
/* try reading directly from user mode */
if (!rdpmc(hdr, &values[0])) {
values[1] = hdr->time_enabled;
values[2] = hdr->time_running;
ret = 0;
} else {
idx = -1;
ret = read(fds->fd, values, sizeof(values));
if (ret < (ssize_t)sizeof(values))
errx(1, "cannot read values");
printf("using read\n");
break;
}
barrier();
} while (hdr->lock != seq);
printf("raw=0x%"PRIx64 " width=%d ena=%"PRIu64 " run=%"PRIu64" idx=%d\n",
values[0],
width,
values[1],
values[2],
idx);
count = values[0];
count <<= 64 - width;
count >>= 64 - width;
values[0] = count;
return perf_scale(values);
}
int
main(int argc, char **argv)
{
perf_event_desc_t *fds = NULL;
long lret;
size_t pgsz;
uint64_t val, prev_val;
int i, ret, num_fds = 0;
lret = sysconf(_SC_PAGESIZE);
if (lret < 0)
err(1, "cannot get page size");
pgsz = (size_t)lret;
/*
* Initialize pfm library (required before we can use it)
*/
ret = pfm_initialize();
if (ret != PFM_SUCCESS)
errx(1, "Cannot initialize library: %s", pfm_strerror(ret));
ret = perf_setup_argv_events(argc > 1 ? (const char **)argv+1 : gen_events, &fds, &num_fds);
if (ret || !num_fds)
errx(1, "cannot setup events");
fds[0].fd = -1;
for(i=0; i < num_fds; i++) {
/* request timing information necesaary for scaling */
fds[i].hw.read_format = PERF_FORMAT_SCALE;
fds[i].hw.disabled = 0;
//fds[i].fd = perf_event_open(&fds[i].hw, 0, -1, fds[0].fd, 0);
fds[i].fd = perf_event_open(&fds[i].hw, 0, -1, -1, 0);
if (fds[i].fd == -1)
err(1, "cannot open event %d", i);
fds[i].buf = mmap(NULL, pgsz, PROT_READ, MAP_SHARED, fds[i].fd, 0);
if (fds[i].buf == MAP_FAILED)
err(1, "cannot mmap page");
}
signal(SIGALRM, sig_handler);
/*
* enable all counters attached to this thread
*/
ioctl(fds[0].fd, PERF_EVENT_IOC_ENABLE, 0);
alarm(10);
prev_val = 0;
for(;quit == 0;) {
for (i = 0; i < num_fds; i++) {
val = read_count(&fds[i]);
/* print evnet deltas */
printf("%20"PRIu64" %s\n", val - prev_val, fds[i].name);
prev_val = val;
}
fib(35);
}
/*
* disable all counters attached to this thread
*/
ioctl(fds[0].fd, PERF_EVENT_IOC_DISABLE, 0);
for (i=0; i < num_fds; i++) {
munmap(fds[i].buf, pgsz);
close(fds[i].fd);
}
perf_free_fds(fds, num_fds);
/* free libpfm resources cleanly */
pfm_terminate();
return 0;
}