为此,我使用了提供的溢出信号行为
perf_event_open.

我正在使用manpage建议实现溢出信号的第二种方式：

Signal overflow

Events can be set to deliver a signal when a threshold
is crossed. The signal handler is set up using the poll(2),select(2),
epoll(2) and fcntl(2),system calls.

[…]

The other way is by use of the PERF_EVENT_IOC_REFRESH ioctl. This
ioctl adds to a counter that decrements each time the event overflows.
When nonzero,a POLL_IN signal is sent on overflow,but once the value
reaches 0,a signal is sent of type POLL_HUP and the underlying event
is disabled.

PERF_EVENT_IOC_REFRESH ioctl的进一步说明：

PERF_EVENT_IOC_REFRESH

Non-inherited overflow counters can use this to enable a
counter for a number of overflows specified by the argument,
after which it is disabled. Subsequent calls of this ioctl
add the argument value to the current count. A signal with
POLL_IN set will happen on each overflow until the count
reaches 0; when that happens a signal with POLL_HUP set is
sent and the event is disabled. Using an argument of 0 is
considered undefined behavior.

一个非常小的例子看起来像这样：

#define _GNU_SOURCE 1
 
#include <asm/unistd.h>
#include <fcntl.h>
#include <linux/perf_event.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
long perf_event_open(struct perf_event_attr* event_attr,pid_t pid,int cpu,int group_fd,unsigned long flags)
{
    return syscall(__NR_perf_event_open,event_attr,pid,cpu,group_fd,flags);
}
 
static void perf_event_handler(int signum,siginfo_t* info,void* ucontext) {
    if(info->si_code != POLL_HUP) {
        // Only POLL_HUP should happen.
        exit(EXIT_FAILURE);
    }
 
    ioctl(info->si_fd,PERF_EVENT_IOC_REFRESH,1);
}
 
int main(int argc,char** argv)
{
    // Configure signal handler
    struct sigaction sa;
    memset(&sa,sizeof(struct sigaction));
    sa.sa_sigaction = perf_event_handler;
    sa.sa_flags = SA_SIGINFO;
 
    // Setup signal handler
    if (sigaction(SIGIO,&sa,NULL) < 0) {
        fprintf(stderr,"Error setting up signal handler\n");
        perror("sigaction");
        exit(EXIT_FAILURE);
    }
 
    // Configure perf_event_attr struct
    struct perf_event_attr pe;
    memset(&pe,sizeof(struct perf_event_attr));
    pe.type = PERF_TYPE_HARDWARE;
    pe.size = sizeof(struct perf_event_attr);
    pe.config = PERF_COUNT_HW_INSTRUCTIONS;     // Count retired hardware instructions
    pe.disabled = 1;        // Event is initially disabled
    pe.sample_type = PERF_SAMPLE_IP;
    pe.sample_period = 1000;
    pe.exclude_kernel = 1;      // excluding events that happen in the kernel-space
    pe.exclude_hv = 1;          // excluding events that happen in the hypervisor
 
    pid_t pid = 0;  // measure the current process/thread
    int cpu = -1;   // measure on any cpu
    int group_fd = -1;
    unsigned long flags = 0;
 
    int fd = perf_event_open(&pe,flags);
    if (fd == -1) {
        fprintf(stderr,"Error opening leader %llx\n",pe.config);
        perror("perf_event_open");
        exit(EXIT_FAILURE);
    }
 
    // Setup event handler for overflow signals
    fcntl(fd,F_SETFL,O_NONBLOCK|O_ASYNC);
    fcntl(fd,F_SETSIG,SIGIO);
    fcntl(fd,F_SETOWN,getpid());
 
    ioctl(fd,PERF_EVENT_IOC_RESET,0);     // Reset event counter to 0
    ioctl(fd,1);   // 
 
// Start monitoring
 
    long loopCount = 1000000;
    long c = 0;
    long i = 0;
 
    // Some sample payload.
    for(i = 0; i < loopCount; i++) {
        c += 1;
    }
 
// End monitoring
 
    ioctl(fd,PERF_EVENT_IOC_DISABLE,0);   // Disable event
 
    long long counter;
    read(fd,&counter,sizeof(long long));  // Read event counter value
 
    printf("Used %lld instructions\n",counter);
 
    close(fd);
}

所以基本上我正在做以下事情：

>为SIGIO信号设置信号处理程序
>使用perf_event_open创建一个新的性能计数器(返回文件描述符)
>使用fcntl将信号发送行为添加到文件描述符.
>运行有效负载循环以执行许多指令.

执行有效负载循环时,在某些时候将执行1000条指令(sample_interval).根据perf_event_open manpage,这会触发溢出,然后递减内部计数器.
一旦该计数器达到零,“发送一个类型为POLL_HUP的信号,并且基础事件被禁用.”

当发送信号时,停止当前进程/线程的控制流程,并执行信号处理程序.场景：

>已执行1000条指令.
>事件自动禁用,并发送信号.
>立即传递信号,停止控制流程并执行信号处理程序.

这种情况意味着两件事：

>计数指令的最终数量总是等于根本不使用信号的示例.
>为信号处理程序保存的指令指针(可通过ucontext访问)将直接指向导致溢出的指令.

基本上你可以说,信号行为可以看作是同步的.

这是我想要实现的完美语义.

但是,就我而言,我配置的信号通常是异步的,并且可能会经过一段时间,直到它最终被传递并执行信号处理程序.这可能对我造成问题.

例如,请考虑以下情形：

>已执行1000条指令.
>事件自动禁用,并发送信号.
>更多指令通过
>传递信号,停止控制流程并执行信号处理程序.

这种情况意味着两件事：

>计算指令的最终数量将小于根本不使用信号的示例.
>为信号处理程序保存的指令指针将指向导致溢出的指令或其后的任何指令.

到目前为止,我已经对上面的示例进行了大量测试,并且没有遇到支持第一个场景的错过指令.

但是,我真的很想知道,我是否可以依赖这个假设.
内核会发生什么？