pf2 0.13.0 → 1.0.0.alpha1

data/ext/pf2/serializer.h

@@ -1,23 +1,21 @@
 #ifndef PF2C_SERIALIZER_H
 #define PF2C_SERIALIZER_H
 
-#include <stdint.h>
-
 #include <ruby.h>
 
 #include "session.h"
 
 struct pf2_ser_sample {
-    size_t *stack; // array of location_indexes
+    int *stack;
     size_t stack_count;
-    size_t *native_stack; // array of location_indexes
+    int *native_stack;
     size_t native_stack_count;
-    uintptr_t ruby_thread_id;
+    size_t ruby_thread_id;
     uint64_t elapsed_ns;
 };
 
 struct pf2_ser_location {
-    size_t function_index;
+    int function_index;
     int32_t lineno;
     size_t address;
 };
@@ -38,8 +36,6 @@ struct pf2_ser_function {
 struct pf2_ser {
     uint64_t start_timestamp_ns;
     uint64_t duration_ns;
-    uint64_t collected_sample_count;
-    uint64_t dropped_sample_count;
 
     struct pf2_ser_sample *samples;
     size_t samples_count;

data/ext/pf2/session.c

@@ -1,10 +1,10 @@
+#include <bits/time.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <sys/time.h>
 #include <time.h>
 
@@ -20,17 +20,14 @@
 #include "session.h"
 #include "serializer.h"
 
-// Pointer to current active session, for access from signal handlers
+#ifndef HAVE_TIMER_CREATE
+// Global session pointer for setitimer fallback
 static struct pf2_session *global_current_session = NULL;
+#endif
 
 static void *sample_collector_thread(void *arg);
-static void drain_ringbuffer(struct pf2_session *session);
 static void sigprof_handler(int sig, siginfo_t *info, void *ucontext);
-static void pf2_session_stop(struct pf2_session *session);
-static size_t intern_location(struct pf2_session *session, VALUE cme, int lineno);
-static size_t intern_stack(struct pf2_session *session, const size_t *frames, size_t depth);
-static size_t intern_native_stack(struct pf2_session *session, const uintptr_t *frames, size_t depth);
-static bool insert_sample(struct pf2_session *session, const struct pf2_sample *sample);
+bool ensure_sample_capacity(struct pf2_session *session);
 
 VALUE
 rb_pf2_session_initialize(int argc, VALUE *argv, VALUE self)
@@ -43,11 +40,10 @@ rb_pf2_session_initialize(int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, ":", &kwargs);
     ID kwarg_labels[] = {
         rb_intern("interval_ms"),
-        rb_intern("time_mode"),
-        rb_intern("_test_no_install_timer")
+        rb_intern("time_mode")
     };
     VALUE *kwarg_values = NULL;
-    rb_get_kwargs(kwargs, kwarg_labels, 0, 3, kwarg_values);
+    rb_get_kwargs(kwargs, kwarg_labels, 0, 2, kwarg_values);
 
     session->configuration = pf2_configuration_new_from_options_hash(kwargs);
 
@@ -60,9 +56,6 @@ rb_pf2_session_start(VALUE self)
     struct pf2_session *session;
     TypedData_Get_Struct(self, struct pf2_session, &pf2_session_type, session);
 
-    // Store pointer to current session for access from signal handlers
-    global_current_session = session;
-
     session->is_running = true;
 
     // Record start time
@@ -94,60 +87,58 @@ rb_pf2_session_start(VALUE self)
     }
 #endif
 
-    global_current_session = session;
-
-    if (!session->configuration->_test_no_install_timer) {
 #ifdef HAVE_TIMER_CREATE
-        // Configure a kernel timer to send SIGPROF periodically
-        struct sigevent sev;
-        sev.sigev_notify = SIGEV_SIGNAL;
-        sev.sigev_signo = SIGPROF;
-        if (timer_create(
-            session->configuration->time_mode == PF2_TIME_MODE_CPU_TIME
-                ? CLOCK_PROCESS_CPUTIME_ID
-                : CLOCK_MONOTONIC,
-            &sev,
-            &session->timer
-        ) == -1) {
-            rb_raise(rb_eRuntimeError, "Failed to create timer");
-        }
-        struct itimerspec its = {
-            .it_value = {
-                .tv_sec = 0,
-                .tv_nsec = session->configuration->interval_ms * 1000000,
-            },
-            .it_interval = {
-                .tv_sec = 0,
-                .tv_nsec = session->configuration->interval_ms * 1000000,
-            },
-        };
-        if (timer_settime(session->timer, 0, &its, NULL) == -1) {
-            rb_raise(rb_eRuntimeError, "Failed to start timer");
-        }
+    // Configure a kernel timer to send SIGPROF periodically
+    struct sigevent sev;
+    sev.sigev_notify = SIGEV_SIGNAL;
+    sev.sigev_signo = SIGPROF;
+    sev.sigev_value.sival_ptr = session; // Passed as info->si_value.sival_ptr
+    if (timer_create(
+        session->configuration->time_mode == PF2_TIME_MODE_CPU_TIME
+            ? CLOCK_PROCESS_CPUTIME_ID
+            : CLOCK_MONOTONIC,
+        &sev,
+        &session->timer
+    ) == -1) {
+        rb_raise(rb_eRuntimeError, "Failed to create timer");
+    }
+    struct itimerspec its = {
+        .it_value = {
+            .tv_sec = 0,
+            .tv_nsec = session->configuration->interval_ms * 1000000,
+        },
+        .it_interval = {
+            .tv_sec = 0,
+            .tv_nsec = session->configuration->interval_ms * 1000000,
+        },
+    };
+    if (timer_settime(session->timer, 0, &its, NULL) == -1) {
+        rb_raise(rb_eRuntimeError, "Failed to start timer");
+    }
 #else
-        // Use setitimer as fallback
-        // Some platforms (e.g. macOS) do not have timer_create(3).
-        // setitimer(3) can be used as a alternative, but has limited functionality.
-
-        struct itimerval itv = {
-            .it_value = {
-                .tv_sec = 0,
-                .tv_usec = session->configuration->interval_ms * 1000,
-            },
-            .it_interval = {
-                .tv_sec = 0,
-                .tv_usec = session->configuration->interval_ms * 1000,
-            },
-        };
-        int which_timer = session->configuration->time_mode == PF2_TIME_MODE_CPU_TIME
-            ? ITIMER_PROF  // CPU time (sends SIGPROF)
-            : ITIMER_REAL; // Wall time (sends SIGALRM)
-
-        if (setitimer(which_timer, &itv, NULL) == -1) {
-            rb_raise(rb_eRuntimeError, "Failed to start timer");
-        }
+    // Use setitimer as fallback
+    // Some platforms (e.g. macOS) do not have timer_create(3).
+    // setitimer(3) can be used as a alternative, but has limited functionality.
+    global_current_session = session;
+
+    struct itimerval itv = {
+        .it_value = {
+            .tv_sec = 0,
+            .tv_usec = session->configuration->interval_ms * 1000,
+        },
+        .it_interval = {
+            .tv_sec = 0,
+            .tv_usec = session->configuration->interval_ms * 1000,
+        },
+    };
+    int which_timer = session->configuration->time_mode == PF2_TIME_MODE_CPU_TIME
+        ? ITIMER_PROF  // CPU time (sends SIGPROF)
+        : ITIMER_REAL; // Wall time (sends SIGALRM)
+
+    if (setitimer(which_timer, &itv, NULL) == -1) {
+        rb_raise(rb_eRuntimeError, "Failed to start timer");
+    }
 #endif
-    } // if !__test_no_install_timer
 
     return Qtrue;
 }
@@ -159,9 +150,19 @@ sample_collector_thread(void *arg)
 
     while (session->is_running == true) {
         // Take samples from the ring buffer
-        drain_ringbuffer(session);
+        struct pf2_sample sample;
+        while (pf2_ringbuffer_pop(session->rbuf, &sample) == true) {
+            // Ensure we have capacity before adding a new sample
+            if (!ensure_sample_capacity(session)) {
+                // Failed to expand buffer
+                PF2_DEBUG_LOG("Failed to expand sample buffer. Dropping sample\n");
+                break;
+            }
+
+            session->samples[session->samples_index++] = sample;
+        }
 
-        // Sleep for 10 ms
+        // Sleep for 100 ms
         // TODO: Replace with high watermark callback
         struct timespec ts = { .tv_sec = 0, .tv_nsec = 10 * 1000000, }; // 10 ms
         nanosleep(&ts, NULL);
@@ -170,20 +171,6 @@ sample_collector_thread(void *arg)
     return NULL;
 }
 
-static void
-drain_ringbuffer(struct pf2_session *session)
-{
-    struct pf2_sample sample;
-    while (pf2_ringbuffer_pop(session->rbuf, &sample) == true) {
-        if (!insert_sample(session, &sample)) {
-            atomic_fetch_add_explicit(&session->dropped_sample_count, 1, memory_order_relaxed);
-            PF2_DEBUG_LOG("Failed to record sample. Dropping sample\n");
-        } else {
-            atomic_fetch_add_explicit(&session->collected_sample_count, 1, memory_order_relaxed);
-        }
-    }
-}
-
 // async-signal-safe
 static void
 sigprof_handler(int sig, siginfo_t *info, void *ucontext)
@@ -193,12 +180,16 @@ sigprof_handler(int sig, siginfo_t *info, void *ucontext)
     clock_gettime(CLOCK_MONOTONIC, &sig_start_time);
 #endif
 
-    struct pf2_session *session = global_current_session;
+    struct pf2_session *session;
+#ifdef HAVE_TIMER_CREATE
+    session = info->si_value.sival_ptr;
+#else
+    session = global_current_session;
+#endif
 
     // If garbage collection is in progress, don't collect samples.
     if (atomic_load_explicit(&session->is_marking, memory_order_acquire)) {
         PF2_DEBUG_LOG("Dropping sample: Garbage collection is in progress\n");
-        atomic_fetch_add_explicit(&session->dropped_sample_count, 1, memory_order_relaxed);
         return;
     }
 
@@ -206,7 +197,6 @@ sigprof_handler(int sig, siginfo_t *info, void *ucontext)
 
     if (pf2_sample_capture(&sample) == false) {
         PF2_DEBUG_LOG("Dropping sample: Failed to capture sample\n");
-        atomic_fetch_add_explicit(&session->dropped_sample_count, 1, memory_order_relaxed);
         return;
     }
 
@@ -214,7 +204,6 @@ sigprof_handler(int sig, siginfo_t *info, void *ucontext)
     if (pf2_ringbuffer_push(session->rbuf, &sample) == false) {
         // Copy failed. The sample buffer is full.
         PF2_DEBUG_LOG("Dropping sample: Sample buffer is full\n");
-        atomic_fetch_add_explicit(&session->dropped_sample_count, 1, memory_order_relaxed);
         return;
     }
 
@@ -231,117 +220,27 @@ sigprof_handler(int sig, siginfo_t *info, void *ucontext)
 #endif
 }
 
-static size_t
-intern_location(struct pf2_session *session, VALUE cme, int lineno)
+// Ensures that the session's sample array has capacity for at least one more sample
+// Returns true if successful, false if memory allocation failed
+bool
+ensure_sample_capacity(struct pf2_session *session)
 {
-    struct pf2_location_key key = { .cme = cme, .lineno = lineno };
-    int absent;
-    khint_t k = pf2_location_table_put(session->location_table, key, &absent);
-    if (k == kh_end(session->location_table)) { return (size_t)-1; }
-    if (absent) {
-        kh_val(session->location_table, k) = kh_size(session->location_table) - 1;
+    // Check if we need to expand
+    if (session->samples_index < session->samples_capacity) {
+        return true;
     }
-    return kh_val(session->location_table, k);
-}
 
-static size_t
-intern_stack(struct pf2_session *session, const size_t *frames, size_t depth)
-{
-    struct pf2_stack_key skey = { .frames = frames, .depth = depth };
-    int absent;
-    khint_t k = pf2_stack_table_put(session->stack_table, skey, &absent);
-    if (k == kh_end(session->stack_table)) { return (size_t)-1; }
-    if (absent) {
-        size_t *copy = NULL;
-        if (depth > 0) {
-            copy = malloc(sizeof(size_t) * depth);
-            // TODO: if allocation fails, remove stack_table entry to avoid dangling stack-local key.
-            if (copy == NULL) return (size_t)-1;
-            memcpy(copy, frames, sizeof(size_t) * depth);
-        }
-        kh_key(session->stack_table, k).frames = copy;
-        kh_key(session->stack_table, k).depth = depth;
-        kh_val(session->stack_table, k) = kh_size(session->stack_table) - 1;
-    }
-    return kh_val(session->stack_table, k);
-}
+    // Calculate new size (double the current size)
+    size_t new_capacity = session->samples_capacity * 2;
 
-static size_t
-intern_native_stack(struct pf2_session *session, const uintptr_t *frames, size_t depth)
-{
-    struct pf2_native_stack_key skey = { .frames = frames, .depth = depth };
-    int absent;
-    khint_t k = pf2_native_stack_table_put(session->native_stack_table, skey, &absent);
-    if (k == kh_end(session->native_stack_table)) { return (size_t)-1; }
-    if (absent) {
-        uintptr_t *copy = NULL;
-        if (depth > 0) {
-            copy = malloc(sizeof(uintptr_t) * depth);
-            if (copy == NULL) return (size_t)-1;
-            memcpy(copy, frames, sizeof(uintptr_t) * depth);
-        }
-        kh_key(session->native_stack_table, k).frames = copy;
-        kh_key(session->native_stack_table, k).depth = depth;
-        kh_val(session->native_stack_table, k) = kh_size(session->native_stack_table) - 1;
+    // Reallocate the array
+    struct pf2_sample *new_samples = realloc(session->samples, new_capacity * sizeof(struct pf2_sample));
+    if (new_samples == NULL) {
+        return false;
     }
-    return kh_val(session->native_stack_table, k);
-}
 
-static bool
-insert_sample(struct pf2_session *session, const struct pf2_sample *sample)
-{
-    size_t frame_ids[PF2_SAMPLE_MAX_RUBY_DEPTH];
-
-    // Convert each frame to a location
-    for (int i = 0; i < sample->depth; i++) {
-        frame_ids[i] = intern_location(session, sample->cmes[i], sample->linenos[i]);
-        if (frame_ids[i] == (size_t)-1) { return false; }
-    }
-
-    // Obtain stack_id for the array of locations
-    size_t stack_id = intern_stack(session, frame_ids, (size_t)sample->depth);
-    if (stack_id == (size_t)-1) { return false; }
-
-    size_t native_stack_id = intern_native_stack(session, sample->native_stack, sample->native_stack_depth);
-    if (native_stack_id == (size_t)-1) { return false; }
-
-    // Increment the observation count for this stack_id
-    int absent;
-    struct pf2_combined_stack_key ckey = {
-        .ruby_stack_id = stack_id,
-        .native_stack_id = native_stack_id
-    };
-    khint_t k = pf2_sample_table_put(session->sample_table, ckey, &absent);
-    if (k == kh_end(session->sample_table)) { return false; }
-    struct pf2_sample_stats *stats = &kh_val(session->sample_table, k);
-    if (absent) {
-        // This is the first time this stack was observed. Initialize stats.
-        stats->count = 0;
-        stats->timestamps = NULL;
-        stats->thread_ids = NULL;
-        stats->timestamps_count = 0;
-        stats->timestamps_capacity = 0;
-    }
-
-    // count
-    stats->count += 1;
-    // timestamps
-    if (stats->timestamps_count == stats->timestamps_capacity) {
-        size_t new_cap = stats->timestamps_capacity ? stats->timestamps_capacity * 2 : 16;
-        uint64_t *new_ts = realloc(stats->timestamps, sizeof(uint64_t) * new_cap);
-        uintptr_t *new_threads = realloc(stats->thread_ids, sizeof(uintptr_t) * new_cap);
-        if (new_ts == NULL || new_threads == NULL) {
-            free(new_ts);
-            free(new_threads);
-            return false;
-        }
-        stats->timestamps = new_ts;
-        stats->thread_ids = new_threads;
-        stats->timestamps_capacity = new_cap;
-    }
-    stats->timestamps[stats->timestamps_count] = sample->timestamp_ns;
-    stats->thread_ids[stats->timestamps_count] = (uintptr_t)sample->context_pthread;
-    stats->timestamps_count++;
+    session->samples = new_samples;
+    session->samples_capacity = new_capacity;
 
     return true;
 }
@@ -352,20 +251,6 @@ rb_pf2_session_stop(VALUE self)
     struct pf2_session *session;
     TypedData_Get_Struct(self, struct pf2_session, &pf2_session_type, session);
 
-    pf2_session_stop(session);
-
-    // Create serializer and serialize
-    struct pf2_ser *serializer = pf2_ser_new();
-    pf2_ser_prepare(serializer, session);
-    VALUE result = pf2_ser_to_ruby_hash(serializer);
-    pf2_ser_free(serializer);
-
-    return result;
-}
-
-static void
-pf2_session_stop(struct pf2_session *session)
-{
     // Calculate duration
     struct timespec end_time;
     clock_gettime(CLOCK_MONOTONIC, &end_time);
@@ -375,10 +260,8 @@ pf2_session_stop(struct pf2_session *session)
 
     // Disarm and delete the timer.
 #ifdef HAVE_TIMER_CREATE
-    if (!session->configuration->_test_no_install_timer) {
-        if (timer_delete(session->timer) == -1) {
-            rb_raise(rb_eRuntimeError, "Failed to delete timer");
-        }
+    if (timer_delete(session->timer) == -1) {
+        rb_raise(rb_eRuntimeError, "Failed to delete timer");
     }
 #else
     struct itimerval zero_timer = {{0, 0}, {0, 0}};
@@ -394,7 +277,14 @@ pf2_session_stop(struct pf2_session *session)
     // Terminate the collector thread
     session->is_running = false;
     pthread_join(*session->collector_thread, NULL);
-    drain_ringbuffer(session);
+
+    // Create serializer and serialize
+    struct pf2_ser *serializer = pf2_ser_new();
+    pf2_ser_prepare(serializer, session);
+    VALUE result = pf2_ser_to_ruby_hash(serializer);
+    pf2_ser_free(serializer);
+
+    return result;
 }
 
 VALUE
@@ -410,7 +300,7 @@ pf2_session_alloc(VALUE self)
 {
     // Initialize state for libbacktrace
     if (global_backtrace_state == NULL) {
-        global_backtrace_state = backtrace_create_state(NULL, 1, pf2_backtrace_print_error, NULL);
+        global_backtrace_state = backtrace_create_state("pf2", 1, pf2_backtrace_print_error, NULL);
         if (global_backtrace_state == NULL) {
             rb_raise(rb_eRuntimeError, "Failed to initialize libbacktrace");
         }
@@ -421,61 +311,26 @@ pf2_session_alloc(VALUE self)
         rb_raise(rb_eNoMemError, "Failed to allocate memory");
     }
 
-    // is_running
-    session->is_running = false;
-
-    // timer
-#ifdef HAVE_TIMER_CREATE
-    session->timer = (timer_t)0;
-#else
-    session->timer = (struct itimerval){0};
-#endif
-
-    // rbuf
     session->rbuf = pf2_ringbuffer_new(1000);
     if (session->rbuf == NULL) {
         rb_raise(rb_eNoMemError, "Failed to allocate memory");
     }
 
-    // is_marking
     atomic_store_explicit(&session->is_marking, false, memory_order_relaxed);
-
-    // collector_thread
     session->collector_thread = malloc(sizeof(pthread_t));
     if (session->collector_thread == NULL) {
         rb_raise(rb_eNoMemError, "Failed to allocate memory");
     }
 
-    // location_table, stack_table, native_stack_table, sample_table
-    session->location_table = pf2_location_table_init();
-    if (session->location_table == NULL) {
-        rb_raise(rb_eNoMemError, "Failed to allocate location table");
-    }
-    session->stack_table = pf2_stack_table_init();
-    if (session->stack_table == NULL) {
-        rb_raise(rb_eNoMemError, "Failed to allocate stack table");
-    }
-    session->native_stack_table = pf2_native_stack_table_init();
-    if (session->native_stack_table == NULL) {
-        rb_raise(rb_eNoMemError, "Failed to allocate native stack table");
-    }
-    session->sample_table = pf2_sample_table_init();
-    if (session->sample_table == NULL) {
-        rb_raise(rb_eNoMemError, "Failed to allocate stack sample table");
-    }
-
-    // collected_sample_count, dropped_sample_count
-    atomic_store_explicit(&session->collected_sample_count, 0, memory_order_relaxed);
-    atomic_store_explicit(&session->dropped_sample_count, 0, memory_order_relaxed);
-
-    // start_time_realtime, start_time
-    session->start_time_realtime = (struct timespec){0};
-    session->start_time = (struct timespec){0};
-
-    // duration_ns
     session->duration_ns = 0;
 
-    // configuration
+    session->samples_index = 0;
+    session->samples_capacity = 500; // 10 seconds worth of samples at 50 Hz
+    session->samples = malloc(sizeof(struct pf2_sample) * session->samples_capacity);
+    if (session->samples == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory");
+    }
+
     session->configuration = NULL;
 
     return TypedData_Wrap_Struct(self, &pf2_session_type, session);
@@ -503,11 +358,11 @@ pf2_session_dmark(void *sess)
         head = (head + 1) % rbuf->size;
     }
 
-    // Mark Ruby VALUEs stored in location_table keys
-    if (session->location_table) {
-        khint_t k;
-        kh_foreach(session->location_table, k) {
-            rb_gc_mark(kh_key(session->location_table, k).cme);
+    // Iterate over all samples in the samples array and mark them
+    for (size_t i = 0; i < session->samples_index; i++) {
+        sample = &session->samples[i];
+        for (int i = 0; i < sample->depth; i++) {
+            rb_gc_mark(sample->cmes[i]);
         }
     }
 
@@ -518,44 +373,11 @@ pf2_session_dmark(void *sess)
 void
 pf2_session_dfree(void *sess)
 {
+    // TODO: Ensure the uninstall process is complete before freeing the session
     struct pf2_session *session = sess;
-
-    assert(session->is_running == false || session->is_running == true);
-
-    // Stop the session if it's still running
-    if (session->is_running) {
-        pf2_session_stop(session);
-    }
-
     pf2_configuration_free(session->configuration);
     pf2_ringbuffer_free(session->rbuf);
-
-    if (session->sample_table) {
-        khint_t k;
-        kh_foreach(session->sample_table, k) {
-            free(kh_val(session->sample_table, k).timestamps);
-            free(kh_val(session->sample_table, k).thread_ids);
-        }
-        pf2_sample_table_destroy(session->sample_table);
-    }
-    if (session->stack_table) {
-        khint_t k;
-        kh_foreach(session->stack_table, k) {
-            free((void *)kh_key(session->stack_table, k).frames);
-        }
-        pf2_stack_table_destroy(session->stack_table);
-    }
-    if (session->native_stack_table) {
-        khint_t k;
-        kh_foreach(session->native_stack_table, k) {
-            free((void *)kh_key(session->native_stack_table, k).frames);
-        }
-        pf2_native_stack_table_destroy(session->native_stack_table);
-    }
-    if (session->location_table) {
-        pf2_location_table_destroy(session->location_table);
-    }
-
+    free(session->samples);
     free(session->collector_thread);
     free(session);
 }
@@ -566,6 +388,7 @@ pf2_session_dsize(const void *sess)
     const struct pf2_session *session = sess;
     return (
         sizeof(struct pf2_session)
+        + sizeof(struct pf2_sample) * session->samples_capacity
         + sizeof(struct pf2_sample) * session->rbuf->size
     );
 }