示例程序2
在上一篇《Linux perf子系统的使用（一）——计数》已经讲解了如何使用perf_event_open、read和ioctl对perf子系统进行编程。但有时我们并不需要计数，而是要采样。比如这么一个需求：统计一个程序中哪些函数最耗时间。嗯，这个功能确实可以通过perf record命令来做，但是perf record内部又是如何做到的呢？自己实现又是怎样的呢？perf record是基于统计学原理的。假设以1000Hz的频率对某个进程采样，每次采样记录下该进程的IP寄存器的值（也就是下一条指令的地址）。通过分析该进程的可执行文件，是可以得知每次采样的IP值处于哪个函数内部。OK，那么我们相当于以1000Hz的频率获知进程当前所执行的函数。如果某个函数f()占用了30%的时间，那么所有采样中，该函数出现的频率也应该将近30%，只要采样数量足够多。这正是perf record的原理。所以，perf的采样模式很有用~
但是，采样比较复杂，主要表现在三点：1、采样需要设置触发源，也就是告诉kernel何时进行一次采样；2、采样需要设置信号，也就是告诉kernnel，采样完成后通知谁；3、采样值的读取需要使用mmap，因为采样有异步性，需要一个环形队列，另外也是出于性能的考虑。
直接上代码吧，对照着官方手册看，学习效率最高：
采集单个值
perf.c
//如果不加，则F_SETSIG未定义
#define _GNU_SOURCE 1
#include <stdio.h>
#include <fcntl.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <linux/perf_event.h>
//环形缓冲区大小，16页，即16*4kB
#define RING_BUFFER_PAGES 16
//目前perf_event_open在glibc中没有封装，需要手工封装一下
int perf_event_open(struct perf_event_attr *attr,pid_t pid,int cpu,int group_fd,unsigned long flags)
{
return syscall(__NR_perf_event_open,attr,pid,cpu,group_fd,flags);
}
//mmap共享内存的开始地址
void* rbuf;
//环形队列中每一项元素
struct perf_my_sample
{
struct perf_event_header header;
uint64_t ip;
};
//下一条采样记录的相对于环形缓冲区开头的偏移量
uint64_t next_offset=0;
//采样完成后的信号处理函数
void sample_handler(int sig_num,siginfo_t *sig_info,void *context)
{
//计算出最新的采样所在的位置（相对于rbuf的偏移量）
uint64_t offset=4096+next_offset;
//指向最新的采样
struct perf_my_sample* sample=(void*)((uint8_t*)rbuf+offset);
//过滤一下记录
if(sample->header.type==PERF_RECORD_SAMPLE)
{
//得到IP值
printf("%lx\n",sample->ip);
}
//共享内存开头是一个struct perf_event_mmap_page，提供环形缓冲区的信息
struct perf_event_mmap_page* rinfo=rbuf;
//手工wrap一下data_head值，得到下一个记录的偏移量
next_offset=rinfo->data_head%(RING_BUFFER_PAGES*4096);
}
//模拟的一个负载
void workload()
{
int i,c=0;
for(i=0;i<100000000;i++)
{
c+=i*i;
c-=i*100;
c+=i*i*i/100;
}
}
int main()
{
struct perf_event_attr attr;
memset(&attr,0,sizeof(struct perf_event_attr));
attr.size=sizeof(struct perf_event_attr);
//触发源为CPU时钟
attr.type=PERF_TYPE_SOFTWARE;
attr.config=PERF_COUNT_SW_CPU_CLOCK;
//每100000个CPU时钟采样一次
attr.sample_period=100000;
//采样目标是IP
attr.sample_type=PERF_SAMPLE_IP;
//初始化为禁用
attr.disabled=1;
int fd=perf_event_open(&attr,0,-1,-1,0);
if(fd<0)
{
perror("Cannot open perf fd!");
return 1;
}
//创建1+16页共享内存，应用程序只读，读取fd产生的内容
rbuf=mmap(0,(1+RING_BUFFER_PAGES)*4096,PROT_READ,MAP_SHARED,fd,0);
if(rbuf<0)
{
perror("Cannot mmap!");
return 1;
}
//这三个fcntl为何一定这么设置不明，但必须这样
fcntl(fd,F_SETFL,O_RDWR|O_NONBLOCK|O_ASYNC);
fcntl(fd,F_SETSIG,SIGIO);
fcntl(fd,F_SETOWN,getpid());
//开始设置采样完成后的信号通知
struct sigaction sig;
memset(&sig,0,sizeof(struct sigaction));
//由sample_handler来处理采样完成事件
sig.sa_sigaction=sample_handler;
//要带上siginfo_t参数（因为perf子系统会传入参数，包括fd）
sig.sa_flags=SA_SIGINFO;
if(sigaction(SIGIO,&sig,0)<0)
{
perror("Cannot sigaction");
return 1;
}
//开始监测
ioctl(fd,PERF_EVENT_IOC_RESET,0);
ioctl(fd,PERF_EVENT_IOC_ENABLE,0);
workload();
//停止监测
ioctl(fd,PERF_EVENT_IOC_DISABLE,0);
munmap(rbuf,(1+RING_BUFFER_PAGES)*4096);
close(fd);
return 0;
}
可以看到一下子比计数模式复杂多了。采样模式是要基于计数模式的——选择一个“参考计数器”，并设置一个阈值，每当这个“参考计数器”达到阈值时，触发一次采样。每次采样，kernel会把值放入队列的末尾。如何得知kernenl完成了一次最新的采样了呢？一种方法就是定时轮询，另一种就是响应信号。
如何读取mmap共享内存中的值呢？首先，共享内存开头是一个struct perf_event_mmap_page，提供环形缓冲区的信息，对我们最重要的字段就是data_head，官方手册的介绍是这样的：
注意，data_head一直递增，不回滚！！所以需要手动处理wrap。另外一个需要注意的地方是，每次事件响应中，得到的data_head是下一次采样的队列头部，所以需要自己保存一个副本next_offset，以供下次使用。
这个struct perf_event_mmap_page独占共享内存的第一页。后面必须跟2n页，n自己决定。这2n页用来存放采样记录。每一条记录的结构体如下：
因为我只选择了采样IP，即PERF_SAMPLE_IP，所以这个结构体就退化为了：
struct perf_my_sample
{
struct perf_event_header header;
uint64_t ip;
};
另外一个需要注意的地方是mmap中的第三个参数，是PROT_READ，表示应用程序只读。如果设置为了PROT_READ|PROT_WRITE，那么读取的过程就不一样了：
这样相当于和kernel做一个同步操作，效率务必下降。而且由于SIGIO这个信号是不可靠信号，所以如果某次采样完成的通知没有被截获，那么就可能产生死锁。
gcc perf.c -o perf
sudo ./perf
运行上面的代码，产生如下输出：
为了验证采集到的IP值是否正确，可以反汇编一下：
objdump -d ./perf
可以看到采集到的IP值全部落在workload这个函数的地址范围内。
采集多个值
要采多个值的话，也很方便：
//如果不加，则F_SETSIG未定义
#define _GNU_SOURCE 1
#include <stdio.h>
#include <fcntl.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <linux/perf_event.h>
//环形缓冲区大小，16页，即16*4kB
#define RING_BUFFER_PAGES 2
//目前perf_event_open在glibc中没有封装，需要手工封装一下
int perf_event_open(struct perf_event_attr *attr,pid_t pid,int cpu,int group_fd,unsigned long flags)
{
return syscall(__NR_perf_event_open,attr,pid,cpu,group_fd,flags);
}
//mmap共享内存的开始地址
void* rbuf;
//环形队列中每一项元素
struct perf_my_sample
{
struct perf_event_header header;
uint64_t ip;
uint64_t nr;
uint64_t ips[0];
};
//下一条采样记录的相对于环形缓冲区开头的偏移量
uint64_t next_offset=0;
//采样完成后的信号处理函数
void sample_handler(int sig_num,siginfo_t *sig_info,void *context)
{
//计算出最新的采样所在的位置（相对于rbuf的偏移量）
uint64_t offset=4096+next_offset;
//指向最新的采样
struct perf_my_sample* sample=(void*)((uint8_t*)rbuf+offset);
//过滤一下记录
if(sample->header.type==PERF_RECORD_SAMPLE)
{
//得到IP值
printf("IP: %lx\n",sample->ip);
if(sample->nr<1024)
{
//得到调用链长度
printf("Call Depth: %lu\n",sample->nr);
//遍历调用链
int i;
for(i=0;i<sample->nr;i++)
printf(" %lx\n",sample->ips[i]);
}
}
//共享内存开头是一个struct perf_event_mmap_page，提供环形缓冲区的信息
struct perf_event_mmap_page* rinfo=rbuf;
//手工wrap一下data_head值，得到下一个记录的偏移量
next_offset=rinfo->data_head%(RING_BUFFER_PAGES*4096);
}
//模拟的一个负载
void workload()
{
int i,c=0;
for(i=0;i<1000000000;i++)
{
c+=i*i;
c-=i*100;
c+=i*i*i/100;
}
}
int main()
{
struct perf_event_attr attr;
memset(&attr,0,sizeof(struct perf_event_attr));
attr.size=sizeof(struct perf_event_attr);
//触发源为CPU时钟
attr.type=PERF_TYPE_SOFTWARE;
attr.config=PERF_COUNT_SW_CPU_CLOCK;
//每100000个CPU时钟采样一次
attr.sample_period=100000;
//采样目标是IP
attr.sample_type=PERF_SAMPLE_IP|PERF_SAMPLE_CALLCHAIN;
//初始化为禁用
attr.disabled=1;
int fd=perf_event_open(&attr,0,-1,-1,0);
if(fd<0)
{
perror("Cannot open perf fd!");
return 1;
}
//创建1+16页共享内存，应用程序只读，读取fd产生的内容
rbuf=mmap(0,(1+RING_BUFFER_PAGES)*4096,PROT_READ,MAP_SHARED,fd,0);
if(rbuf<0)
{
perror("Cannot mmap!");
return 1;
}
//这三个fcntl为何一定这么设置不明，但必须这样
fcntl(fd,F_SETFL,O_RDWR|O_NONBLOCK|O_ASYNC);
fcntl(fd,F_SETSIG,SIGIO);
fcntl(fd,F_SETOWN,getpid());
//开始设置采样完成后的信号通知
struct sigaction sig;
memset(&sig,0,sizeof(struct sigaction));
//由sample_handler来处理采样完成事件
sig.sa_sigaction=sample_handler;
//要带上siginfo_t参数（因为perf子系统会传入参数，包括fd）
sig.sa_flags=SA_SIGINFO;
if(sigaction(SIGIO,&sig,0)<0)
{
perror("Cannot sigaction");
return 1;
}
//开始监测
ioctl(fd,PERF_EVENT_IOC_RESET,0);
ioctl(fd,PERF_EVENT_IOC_ENABLE,0);
workload();
//停止监测
ioctl(fd,PERF_EVENT_IOC_DISABLE,0);
munmap(rbuf,(1+RING_BUFFER_PAGES)*4096);
close(fd);
return 0;
}
示例程序2
在上一篇《Linux perf子系统的使用（二）——采样（signal方式）》中，我使用了信号来接收采样完成通知，并在回调函数中读取最新的采样值。虽说回调方式有很多优点，但是并不是太通用。更加糟糕的是，信号会打断几乎所有的系统调用，使得本来的程序逻辑被破坏。另一个很糟糕的点是，如果一个进程中需要开多个采样器，那么就要共享同一个事件回调函数，破坏了封装性。
因此，最好有一个阻塞式轮询的办法。嗯，这就是今天要讲的东西——通过poll()函数等待采样完成。
其实poll()轮询的实现比信号的方式简单，只要把perf_event_open()返回的文件描述符当做普通的文件描述符传入poll()就可以了。在创建perf文件描述附时，唯一需要注意的就是需要手动设置wakeup_events的值。wakeup_events决定了多少次采样以后进行一次通知（poll模式下就是让poll返回），一般设置为1。
直接上代码吧，和《Linux perf子系统的使用（二）——采样（signal方式）》中的代码比较一下就一目了然了。
perf_poll.cpp
#include <poll.h>
#include <errno.h>
#include <stdio.h>
#include <stdint.h>
#include <assert.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <linux/perf_event.h>
// the number of pages to hold ring buffer
#define RING_BUFFER_PAGES 8
// a wrapper for perf_event_open()
static int perf_event_open(struct perf_event_attr *attr,
pid_t pid,int cpu,int group_fd,unsigned long flags)
{
return syscall(__NR_perf_event_open,attr,pid,cpu,group_fd,flags);
}
static bool sg_running=true;
// to receive SIGINT to stop sampling and exit
static void on_closing(int signum)
{
sg_running=false;
}
int main()
{
// 这里我强行指定了一个值
pid_t pid=6268;
// create a perf fd
struct perf_event_attr attr;
memset(&attr,0,sizeof(struct perf_event_attr));
attr.size=sizeof(struct perf_event_attr);
// disable at init time
attr.disabled=1;
// set what is the event
attr.type=PERF_TYPE_SOFTWARE;
attr.config=PERF_COUNT_SW_CPU_CLOCK;
// how many clocks to trigger sampling
attr.sample_period=1000000;
// what to sample is IP
attr.sample_type=PERF_SAMPLE_IP;
// notify every 1 overflow
attr.wakeup_events=1;
// open perf fd
int perf_fd=perf_event_open(&attr,pid,-1,-1,0);
if(perf_fd<0)
{
perror("perf_event_open() failed!");
return errno;
}
// create a shared memory to read samples from kernel
void* shared_mem=mmap(0,(1+RING_BUFFER_PAGES)*4096,PROT_READ,MAP_SHARED,perf_fd,0);
if(shared_mem==0)
{
perror("mmap() failed!");
return errno;
}
// reset and enable
ioctl(perf_fd,PERF_EVENT_IOC_RESET,0);
ioctl(perf_fd,PERF_EVENT_IOC_ENABLE,0);
// the offset from the head of ring-buffer where the next sample is
uint64_t next_offset=0;
// poll perf_fd
struct pollfd perf_poll;
perf_poll.fd=perf_fd;
perf_poll.events=POLLIN;
signal(SIGINT,on_closing);
while(sg_running)
{
if(poll(&perf_poll,1,-1)<0)
{
perror("poll() failed!");
break;
}
// the pointer to the completed sample
struct sample
{
struct perf_event_header header;
uint64_t ip;
}*
sample=(struct sample*)((uint8_t*)shared_mem+4096+next_offset);
// the pointer to the info structure of ring-buffer
struct perf_event_mmap_page* info=(struct perf_event_mmap_page*)shared_mem;
// update the offset, wrap the offset
next_offset=info->data_head%(RING_BUFFER_PAGES*4096);
// allow only the PERF_RECORD_SAMPLE
if(sample->header.type!=PERF_RECORD_SAMPLE)
continue;
printf("%lx\n",sample->ip);
}
printf("clean up\n");
// disable
ioctl(perf_fd,PERF_EVENT_IOC_DISABLE,0);
// unmap shared memory
munmap(shared_mem,(1+RING_BUFFER_PAGES)*4096);
// close perf fd
close(perf_fd);
return 0;
}
可以看到除了获取通知的部分由signal改为poll()以外，几乎没有改动。
g++ perf_poll.cpp -o perf_poll
sudo ./perf_poll
==2017年7月28日补充
首先，为了方便以后的使用，我把perf采样callchain的功能封装成了一个C++的类，它能够针对一个特定的pid进行采样，支持带有超时的轮询。接口声明如下：
CallChainSampler.h
#ifndef CALLCHAINSAMPLER_H
#define CALLCHAINSAMPLER_H
#include <stdint.h>
#include <unistd.h>
// a class to sample the callchain of a process
class CallChainSampler
{
public:
// the structure of a sampled callchain
struct callchain
{
// the timestamp when sampling
uint64_t time;
// the pid and tid
uint32_t pid,tid;
// the depth of callchain, or called the length
uint64_t depth;
// <depth>-array, each items is an IP register value
const uint64_t* ips;
};
// constructor
// pid: the process's id
// period: how many clocks to trigger a sample
// pages: how many pages (4K) allocated for the ring-buffer to hold samples
CallChainSampler(pid_t pid,uint64_t period,uint32_t pages);
// destructor
~CallChainSampler();
// start sampling
void start();
// stop sampling
void stop();
// wait and get the next sample
// timeout: the max milliseconds that will block
// max_depth: the max depth of the call chain
// callchain: the sampled callchain to be outputed
// return: if get before timeout, return 0,
// if timeout, return -1
// if an error occurs, return errno
// ATTENTION: the field [ips] in callchain should be used immediately,
// don't hold it for too long time
int sample(int32_t timeout,uint64_t max_depth,struct callchain* callchain);
private:
// the perf file descriptor
int fd;
// the mmap area
void* mem;
// how many pages to hold the ring-buffer
uint32_t pages;
// the offset in the ring-buffer where the next sample is
uint64_t offset;
};
#endif
实现基本就是把上面的C代码封装一下：
CallChainSampler.cpp
#include "CallChainSampler.h"
#include <poll.h>
#include <errno.h>
#include <assert.h>
#include <string.h>
#include <stdexcept>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <linux/perf_event.h>
// a wrapper for perf_event_open()
static int perf_event_open(struct perf_event_attr *attr,
pid_t pid,int cpu,int group_fd,unsigned long flags)
{
return syscall(__NR_perf_event_open,attr,pid,cpu,group_fd,flags);
}
// a tool function to get the time in ms
static uint64_t get_milliseconds()
{
struct timeval now;
assert(gettimeofday(&now,0)==0);
return now.tv_sec*1000+now.tv_usec/1000;
}
#define min(a,b) ((a)<(b)?(a):(b))
CallChainSampler::CallChainSampler(pid_t pid,uint64_t period,uint32_t pages)
{
// create a perf fd
struct perf_event_attr attr;
memset(&attr,0,sizeof(struct perf_event_attr));
attr.size=sizeof(struct perf_event_attr);
// disable at init time
attr.disabled=1;
// set what is the event
attr.type=PERF_TYPE_SOFTWARE;
attr.config=PERF_COUNT_SW_CPU_CLOCK;
// how many clocks to trigger sampling
attr.sample_period=period;
// what to sample is IP
attr.sample_type=PERF_SAMPLE_TIME|PERF_SAMPLE_TID|PERF_SAMPLE_CALLCHAIN;
// notify every 1 overflow
attr.wakeup_events=1;
// open perf fd
fd=perf_event_open(&attr,pid,-1,-1,0);
if(fd<0)
throw std::runtime_error("perf_event_open() failed!");
// create a shared memory to read samples from kernel
mem=mmap(0,(1+pages)*4096,PROT_READ,MAP_SHARED,fd,0);
if(mem==0)
throw std::runtime_error("mmap() failed!");
this->pages=pages;
// the offset of next sample
offset=0;
}
CallChainSampler::~CallChainSampler()
{
stop();
// unmap shared memory
munmap(mem,(1+pages)*4096);
// close perf fd
close(fd);
}
void CallChainSampler::start()
{
// enable
ioctl(fd,PERF_EVENT_IOC_ENABLE,0);
}
void CallChainSampler::stop()
{
// disable
ioctl(fd,PERF_EVENT_IOC_DISABLE,0);
}
int CallChainSampler::sample(int32_t timeout,uint64_t max_depth,struct callchain* callchain)
{
if(callchain==0)
throw std::runtime_error("arg <callchain> is NULL!");
// the poll sturct
struct pollfd pfd;
pfd.fd=fd;
pfd.events=POLLIN;
// the time when start
uint64_t start=get_milliseconds();
while(1)
{
// the current time
uint64_t now=get_milliseconds();
// the milliseconds to wait
int32_t to_wait;
if(timeout<0)
to_wait=-1;
else
{
to_wait=timeout-(int32_t)(now-start);
if(to_wait<0)
return -1;
}
// wait next sample
int ret=poll(&pfd,1,to_wait);
if(ret==0)
return -1;
else if(ret==-1)
return errno;
// the pointer to the completed sample
struct sample
{
struct perf_event_header header;
uint32_t pid,tid;
uint64_t time;
uint64_t nr;
uint64_t ips[0];
}*
sample=(struct sample*)((uint8_t*)mem+4096+offset);
// the pointer to the info structure of ring-buffer
struct perf_event_mmap_page* info=(struct perf_event_mmap_page*)mem;
// update the offset, wrap the offset
offset=info->data_head%(pages*4096);
// allow only the PERF_RECORD_SAMPLE
if(sample->header.type!=PERF_RECORD_SAMPLE)
continue;
// fill the result
callchain->time=sample->time;
callchain->pid=sample->pid;
callchain->tid=sample->tid;
callchain->depth=min(max_depth,sample->nr);
callchain->ips=sample->ips;
return 0;
}
}
最后要补充一个我最新的发现！perf_event_open()里面传入的pid，本质上是一个线程id，也就是tid。它只能监控一个线程，而无法监控一个进程中的所有线程。所以要用到实际项目中，肯定得配合使用epoll来监控所有的线程。
测试代码如下：
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include "CallChainSampler.h"
CallChainSampler* sampler;
// to receive SIGINT to stop sampling and exit
static void on_closing(int signum)
{
delete sampler;
exit(0);
}
int main()
{
// create a sampler, pid=5281, 10000 clocks trigger a sample
// and allocate 128 pages to hold the ring-buffer
sampler=new CallChainSampler(5281,10000,128);
signal(SIGINT,on_closing);
sampler->start();
for(int i=0;i<10000;i++)
{
CallChainSampler::callchain callchain;
// sample, max depth of callchain is 256
int ret=sampler->sample(-1,256,&callchain);
printf("%d\n",ret);
if(ret==0)
{
// successful sample, print it out
printf("time=%lu\n",callchain.time);
printf("pid,tid=%d,%d\n",callchain.pid,callchain.tid);
printf("stack:\n");
for(int j=0;j<callchain.depth;j++)
printf("[%d] %lx\n",j,callchain.ips[j]);
}
}
return 0;
}
示例程序3
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <string.h>
#include <sys/ioctl.h>
#include <linux/perf_event.h>
#include <sys/mman.h>
#include <linux/hw_breakpoint.h>
#include <asm/unistd.h>
#include <errno.h>
#include <stdint.h>
#include <inttypes.h>
#ifndef MAP_FAILED
#define MAP_FAILED ((void *)-1)
#endif
struct perf_sample_event {
struct perf_event_header hdr;
uint64_t sample_id; // if PERF_SAMPLE_IDENTIFIER
uint64_t ip; // if PERF_SAMPLE_IP
uint32_t pid, tid; // if PERF_SAMPLE_TID
uint64_t time; // if PERF_SAMPLE_TIME
uint64_t addr; // if PERF_SAMPLE_ADDR
uint64_t id; // if PERF_SAMPLE_ID
uint64_t stream_id; // if PERF_SAMPLE_STREAM_ID
uint32_t cpu, res; // if PERF_SAMPLE_CPU
uint64_t period; // if PERF_SAMPLE_PERIOD
struct read_format *v; // if PERF_SAMPLE_READ
uint64_t nr; // if PERF_SAMPLE_CALLCHAIN
uint64_t *ips; // if PERF_SAMPLE_CALLCHAIN
uint32_t size_raw; // if PERF_SAMPLE_RAW
char *data_raw; // if PERF_SAMPLE_RAW
uint64_t bnr; // if PERF_SAMPLE_BRANCH_STACK
struct perf_branch_entry *lbr; // if PERF_SAMPLE_BRANCH_STACK
uint64_t abi; // if PERF_SAMPLE_REGS_USER
uint64_t *regs; // if PERF_SAMPLE_REGS_USER
uint64_t size_stack; // if PERF_SAMPLE_STACK_USER
char *data_stack; // if PERF_SAMPLE_STACK_USER
uint64_t dyn_size_stack; // if PERF_SAMPLE_STACK_USER
uint64_t weight; // if PERF_SAMPLE_WEIGHT
uint64_t data_src; // if PERF_SAMPLE_DATA_SRC
uint64_t transaction; // if PERF_SAMPLE_TRANSACTION
uint64_t abi_intr; // if PERF_SAMPLE_REGS_INTR
uint64_t *regs_intr; // if PERF_SAMPLE_REGS_INTR
};
int fib(int n) {
if (n == 0) {
return 0;
} else if (n == 1 || n == 2) {
return 1;
} else {
return fib(n-1) + fib(n-2);
}
}
void do_something() {
int i;
char* ptr;
ptr = malloc(100*1024*1024);
for (i = 0; i < 100*1024*1024; i++) {
ptr[i] = (char) (i & 0xff); // pagefault
}
free(ptr);
}
void insertion_sort(int *nums, size_t n) {
int i = 1;
while (i < n) {
int j = i;
while (j > 0 && nums[j-1] > nums[j]) {
int tmp = nums[j];
nums[j] = nums[j-1];
nums[j-1] = tmp;
j -= 1;
}
i += 1;
}
}
static void process_ring_buffer_events(struct perf_event_mmap_page *data, int page_size) {
struct perf_event_header *header = (uintptr_t) data + page_size + data->data_tail;
void *end = (uintptr_t) data + page_size + data->data_head;
while (header != end) {
if (header->type == PERF_RECORD_SAMPLE) {
struct perf_sample_event *event = (uintptr_t) header;
uint64_t ip = event->ip;
printf("PERF_RECORD_SAMPLE found with ip: %lld\n", ip);
uint64_t size_stack = event->size_stack;
char *data_stack = (uintptr_t) event->data_stack;
if (data_stack > 0) {
printf("PERF_RECORD_SAMPLE has size stack: %lld at location: %lld\n", size_stack, data_stack);
}
} else {
printf("other type %d found!", header->type);
}
header = (uintptr_t) header + header->size;
}
}
int main(int argc, char* argv[]) {
struct perf_event_attr pea;
int fd1, fd2;
uint64_t id1, id2;
uint64_t val1, val2;
char buf[4096];
const int NUM_MMAP_PAGES = (1U << 4) + 1;
// const int NUM_MMAP_PAGES = 17;
int i;
int some_nums[1000];
for (int i=0; i < 1000; i++) {
some_nums[i] = 1000-i;
}
memset(&pea, 0, sizeof(struct perf_event_attr));
pea.type = PERF_TYPE_SOFTWARE;
pea.size = sizeof(struct perf_event_attr);
pea.config = PERF_COUNT_SW_CPU_CLOCK;
pea.disabled = 1;
pea.exclude_kernel = 1;
pea.exclude_hv = 0;
pea.sample_period = 1;
pea.precise_ip = 3;
pea.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_STACK_USER;
// pea.sample_type = PERF_SAMPLE_IP;
pea.sample_stack_user = 10000;
fd1 = syscall(__NR_perf_event_open, &pea, 0, -1, -1, 0);
printf("size of perf_event_mmap_page struct is %d\n", sizeof(struct perf_event_mmap_page));
int page_size = (int) sysconf(_SC_PAGESIZE);
printf("page size in general is: %d\n", page_size);
// Map the ring buffer into memory
struct perf_event_mmap_page *pages = mmap(NULL, page_size * NUM_MMAP_PAGES, PROT_READ
| PROT_WRITE, MAP_SHARED, fd1, 0);
if (pages == MAP_FAILED) {
perror("Error mapping ring buffer");
return 1;
}
ioctl(fd1, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP);
ioctl(fd1, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP);
// do_something();
// fib(40);
size_t n = sizeof(some_nums)/sizeof(some_nums[0]);
insertion_sort(&some_nums, n);
ioctl(fd1, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP);
printf("head of perf ring buffer is at: %d", pages->data_head);
process_ring_buffer_events(pages, page_size);
munmap(pages, page_size * NUM_MMAP_PAGES);
return 0;
}