rperf 0.8.0 → 0.10.0

data/ext/rperf/rperf.c

@@ -25,8 +25,10 @@
 #ifdef __linux__
 #define RPERF_USE_TIMER_SIGNAL 1
 #define RPERF_TIMER_SIGNAL_DEFAULT (SIGRTMIN + 8)
+#define RPERF_COND_CLOCK CLOCK_MONOTONIC
 #else
 #define RPERF_USE_TIMER_SIGNAL 0
+#define RPERF_COND_CLOCK CLOCK_REALTIME  /* macOS lacks pthread_condattr_setclock */
 #endif
 
 #define RPERF_MAX_STACK_DEPTH 512
@@ -51,6 +53,11 @@ enum rperf_vm_state {
 /* ---- Data structures ---- */
 
 
+enum rperf_mode {
+    RPERF_MODE_CPU  = 0,
+    RPERF_MODE_WALL = 1,
+};
+
 enum rperf_gc_phase {
     RPERF_GC_NONE     = 0,
     RPERF_GC_MARKING  = 1,
@@ -73,7 +80,11 @@ typedef struct rperf_sample_buffer {
     size_t sample_count;
     size_t sample_capacity;
     VALUE *frame_pool;
-    size_t frame_pool_count;
+    /* _Atomic: read by GC dmark concurrently with the aggregator's clear.
+     * Seq-cst accesses pair with the frame_table count release-stores so
+     * dmark never observes the cleared pool together with a stale
+     * frame_table count (which would leave frames unmarked). */
+    _Atomic size_t frame_pool_count;
     size_t frame_pool_capacity;
 } rperf_sample_buffer_t;
 
@@ -83,7 +94,7 @@ typedef struct rperf_sample_buffer {
 
 typedef struct rperf_frame_table {
     _Atomic(VALUE *) keys;    /* unique VALUE array (GC mark target) */
-    size_t count;             /* = next frame_id */
+    _Atomic(size_t) count;    /* = next frame_id */
     size_t capacity;
     uint32_t *buckets;        /* open addressing: stores index into keys[] */
     size_t bucket_capacity;
@@ -95,8 +106,6 @@ typedef struct rperf_frame_table {
 
 /* ---- Aggregation table: stack → weight ---- */
 
-#define RPERF_AGG_ENTRY_EMPTY 0
-
 typedef struct rperf_agg_entry {
     uint32_t frame_start;     /* offset into stack_pool */
     int depth;
@@ -119,7 +128,6 @@ typedef struct rperf_agg_table {
 
 typedef struct rperf_thread_data {
     int64_t prev_time_ns;
-    int64_t prev_wall_ns;
     /* GVL event tracking */
     int64_t suspended_at_ns;        /* wall time at SUSPENDED */
     int64_t ready_at_ns;            /* wall time at READY */
@@ -139,15 +147,19 @@ typedef struct rperf_gc_state {
 /* ---- Sampling overhead stats ---- */
 
 typedef struct rperf_stats {
-    size_t trigger_count;
+    /* _Atomic: incremented by the signal handler / nanosleep worker, read and
+     * cleared by snapshot while running (atomic size_t is async-signal-safe
+     * when lock-free, which it is on all supported platforms). */
+    _Atomic size_t trigger_count;
     size_t sampling_count;
     int64_t sampling_total_ns;
     size_t dropped_samples;     /* samples lost due to allocation failure */
+    size_t dropped_aggregation; /* samples lost during aggregation (frame_table/agg_table full) */
 } rperf_stats_t;
 
 typedef struct rperf_profiler {
     int frequency;
-    int mode; /* 0 = cpu, 1 = wall */
+    enum rperf_mode mode;
     _Atomic int running;
     pthread_t worker_thread;     /* combined timer + aggregation */
 #if RPERF_USE_TIMER_SIGNAL
@@ -199,12 +211,17 @@ rperf_profiler_mark(void *ptr)
 {
     rperf_profiler_t *prof = (rperf_profiler_t *)ptr;
     int i;
-    /* Mark both sample buffers' frame_pools */
+    /* Mark both sample buffers' frame_pools.
+     * Load the count once: the aggregator may clear it concurrently, and the
+     * pools must be read BEFORE frame_table.count below — seeing the cleared
+     * count (seq-cst) guarantees the corresponding frame_table inserts are
+     * visible, so every frame is covered by at least one mark source. */
     for (i = 0; i < 2; i++) {
         rperf_sample_buffer_t *buf = &prof->buffers[i];
-        if (buf->frame_pool && buf->frame_pool_count > 0) {
+        size_t fp_count = buf->frame_pool_count;
+        if (buf->frame_pool && fp_count > 0) {
             rb_gc_mark_locations(buf->frame_pool,
-                                buf->frame_pool + buf->frame_pool_count);
+                                buf->frame_pool + fp_count);
         }
     }
     /* Mark label_sets array */
@@ -217,7 +234,7 @@ rperf_profiler_mark(void *ptr)
      * If we see an old count, both old and new keys arrays have valid
      * data (old keys are kept alive in old_keys[]). */
     {
-        size_t ft_count = __atomic_load_n(&prof->frame_table.count, __ATOMIC_ACQUIRE);
+        size_t ft_count = atomic_load_explicit(&prof->frame_table.count, memory_order_acquire);
         VALUE *ft_keys = atomic_load_explicit(&prof->frame_table.keys, memory_order_acquire);
         if (ft_keys && ft_count > 0) {
             rb_gc_mark_locations(ft_keys, ft_keys + ft_count);
@@ -225,12 +242,40 @@ rperf_profiler_mark(void *ptr)
     }
 }
 
+static size_t
+rperf_profiler_memsize(const void *ptr)
+{
+    const rperf_profiler_t *prof = (const rperf_profiler_t *)ptr;
+    size_t size = sizeof(rperf_profiler_t);
+    int i;
+
+    /* Double-buffered sample storage */
+    for (i = 0; i < 2; i++) {
+        const rperf_sample_buffer_t *buf = &prof->buffers[i];
+        size += buf->sample_capacity * sizeof(rperf_sample_t);
+        size += buf->frame_pool_capacity * sizeof(VALUE);
+    }
+
+    /* Frame table */
+    size += prof->frame_table.capacity * sizeof(VALUE);           /* keys */
+    size += prof->frame_table.bucket_capacity * sizeof(uint32_t); /* buckets */
+    /* old_keys entries are previous keys arrays; exact sizes unknown,
+     * only the pointer array itself is accounted for. */
+    size += prof->frame_table.old_keys_capacity * sizeof(VALUE *); /* old_keys */
+
+    /* Aggregation table */
+    size += prof->agg_table.bucket_capacity * sizeof(rperf_agg_entry_t);
+    size += prof->agg_table.stack_pool_capacity * sizeof(uint32_t);
+
+    return size;
+}
+
 static const rb_data_type_t rperf_profiler_type = {
     .wrap_struct_name = "rperf_profiler",
     .function = {
         .dmark = rperf_profiler_mark,
         .dfree = NULL,
-        .dsize = NULL,
+        .dsize = rperf_profiler_memsize,
     },
 };
 
@@ -259,7 +304,7 @@ rperf_wall_time_ns(void)
 static int64_t
 rperf_current_time_ns(rperf_profiler_t *prof)
 {
-    if (prof->mode == 0) {
+    if (prof->mode == RPERF_MODE_CPU) {
         return rperf_cpu_time_ns();
     } else {
         return rperf_wall_time_ns();
@@ -300,7 +345,7 @@ static int
 rperf_ensure_sample_capacity(rperf_sample_buffer_t *buf)
 {
     if (buf->sample_count >= buf->sample_capacity) {
-        if (buf->sample_capacity > SIZE_MAX / 2) return -1;
+        if (buf->sample_capacity > SIZE_MAX / (2 * sizeof(rperf_sample_t))) return -1;
         size_t new_cap = buf->sample_capacity * 2;
         rperf_sample_t *new_samples = (rperf_sample_t *)realloc(
             buf->samples,
@@ -319,7 +364,7 @@ static int
 rperf_ensure_frame_pool_capacity(rperf_sample_buffer_t *buf, int needed)
 {
     while (buf->frame_pool_count + (size_t)needed > buf->frame_pool_capacity) {
-        if (buf->frame_pool_capacity > SIZE_MAX / 2) return -1;
+        if (buf->frame_pool_capacity > SIZE_MAX / (2 * sizeof(VALUE))) return -1;
         size_t new_cap = buf->frame_pool_capacity * 2;
         VALUE *new_pool = (VALUE *)realloc(
             buf->frame_pool,
@@ -438,7 +483,7 @@ rperf_frame_table_insert(rperf_frame_table_t *ft, VALUE fval)
     keys[frame_id] = fval;
     /* Store fence: ensure keys[frame_id] is visible before count is incremented,
      * so GC dmark never reads uninitialized keys[count-1]. */
-    __atomic_store_n(&ft->count, ft->count + 1, __ATOMIC_RELEASE);
+    atomic_store_explicit(&ft->count, ft->count + 1, memory_order_release);
     ft->buckets[idx] = frame_id;
 
     /* Rehash if load factor > 0.7 */
@@ -494,7 +539,7 @@ rperf_agg_table_free(rperf_agg_table_t *at)
 static void
 rperf_agg_table_rehash(rperf_agg_table_t *at)
 {
-    if (at->bucket_capacity > SIZE_MAX / 2) return;
+    if (at->bucket_capacity > SIZE_MAX / (2 * sizeof(rperf_agg_entry_t))) return;
     size_t new_cap = at->bucket_capacity * 2;
     rperf_agg_entry_t *new_buckets = (rperf_agg_entry_t *)calloc(new_cap, sizeof(rperf_agg_entry_t));
     if (!new_buckets) return; /* keep using current buckets at higher load factor */
@@ -519,7 +564,7 @@ static int
 rperf_agg_ensure_stack_pool(rperf_agg_table_t *at, int needed)
 {
     while (at->stack_pool_count + (size_t)needed > at->stack_pool_capacity) {
-        if (at->stack_pool_capacity > SIZE_MAX / 2) return -1;
+        if (at->stack_pool_capacity > SIZE_MAX / (2 * sizeof(uint32_t))) return -1;
         size_t new_cap = at->stack_pool_capacity * 2;
         uint32_t *new_pool = (uint32_t *)realloc(at->stack_pool,
                                                   new_cap * sizeof(uint32_t));
@@ -530,8 +575,9 @@ rperf_agg_ensure_stack_pool(rperf_agg_table_t *at, int needed)
     return 0;
 }
 
-/* Insert or merge a stack into the aggregation table */
-static void
+/* Insert or merge a stack into the aggregation table.
+ * Returns 0 on success, -1 on failure (table full or allocation failure). */
+static int
 rperf_agg_table_insert(rperf_agg_table_t *at, const uint32_t *frame_ids,
                        int depth, int thread_seq, int label_set_id,
                        enum rperf_vm_state vm_state, int64_t weight, uint32_t hash)
@@ -548,14 +594,14 @@ rperf_agg_table_insert(rperf_agg_table_t *at, const uint32_t *frame_ids,
                    depth * sizeof(uint32_t)) == 0) {
             /* Match — merge weight */
             e->weight += weight;
-            return;
+            return 0;
         }
         idx = (idx + 1) % at->bucket_capacity;
-        if (++probes >= at->bucket_capacity) return; /* table full, drop sample */
+        if (++probes >= at->bucket_capacity) return -1; /* table full */
     }
 
     /* New entry — append frame_ids to stack_pool */
-    if (rperf_agg_ensure_stack_pool(at, depth) < 0) return;
+    if (rperf_agg_ensure_stack_pool(at, depth) < 0) return -1;
 
     rperf_agg_entry_t *e = &at->buckets[idx];
     e->frame_start = (uint32_t)at->stack_pool_count;
@@ -576,6 +622,7 @@ rperf_agg_table_insert(rperf_agg_table_t *at, const uint32_t *frame_ids,
     if (at->count * 10 > at->bucket_capacity * 7) {
         rperf_agg_table_rehash(at);
     }
+    return 0;
 }
 
 /* ---- Aggregation: process a sample buffer into frame_table + agg_table ---- */
@@ -598,25 +645,38 @@ rperf_aggregate_buffer(rperf_profiler_t *prof, rperf_sample_buffer_t *buf)
         /* Convert VALUE frames to frame_ids */
         int overflow = 0;
         for (j = 0; j < s->depth; j++) {
+            if (s->frame_start + j >= buf->frame_pool_count) {
+                /* Defensive: sample points past the pool — truncate the
+                 * sample so we never hash/insert uninitialized temp_ids */
+                s->depth = j;
+                break;
+            }
             VALUE fval = buf->frame_pool[s->frame_start + j];
             uint32_t fid = rperf_frame_table_insert(&prof->frame_table, fval);
             if (fid == RPERF_FRAME_TABLE_EMPTY) { overflow = 1; break; }
             temp_ids[j] = fid;
         }
-        if (overflow) break; /* frame_table full, stop aggregating this buffer */
+        if (overflow) {
+            /* frame_table full — count remaining samples as dropped */
+            prof->stats.dropped_aggregation += buf->sample_count - i;
+            break;
+        }
+        if (s->depth <= 0) continue;
 
         hash = rperf_fnv1a_u32(temp_ids, s->depth, s->thread_seq, s->label_set_id, s->vm_state);
 
-        rperf_agg_table_insert(&prof->agg_table, temp_ids, s->depth,
+        if (rperf_agg_table_insert(&prof->agg_table, temp_ids, s->depth,
                                s->thread_seq, s->label_set_id, s->vm_state,
-                               s->weight, hash);
+                               s->weight, hash) < 0) {
+            prof->stats.dropped_aggregation++;
+        }
     }
 
     /* Reset buffer for reuse.
      * Release fence: ensure all frame_table inserts are visible (to GC dmark)
      * before frame_pool_count is cleared, so dmark always has at least one
      * source (frame_table or frame_pool) covering each VALUE. */
-    __atomic_thread_fence(__ATOMIC_RELEASE);
+    atomic_thread_fence(memory_order_release);
     buf->sample_count = 0;
     buf->frame_pool_count = 0;
 }
@@ -693,8 +753,9 @@ rperf_thread_data_create(rperf_profiler_t *prof, VALUE thread)
 {
     rperf_thread_data_t *td = (rperf_thread_data_t *)calloc(1, sizeof(rperf_thread_data_t));
     if (!td) return NULL;
-    td->prev_time_ns = rperf_current_time_ns(prof);
-    td->prev_wall_ns = rperf_wall_time_ns();
+    int64_t t = rperf_current_time_ns(prof);
+    if (t < 0) { free(td); return NULL; }
+    td->prev_time_ns = t;
     td->thread_seq = ++prof->next_thread_seq;
     rb_internal_thread_specific_set(thread, prof->ts_key, td);
     return td;
@@ -706,7 +767,8 @@ static void
 rperf_handle_suspended(rperf_profiler_t *prof, VALUE thread, rperf_thread_data_t *td)
 {
     /* Has GVL — safe to call Ruby APIs */
-    int64_t wall_now = rperf_wall_time_ns();
+    /* suspended_at_ns is only consumed by RESUMED in wall mode */
+    int64_t wall_now = (prof->mode == RPERF_MODE_WALL) ? rperf_wall_time_ns() : 0;
 
     int is_first = 0;
 
@@ -719,25 +781,27 @@ rperf_handle_suspended(rperf_profiler_t *prof, VALUE thread, rperf_thread_data_t
     int64_t time_now = rperf_current_time_ns(prof);
     if (time_now < 0) return;
 
-    /* Capture backtrace into active buffer's frame_pool */
-    rperf_sample_buffer_t *buf = &prof->buffers[atomic_load_explicit(&prof->active_idx, memory_order_relaxed)];
-    if (rperf_ensure_frame_pool_capacity(buf, RPERF_MAX_STACK_DEPTH) < 0) return;
-    size_t frame_start = buf->frame_pool_count;
-    int depth = rb_profile_frames(0, RPERF_MAX_STACK_DEPTH,
-                                  &buf->frame_pool[frame_start], NULL);
-    if (depth <= 0) return;
-    buf->frame_pool_count += depth;
-
-    /* Record normal sample (skip if first time — no prev_time, or if paused) */
+    /* Record normal sample (skip if first time — no prev_time, or if paused).
+     * The backtrace is captured only when a sample is actually recorded:
+     * committing frames to the pool while paused would grow it without bound,
+     * because no aggregation runs until samples accumulate. */
     if (!is_first && !RPERF_PAUSED(prof)) {
-        int64_t weight = time_now - td->prev_time_ns;
-        rperf_record_sample(prof, frame_start, depth, weight, RPERF_VM_STATE_NORMAL, td->thread_seq, td->label_set_id);
+        rperf_sample_buffer_t *buf = &prof->buffers[atomic_load_explicit(&prof->active_idx, memory_order_relaxed)];
+        if (rperf_ensure_frame_pool_capacity(buf, RPERF_MAX_STACK_DEPTH) >= 0) {
+            size_t frame_start = buf->frame_pool_count;
+            int depth = rb_profile_frames(0, RPERF_MAX_STACK_DEPTH,
+                                          &buf->frame_pool[frame_start], NULL);
+            if (depth > 0) {
+                buf->frame_pool_count += depth;
+                int64_t weight = time_now - td->prev_time_ns;
+                rperf_record_sample(prof, frame_start, depth, weight, RPERF_VM_STATE_NORMAL, td->thread_seq, td->label_set_id);
+            }
+        }
     }
 
     /* Save timestamp for READY/RESUMED */
     td->suspended_at_ns = wall_now;
     td->prev_time_ns = time_now;
-    td->prev_wall_ns = wall_now;
 }
 
 static void
@@ -768,7 +832,7 @@ rperf_handle_resumed(rperf_profiler_t *prof, VALUE thread, rperf_thread_data_t *
      * Both samples are written directly into the same buffer before calling
      * rperf_try_swap, so that a swap triggered by the first sample cannot
      * move the second into a different buffer with a stale frame_start. */
-    if (prof->mode == 1 && td->suspended_at_ns > 0 && !RPERF_PAUSED(prof)) {
+    if (prof->mode == RPERF_MODE_WALL && td->suspended_at_ns > 0 && !RPERF_PAUSED(prof)) {
         rperf_sample_buffer_t *buf = &prof->buffers[atomic_load_explicit(&prof->active_idx, memory_order_relaxed)];
         if (rperf_ensure_frame_pool_capacity(buf, RPERF_MAX_STACK_DEPTH) < 0) goto skip_gvl;
         size_t frame_start = buf->frame_pool_count;
@@ -798,7 +862,6 @@ skip_gvl:
     /* Reset prev times to current — next timer sample measures from resume */
     int64_t time_now = rperf_current_time_ns(prof);
     if (time_now >= 0) td->prev_time_ns = time_now;
-    td->prev_wall_ns = wall_now;
 
     /* Clear suspended state */
     td->suspended_at_ns = 0;
@@ -818,19 +881,26 @@ static void
 rperf_thread_event_hook(rb_event_flag_t event, const rb_internal_thread_event_data_t *data, void *user_data)
 {
     rperf_profiler_t *prof = (rperf_profiler_t *)user_data;
-    if (!prof->running) return;
 
     VALUE thread = data->thread;
     rperf_thread_data_t *td = (rperf_thread_data_t *)rb_internal_thread_specific_get(thread, prof->ts_key);
 
+    /* EXITED frees the thread's data even when running == 0: a thread can
+     * exit between stop setting running = 0 and the hook removal, and its td
+     * would otherwise leak (stop's Thread.list cleanup no longer sees it). */
+    if (event & RUBY_INTERNAL_THREAD_EVENT_EXITED) {
+        rperf_handle_exited(prof, thread, td);
+        return;
+    }
+
+    if (!prof->running) return;
+
     if (event & RUBY_INTERNAL_THREAD_EVENT_SUSPENDED)
         rperf_handle_suspended(prof, thread, td);
     else if (event & RUBY_INTERNAL_THREAD_EVENT_READY)
         rperf_handle_ready(td);
     else if (event & RUBY_INTERNAL_THREAD_EVENT_RESUMED)
         rperf_handle_resumed(prof, thread, td);
-    else if (event & RUBY_INTERNAL_THREAD_EVENT_EXITED)
-        rperf_handle_exited(prof, thread, td);
 }
 
 /* ---- GC event hook ---- */
@@ -895,17 +965,15 @@ rperf_gc_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID id, VALUE
 
 /* ---- Sampling callback (postponed job) — current thread only ---- */
 
-static void
-rperf_sample_job(void *arg)
+/* Core sampling logic, parameterized by mode constant.
+ * Called from rperf_sample_cpu/rperf_sample_wall so the compiler
+ * can inline and eliminate mode branches at compile time. */
+static inline void
+rperf_sample_core(rperf_profiler_t *prof, enum rperf_mode mode)
 {
-    rperf_profiler_t *prof = (rperf_profiler_t *)arg;
-
-    if (!prof->running) return;
-    if (RPERF_PAUSED(prof)) return;
-
-    /* Measure sampling overhead */
+    /* Measure sampling overhead (wall time — runs under GVL, no I/O) */
     struct timespec ts_start, ts_end;
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_start);
+    clock_gettime(CLOCK_MONOTONIC, &ts_start);
 
     VALUE thread = rb_thread_current();
 
@@ -917,12 +985,11 @@ rperf_sample_job(void *arg)
         return; /* Skip first sample for this thread */
     }
 
-    int64_t time_now = rperf_current_time_ns(prof);
+    int64_t time_now = (mode == RPERF_MODE_CPU) ? rperf_cpu_time_ns() : rperf_wall_time_ns();
     if (time_now < 0) return;
 
     int64_t weight = time_now - td->prev_time_ns;
     td->prev_time_ns = time_now;
-    td->prev_wall_ns = rperf_wall_time_ns();
 
     if (weight <= 0) return;
 
@@ -938,13 +1005,33 @@ rperf_sample_job(void *arg)
 
     rperf_record_sample(prof, frame_start, depth, weight, RPERF_VM_STATE_NORMAL, td->thread_seq, td->label_set_id);
 
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_end);
+    clock_gettime(CLOCK_MONOTONIC, &ts_end);
     prof->stats.sampling_count++;
     prof->stats.sampling_total_ns +=
         ((int64_t)ts_end.tv_sec - ts_start.tv_sec) * 1000000000LL +
         (ts_end.tv_nsec - ts_start.tv_nsec);
 }
 
+static void
+rperf_sample_cpu(rperf_profiler_t *prof) { rperf_sample_core(prof, RPERF_MODE_CPU); }
+
+static void
+rperf_sample_wall(rperf_profiler_t *prof) { rperf_sample_core(prof, RPERF_MODE_WALL); }
+
+static void
+rperf_sample_job(void *arg)
+{
+    rperf_profiler_t *prof = (rperf_profiler_t *)arg;
+
+    if (!prof->running) return;
+    if (RPERF_PAUSED(prof)) return;
+
+    if (prof->mode == RPERF_MODE_CPU)
+        rperf_sample_cpu(prof);
+    else
+        rperf_sample_wall(prof);
+}
+
 /* ---- Worker thread: timer + aggregation ---- */
 
 #if RPERF_USE_TIMER_SIGNAL
@@ -990,7 +1077,7 @@ rperf_worker_nanosleep_func(void *arg)
     struct timespec deadline;
     long interval_ns = 1000000000L / prof->frequency;
 
-    clock_gettime(CLOCK_REALTIME, &deadline);
+    clock_gettime(RPERF_COND_CLOCK, &deadline);
     deadline.tv_nsec += interval_ns;
     if (deadline.tv_nsec >= 1000000000L) {
         deadline.tv_sec++;
@@ -1005,7 +1092,7 @@ rperf_worker_nanosleep_func(void *arg)
             CHECKED(pthread_cond_wait(&prof->worker_cond, &prof->worker_mutex));
             prof->worker_paused = 0;
             /* Reset deadline on wake to avoid burst of catch-up triggers */
-            clock_gettime(CLOCK_REALTIME, &deadline);
+            clock_gettime(RPERF_COND_CLOCK, &deadline);
             deadline.tv_nsec += interval_ns;
             if (deadline.tv_nsec >= 1000000000L) {
                 deadline.tv_sec++;
@@ -1076,13 +1163,15 @@ rperf_build_aggregated_result(rperf_profiler_t *prof)
     result = rb_hash_new();
 
     rb_hash_aset(result, ID2SYM(rb_intern("mode")),
-                 ID2SYM(rb_intern(prof->mode == 1 ? "wall" : "cpu")));
+                 ID2SYM(rb_intern(prof->mode == RPERF_MODE_WALL ? "wall" : "cpu")));
     rb_hash_aset(result, ID2SYM(rb_intern("frequency")), INT2NUM(prof->frequency));
     rb_hash_aset(result, ID2SYM(rb_intern("trigger_count")), SIZET2NUM(prof->stats.trigger_count));
     rb_hash_aset(result, ID2SYM(rb_intern("sampling_count")), SIZET2NUM(prof->stats.sampling_count));
-    rb_hash_aset(result, ID2SYM(rb_intern("sampling_time_ns")), LONG2NUM(prof->stats.sampling_total_ns));
+    rb_hash_aset(result, ID2SYM(rb_intern("sampling_time_ns")), LL2NUM(prof->stats.sampling_total_ns));
     if (prof->stats.dropped_samples > 0)
         rb_hash_aset(result, ID2SYM(rb_intern("dropped_samples")), SIZET2NUM(prof->stats.dropped_samples));
+    if (prof->stats.dropped_aggregation > 0)
+        rb_hash_aset(result, ID2SYM(rb_intern("dropped_aggregation")), SIZET2NUM(prof->stats.dropped_aggregation));
     rb_hash_aset(result, ID2SYM(rb_intern("detected_thread_count")), INT2NUM(prof->next_thread_seq));
     rb_hash_aset(result, ID2SYM(rb_intern("unique_frames")),
                  SIZET2NUM(prof->frame_table.count));
@@ -1097,8 +1186,8 @@ rperf_build_aggregated_result(rperf_profiler_t *prof)
                  + (int64_t)prof->start_realtime.tv_nsec;
         duration_ns = ((int64_t)now_monotonic.tv_sec - (int64_t)prof->start_monotonic.tv_sec) * 1000000000LL
                     + ((int64_t)now_monotonic.tv_nsec - (int64_t)prof->start_monotonic.tv_nsec);
-        rb_hash_aset(result, ID2SYM(rb_intern("start_time_ns")), LONG2NUM(start_ns));
-        rb_hash_aset(result, ID2SYM(rb_intern("duration_ns")), LONG2NUM(duration_ns));
+        rb_hash_aset(result, ID2SYM(rb_intern("start_time_ns")), LL2NUM(start_ns));
+        rb_hash_aset(result, ID2SYM(rb_intern("duration_ns")), LL2NUM(duration_ns));
     }
 
     {
@@ -1124,7 +1213,7 @@ rperf_build_aggregated_result(rperf_profiler_t *prof)
 
             VALUE sample = rb_ary_new_capa(5);
             rb_ary_push(sample, frames);
-            rb_ary_push(sample, LONG2NUM(e->weight));
+            rb_ary_push(sample, LL2NUM(e->weight));
             rb_ary_push(sample, INT2NUM(e->thread_seq));
             rb_ary_push(sample, INT2NUM(e->label_set_id));
             rb_ary_push(sample, INT2NUM(e->vm_state));
@@ -1154,7 +1243,7 @@ static VALUE
 rb_rperf_start(VALUE self, VALUE vfreq, VALUE vmode, VALUE vagg, VALUE vsig, VALUE vdefer)
 {
     int frequency = NUM2INT(vfreq);
-    int mode = NUM2INT(vmode);
+    enum rperf_mode mode = (enum rperf_mode)NUM2INT(vmode);
     int aggregate = RTEST(vagg) ? 1 : 0;
 #if RPERF_USE_TIMER_SIGNAL
     int sig = NUM2INT(vsig);
@@ -1173,13 +1262,26 @@ rb_rperf_start(VALUE self, VALUE vfreq, VALUE vmode, VALUE vagg, VALUE vsig, VAL
     g_profiler.stats.sampling_total_ns = 0;
     g_profiler.stats.trigger_count = 0;
     g_profiler.stats.dropped_samples = 0;
+    g_profiler.stats.dropped_aggregation = 0;
     atomic_store_explicit(&g_profiler.active_idx, 0, memory_order_relaxed);
     atomic_store_explicit(&g_profiler.swap_ready, 0, memory_order_relaxed);
     g_profiler.label_sets = Qnil;
 
     /* Initialize worker mutex/cond */
     CHECKED(pthread_mutex_init(&g_profiler.worker_mutex, NULL));
+#ifdef __linux__
+    {
+        /* Use CLOCK_MONOTONIC for pthread_cond_timedwait so that
+         * system clock adjustments (NTP etc.) don't affect timer intervals. */
+        pthread_condattr_t cond_attr;
+        CHECKED(pthread_condattr_init(&cond_attr));
+        CHECKED(pthread_condattr_setclock(&cond_attr, CLOCK_MONOTONIC));
+        CHECKED(pthread_cond_init(&g_profiler.worker_cond, &cond_attr));
+        CHECKED(pthread_condattr_destroy(&cond_attr));
+    }
+#else
     CHECKED(pthread_cond_init(&g_profiler.worker_cond, NULL));
+#endif
 
     /* Initialize sample buffer(s) */
     if (rperf_sample_buffer_init(&g_profiler.buffers[0]) < 0) {
@@ -1236,6 +1338,14 @@ rb_rperf_start(VALUE self, VALUE vfreq, VALUE vmode, VALUE vagg, VALUE vsig, VAL
     /* Pre-initialize current thread's time so the first sample is not skipped */
     {
         VALUE cur_thread = rb_thread_current();
+        /* A stale td can survive a fork (the atfork child handler does not
+         * free the forking thread's data) — free it before creating a fresh
+         * one, or it would leak on every fork + restart cycle. */
+        rperf_thread_data_t *stale = (rperf_thread_data_t *)rb_internal_thread_specific_get(cur_thread, g_profiler.ts_key);
+        if (stale) {
+            free(stale);
+            rb_internal_thread_specific_set(cur_thread, g_profiler.ts_key, NULL);
+        }
         rperf_thread_data_t *td = rperf_thread_data_create(&g_profiler, cur_thread);
         if (!td) {
             rb_remove_event_hook(rperf_gc_event_hook);
@@ -1300,24 +1410,34 @@ rb_rperf_start(VALUE self, VALUE vfreq, VALUE vmode, VALUE vagg, VALUE vsig, VAL
         if (timer_create(CLOCK_MONOTONIC, &sev, &g_profiler.timer_id) != 0) {
             g_profiler.running = 0;
             sigaction(g_profiler.timer_signal, &g_profiler.old_sigaction, NULL);
+            /* Signal under the mutex — see rb_rperf_stop for the rationale */
+            CHECKED(pthread_mutex_lock(&g_profiler.worker_mutex));
             CHECKED(pthread_cond_signal(&g_profiler.worker_cond));
+            CHECKED(pthread_mutex_unlock(&g_profiler.worker_mutex));
             CHECKED(pthread_join(g_profiler.worker_thread, NULL));
             goto timer_fail;
         }
 
-        its.it_value.tv_sec = 0;
         if (RPERF_PAUSED(&g_profiler)) {
             /* defer mode: create timer but don't arm it */
+            its.it_value.tv_sec = 0;
             its.it_value.tv_nsec = 0;
         } else {
-            its.it_value.tv_nsec = 1000000000L / g_profiler.frequency;
+            /* Split into sec/nsec: frequency 1 gives a 1s interval, and
+             * tv_nsec must be < 1e9 or timer_settime fails with EINVAL */
+            long interval_ns = 1000000000L / g_profiler.frequency;
+            its.it_value.tv_sec = interval_ns / 1000000000L;
+            its.it_value.tv_nsec = interval_ns % 1000000000L;
         }
         its.it_interval = its.it_value;
         if (timer_settime(g_profiler.timer_id, 0, &its, NULL) != 0) {
             timer_delete(g_profiler.timer_id);
             g_profiler.running = 0;
             sigaction(g_profiler.timer_signal, &g_profiler.old_sigaction, NULL);
+            /* Signal under the mutex — see rb_rperf_stop for the rationale */
+            CHECKED(pthread_mutex_lock(&g_profiler.worker_mutex));
             CHECKED(pthread_cond_signal(&g_profiler.worker_cond));
+            CHECKED(pthread_mutex_unlock(&g_profiler.worker_mutex));
             CHECKED(pthread_join(g_profiler.worker_thread, NULL));
             goto timer_fail;
         }
@@ -1378,10 +1498,15 @@ rb_rperf_stop(VALUE self)
     }
 #endif
 
-    /* Wake and join worker thread.
+    /* Wake and join worker thread.  Signal while holding worker_mutex:
+     * the worker re-checks its predicate (running) with the mutex held, so
+     * signaling under the mutex guarantees it either sees running == 0 or is
+     * already inside cond_wait when the signal fires — no lost wakeup.
      * Any pending timer signals are still handled by rperf_signal_handler
      * (just increments trigger_count + calls rb_postponed_job_trigger). */
+    CHECKED(pthread_mutex_lock(&g_profiler.worker_mutex));
     CHECKED(pthread_cond_signal(&g_profiler.worker_cond));
+    CHECKED(pthread_mutex_unlock(&g_profiler.worker_mutex));
     CHECKED(pthread_join(g_profiler.worker_thread, NULL));
     CHECKED(pthread_mutex_destroy(&g_profiler.worker_mutex));
     CHECKED(pthread_cond_destroy(&g_profiler.worker_cond));
@@ -1436,13 +1561,15 @@ rb_rperf_stop(VALUE self)
 
         result = rb_hash_new();
         rb_hash_aset(result, ID2SYM(rb_intern("mode")),
-                     ID2SYM(rb_intern(g_profiler.mode == 1 ? "wall" : "cpu")));
+                     ID2SYM(rb_intern(g_profiler.mode == RPERF_MODE_WALL ? "wall" : "cpu")));
         rb_hash_aset(result, ID2SYM(rb_intern("frequency")), INT2NUM(g_profiler.frequency));
         rb_hash_aset(result, ID2SYM(rb_intern("trigger_count")), SIZET2NUM(g_profiler.stats.trigger_count));
         rb_hash_aset(result, ID2SYM(rb_intern("sampling_count")), SIZET2NUM(g_profiler.stats.sampling_count));
-        rb_hash_aset(result, ID2SYM(rb_intern("sampling_time_ns")), LONG2NUM(g_profiler.stats.sampling_total_ns));
+        rb_hash_aset(result, ID2SYM(rb_intern("sampling_time_ns")), LL2NUM(g_profiler.stats.sampling_total_ns));
         if (g_profiler.stats.dropped_samples > 0)
             rb_hash_aset(result, ID2SYM(rb_intern("dropped_samples")), SIZET2NUM(g_profiler.stats.dropped_samples));
+        if (g_profiler.stats.dropped_aggregation > 0)
+            rb_hash_aset(result, ID2SYM(rb_intern("dropped_aggregation")), SIZET2NUM(g_profiler.stats.dropped_aggregation));
         rb_hash_aset(result, ID2SYM(rb_intern("detected_thread_count")), INT2NUM(g_profiler.next_thread_seq));
         {
             struct timespec stop_monotonic;
@@ -1452,8 +1579,8 @@ rb_rperf_stop(VALUE self)
                      + (int64_t)g_profiler.start_realtime.tv_nsec;
             duration_ns = ((int64_t)stop_monotonic.tv_sec - (int64_t)g_profiler.start_monotonic.tv_sec) * 1000000000LL
                         + ((int64_t)stop_monotonic.tv_nsec - (int64_t)g_profiler.start_monotonic.tv_nsec);
-            rb_hash_aset(result, ID2SYM(rb_intern("start_time_ns")), LONG2NUM(start_ns));
-            rb_hash_aset(result, ID2SYM(rb_intern("duration_ns")), LONG2NUM(duration_ns));
+            rb_hash_aset(result, ID2SYM(rb_intern("start_time_ns")), LL2NUM(start_ns));
+            rb_hash_aset(result, ID2SYM(rb_intern("duration_ns")), LL2NUM(duration_ns));
         }
 
         samples_ary = rb_ary_new_capa((long)buf->sample_count);
@@ -1469,7 +1596,7 @@ rb_rperf_stop(VALUE self)
 
             VALUE sample = rb_ary_new_capa(5);
             rb_ary_push(sample, frames);
-            rb_ary_push(sample, LONG2NUM(s->weight));
+            rb_ary_push(sample, LL2NUM(s->weight));
             rb_ary_push(sample, INT2NUM(s->thread_seq));
             rb_ary_push(sample, INT2NUM(s->label_set_id));
             rb_ary_push(sample, INT2NUM(s->vm_state));
@@ -1508,6 +1635,7 @@ rperf_clear_aggregated_data(rperf_profiler_t *prof)
     prof->stats.sampling_count = 0;
     prof->stats.sampling_total_ns = 0;
     prof->stats.dropped_samples = 0;
+    prof->stats.dropped_aggregation = 0;
 
     /* Reset start timestamps so next snapshot's duration_ns covers
      * only the period since this clear. */
@@ -1604,10 +1732,13 @@ rperf_arm_timer(rperf_profiler_t *prof)
 #if RPERF_USE_TIMER_SIGNAL
     if (prof->timer_signal > 0) {
         struct itimerspec its;
-        its.it_value.tv_sec = 0;
-        its.it_value.tv_nsec = 1000000000L / prof->frequency;
+        long interval_ns = 1000000000L / prof->frequency;
+        its.it_value.tv_sec = interval_ns / 1000000000L;
+        its.it_value.tv_nsec = interval_ns % 1000000000L;
         its.it_interval = its.it_value;
-        timer_settime(prof->timer_id, 0, &its, NULL);
+        if (timer_settime(prof->timer_id, 0, &its, NULL) != 0) {
+            fprintf(stderr, "rperf: timer_settime (arm) failed: %s\n", strerror(errno));
+        }
         return;
     }
 #endif
@@ -1625,7 +1756,9 @@ rperf_disarm_timer(rperf_profiler_t *prof)
     if (prof->timer_signal > 0) {
         struct itimerspec its;
         memset(&its, 0, sizeof(its));
-        timer_settime(prof->timer_id, 0, &its, NULL);
+        if (timer_settime(prof->timer_id, 0, &its, NULL) != 0) {
+            fprintf(stderr, "rperf: timer_settime (disarm) failed: %s\n", strerror(errno));
+        }
         return;
     }
 #endif
@@ -1652,7 +1785,6 @@ rperf_reset_thread_times(rperf_profiler_t *prof)
         rperf_thread_data_t *td = (rperf_thread_data_t *)rb_internal_thread_specific_get(thread, prof->ts_key);
         if (td) {
             td->prev_time_ns = rperf_current_time_ns(prof);
-            td->prev_wall_ns = rperf_wall_time_ns();
         }
     }
 }
@@ -1692,6 +1824,12 @@ rb_rperf_running_p(VALUE self)
     return g_profiler.running ? Qtrue : Qfalse;
 }
 
+static VALUE
+rb_rperf_profiler_wrapper(VALUE self)
+{
+    return g_profiler_wrapper;
+}
+
 /* ---- Fork safety ---- */
 
 static void
@@ -1771,6 +1909,7 @@ Init_rperf(void)
     rb_define_module_function(mRperf, "_c_profile_inc", rb_rperf_profile_inc, 0);
     rb_define_module_function(mRperf, "_c_profile_dec", rb_rperf_profile_dec, 0);
     rb_define_module_function(mRperf, "_c_running?", rb_rperf_running_p, 0);
+    rb_define_module_function(mRperf, "_c_profiler_wrapper", rb_rperf_profiler_wrapper, 0);
 
     memset(&g_profiler, 0, sizeof(g_profiler));
     g_profiler.label_sets = Qnil;