Is there some mechanism for "sampling" tables at a periodic rate?

[pontaoski]

usecase: writing BPF programs that track how many of an event happens per second over time

I started down this path (code incomplete as i realised that this probably isn't the best way partway through):

#include <uapi/linux/ptrace.h>
#include <linux/sched.h>

BPF_HASH(counts, u32);
BPF_ARRAY_OF_MAPS(last_ten_counts, "counts", 10);

BPF_ARRAY(probing_start_time, u64, 1);
BPF_ARRAY(current_count, u64, 1);

static int count_wakeup(struct bpf_raw_tracepoint_args *ctx, struct task_struct *process) {
    int key = 0;
    u64* pst = probing_start_time.lookup(&key);
    u64* cc = current_count.lookup(&key);
    if (pst == 0 || cc == 0) {
        return 0;
    }
    if (process->flags & PF_KTHREAD) {
        return 0;
    }
    u32 taskID = process->tgid;
    counts.atomic_increment(taskID);
    u64 now = bpf_ktime_get_ns();
    if (*pst == -1) {
        *pst = now;
    } else {
        if ((now - *pst) >= 1000000000) {
            *pst = now;

            // copy counts to last_ten_counts[*cc]

            *cc++;
            if (cc >= 10) {
                *cc = 0;
            }
        }
    }
    return 0;
}

RAW_TRACEPOINT_PROBE(sched_wakeup)
{
    struct task_struct *p = (struct task_struct *)ctx->args[0];
    return count_wakeup(ctx, p);
}

but then realised that this Seems rather unwieldy for what is seemingly a pretty basic profiling thing

is there some obvious solution i'm missing to track "rates" of stuff over time?