pf2 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a0dc2d338a482c56472ec6279cc4fd111c4263a540ab00872d57439a14244af
-  data.tar.gz: 56bdc8e81a1d4bccee07d7785eec713329c8ec4b9e659f2b494e12e8e016e60a
+  metadata.gz: 74e3ac2900007b7750e3c3274833e1f713b6e85570db0aa738761ea99b517fe8
+  data.tar.gz: 68ffc8d681328e4d5542e4bd4b3a98edfd08d69fa1b54342fdccbe8f9495bcf0
 SHA512:
-  metadata.gz: 43449c0433cfdc390aecf5335f2a8631d11a0a41ac3afc6fc469909e5fd28c45bde16de8fbcff5229c16551d26a2b47210ff2342dea5b190a47ca128e9656c80
-  data.tar.gz: e6f5f2481932100cd82504dcb3b24e71b123b1263a2588b584cf5e72e53817f2004c7ffe6e96ff12f9815975ddfeac679219468a1af9223f6b5a367b3ec0b5e6
+  metadata.gz: 4f1e67870eac32734a7532f46f29b74589ec6d71c59c925fc02456f473a516218fbbf46fed730558f0b9525c585dbb2fbc088fcf9cbfb47e7f4b89adda7f4974
+  data.tar.gz: 8f5ec74f112eb65a512dbcd7002b0db9a4da0d3a2124d3bd2e7106412c71009b36f92ff442efc87910a5a8829094c06e1ee93169c829ab893dd8e1bd86a81a4f

data/.document

@@ -0,0 +1,3 @@
+ext/
+lib/
+*.md

data/.rdoc_options

@@ -0,0 +1,6 @@
+title: Pf2
+main_page: README.md
+encoding: UTF-8
+
+autolink_excluded_words:
+  - Pf2

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 ## [Unreleased]
 
+## [0.11.0] - 2025-12-27
+
+### Added
+
+- RDoc documentation is now online - https://osyoyu.github.io/pf2/
+- Native stack consolidation now supports LTO-ed binaries (@hanazuki)
+
+### Changed
+
+- `Pf2c` module is now completely removed. `Pf2c::Session` has been merged as `Pf2::Session`.
+
+### Fixed
+
+- Fixed an bug where the program crashes when a `Pf2::Session` is GC'd before profiling starts.
+- Fixed an bug where the program crashes when the native stack was more than 200 frames deep.
+
+
+## [0.10.0] - 2025-12-26
+
+### Added
+
+**This version contains a complete rewrite of the profiler!**
+
+- The default sample collection backend has been switched to the new C-based backend.
+  - The previous Rust-based backed has been removed. Use v0.9.0 if you need it.
+- macOS / non-Linux platform support!
+  - On platforms which lack `timer_create(3)` such as macOS, Pf2 now fall backs to `setitimer(3)` based sampling. This mode does not support per-thread CPU time sampling.
+
+### Changed
+
+- `logger` is now declared as a dependency (Ruby 4.0 compat).
+
+
 ## [0.9.0] - 2025-03-22
 
 ## Added
@@ -11,6 +44,7 @@
 
 - Set SA_RESTART flag to reduce EINTRs in profiled code
 
+
 ## [0.8.0] - 2025-01-27
 
 ## Added
@@ -19,12 +53,14 @@
   - This serializer is more efficient and has a smaller memory footprint than the default serializer.
   - Ser2 still lacks some features, such as weaving of native stacks.
 
+
 ## [0.7.1] - 2025-01-02
 
 ### Fixed
 
 - Reverted Cargo.lock version to 3 to support older versions of Rust (<1.78).
 
+
 ## [0.7.0] - 2025-01-03
 
 ### Changed

data/README.md

@@ -3,6 +3,9 @@ Pf2
 
 A experimental sampling-based profiler for Ruby 3.3+.
 
+- GitHub: https://github.com/osyoyu/pf2
+- Documentation: https://osyoyu.github.io/pf2/
+
 Notable Capabilites
 --------
 
@@ -13,6 +16,25 @@ Notable Capabilites
 Usage
 --------
 
+### Installation
+
+You will need a C compiler to build the native extension.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pf2'
+
+# When using the main branch, specify submodules: true
+gem 'pf2', git: 'https://github.com/osyoyu/pf2.git', submodules: true
+```
+
+Pf2 can be installed as a standalone CLI tool as well.
+
+```console
+gem install pf2
+```
+
 ### Quickstart
 
 Run your Ruby program through `pf2 serve`.
@@ -116,7 +138,7 @@ Schedulers determine when to execute sample collection, based on configuration (
 
 The first is the `SignalScheduler`, based on POSIX timers. Pf2 will use this scheduler when possible. SignalScheduler creates a POSIX timer for each Ruby Thread (the underlying pthread to be more accurate) using `timer_create(2)`. This leaves the actual time-keeping to the OS, which is capable of tracking accurate per-thread CPU time usage.
 
-When the specified interval has arrived (the timer has _expired_), the OS delivers us a SIGALRM (note: Unlike `setitimer(2)`, `timer_create(2)` allows us to choose which signal to be delivered, and Pf2 uses SIGALRM regardless of time mode). This is why the scheduler is named SignalScheduler.
+When the specified interval has arrived (the timer has _expired_), the OS delivers us a SIGPROF signal. This is why the scheduler is named SignalScheduler.
 
 Signals are directed to Ruby Threads' underlying pthread, effectively "pausing" the Thread's activity. This routing is done using `SIGEV_THREAD_ID`, which is a Linux-only feature. Sample collection is done in the signal handler, which is expected to be more _accurate_, capturing the paused Thread's activity.
 
@@ -128,11 +150,16 @@ Another scheduler is the `TimerThreadScheduler`, which maintains a time-keeping
 
 This scheduler is wall-time only, and does not support CPU-time based profiling.
 
-Future Plans
+#### macOS Support
+
+On platforms where `timer_create()` is not supported (namely macOS), Pf2 falls back to `setitimer()`.
+
+
+Wishlist
 --------
 
-- Remove known limitations, if possible
-- Implement a "tracing" scheduler, using the C TracePoint API
+- [Flame Scopes](https://www.brendangregg.com/flamescope.html)
+- More unit/e2e tests
 - more
 
 Development

data/Rakefile

@@ -1,18 +1,13 @@
 require 'bundler/gem_tasks'
 require 'rake/extensiontask'
 require 'minitest/test_task'
+require 'rdoc/task'
 
 task default: %i[]
 
-if ENV['PF2_PF2C'] == '1'
-  Rake::ExtensionTask.new 'pf2c' do |ext|
-    ext.name = 'pf2'
-    ext.lib_dir = 'lib/pf2'
-  end
-else
-  Rake::ExtensionTask.new 'pf2' do |ext|
-    ext.lib_dir = 'lib/pf2'
-  end
+Rake::ExtensionTask.new 'pf2' do |ext|
+  ext.name = 'pf2'
+  ext.lib_dir = 'lib/pf2'
 end
 
 Minitest::TestTask.create(:test) do |t|
@@ -21,3 +16,7 @@ Minitest::TestTask.create(:test) do |t|
   t.warning = false
   t.test_globs = ["test/**/*_test.rb"]
 end
+
+RDoc::Task.new do |doc|
+  doc.rdoc_dir = "_site" # for GitHub pages
+end

data/doc/development.md

@@ -1,6 +1,12 @@
 Pf2 Development
 ===========
 
+Setup
+--------
+
+- `git submodule update --init`
+
+
 Releasing
 --------
 

data/ext/pf2/debug.h

@@ -0,0 +1,12 @@
+#ifndef PF2_DEBUG_H
+#define PF2_DEBUG_H
+
+#include <stdio.h>
+
+#ifdef PF2_DEBUG
+    #define PF2_DEBUG_LOG(format, ...) printf(format, ##__VA_ARGS__)
+#else
+    #define PF2_DEBUG_LOG(format, ...) ((void)0)
+#endif
+
+#endif // PF2_DEBUG_H

data/ext/pf2/extconf.rb

@@ -1,10 +1,27 @@
 require 'mkmf'
-require 'rb_sys/mkmf'
+require 'mini_portile2'
 
-abort 'missing rb_profile_thread_frames()' unless have_func 'rb_profile_thread_frames'
+libbacktrace = MiniPortile.new('libbacktrace', '1.0.0')
+libbacktrace.source_directory = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'vendor', 'libbacktrace'))
+libbacktrace.configure_options << 'CFLAGS=-fPIC'
+libbacktrace.cook
+libbacktrace.mkmf_config
 
-create_rust_makefile 'pf2/pf2' do |r|
-  if ENV['PF2_FEATURES']
-    r.features = ENV['PF2_FEATURES'].split(",")
-  end
+if !have_func('backtrace_full', 'backtrace.h')
+  raise 'libbacktrace has not been properly configured'
+end
+
+append_ldflags('-lrt') # for timer_create
+append_cflags('-fvisibility=hidden')
+append_cflags('-DPF2_DEBUG') if ENV['PF2_DEBUG'] == '1'
+
+# Check for timer functions
+have_timer_create = have_func('timer_create')
+have_setitimer = have_func('setitimer')
+
+if have_timer_create || have_setitimer
+  $srcs = Dir.glob("#{File.join(File.dirname(__FILE__), '*.c')}")
+  create_makefile 'pf2/pf2'
+else
+  raise 'Neither timer_create nor setitimer is available'
 end

data/ext/pf2/pf2.c

@@ -0,0 +1,17 @@
+#include <ruby.h>
+
+#include "session.h"
+
+VALUE rb_mPf2;
+
+RUBY_FUNC_EXPORTED void
+Init_pf2(void)
+{
+    rb_mPf2 = rb_define_module("Pf2");
+    VALUE rb_mPf2_cSession = rb_define_class_under(rb_mPf2, "Session", rb_cObject);
+    rb_define_alloc_func(rb_mPf2_cSession, pf2_session_alloc);
+    rb_define_method(rb_mPf2_cSession, "initialize", rb_pf2_session_initialize, -1);
+    rb_define_method(rb_mPf2_cSession, "start", rb_pf2_session_start, 0);
+    rb_define_method(rb_mPf2_cSession, "stop", rb_pf2_session_stop, 0);
+    rb_define_method(rb_mPf2_cSession, "configuration", rb_pf2_session_configuration, 0);
+}

data/ext/{pf2c → pf2}/sample.c

@@ -1,5 +1,6 @@
 #include <stdbool.h>
 #include <time.h>
+#include <pthread.h>
 
 #include <backtrace.h>
 #include <ruby.h>
@@ -8,8 +9,6 @@
 #include "backtrace_state.h"
 #include "sample.h"
 
-const int PF2_SAMPLE_MAX_NATIVE_DEPTH = 300;
-
 static int capture_native_backtrace(struct pf2_sample *sample);
 static int backtrace_on_ok(void *data, uintptr_t pc);
 
@@ -17,13 +16,18 @@ static int backtrace_on_ok(void *data, uintptr_t pc);
 bool
 pf2_sample_capture(struct pf2_sample *sample)
 {
+    // Initialize sample
+    memset(sample, 0, sizeof(struct pf2_sample));
+
     // Record the current time
     struct timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
     sample->timestamp_ns = (uint64_t)now.tv_sec * 1000000000ULL + (uint64_t)now.tv_nsec;
 
+    sample->context_pthread = pthread_self();
+
     // Obtain the current stack from Ruby
-    sample->depth = rb_profile_frames(0, 200, sample->cmes, sample->linenos);
+    sample->depth = rb_profile_frames(0, PF2_SAMPLE_MAX_RUBY_DEPTH, sample->cmes, sample->linenos);
 
     // Capture C-level backtrace
     sample->native_stack_depth = capture_native_backtrace(sample);

data/ext/pf2/sample.h

@@ -0,0 +1,27 @@
+#ifndef PF2_SAMPLE_H
+#define PF2_SAMPLE_H
+
+#include <pthread.h>
+
+#include <ruby.h>
+
+#define PF2_SAMPLE_MAX_RUBY_DEPTH 200
+#define PF2_SAMPLE_MAX_NATIVE_DEPTH 300
+
+struct pf2_sample {
+    pthread_t context_pthread;
+
+    int depth;
+    VALUE cmes[PF2_SAMPLE_MAX_RUBY_DEPTH];
+    int linenos[PF2_SAMPLE_MAX_RUBY_DEPTH];
+
+    size_t native_stack_depth;
+    uintptr_t native_stack[PF2_SAMPLE_MAX_NATIVE_DEPTH];
+
+    uint64_t consumed_time_ns;
+    uint64_t timestamp_ns;
+};
+
+bool pf2_sample_capture(struct pf2_sample *sample);
+
+#endif // PF2_SAMPLE_H

data/ext/{pf2c → pf2}/serializer.c

@@ -83,7 +83,7 @@ pf2_ser_prepare(struct pf2_ser *serializer, struct pf2_session *session) {
         ensure_samples_capacity(serializer);
 
         struct pf2_ser_sample *ser_sample = &serializer->samples[serializer->samples_count++];
-        ser_sample->ruby_thread_id = 0; // TODO: Add thread ID support
+        ser_sample->ruby_thread_id = sample->context_pthread;
         ser_sample->elapsed_ns = sample->timestamp_ns - serializer->start_timestamp_ns;
 
         // Copy and process Ruby stack frames

data/ext/{pf2c → pf2}/session.c

@@ -1,11 +1,12 @@
 #include <bits/time.h>
+#include <pthread.h>
+#include <signal.h>
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <signal.h>
+#include <sys/time.h>
 #include <time.h>
-#include <pthread.h>
 
 #include <ruby.h>
 #include <ruby/debug.h>
@@ -14,13 +15,20 @@
 
 #include "backtrace_state.h"
 #include "configuration.h"
+#include "debug.h"
 #include "sample.h"
 #include "session.h"
 #include "serializer.h"
 
+#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 sigprof_handler(int sig, siginfo_t *info, void *ucontext);
 bool ensure_sample_capacity(struct pf2_session *session);
+static void pf2_session_stop(struct pf2_session *session);
 
 VALUE
 rb_pf2_session_initialize(int argc, VALUE *argv, VALUE self)
@@ -60,17 +68,28 @@ rb_pf2_session_start(VALUE self)
         rb_raise(rb_eRuntimeError, "Failed to spawn sample collector thread");
     }
 
-    // Configure signal handler
+    // Install signal handler for SIGPROF
     struct sigaction sa;
     sa.sa_sigaction = sigprof_handler;
     sigemptyset(&sa.sa_mask);
     sigaddset(&sa.sa_mask, SIGPROF); // Mask SIGPROFs when handler is running
     sa.sa_flags = SA_SIGINFO | SA_RESTART;
     if (sigaction(SIGPROF, &sa, NULL) == -1) {
-        rb_raise(rb_eRuntimeError, "Failed to install signal handler");
+        rb_raise(rb_eRuntimeError, "Failed to install SIGPROF handler");
     }
 
-    // Configure a timer to send SIGPROF every 10 ms of CPU time
+#ifndef HAVE_TIMER_CREATE
+    // Install signal handler for SIGALRM if using wall time mode with setitimer
+    if (session->configuration->time_mode != PF2_TIME_MODE_CPU_TIME) {
+        sigaddset(&sa.sa_mask, SIGALRM);
+        if (sigaction(SIGALRM, &sa, NULL) == -1) {
+            rb_raise(rb_eRuntimeError, "Failed to install SIGALRM handler");
+        }
+    }
+#endif
+
+#ifdef HAVE_TIMER_CREATE
+    // Configure a kernel timer to send SIGPROF periodically
     struct sigevent sev;
     sev.sigev_notify = SIGEV_SIGNAL;
     sev.sigev_signo = SIGPROF;
@@ -97,6 +116,30 @@ rb_pf2_session_start(VALUE self)
     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.
+    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
 
     return Qtrue;
 }
@@ -113,9 +156,7 @@ sample_collector_thread(void *arg)
             // Ensure we have capacity before adding a new sample
             if (!ensure_sample_capacity(session)) {
                 // Failed to expand buffer
-#ifdef PF2_DEBUG
-                printf("Failed to expand sample buffer. Dropping sample\n");
-#endif
+                PF2_DEBUG_LOG("Failed to expand sample buffer. Dropping sample\n");
                 break;
             }
 
@@ -140,31 +181,30 @@ sigprof_handler(int sig, siginfo_t *info, void *ucontext)
     clock_gettime(CLOCK_MONOTONIC, &sig_start_time);
 #endif
 
-    struct pf2_session *session = info->si_value.sival_ptr;
+    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)) {
-#ifdef PF2_DEBUG
-        printf("Dropping sample: Garbage collection is in progress\n");
-#endif
+        PF2_DEBUG_LOG("Dropping sample: Garbage collection is in progress\n");
         return;
     }
 
-    struct pf2_sample sample = { 0 };
+    struct pf2_sample sample;
 
     if (pf2_sample_capture(&sample) == false) {
-#ifdef PF2_DEBUG
-        printf("Dropping sample: Failed to capture sample\n");
-#endif
+        PF2_DEBUG_LOG("Dropping sample: Failed to capture sample\n");
         return;
     }
 
     // Copy the sample to the ringbuffer
     if (pf2_ringbuffer_push(session->rbuf, &sample) == false) {
         // Copy failed. The sample buffer is full.
-#ifdef PF2_DEBUG
-        printf("Dropping sample: Sample buffer is full\n");
-#endif
+        PF2_DEBUG_LOG("Dropping sample: Sample buffer is full\n");
         return;
     }
 
@@ -177,7 +217,7 @@ sigprof_handler(int sig, siginfo_t *info, void *ucontext)
         (sig_end_time.tv_sec - sig_start_time.tv_sec) * 1000000000L +
         (sig_end_time.tv_nsec - sig_start_time.tv_nsec);
 
-    printf("sigprof_handler: consumed_time_ns: %lu\n", sample.consumed_time_ns);
+    PF2_DEBUG_LOG("sigprof_handler: consumed_time_ns: %lu\n", sample.consumed_time_ns);
 #endif
 }
 
@@ -212,6 +252,20 @@ 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);
@@ -220,21 +274,24 @@ rb_pf2_session_stop(VALUE self)
     session->duration_ns = end_ns - start_ns;
 
     // Disarm and delete the timer.
+#ifdef HAVE_TIMER_CREATE
     if (timer_delete(session->timer) == -1) {
         rb_raise(rb_eRuntimeError, "Failed to delete timer");
     }
+#else
+    struct itimerval zero_timer = {{0, 0}, {0, 0}};
+    int which_timer = session->configuration->time_mode == PF2_TIME_MODE_CPU_TIME
+        ? ITIMER_PROF
+        : ITIMER_REAL;
+    if (setitimer(which_timer, &zero_timer, NULL) == -1) {
+        rb_raise(rb_eRuntimeError, "Failed to stop timer");
+    }
+    global_current_session = NULL;
+#endif
 
     // Terminate the collector thread
     session->is_running = false;
     pthread_join(*session->collector_thread, NULL);
-
-    // 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
@@ -261,19 +318,32 @@ 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");
     }
 
-    session->duration_ns = 0;
-
+    // samples, samples_index, samples_capacity
     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);
@@ -281,6 +351,14 @@ pf2_session_alloc(VALUE self)
         rb_raise(rb_eNoMemError, "Failed to allocate memory");
     }
 
+    // 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->configuration = NULL;
 
     return TypedData_Wrap_Struct(self, &pf2_session_type, session);
@@ -323,8 +401,15 @@ 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);
     free(session->samples);

data/ext/{pf2c → pf2}/session.h

@@ -3,6 +3,7 @@
 
 #include <pthread.h>
 #include <stdatomic.h>
+#include <sys/time.h>
 
 #include <ruby.h>
 
@@ -12,7 +13,11 @@
 
 struct pf2_session {
     bool is_running;
+#ifdef HAVE_TIMER_CREATE
     timer_t timer;
+#else
+    struct itimerval timer;
+#endif
     struct pf2_ringbuffer *rbuf;
     atomic_bool is_marking; // Whether garbage collection is in progress
     pthread_t *collector_thread;
@@ -38,14 +43,14 @@ void pf2_session_dfree(void *sess);
 size_t pf2_session_dsize(const void *sess);
 
 static const rb_data_type_t pf2_session_type = {
-    .wrap_struct_name = "Pf2c::Session",
+    .wrap_struct_name = "Pf2::Session",
     .function = {
         .dmark = pf2_session_dmark,
         .dfree = pf2_session_dfree,
         .dsize = pf2_session_dsize,
     },
     .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = 0,
 };
 
 #endif // PF2_SESSION_H

data/lib/pf2/cli.rb

@@ -55,20 +55,12 @@ module Pf2
         opts.on('-o', '--output FILE', 'Output file') do |path|
           options[:output_file] = path
         end
-        opts.on('--experimental-serializer', 'Enable the experimental serializer mode') do
-          options[:experimental_serializer] = true
-        end
       end
       option_parser.parse!(argv)
 
-      if options[:experimental_serializer]
-        profile = Marshal.load(File.read(argv[0]))
-        report = Pf2::Reporter::FirefoxProfilerSer2.new(profile).emit
-        report = JSON.generate(report)
-      else
-        profile = JSON.parse(File.read(argv[0]), symbolize_names: true, max_nesting: false)
-        report = JSON.generate(Pf2::Reporter::FirefoxProfiler.new(profile).emit)
-      end
+      profile = Marshal.load(File.read(argv[0]))
+      report = Pf2::Reporter::FirefoxProfilerSer2.new(profile).emit
+      report = JSON.generate(report)
 
       if options[:output_file]
         File.write(options[:output_file], report)