rperf 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5e10797e7670051bb82e49f32a80bac5371c9bd7652809ece4894a7d508c4bf
-  data.tar.gz: b577d93730398a5b91ab89df80e0cec422300839ec3d9879043b711285d4c4c2
+  metadata.gz: ab923fe1fc0a0d6928941271cdffc979012af73d6d0bd0aa5c5d43a95e9451c2
+  data.tar.gz: 74a0200ec71ae3743d2b99d578df0b484d23dea57285385209e23b0748a95564
 SHA512:
-  metadata.gz: 2b5eb6e2125e2155937af009e084b43ff4ea4a5599a4b9d2015f3d6cd13a86f6644ecf05b58a383867853bb87e2017a4097d0f9c34662622dfaafba21efdd98c
-  data.tar.gz: e3585af44f4cfbb5bace10a7ea127d801035006123a45a54aa1c2b095aeb93f8b98a41041f39cda62a5bda7e16ce4ee5acb6a88290224db5b3162e08c969f6da
+  metadata.gz: b2d95c3e58fd883efebfcad8506a5249dee8c7322fb53e75a25afcd5050bbb1885fb620eef18a86e74fa54cb542ba83b1761f13630746862c619477e022b09db
+  data.tar.gz: ee4236170102e0be1cd13749389a29679ba7361c4c77db98ed708e9b509e8e1c28ba3b47a2d8a4b704ada2fe5a11859bc61c0476d8f061fbd43703168232f5f6

data/docs/help.md

@@ -19,22 +19,27 @@ POSIX systems (Linux, macOS). Requires Ruby >= 3.4.0.
     -f, --frequency HZ      Sampling frequency in Hz (default: 1000)
     -m, --mode MODE         cpu or wall (default: cpu)
     --format FORMAT         pprof, collapsed, or text (default: auto from extension)
+    -p, --print             Print text profile to stdout
+                            (same as --format=text --output=/dev/stdout)
     --signal VALUE          Timer signal (Linux only): signal number, or 'false'
                             for nanosleep thread (default: auto)
     -v, --verbose           Print sampling statistics to stderr
 
 ### stat: Run command and print performance summary to stderr.
 
-Always uses wall mode. No file output by default.
+Uses wall mode by default. No file output by default.
 
     -o, --output PATH       Also save profile to file (default: none)
     -f, --frequency HZ      Sampling frequency in Hz (default: 1000)
+    -m, --mode MODE         cpu or wall (default: wall)
+    --report                Include flat/cumulative profile tables in output
     --signal VALUE          Timer signal (Linux only): signal number, or 'false'
                             for nanosleep thread (default: auto)
     -v, --verbose           Print additional sampling statistics
 
 Shows: user/sys/real time, time breakdown (CPU execution, GVL blocked,
-GVL wait, GC marking, GC sweeping), and top 5 hot functions.
+GVL wait, GC marking, GC sweeping), GC/memory/OS stats, and profiler overhead.
+Use --report to add flat and cumulative top-50 function tables.
 
 ### report: Open pprof profile with go tool pprof. Requires Go.
 
@@ -58,7 +63,9 @@ Default (no flag): opens diff in browser.
     rperf record -m wall -f 500 -o profile.pb.gz ruby server.rb
     rperf record -o profile.collapsed ruby app.rb
     rperf record -o profile.txt ruby app.rb
+    rperf record -p ruby app.rb
     rperf stat ruby app.rb
+    rperf stat --report ruby app.rb
     rperf stat -o profile.pb.gz ruby app.rb
     rperf report
     rperf report --top profile.pb.gz
@@ -168,14 +175,14 @@ Example output:
     Total: 1523.4ms (cpu)
     Samples: 4820, Frequency: 500Hz
 
-    Flat:
-         820.3ms  53.8%  Array#each (app/models/user.rb)
-         312.1ms  20.5%  JSON.parse (lib/json/parser.rb)
-         ...
+     Flat:
+               820.3 ms  53.8%  Array#each (app/models/user.rb)
+               312.1 ms  20.5%  JSON.parse (lib/json/parser.rb)
+               ...
 
-    Cumulative:
-        1401.2ms  92.0%  UsersController#index (app/controllers/users_controller.rb)
-         ...
+     Cumulative:
+             1,401.2 ms  92.0%  UsersController#index (app/controllers/users_controller.rb)
+               ...
 
 ### Format auto-detection
 
@@ -281,6 +288,7 @@ Used internally by the CLI to pass options to the auto-started profiler:
     RPERF_VERBOSE=1       Print statistics
     RPERF_SIGNAL=N|false  Timer signal number or 'false' for nanosleep (Linux only)
     RPERF_STAT=1          Enable stat mode (used by rperf stat)
+    RPERF_STAT_REPORT=1   Include profile tables in stat output
 
 ## TIPS
 

data/exe/rperf

@@ -134,9 +134,14 @@ mode = (subcommand == "stat") ? "wall" : "cpu"
 format = nil
 signal = nil
 verbose = false
+aggregate = true
+stat_report = false
 
 parser = OptionParser.new do |opts|
-  opts.banner = USAGE
+  opts.banner = case subcommand
+                when "record" then "Usage: rperf record [options] command [args...]"
+                when "stat"   then "Usage: rperf stat [options] command [args...]"
+                end
 
   opts.on("-o", "--output PATH", "Output file#{subcommand == 'stat' ? ' (default: none)' : ' (default: rperf.data)'}") do |v|
     output = v
@@ -146,21 +151,37 @@ parser = OptionParser.new do |opts|
     frequency = v
   end
 
-  if subcommand == "record"
-    opts.on("-m", "--mode MODE", %w[cpu wall], "Profiling mode: cpu or wall (default: cpu)") do |v|
-      mode = v
-    end
+  default_mode = (subcommand == "stat") ? "wall" : "cpu"
+  opts.on("-m", "--mode MODE", %w[cpu wall], "Profiling mode: cpu or wall (default: #{default_mode})") do |v|
+    mode = v
+  end
 
+  if subcommand == "record"
     opts.on("--format FORMAT", %w[pprof collapsed text],
             "Output format: pprof, collapsed, or text (default: auto from extension)") do |v|
       format = v
     end
+
+    opts.on("-p", "--print", "Print text profile to stdout (same as --format=text --output=/dev/stdout)") do
+      format = "text"
+      output = "/dev/stdout"
+    end
   end
 
   opts.on("--signal VALUE", "Timer signal (Linux only): signal number, or 'false' for nanosleep thread") do |v|
     signal = (v == "false") ? "false" : v
   end
 
+  opts.on("--no-aggregate", "Disable sample aggregation (keep raw samples)") do
+    aggregate = false
+  end
+
+  if subcommand == "stat"
+    opts.on("--report", "Include flat/cumulative profile tables in output") do
+      stat_report = true
+    end
+  end
+
   opts.on("-v", "--verbose", "Print sampling statistics to stderr") do
     verbose = true
   end
@@ -198,10 +219,12 @@ ENV["RPERF_MODE"] = mode
 ENV["RPERF_FORMAT"] = format if format
 ENV["RPERF_VERBOSE"] = "1" if verbose
 ENV["RPERF_SIGNAL"] = signal if signal
+ENV["RPERF_AGGREGATE"] = "0" unless aggregate
 
 if subcommand == "stat"
   ENV["RPERF_STAT"] = "1"
   ENV["RPERF_STAT_COMMAND"] = ARGV.join(" ")
+  ENV["RPERF_STAT_REPORT"] = "1" if stat_report
 end
 
 exec(*ARGV)

data/ext/rperf/rperf.c

@@ -7,6 +7,13 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>
+#include <assert.h>
+#ifdef __linux__
+#include <sys/syscall.h>
+#endif
+
+/* Checked pthread wrappers — assert on unexpected errors */
+#define CHECKED(call) do { int _r = (call); assert(_r == 0 && #call); (void)_r; } while (0)
 
 #ifdef __linux__
 #define RPERF_USE_TIMER_SIGNAL 1
@@ -16,8 +23,19 @@
 #endif
 
 #define RPERF_MAX_STACK_DEPTH 512
-#define RPERF_INITIAL_SAMPLES 1024
+#define RPERF_INITIAL_SAMPLES 16384  /* >= AGG_THRESHOLD to avoid realloc before first aggregation */
 #define RPERF_INITIAL_FRAME_POOL (1024 * 1024 / sizeof(VALUE)) /* ~1MB */
+#define RPERF_AGG_THRESHOLD 10000  /* aggregate every N samples */
+#define RPERF_FRAME_TABLE_INITIAL 65536  /* pre-allocate to avoid realloc race with GC dmark */
+#define RPERF_AGG_TABLE_INITIAL 1024
+#define RPERF_STACK_POOL_INITIAL 4096
+
+/* Synthetic frame IDs (reserved in frame_table, 0-based) */
+#define RPERF_SYNTHETIC_GVL_BLOCKED 0
+#define RPERF_SYNTHETIC_GVL_WAIT    1
+#define RPERF_SYNTHETIC_GC_MARKING  2
+#define RPERF_SYNTHETIC_GC_SWEEPING 3
+#define RPERF_SYNTHETIC_COUNT       4
 
 /* ---- Data structures ---- */
 
@@ -43,6 +61,51 @@ typedef struct rperf_sample {
     int thread_seq;     /* thread sequence number (1-based) */
 } rperf_sample_t;
 
+/* ---- Sample buffer (double-buffered) ---- */
+
+typedef struct rperf_sample_buffer {
+    rperf_sample_t *samples;
+    size_t sample_count;
+    size_t sample_capacity;
+    VALUE *frame_pool;
+    size_t frame_pool_count;
+    size_t frame_pool_capacity;
+} rperf_sample_buffer_t;
+
+/* ---- Frame table: VALUE → uint32_t frame_id ---- */
+
+#define RPERF_FRAME_TABLE_EMPTY UINT32_MAX
+
+typedef struct rperf_frame_table {
+    VALUE *keys;              /* unique VALUE array (GC mark target) */
+    size_t count;             /* = next frame_id (starts after RPERF_SYNTHETIC_COUNT) */
+    size_t capacity;
+    uint32_t *buckets;        /* open addressing: stores index into keys[] */
+    size_t bucket_capacity;
+} rperf_frame_table_t;
+
+/* ---- 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;                /* includes synthetic frame */
+    int thread_seq;
+    int64_t weight;           /* accumulated */
+    uint32_t hash;            /* cached hash value */
+    int used;                 /* 0 = empty, 1 = used */
+} rperf_agg_entry_t;
+
+typedef struct rperf_agg_table {
+    rperf_agg_entry_t *buckets;
+    size_t bucket_capacity;
+    size_t count;
+    uint32_t *stack_pool;     /* frame_id sequences stored contiguously */
+    size_t stack_pool_count;
+    size_t stack_pool_capacity;
+} rperf_agg_table_t;
+
 typedef struct rperf_thread_data {
     int64_t prev_cpu_ns;
     int64_t prev_wall_ns;
@@ -58,18 +121,23 @@ typedef struct rperf_profiler {
     int frequency;
     int mode; /* 0 = cpu, 1 = wall */
     volatile int running;
-    pthread_t timer_thread;
+    pthread_t worker_thread;     /* combined timer + aggregation */
 #if RPERF_USE_TIMER_SIGNAL
     timer_t timer_id;
     int timer_signal;     /* >0: use timer signal, 0: use nanosleep thread */
+    volatile pid_t worker_tid;   /* kernel TID of worker thread (for SIGEV_THREAD_ID) */
 #endif
     rb_postponed_job_handle_t pj_handle;
-    rperf_sample_t *samples;
-    size_t sample_count;
-    size_t sample_capacity;
-    VALUE *frame_pool;       /* raw frame VALUEs from rb_profile_frames */
-    size_t frame_pool_count;
-    size_t frame_pool_capacity;
+    int aggregate;               /* 1 = aggregate samples, 0 = raw */
+    /* Double-buffered sample storage (only buffers[0] used when !aggregate) */
+    rperf_sample_buffer_t buffers[2];
+    int active_idx;              /* 0 or 1 */
+    /* Aggregation (only used when aggregate=1) */
+    rperf_frame_table_t frame_table;
+    rperf_agg_table_t agg_table;
+    volatile int swap_ready;     /* 1 = standby buffer ready for aggregation */
+    pthread_mutex_t worker_mutex;
+    pthread_cond_t worker_cond;
     rb_internal_thread_specific_key_t ts_key;
     rb_internal_thread_event_hook_t *thread_hook;
     /* GC tracking */
@@ -98,8 +166,19 @@ static void
 rperf_profiler_mark(void *ptr)
 {
     rperf_profiler_t *prof = (rperf_profiler_t *)ptr;
-    if (prof->frame_pool && prof->frame_pool_count > 0) {
-        rb_gc_mark_locations(prof->frame_pool, prof->frame_pool + prof->frame_pool_count);
+    int i;
+    /* Mark both sample buffers' frame_pools */
+    for (i = 0; i < 2; i++) {
+        rperf_sample_buffer_t *buf = &prof->buffers[i];
+        if (buf->frame_pool && buf->frame_pool_count > 0) {
+            rb_gc_mark_locations(buf->frame_pool,
+                                buf->frame_pool + buf->frame_pool_count);
+        }
+    }
+    /* Mark frame_table keys (unique frame VALUEs) */
+    if (prof->frame_table.keys && prof->frame_table.count > 0) {
+        rb_gc_mark_locations(prof->frame_table.keys + RPERF_SYNTHETIC_COUNT,
+                            prof->frame_table.keys + prof->frame_table.count);
     }
 }
 
@@ -146,18 +225,45 @@ rperf_current_time_ns(rperf_profiler_t *prof, rperf_thread_data_t *td)
 
 /* ---- Sample buffer ---- */
 
+static int
+rperf_sample_buffer_init(rperf_sample_buffer_t *buf)
+{
+    buf->sample_count = 0;
+    buf->sample_capacity = RPERF_INITIAL_SAMPLES;
+    buf->samples = (rperf_sample_t *)calloc(buf->sample_capacity, sizeof(rperf_sample_t));
+    if (!buf->samples) return -1;
+
+    buf->frame_pool_count = 0;
+    buf->frame_pool_capacity = RPERF_INITIAL_FRAME_POOL;
+    buf->frame_pool = (VALUE *)calloc(buf->frame_pool_capacity, sizeof(VALUE));
+    if (!buf->frame_pool) {
+        free(buf->samples);
+        buf->samples = NULL;
+        return -1;
+    }
+    return 0;
+}
+
+static void
+rperf_sample_buffer_free(rperf_sample_buffer_t *buf)
+{
+    free(buf->samples);
+    free(buf->frame_pool);
+    memset(buf, 0, sizeof(*buf));
+}
+
 /* Returns 0 on success, -1 on allocation failure */
 static int
-rperf_ensure_sample_capacity(rperf_profiler_t *prof)
+rperf_ensure_sample_capacity(rperf_sample_buffer_t *buf)
 {
-    if (prof->sample_count >= prof->sample_capacity) {
-        size_t new_cap = prof->sample_capacity * 2;
+    if (buf->sample_count >= buf->sample_capacity) {
+        size_t new_cap = buf->sample_capacity * 2;
         rperf_sample_t *new_samples = (rperf_sample_t *)realloc(
-            prof->samples,
+            buf->samples,
             new_cap * sizeof(rperf_sample_t));
         if (!new_samples) return -1;
-        prof->samples = new_samples;
-        prof->sample_capacity = new_cap;
+        buf->samples = new_samples;
+        buf->sample_capacity = new_cap;
     }
     return 0;
 }
@@ -166,36 +272,310 @@ rperf_ensure_sample_capacity(rperf_profiler_t *prof)
 
 /* Ensure frame_pool has room for `needed` more entries. Returns 0 on success. */
 static int
-rperf_ensure_frame_pool_capacity(rperf_profiler_t *prof, int needed)
+rperf_ensure_frame_pool_capacity(rperf_sample_buffer_t *buf, int needed)
 {
-    while (prof->frame_pool_count + (size_t)needed > prof->frame_pool_capacity) {
-        size_t new_cap = prof->frame_pool_capacity * 2;
+    while (buf->frame_pool_count + (size_t)needed > buf->frame_pool_capacity) {
+        size_t new_cap = buf->frame_pool_capacity * 2;
         VALUE *new_pool = (VALUE *)realloc(
-            prof->frame_pool,
+            buf->frame_pool,
             new_cap * sizeof(VALUE));
         if (!new_pool) return -1;
-        prof->frame_pool = new_pool;
-        prof->frame_pool_capacity = new_cap;
+        buf->frame_pool = new_pool;
+        buf->frame_pool_capacity = new_cap;
+    }
+    return 0;
+}
+
+/* ---- Frame table operations (all malloc-based, no GVL needed) ---- */
+
+static void
+rperf_frame_table_init(rperf_frame_table_t *ft)
+{
+    ft->capacity = RPERF_FRAME_TABLE_INITIAL;
+    ft->keys = (VALUE *)calloc(ft->capacity, sizeof(VALUE));
+    ft->count = RPERF_SYNTHETIC_COUNT; /* reserve slots for synthetic frames */
+    ft->bucket_capacity = RPERF_FRAME_TABLE_INITIAL * 2;
+    ft->buckets = (uint32_t *)malloc(ft->bucket_capacity * sizeof(uint32_t));
+    memset(ft->buckets, 0xFF, ft->bucket_capacity * sizeof(uint32_t)); /* EMPTY */
+}
+
+static void
+rperf_frame_table_free(rperf_frame_table_t *ft)
+{
+    free(ft->keys);
+    free(ft->buckets);
+    memset(ft, 0, sizeof(*ft));
+}
+
+static void
+rperf_frame_table_rehash(rperf_frame_table_t *ft)
+{
+    size_t new_cap = ft->bucket_capacity * 2;
+    uint32_t *new_buckets = (uint32_t *)malloc(new_cap * sizeof(uint32_t));
+    memset(new_buckets, 0xFF, new_cap * sizeof(uint32_t));
+
+    size_t i;
+    for (i = RPERF_SYNTHETIC_COUNT; i < ft->count; i++) {
+        uint32_t h = (uint32_t)(ft->keys[i] >> 3); /* shift out tag bits */
+        size_t idx = h % new_cap;
+        while (new_buckets[idx] != RPERF_FRAME_TABLE_EMPTY)
+            idx = (idx + 1) % new_cap;
+        new_buckets[idx] = (uint32_t)i;
+    }
+
+    free(ft->buckets);
+    ft->buckets = new_buckets;
+    ft->bucket_capacity = new_cap;
+}
+
+/* Returns frame_id for the given VALUE, inserting if new */
+static uint32_t
+rperf_frame_table_insert(rperf_frame_table_t *ft, VALUE fval)
+{
+    uint32_t h = (uint32_t)(fval >> 3);
+    size_t idx = h % ft->bucket_capacity;
+
+    while (1) {
+        uint32_t slot = ft->buckets[idx];
+        if (slot == RPERF_FRAME_TABLE_EMPTY) break;
+        if (ft->keys[slot] == fval) return slot;
+        idx = (idx + 1) % ft->bucket_capacity;
+    }
+
+    /* Insert new entry.
+     * keys array is pre-allocated and never realloc'd to avoid race with GC dmark.
+     * If capacity is exhausted, return EMPTY to signal aggregation should stop. */
+    if (ft->count >= ft->capacity) {
+        return RPERF_FRAME_TABLE_EMPTY;
+    }
+
+    uint32_t frame_id = (uint32_t)ft->count;
+    ft->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);
+    ft->buckets[idx] = frame_id;
+
+    /* Rehash if load factor > 0.7 */
+    if (ft->count * 10 > ft->bucket_capacity * 7) {
+        rperf_frame_table_rehash(ft);
+    }
+
+    return frame_id;
+}
+
+/* ---- Aggregation table operations (all malloc-based, no GVL needed) ---- */
+
+static uint32_t
+rperf_fnv1a_u32(const uint32_t *data, int len, int thread_seq)
+{
+    uint32_t h = 2166136261u;
+    int i;
+    for (i = 0; i < len; i++) {
+        h ^= data[i];
+        h *= 16777619u;
+    }
+    h ^= (uint32_t)thread_seq;
+    h *= 16777619u;
+    return h;
+}
+
+static void
+rperf_agg_table_init(rperf_agg_table_t *at)
+{
+    at->bucket_capacity = RPERF_AGG_TABLE_INITIAL * 2;
+    at->buckets = (rperf_agg_entry_t *)calloc(at->bucket_capacity, sizeof(rperf_agg_entry_t));
+    at->count = 0;
+    at->stack_pool_capacity = RPERF_STACK_POOL_INITIAL;
+    at->stack_pool = (uint32_t *)malloc(at->stack_pool_capacity * sizeof(uint32_t));
+    at->stack_pool_count = 0;
+}
+
+static void
+rperf_agg_table_free(rperf_agg_table_t *at)
+{
+    free(at->buckets);
+    free(at->stack_pool);
+    memset(at, 0, sizeof(*at));
+}
+
+static void
+rperf_agg_table_rehash(rperf_agg_table_t *at)
+{
+    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));
+
+    size_t i;
+    for (i = 0; i < at->bucket_capacity; i++) {
+        if (!at->buckets[i].used) continue;
+        rperf_agg_entry_t *e = &at->buckets[i];
+        size_t idx = e->hash % new_cap;
+        while (new_buckets[idx].used)
+            idx = (idx + 1) % new_cap;
+        new_buckets[idx] = *e;
+    }
+
+    free(at->buckets);
+    at->buckets = new_buckets;
+    at->bucket_capacity = new_cap;
+}
+
+/* Ensure stack_pool has room for `needed` more entries */
+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) {
+        size_t new_cap = at->stack_pool_capacity * 2;
+        uint32_t *new_pool = (uint32_t *)realloc(at->stack_pool,
+                                                  new_cap * sizeof(uint32_t));
+        if (!new_pool) return -1;
+        at->stack_pool = new_pool;
+        at->stack_pool_capacity = new_cap;
     }
     return 0;
 }
 
+/* Insert or merge a stack into the aggregation table */
+static void
+rperf_agg_table_insert(rperf_agg_table_t *at, const uint32_t *frame_ids,
+                       int depth, int thread_seq, int64_t weight, uint32_t hash)
+{
+    size_t idx = hash % at->bucket_capacity;
+
+    while (1) {
+        rperf_agg_entry_t *e = &at->buckets[idx];
+        if (!e->used) break;
+        if (e->hash == hash && e->depth == depth && e->thread_seq == thread_seq &&
+            memcmp(at->stack_pool + e->frame_start, frame_ids,
+                   depth * sizeof(uint32_t)) == 0) {
+            /* Match — merge weight */
+            e->weight += weight;
+            return;
+        }
+        idx = (idx + 1) % at->bucket_capacity;
+    }
+
+    /* New entry — append frame_ids to stack_pool */
+    if (rperf_agg_ensure_stack_pool(at, depth) < 0) return;
+
+    rperf_agg_entry_t *e = &at->buckets[idx];
+    e->frame_start = (uint32_t)at->stack_pool_count;
+    e->depth = depth;
+    e->thread_seq = thread_seq;
+    e->weight = weight;
+    e->hash = hash;
+    e->used = 1;
+
+    memcpy(at->stack_pool + at->stack_pool_count, frame_ids,
+           depth * sizeof(uint32_t));
+    at->stack_pool_count += depth;
+    at->count++;
+
+    /* Rehash if load factor > 0.7 */
+    if (at->count * 10 > at->bucket_capacity * 7) {
+        rperf_agg_table_rehash(at);
+    }
+}
+
+/* ---- Aggregation: process a sample buffer into frame_table + agg_table ---- */
+
+static void
+rperf_aggregate_buffer(rperf_profiler_t *prof, rperf_sample_buffer_t *buf)
+{
+    size_t i;
+    uint32_t temp_ids[RPERF_MAX_STACK_DEPTH + 1];
+
+    for (i = 0; i < buf->sample_count; i++) {
+        rperf_sample_t *s = &buf->samples[i];
+        int off = 0;
+        uint32_t hash;
+        int j;
+
+        /* Prepend synthetic frame if needed */
+        if (s->type == RPERF_SAMPLE_GVL_BLOCKED) {
+            temp_ids[off++] = RPERF_SYNTHETIC_GVL_BLOCKED;
+        } else if (s->type == RPERF_SAMPLE_GVL_WAIT) {
+            temp_ids[off++] = RPERF_SYNTHETIC_GVL_WAIT;
+        } else if (s->type == RPERF_SAMPLE_GC_MARKING) {
+            temp_ids[off++] = RPERF_SYNTHETIC_GC_MARKING;
+        } else if (s->type == RPERF_SAMPLE_GC_SWEEPING) {
+            temp_ids[off++] = RPERF_SYNTHETIC_GC_SWEEPING;
+        }
+
+        /* Convert VALUE frames to frame_ids */
+        int overflow = 0;
+        for (j = 0; j < s->depth; j++) {
+            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[off + j] = fid;
+        }
+        if (overflow) break; /* frame_table full, stop aggregating this buffer */
+
+        int total_depth = off + s->depth;
+        hash = rperf_fnv1a_u32(temp_ids, total_depth, s->thread_seq);
+
+        rperf_agg_table_insert(&prof->agg_table, temp_ids, total_depth,
+                               s->thread_seq, s->weight, hash);
+    }
+
+    /* 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);
+    buf->sample_count = 0;
+    buf->frame_pool_count = 0;
+}
+
+/* ---- Aggregation thread ---- */
+
+/* Try to aggregate the standby buffer if swap_ready is set.
+ * Called from worker thread (with or without worker_mutex held). */
+static void
+rperf_try_aggregate(rperf_profiler_t *prof)
+{
+    if (!prof->aggregate || !prof->swap_ready) return;
+    int standby_idx = prof->active_idx ^ 1;
+    rperf_aggregate_buffer(prof, &prof->buffers[standby_idx]);
+    prof->swap_ready = 0;
+}
+
 /* ---- Record a sample ---- */
 
+static void
+rperf_try_swap(rperf_profiler_t *prof)
+{
+    if (!prof->aggregate) return;
+    rperf_sample_buffer_t *buf = &prof->buffers[prof->active_idx];
+    if (buf->sample_count < RPERF_AGG_THRESHOLD) return;
+    if (prof->swap_ready) return; /* standby still being aggregated */
+
+    /* Swap active buffer */
+    prof->active_idx ^= 1;
+    prof->swap_ready = 1;
+
+    /* Wake worker thread */
+    CHECKED(pthread_cond_signal(&prof->worker_cond));
+}
+
 static void
 rperf_record_sample(rperf_profiler_t *prof, size_t frame_start, int depth,
                     int64_t weight, int type, int thread_seq)
 {
     if (weight <= 0) return;
-    if (rperf_ensure_sample_capacity(prof) < 0) return;
+    rperf_sample_buffer_t *buf = &prof->buffers[prof->active_idx];
+    if (rperf_ensure_sample_capacity(buf) < 0) return;
 
-    rperf_sample_t *sample = &prof->samples[prof->sample_count];
+    rperf_sample_t *sample = &buf->samples[buf->sample_count];
     sample->depth = depth;
     sample->frame_start = frame_start;
     sample->weight = weight;
     sample->type = type;
     sample->thread_seq = thread_seq;
-    prof->sample_count++;
+    buf->sample_count++;
+
+    rperf_try_swap(prof);
 }
 
 /* ---- Thread data initialization ---- */
@@ -233,13 +613,14 @@ rperf_handle_suspended(rperf_profiler_t *prof, VALUE thread)
     int64_t time_now = rperf_current_time_ns(prof, td);
     if (time_now < 0) return;
 
-    /* Capture backtrace into frame_pool */
-    if (rperf_ensure_frame_pool_capacity(prof, RPERF_MAX_STACK_DEPTH) < 0) return;
-    size_t frame_start = prof->frame_pool_count;
+    /* Capture backtrace into active buffer's frame_pool */
+    rperf_sample_buffer_t *buf = &prof->buffers[prof->active_idx];
+    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,
-                                  &prof->frame_pool[frame_start], NULL);
+                                  &buf->frame_pool[frame_start], NULL);
     if (depth <= 0) return;
-    prof->frame_pool_count += depth;
+    buf->frame_pool_count += depth;
 
     /* Record normal sample (skip if first time — no prev_time) */
     if (!is_first) {
@@ -353,15 +734,16 @@ rperf_gc_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID id, VALUE
         /* Capture backtrace and timestamp at GC entry */
         prof->gc_enter_ns = rperf_wall_time_ns();
 
-        if (rperf_ensure_frame_pool_capacity(prof, RPERF_MAX_STACK_DEPTH) < 0) return;
-        size_t frame_start = prof->frame_pool_count;
+        rperf_sample_buffer_t *buf = &prof->buffers[prof->active_idx];
+        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,
-                                      &prof->frame_pool[frame_start], NULL);
+                                      &buf->frame_pool[frame_start], NULL);
         if (depth <= 0) {
             prof->gc_frame_depth = 0;
             return;
         }
-        prof->frame_pool_count += depth;
+        buf->frame_pool_count += depth;
         prof->gc_frame_start = frame_start;
         prof->gc_frame_depth = depth;
 
@@ -420,13 +802,14 @@ rperf_sample_job(void *arg)
     if (weight <= 0) return;
 
     /* Capture backtrace and record sample */
-    if (rperf_ensure_frame_pool_capacity(prof, RPERF_MAX_STACK_DEPTH) < 0) return;
+    rperf_sample_buffer_t *buf = &prof->buffers[prof->active_idx];
+    if (rperf_ensure_frame_pool_capacity(buf, RPERF_MAX_STACK_DEPTH) < 0) return;
 
-    size_t frame_start = prof->frame_pool_count;
+    size_t frame_start = buf->frame_pool_count;
     int depth = rb_profile_frames(0, RPERF_MAX_STACK_DEPTH,
-                                  &prof->frame_pool[frame_start], NULL);
+                                  &buf->frame_pool[frame_start], NULL);
     if (depth <= 0) return;
-    prof->frame_pool_count += depth;
+    buf->frame_pool_count += depth;
 
     rperf_record_sample(prof, frame_start, depth, weight, RPERF_SAMPLE_NORMAL, td->thread_seq);
 
@@ -437,7 +820,7 @@ rperf_sample_job(void *arg)
         (ts_end.tv_nsec - ts_start.tv_nsec);
 }
 
-/* ---- Timer ---- */
+/* ---- Worker thread: timer + aggregation ---- */
 
 #if RPERF_USE_TIMER_SIGNAL
 static void
@@ -446,21 +829,65 @@ rperf_signal_handler(int sig)
     g_profiler.trigger_count++;
     rb_postponed_job_trigger(g_profiler.pj_handle);
 }
+
+/* Worker thread for signal mode: aggregation only.
+ * Timer signals are directed to this thread via SIGEV_THREAD_ID,
+ * and handled by the sigaction handler (rperf_signal_handler).
+ * This ensures the timer signal does not interrupt other threads. */
+static void *
+rperf_worker_signal_func(void *arg)
+{
+    rperf_profiler_t *prof = (rperf_profiler_t *)arg;
+
+    /* Publish our kernel TID so start() can use it for SIGEV_THREAD_ID */
+    CHECKED(pthread_mutex_lock(&prof->worker_mutex));
+    prof->worker_tid = (pid_t)syscall(SYS_gettid);
+    CHECKED(pthread_cond_signal(&prof->worker_cond));
+
+    while (prof->running) {
+        CHECKED(pthread_cond_wait(&prof->worker_cond, &prof->worker_mutex));
+        rperf_try_aggregate(prof);
+    }
+    CHECKED(pthread_mutex_unlock(&prof->worker_mutex));
+    return NULL;
+}
 #endif
 
+/* Worker thread for nanosleep mode: timer + aggregation.
+ * Uses pthread_cond_timedwait with absolute deadline.
+ * Timeout → trigger + advance deadline.
+ * Signal (swap_ready) → aggregate only, keep same deadline. */
 static void *
-rperf_timer_func(void *arg)
+rperf_worker_nanosleep_func(void *arg)
 {
     rperf_profiler_t *prof = (rperf_profiler_t *)arg;
-    struct timespec interval;
-    interval.tv_sec = 0;
-    interval.tv_nsec = 1000000000L / prof->frequency;
+    struct timespec deadline;
+    long interval_ns = 1000000000L / prof->frequency;
+
+    clock_gettime(CLOCK_REALTIME, &deadline);
+    deadline.tv_nsec += interval_ns;
+    if (deadline.tv_nsec >= 1000000000L) {
+        deadline.tv_sec++;
+        deadline.tv_nsec -= 1000000000L;
+    }
 
+    CHECKED(pthread_mutex_lock(&prof->worker_mutex));
     while (prof->running) {
-        prof->trigger_count++;
-        rb_postponed_job_trigger(prof->pj_handle);
-        nanosleep(&interval, NULL);
+        int ret = pthread_cond_timedwait(&prof->worker_cond, &prof->worker_mutex, &deadline);
+        assert(ret == 0 || ret == ETIMEDOUT);
+        if (ret == ETIMEDOUT) {
+            prof->trigger_count++;
+            rb_postponed_job_trigger(prof->pj_handle);
+            /* Advance deadline by interval */
+            deadline.tv_nsec += interval_ns;
+            if (deadline.tv_nsec >= 1000000000L) {
+                deadline.tv_sec++;
+                deadline.tv_nsec -= 1000000000L;
+            }
+        }
+        rperf_try_aggregate(prof);
     }
+    CHECKED(pthread_mutex_unlock(&prof->worker_mutex));
     return NULL;
 }
 
@@ -488,12 +915,17 @@ rb_rperf_start(int argc, VALUE *argv, VALUE self)
     VALUE opts;
     int frequency = 1000;
     int mode = 0; /* 0 = cpu, 1 = wall */
+    int aggregate = 1; /* default: aggregate */
 #if RPERF_USE_TIMER_SIGNAL
     int timer_signal = RPERF_TIMER_SIGNAL_DEFAULT;
 #endif
 
     rb_scan_args(argc, argv, ":", &opts);
     if (!NIL_P(opts)) {
+        VALUE vagg = rb_hash_aref(opts, ID2SYM(rb_intern("aggregate")));
+        if (!NIL_P(vagg)) {
+            aggregate = RTEST(vagg) ? 1 : 0;
+        }
         VALUE vfreq = rb_hash_aref(opts, ID2SYM(rb_intern("frequency")));
         if (!NIL_P(vfreq)) {
             frequency = NUM2INT(vfreq);
@@ -535,25 +967,35 @@ rb_rperf_start(int argc, VALUE *argv, VALUE self)
 
     g_profiler.frequency = frequency;
     g_profiler.mode = mode;
-    g_profiler.sample_count = 0;
+    g_profiler.aggregate = aggregate;
     g_profiler.next_thread_seq = 0;
     g_profiler.sampling_count = 0;
     g_profiler.sampling_total_ns = 0;
-    g_profiler.sample_capacity = RPERF_INITIAL_SAMPLES;
-    g_profiler.samples = (rperf_sample_t *)calloc(
-        g_profiler.sample_capacity, sizeof(rperf_sample_t));
-    if (!g_profiler.samples) {
-        rb_raise(rb_eNoMemError, "rperf: failed to allocate sample buffer");
+    g_profiler.trigger_count = 0;
+    g_profiler.active_idx = 0;
+    g_profiler.swap_ready = 0;
+
+    /* Initialize worker mutex/cond */
+    CHECKED(pthread_mutex_init(&g_profiler.worker_mutex, NULL));
+    CHECKED(pthread_cond_init(&g_profiler.worker_cond, NULL));
+
+    /* Initialize sample buffer(s) */
+    if (rperf_sample_buffer_init(&g_profiler.buffers[0]) < 0) {
+        CHECKED(pthread_mutex_destroy(&g_profiler.worker_mutex));
+        CHECKED(pthread_cond_destroy(&g_profiler.worker_cond));
+        rb_raise(rb_eNoMemError, "rperf: failed to allocate sample buffer 0");
     }
+    if (aggregate) {
+        if (rperf_sample_buffer_init(&g_profiler.buffers[1]) < 0) {
+            rperf_sample_buffer_free(&g_profiler.buffers[0]);
+            CHECKED(pthread_mutex_destroy(&g_profiler.worker_mutex));
+            CHECKED(pthread_cond_destroy(&g_profiler.worker_cond));
+            rb_raise(rb_eNoMemError, "rperf: failed to allocate sample buffer 1");
+        }
 
-    g_profiler.frame_pool_count = 0;
-    g_profiler.frame_pool_capacity = RPERF_INITIAL_FRAME_POOL;
-    g_profiler.frame_pool = (VALUE *)calloc(
-        g_profiler.frame_pool_capacity, sizeof(VALUE));
-    if (!g_profiler.frame_pool) {
-        free(g_profiler.samples);
-        g_profiler.samples = NULL;
-        rb_raise(rb_eNoMemError, "rperf: failed to allocate frame pool");
+        /* Initialize aggregation structures */
+        rperf_frame_table_init(&g_profiler.frame_table);
+        rperf_agg_table_init(&g_profiler.agg_table);
     }
 
     /* Register GC event hook */
@@ -581,12 +1023,16 @@ rb_rperf_start(int argc, VALUE *argv, VALUE self)
         VALUE cur_thread = rb_thread_current();
         rperf_thread_data_t *td = rperf_thread_data_create(&g_profiler, cur_thread);
         if (!td) {
-            free(g_profiler.samples);
-            g_profiler.samples = NULL;
-            free(g_profiler.frame_pool);
-            g_profiler.frame_pool = NULL;
             rb_internal_thread_remove_event_hook(g_profiler.thread_hook);
             g_profiler.thread_hook = NULL;
+            if (g_profiler.aggregate) {
+                rperf_sample_buffer_free(&g_profiler.buffers[1]);
+                rperf_frame_table_free(&g_profiler.frame_table);
+                rperf_agg_table_free(&g_profiler.agg_table);
+            }
+            rperf_sample_buffer_free(&g_profiler.buffers[0]);
+            CHECKED(pthread_mutex_destroy(&g_profiler.worker_mutex));
+            CHECKED(pthread_cond_destroy(&g_profiler.worker_cond));
             rb_raise(rb_eNoMemError, "rperf: failed to allocate thread data");
         }
     }
@@ -609,12 +1055,32 @@ rb_rperf_start(int argc, VALUE *argv, VALUE self)
         sa.sa_flags = SA_RESTART;
         sigaction(g_profiler.timer_signal, &sa, NULL);
 
+        /* Start worker thread first to get its kernel TID */
+        g_profiler.worker_tid = 0;
+        if (pthread_create(&g_profiler.worker_thread, NULL,
+                           rperf_worker_signal_func, &g_profiler) != 0) {
+            g_profiler.running = 0;
+            signal(g_profiler.timer_signal, SIG_DFL);
+            goto timer_fail;
+        }
+
+        /* Wait for worker thread to publish its TID */
+        CHECKED(pthread_mutex_lock(&g_profiler.worker_mutex));
+        while (g_profiler.worker_tid == 0) {
+            CHECKED(pthread_cond_wait(&g_profiler.worker_cond, &g_profiler.worker_mutex));
+        }
+        CHECKED(pthread_mutex_unlock(&g_profiler.worker_mutex));
+
+        /* Create timer targeting the worker thread via SIGEV_THREAD_ID */
         memset(&sev, 0, sizeof(sev));
-        sev.sigev_notify = SIGEV_SIGNAL;
+        sev.sigev_notify = SIGEV_THREAD_ID;
         sev.sigev_signo = g_profiler.timer_signal;
+        sev._sigev_un._tid = g_profiler.worker_tid;
         if (timer_create(CLOCK_MONOTONIC, &sev, &g_profiler.timer_id) != 0) {
             g_profiler.running = 0;
             signal(g_profiler.timer_signal, SIG_DFL);
+            CHECKED(pthread_cond_signal(&g_profiler.worker_cond));
+            CHECKED(pthread_join(g_profiler.worker_thread, NULL));
             goto timer_fail;
         }
 
@@ -625,7 +1091,9 @@ rb_rperf_start(int argc, VALUE *argv, VALUE self)
     } else
 #endif
     {
-        if (pthread_create(&g_profiler.timer_thread, NULL, rperf_timer_func, &g_profiler) != 0) {
+        /* Start worker thread (timer via timedwait + aggregation) */
+        if (pthread_create(&g_profiler.worker_thread, NULL,
+                           rperf_worker_nanosleep_func, &g_profiler) != 0) {
             g_profiler.running = 0;
             goto timer_fail;
         }
@@ -643,10 +1111,14 @@ timer_fail:
         }
         rb_internal_thread_remove_event_hook(g_profiler.thread_hook);
         g_profiler.thread_hook = NULL;
-        free(g_profiler.samples);
-        g_profiler.samples = NULL;
-        free(g_profiler.frame_pool);
-        g_profiler.frame_pool = NULL;
+        if (g_profiler.aggregate) {
+            rperf_sample_buffer_free(&g_profiler.buffers[1]);
+            rperf_frame_table_free(&g_profiler.frame_table);
+            rperf_agg_table_free(&g_profiler.agg_table);
+        }
+        rperf_sample_buffer_free(&g_profiler.buffers[0]);
+        CHECKED(pthread_mutex_destroy(&g_profiler.worker_mutex));
+        CHECKED(pthread_cond_destroy(&g_profiler.worker_cond));
         rb_raise(rb_eRuntimeError, "rperf: failed to create timer");
     }
 
@@ -668,12 +1140,15 @@ rb_rperf_stop(VALUE self)
 #if RPERF_USE_TIMER_SIGNAL
     if (g_profiler.timer_signal > 0) {
         timer_delete(g_profiler.timer_id);
-        signal(g_profiler.timer_signal, SIG_DFL);
-    } else
-#endif
-    {
-        pthread_join(g_profiler.timer_thread, NULL);
+        signal(g_profiler.timer_signal, SIG_IGN);
     }
+#endif
+
+    /* Wake and join worker thread */
+    CHECKED(pthread_cond_signal(&g_profiler.worker_cond));
+    CHECKED(pthread_join(g_profiler.worker_thread, NULL));
+    CHECKED(pthread_mutex_destroy(&g_profiler.worker_mutex));
+    CHECKED(pthread_cond_destroy(&g_profiler.worker_cond));
 
     if (g_profiler.thread_hook) {
         rb_internal_thread_remove_event_hook(g_profiler.thread_hook);
@@ -683,6 +1158,16 @@ rb_rperf_stop(VALUE self)
     /* Remove GC event hook */
     rb_remove_event_hook(rperf_gc_event_hook);
 
+    if (g_profiler.aggregate) {
+        /* Aggregate remaining samples from both buffers */
+        if (g_profiler.swap_ready) {
+            int standby_idx = g_profiler.active_idx ^ 1;
+            rperf_aggregate_buffer(&g_profiler, &g_profiler.buffers[standby_idx]);
+            g_profiler.swap_ready = 0;
+        }
+        rperf_aggregate_buffer(&g_profiler, &g_profiler.buffers[g_profiler.active_idx]);
+    }
+
     /* Clean up thread-specific data for all live threads */
     {
         VALUE threads = rb_funcall(rb_cThread, rb_intern("list"), 0);
@@ -713,6 +1198,14 @@ rb_rperf_stop(VALUE self)
     rb_hash_aset(result, ID2SYM(rb_intern("sampling_count")), SIZET2NUM(g_profiler.sampling_count));
     rb_hash_aset(result, ID2SYM(rb_intern("sampling_time_ns")), LONG2NUM(g_profiler.sampling_total_ns));
 
+    /* aggregation stats */
+    if (g_profiler.aggregate) {
+        rb_hash_aset(result, ID2SYM(rb_intern("unique_frames")),
+                     SIZET2NUM(g_profiler.frame_table.count - RPERF_SYNTHETIC_COUNT));
+        rb_hash_aset(result, ID2SYM(rb_intern("unique_stacks")),
+                     SIZET2NUM(g_profiler.agg_table.count));
+    }
+
     /* start_time_ns (CLOCK_REALTIME epoch nanos), duration_ns (CLOCK_MONOTONIC delta) */
     {
         struct timespec stop_monotonic;
@@ -726,45 +1219,76 @@ rb_rperf_stop(VALUE self)
         rb_hash_aset(result, ID2SYM(rb_intern("duration_ns")), LONG2NUM(duration_ns));
     }
 
-    /* samples: array of [frames_array, weight]
-     * Each frame is [path_string, label_string]
-     * GVL blocked/wait samples get synthetic frame prepended (leaf position) */
-    samples_ary = rb_ary_new_capa((long)g_profiler.sample_count);
-    for (i = 0; i < g_profiler.sample_count; i++) {
-        rperf_sample_t *s = &g_profiler.samples[i];
-        VALUE frames = rb_ary_new_capa(s->depth + 1);
-
-        /* Prepend synthetic frame at leaf position (index 0) */
-        if (s->type == RPERF_SAMPLE_GVL_BLOCKED) {
-            VALUE syn = rb_ary_new3(2, rb_str_new_lit("<GVL>"), rb_str_new_lit("[GVL blocked]"));
-            rb_ary_push(frames, syn);
-        } else if (s->type == RPERF_SAMPLE_GVL_WAIT) {
-            VALUE syn = rb_ary_new3(2, rb_str_new_lit("<GVL>"), rb_str_new_lit("[GVL wait]"));
-            rb_ary_push(frames, syn);
-        } else if (s->type == RPERF_SAMPLE_GC_MARKING) {
-            VALUE syn = rb_ary_new3(2, rb_str_new_lit("<GC>"), rb_str_new_lit("[GC marking]"));
-            rb_ary_push(frames, syn);
-        } else if (s->type == RPERF_SAMPLE_GC_SWEEPING) {
-            VALUE syn = rb_ary_new3(2, rb_str_new_lit("<GC>"), rb_str_new_lit("[GC sweeping]"));
-            rb_ary_push(frames, syn);
+    if (g_profiler.aggregate) {
+        /* Build samples from aggregation table.
+         * Use a Ruby array for resolved frames so GC protects them. */
+        rperf_frame_table_t *ft = &g_profiler.frame_table;
+        VALUE resolved_ary = rb_ary_new_capa((long)ft->count);
+        /* Synthetic frames */
+        rb_ary_push(resolved_ary, rb_ary_new3(2, rb_str_new_lit("<GVL>"), rb_str_new_lit("[GVL blocked]")));
+        rb_ary_push(resolved_ary, rb_ary_new3(2, rb_str_new_lit("<GVL>"), rb_str_new_lit("[GVL wait]")));
+        rb_ary_push(resolved_ary, rb_ary_new3(2, rb_str_new_lit("<GC>"),  rb_str_new_lit("[GC marking]")));
+        rb_ary_push(resolved_ary, rb_ary_new3(2, rb_str_new_lit("<GC>"),  rb_str_new_lit("[GC sweeping]")));
+        /* Real frames */
+        for (i = RPERF_SYNTHETIC_COUNT; i < ft->count; i++) {
+            rb_ary_push(resolved_ary, rperf_resolve_frame(ft->keys[i]));
         }
 
-        for (j = 0; j < s->depth; j++) {
-            VALUE fval = g_profiler.frame_pool[s->frame_start + j];
-            rb_ary_push(frames, rperf_resolve_frame(fval));
+        rperf_agg_table_t *at = &g_profiler.agg_table;
+        samples_ary = rb_ary_new();
+        for (i = 0; i < at->bucket_capacity; i++) {
+            rperf_agg_entry_t *e = &at->buckets[i];
+            if (!e->used) continue;
+
+            VALUE frames = rb_ary_new_capa(e->depth);
+            for (j = 0; j < e->depth; j++) {
+                uint32_t fid = at->stack_pool[e->frame_start + j];
+                rb_ary_push(frames, RARRAY_AREF(resolved_ary, fid));
+            }
+
+            VALUE sample = rb_ary_new3(3, frames, LONG2NUM(e->weight), INT2NUM(e->thread_seq));
+            rb_ary_push(samples_ary, sample);
         }
 
-        VALUE sample = rb_ary_new3(3, frames, LONG2NUM(s->weight), INT2NUM(s->thread_seq));
-        rb_ary_push(samples_ary, sample);
+        rperf_sample_buffer_free(&g_profiler.buffers[1]);
+        rperf_frame_table_free(&g_profiler.frame_table);
+        rperf_agg_table_free(&g_profiler.agg_table);
+    } else {
+        /* Raw samples path (aggregate: false) */
+        rperf_sample_buffer_t *buf = &g_profiler.buffers[0];
+        samples_ary = rb_ary_new_capa((long)buf->sample_count);
+        for (i = 0; i < buf->sample_count; i++) {
+            rperf_sample_t *s = &buf->samples[i];
+            VALUE frames = rb_ary_new_capa(s->depth + 1);
+
+            /* Prepend synthetic frame at leaf position (index 0) */
+            if (s->type == RPERF_SAMPLE_GVL_BLOCKED) {
+                VALUE syn = rb_ary_new3(2, rb_str_new_lit("<GVL>"), rb_str_new_lit("[GVL blocked]"));
+                rb_ary_push(frames, syn);
+            } else if (s->type == RPERF_SAMPLE_GVL_WAIT) {
+                VALUE syn = rb_ary_new3(2, rb_str_new_lit("<GVL>"), rb_str_new_lit("[GVL wait]"));
+                rb_ary_push(frames, syn);
+            } else if (s->type == RPERF_SAMPLE_GC_MARKING) {
+                VALUE syn = rb_ary_new3(2, rb_str_new_lit("<GC>"), rb_str_new_lit("[GC marking]"));
+                rb_ary_push(frames, syn);
+            } else if (s->type == RPERF_SAMPLE_GC_SWEEPING) {
+                VALUE syn = rb_ary_new3(2, rb_str_new_lit("<GC>"), rb_str_new_lit("[GC sweeping]"));
+                rb_ary_push(frames, syn);
+            }
+
+            for (j = 0; j < s->depth; j++) {
+                VALUE fval = buf->frame_pool[s->frame_start + j];
+                rb_ary_push(frames, rperf_resolve_frame(fval));
+            }
+
+            VALUE sample = rb_ary_new3(3, frames, LONG2NUM(s->weight), INT2NUM(s->thread_seq));
+            rb_ary_push(samples_ary, sample);
+        }
     }
     rb_hash_aset(result, ID2SYM(rb_intern("samples")), samples_ary);
 
     /* Cleanup */
-    free(g_profiler.samples);
-    g_profiler.samples = NULL;
-    free(g_profiler.frame_pool);
-    g_profiler.frame_pool = NULL;
-    g_profiler.frame_pool_count = 0;
+    rperf_sample_buffer_free(&g_profiler.buffers[0]);
 
     return result;
 }
@@ -793,16 +1317,13 @@ rperf_after_fork_child(void)
     }
     rb_remove_event_hook(rperf_gc_event_hook);
 
-    /* Free sample buffer and frame pool — these hold parent's data */
-    free(g_profiler.samples);
-    g_profiler.samples = NULL;
-    g_profiler.sample_count = 0;
-    g_profiler.sample_capacity = 0;
-
-    free(g_profiler.frame_pool);
-    g_profiler.frame_pool = NULL;
-    g_profiler.frame_pool_count = 0;
-    g_profiler.frame_pool_capacity = 0;
+    /* Free sample buffers, frame table, and agg table — these hold parent's data */
+    rperf_sample_buffer_free(&g_profiler.buffers[0]);
+    if (g_profiler.aggregate) {
+        rperf_sample_buffer_free(&g_profiler.buffers[1]);
+        rperf_frame_table_free(&g_profiler.frame_table);
+        rperf_agg_table_free(&g_profiler.agg_table);
+    }
 
     /* Reset GC state */
     g_profiler.gc_phase = 0;
@@ -810,6 +1331,7 @@ rperf_after_fork_child(void)
     /* Reset stats */
     g_profiler.sampling_count = 0;
     g_profiler.sampling_total_ns = 0;
+    g_profiler.swap_ready = 0;
 }
 
 /* ---- Init ---- */
@@ -830,5 +1352,5 @@ Init_rperf(void)
     rb_gc_register_address(&g_profiler_wrapper);
 
     /* Fork safety: silently stop profiling in child process */
-    pthread_atfork(NULL, NULL, rperf_after_fork_child);
+    CHECKED(pthread_atfork(NULL, NULL, rperf_after_fork_child));
 }

data/lib/rperf/version.rb

@@ -1,3 +1,3 @@
 module Rperf
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/rperf.rb

@@ -17,21 +17,19 @@ module Rperf
   @output = nil
   @stat = false
   @stat_start_mono = nil
-  STAT_TOP_N = 5
-  SYNTHETIC_LABELS = %w[[GVL\ blocked] [GVL\ wait] [GC\ marking] [GC\ sweeping]].freeze
 
   # Starts profiling.
   # format: :pprof, :collapsed, or :text. nil = auto-detect from output extension
   #   .collapsed → collapsed stacks (FlameGraph / speedscope compatible)
   #   .txt       → text report (human/AI readable flat + cumulative table)
   #   otherwise (.pb.gz etc) → pprof protobuf (gzip compressed)
-  def self.start(frequency: 1000, mode: :cpu, output: nil, verbose: false, format: nil, stat: false, signal: nil)
+  def self.start(frequency: 1000, mode: :cpu, output: nil, verbose: false, format: nil, stat: false, signal: nil, aggregate: true)
     @verbose = verbose || ENV["RPERF_VERBOSE"] == "1"
     @output = output
     @format = format
     @stat = stat
     @stat_start_mono = Process.clock_gettime(Process::CLOCK_MONOTONIC) if @stat
-    c_opts = { frequency: frequency, mode: mode }
+    c_opts = { frequency: frequency, mode: mode, aggregate: aggregate }
     c_opts[:signal] = signal unless signal.nil?
     _c_start(**c_opts)
 
@@ -104,7 +102,7 @@ module Rperf
   def self.print_stats(data)
     count = data[:sampling_count] || 0
     total_ns = data[:sampling_time_ns] || 0
-    samples = data[:samples]&.size || 0
+    sample_count = data[:sampling_count] || 0
     mode = data[:mode] || :cpu
     frequency = data[:frequency] || 0
 
@@ -113,7 +111,7 @@ module Rperf
 
     $stderr.puts "[rperf] mode=#{mode} frequency=#{frequency}Hz"
     $stderr.puts "[rperf] sampling: #{count} calls, #{format("%.2f", total_ms)}ms total, #{format("%.1f", avg_us)}us/call avg"
-    $stderr.puts "[rperf] samples recorded: #{samples}"
+    $stderr.puts "[rperf] samples recorded: #{sample_count}"
 
     print_top(data)
   end
@@ -202,7 +200,7 @@ module Rperf
       print_stat_breakdown(breakdown, total_weight)
       print_stat_runtime_info
       print_stat_system_info
-      print_stat_top(samples_raw, total_weight)
+      print_stat_report(data) if ENV["RPERF_STAT_REPORT"] == "1"
       print_stat_footer(samples_raw, real_ns, data)
     end
 
@@ -291,37 +289,20 @@ module Rperf
   end
   private_class_method :print_stat_system_info
 
-  def self.print_stat_top(samples_raw, total_weight)
-    flat = Hash.new(0)
-    samples_raw.each do |frames, weight|
-      leaf = frames.first
-      if leaf
-        _, label = leaf
-        next if SYNTHETIC_LABELS.include?(label)
-        flat[[label, leaf[0]]] += weight
-      end
-    end
-
-    return if flat.empty?
 
-    top = flat.sort_by { |_, w| -w }.first(STAT_TOP_N)
+  def self.print_stat_report(data)
     $stderr.puts
-    $stderr.puts " Top #{top.size} by flat:"
-    top.each do |key, weight|
-      label, path = key
-      pct = total_weight > 0 ? weight * 100.0 / total_weight : 0.0
-      loc = path.empty? ? "" : " (#{path})"
-      $stderr.puts STAT_PCT_LINE.call(format_ms(weight), "ms", pct, "#{label}#{loc}")
-    end
+    $stderr.puts Text.encode(data, header: false)
   end
-  private_class_method :print_stat_top
+  private_class_method :print_stat_report
 
   def self.print_stat_footer(samples_raw, real_ns, data)
-    unique_stacks = samples_raw.map { |frames, _| frames }.uniq.size
+    triggers = data[:trigger_count] || 0
     overhead_pct = real_ns > 0 ? (data[:sampling_time_ns] || 0) * 100.0 / real_ns : 0.0
     $stderr.puts
-    $stderr.puts format("  %d samples (%d unique stacks), %.1f%% profiler overhead",
-                        samples_raw.size, unique_stacks, overhead_pct)
+    samples = data[:sampling_count] || samples_raw.size
+    $stderr.puts format("  %d samples / %d triggers, %.1f%% profiler overhead",
+                        samples, triggers, overhead_pct)
   end
   private_class_method :print_stat_footer
 
@@ -393,11 +374,13 @@ module Rperf
                     when "false" then false
                     else ENV["RPERF_SIGNAL"].to_i
                     end
+    _rperf_aggregate = ENV["RPERF_AGGREGATE"] != "0"
     _rperf_start_opts = { frequency: (ENV["RPERF_FREQUENCY"] || 1000).to_i, mode: _rperf_mode,
                           output: _rperf_stat ? ENV["RPERF_OUTPUT"] : (ENV["RPERF_OUTPUT"] || "rperf.data"),
                           verbose: ENV["RPERF_VERBOSE"] == "1",
                           format: _rperf_format,
-                          stat: _rperf_stat }
+                          stat: _rperf_stat,
+                          aggregate: _rperf_aggregate }
     _rperf_start_opts[:signal] = _rperf_signal unless _rperf_signal.nil?
     start(**_rperf_start_opts)
     at_exit { stop }
@@ -407,7 +390,7 @@ module Rperf
   module Text
     module_function
 
-    def encode(data, top_n: 50)
+    def encode(data, top_n: 50, header: true)
       samples_raw = data[:samples]
       mode = data[:mode] || :cpu
       frequency = data[:frequency] || 0
@@ -417,10 +400,13 @@ module Rperf
       result = Rperf.send(:compute_flat_cum, samples_raw)
 
       out = String.new
-      total_ms = result[:total_weight] / 1_000_000.0
-      out << "Total: #{"%.1f" % total_ms}ms (#{mode})\n"
-      out << "Samples: #{samples_raw.size}, Frequency: #{frequency}Hz\n"
-      out << "\n"
+      if header
+        total_ms = result[:total_weight] / 1_000_000.0
+        out << "Total: #{"%.1f" % total_ms}ms (#{mode})\n"
+        sample_count = data[:sampling_count] || samples_raw.size
+        out << "Samples: #{sample_count}, Frequency: #{frequency}Hz\n"
+        out << "\n"
+      end
       out << format_table("Flat", result[:flat], result[:total_weight], top_n)
       out << "\n"
       out << format_table("Cumulative", result[:cum], result[:total_weight], top_n)
@@ -430,13 +416,12 @@ module Rperf
     def format_table(title, table, total_weight, top_n)
       sorted = table.sort_by { |_, w| -w }.first(top_n)
       out = String.new
-      out << "#{title}:\n"
+      out << " #{title}:\n"
       sorted.each do |key, weight|
         label, path = key
-        ms = weight / 1_000_000.0
         pct = total_weight > 0 ? weight * 100.0 / total_weight : 0.0
         loc = path.empty? ? "" : " (#{path})"
-        out << ("  %8.1fms %5.1f%%  %s%s\n" % [ms, pct, label, loc])
+        out << format("  %14s ms %5.1f%%  %s%s\n", Rperf.send(:format_ms, weight), pct, label, loc)
       end
       out
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rperf
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Koichi Sasada