vernier 1.10.1 → 1.12.0

data/ext/vernier/vernier.cc

@@ -8,7 +8,6 @@
 #include <sstream>
 #include <unordered_map>
 #include <unordered_set>
-#include <cassert>
 #include <atomic>
 #include <mutex>
 
@@ -26,9 +25,6 @@
 #include "ruby/debug.h"
 #include "ruby/thread.h"
 
-#undef assert
-#define assert RUBY_ASSERT_ALWAYS
-
 #ifndef PTR2NUM
 # define PTR2NUM(x)   (rb_int2inum((intptr_t)(void *)(x)))
 #endif
@@ -76,6 +72,10 @@ static const char *gvl_event_name(rb_event_flag_t event) {
 // This is used for communication between the profiler thread and the signal
 // handlers in the observed thread.
 struct LiveSample {
+    LiveSample() = default;
+    LiveSample(const LiveSample &) = delete;
+    LiveSample &operator=(const LiveSample &) = delete;
+
     RawSample sample;
 
     SignalSafeSemaphore sem_complete;
@@ -244,6 +244,10 @@ class Marker {
 
 class MarkerTable {
     public:
+        MarkerTable() = default;
+        MarkerTable(const MarkerTable &) = delete;
+        MarkerTable &operator=(const MarkerTable &) = delete;
+
         std::mutex mutex;
         std::vector<Marker> list;
 
@@ -289,7 +293,11 @@ class GCMarkerTable: public MarkerTable {
                     .gc_state = gc_state
                 }
             };
-            list.push_back({ Marker::MARKER_GC_PAUSE, Marker::INTERVAL, last_gc_entry, TimeStamp::Now(), -1, info });
+            TimeStamp now = TimeStamp::Now();
+
+            // Take the lock only after calling into Ruby above
+            const std::lock_guard<std::mutex> lock(mutex);
+            list.push_back({ Marker::MARKER_GC_PAUSE, Marker::INTERVAL, last_gc_entry, now, -1, info });
         }
 
         void record_gc_end_mark() {
@@ -415,6 +423,23 @@ class SampleList {
         }
 };
 
+static rb_internal_thread_specific_key_t thread_serial_key;
+
+// A number identifying th for as long as it lives, kept in its thread
+// specific storage
+static uintptr_t thread_serial(VALUE th) {
+    static std::mutex mutex;
+    static uintptr_t last_serial = 0;
+
+    const std::lock_guard<std::mutex> lock(mutex);
+    uintptr_t serial = (uintptr_t)rb_internal_thread_specific_get(th, thread_serial_key);
+    if (!serial) {
+        serial = ++last_serial;
+        rb_internal_thread_specific_set(th, thread_serial_key, (void *)serial);
+    }
+    return serial;
+}
+
 class Thread {
     public:
         SampleList samples;
@@ -429,8 +454,10 @@ class Thread {
             INITIAL,
         };
 
-        VALUE ruby_thread;
-        VALUE ruby_thread_id;
+        uintptr_t serial;
+        VALUE ruby_thread_id = Qnil;
+        bool is_main = false;
+        bool is_start = false;
         pthread_t pthread_id;
         native_thread_id_t native_tid;
         State state;
@@ -445,15 +472,10 @@ class Thread {
         unique_ptr<MarkerTable> markers;
 
         // FIXME: don't use pthread at start
-        Thread(State state, pthread_t pthread_id, VALUE ruby_thread, VALUE ruby_thread_id) : pthread_id(pthread_id), ruby_thread(ruby_thread), state(state), stack_on_suspend_idx(-1), ruby_thread_id(ruby_thread_id) {
-            //ruby_thread_id = ULL2NUM(ruby_thread);
+        Thread(pthread_t pthread_id, uintptr_t serial) : serial(serial), pthread_id(pthread_id), state(State::INITIAL), stack_on_suspend_idx(-1) {
             native_tid = get_native_thread_id();
             started_at = state_changed_at = TimeStamp::Now();
             markers = std::make_unique<MarkerTable>();
-
-            if (state == State::STARTED) {
-                markers->record(Marker::Type::MARKER_GVL_THREAD_STARTED);
-            }
         }
 
         void record_newobj(VALUE obj, StackTable &frame_list) {
@@ -468,12 +490,13 @@ class Thread {
             }
         }
 
-        void record_fiber(VALUE fiber, StackTable &frame_list) {
+        // fiber_id must be computed by the caller: rb_obj_id can raise, and we
+        // are called with the thread table mutex held.
+        void record_fiber(VALUE fiber_id, StackTable &frame_list) {
             RawSample sample;
             sample.sample();
 
             int stack_idx = translator.translate(frame_list, sample);
-            VALUE fiber_id = rb_obj_id(fiber);
             markers->record(Marker::Type::MARKER_FIBER_SWITCH, stack_idx, { .fiber_data = { .fiber_id = fiber_id } });
         }
 
@@ -482,7 +505,7 @@ class Thread {
                 return;
             }
             if (new_state == Thread::State::SUSPENDED && state == new_state) {
-                // on Ruby 3.2 (only?) we may see duplicate suspended states
+                // Preserve the original timestamp when Ruby emits duplicate suspended events.
                 return;
             }
 
@@ -501,7 +524,7 @@ class Thread {
                     return; // no mutation of current state
                     break;
                 case State::RUNNING:
-                    assert(state == INITIAL || state == State::READY || state == State::RUNNING);
+                    VERNIER_ASSERT(state == INITIAL || state == State::READY || state == State::RUNNING);
                     pthread_id = pthread_self();
                     native_tid = get_native_thread_id();
 
@@ -512,29 +535,20 @@ class Thread {
                     }
                     break;
                 case State::READY:
-                    // The ready state means "I would like to do some work, but I can't
-                    // do it right now either because I blocked on IO and now I want the GVL back,
-                    // or because the VM timer put me to sleep"
-                    //
-                    // Threads can be preempted, which means they will have been in "Running"
-                    // state, and then the VM was like "no I need to stop you from working,
-                    // so I'll put you in the 'ready' (or stalled) state"
-                    assert(state == State::INITIAL || state == State::STARTED || state == State::SUSPENDED || state == State::RUNNING);
+                    // A ready thread is waiting to acquire the GVL.
+                    VERNIER_ASSERT(state == State::INITIAL || state == State::STARTED || state == State::SUSPENDED);
                     if (state == State::SUSPENDED) {
                         markers->record_interval(Marker::Type::MARKER_THREAD_SUSPENDED, from, now, stack_on_suspend_idx);
                     }
-                    else if (state == State::RUNNING) {
-                        markers->record_interval(Marker::Type::MARKER_THREAD_RUNNING, from, now);
-                    }
                     break;
                 case State::SUSPENDED:
                     // We can go from RUNNING or STARTED to SUSPENDED
-                    assert(state == State::INITIAL || state == State::RUNNING || state == State::STARTED || state == State::SUSPENDED);
+                    VERNIER_ASSERT(state == State::INITIAL || state == State::RUNNING || state == State::STARTED || state == State::SUSPENDED);
                     markers->record_interval(Marker::Type::MARKER_THREAD_RUNNING, from, now);
                     break;
                 case State::STOPPED:
                     // We can go from RUNNING or STARTED or SUSPENDED to STOPPED
-                    assert(state == State::INITIAL || state == State::RUNNING || state == State::STARTED || state == State::SUSPENDED);
+                    VERNIER_ASSERT(state == State::INITIAL || state == State::RUNNING || state == State::STARTED || state == State::SUSPENDED);
                     markers->record_interval(Marker::Type::MARKER_THREAD_RUNNING, from, now);
                     markers->record(Marker::Type::MARKER_GVL_THREAD_EXITED);
 
@@ -547,14 +561,6 @@ class Thread {
             state_changed_at = now;
         }
 
-        bool is_main() {
-            return rb_thread_main() == ruby_thread;
-        }
-
-        bool is_start(VALUE start_thread) {
-            return start_thread == ruby_thread;
-        }
-
         bool running() {
             return state != State::STOPPED;
         }
@@ -573,14 +579,24 @@ class ThreadTable {
         ThreadTable(StackTable &frame_list) : frame_list(frame_list) {
         }
 
+        ThreadTable(const ThreadTable &) = delete;
+        ThreadTable &operator=(const ThreadTable &) = delete;
+
         void mark() {
             for (const auto &thread : list) {
                 thread->mark();
             }
         }
 
-        void initial(VALUE th) {
-            set_state(Thread::State::INITIAL, th);
+        // Must hold the GVL, and th must be in this Ractor
+        Thread* add(VALUE th) {
+            // Compute ID outside the lock
+            VALUE ruby_thread_id = rb_obj_id(th);
+
+            const std::lock_guard<std::mutex> lock(mutex);
+            Thread* thread = find_or_create_thread(th);
+            thread->ruby_thread_id = ruby_thread_id;
+            return thread;
         }
 
         void started(VALUE th) {
@@ -604,41 +620,34 @@ class ThreadTable {
             set_state(Thread::State::STOPPED, th);
         }
 
-    private:
         Thread* find_thread(VALUE th) {
             // Assumes lock is already held by caller
-            for (auto &threadptr : list) {
-                if (thread_equal(th, threadptr->ruby_thread)) {
-                    return threadptr.get();
+            uintptr_t serial = (uintptr_t)rb_internal_thread_specific_get(th, thread_serial_key);
+            if (serial) {
+                for (auto &threadptr : list) {
+                    if (threadptr->serial == serial) {
+                        return threadptr.get();
+                    }
                 }
             }
             return nullptr;
         }
 
-        Thread& find_or_create_thread(VALUE th, Thread::State initial_state) {
-            {
-                const std::lock_guard<std::mutex> lock(mutex);
-                Thread* existing = find_thread(th);
-                if (existing) {
-                    return *existing;
-                }
-            }
-
-            // Thread not found, compute ID outside the lock
-            VALUE ruby_thread_id = rb_obj_id(th);
-
-            const std::lock_guard<std::mutex> lock(mutex);
-            // Check again in case another thread created it while we were unlocked
+    private:
+        Thread* find_or_create_thread(VALUE th) {
+            // Assumes lock is already held by caller
             Thread* existing = find_thread(th);
             if (existing) {
-                return *existing;
+                return existing;
+            }
+
+            // Not from Ruby's timer thread
+            if (!ruby_native_thread_p()) {
+                return nullptr;
             }
 
-            //fprintf(stderr, "NEW THREAD: th: %p, state: %i\n", th, initial_state);
-            auto new_thread = std::make_unique<Thread>(initial_state, pthread_self(), th, ruby_thread_id);
-            Thread& thread_ref = *new_thread;
-            list.push_back(std::move(new_thread));
-            return thread_ref;
+            list.push_back(std::make_unique<Thread>(pthread_self(), thread_serial(th)));
+            return list.back().get();
         }
 
         void set_state(Thread::State new_state, VALUE th) {
@@ -649,33 +658,31 @@ class ThreadTable {
 
             //fprintf(stderr, "th %p (tid: %i) from %s to %s\n", (void *)th, native_tid, gvl_event_name(state), gvl_event_name(new_state));
 
-            Thread& thread = find_or_create_thread(th, new_state);
-
             const std::lock_guard<std::mutex> lock(mutex);
 
-            if (new_state == Thread::State::SUSPENDED || new_state == Thread::State::READY && (thread.state != Thread::State::SUSPENDED)) {
+            Thread* thread = find_or_create_thread(th);
+            if (!thread) {
+                return;
+            }
 
+            if (new_state == Thread::State::SUSPENDED) {
                 RawSample sample;
                 sample.sample();
 
-                thread.stack_on_suspend_idx = thread.translator.translate(frame_list, sample);
-                //cerr << gettid() << " suspended! Stack size:" << thread.stack_on_suspend.size() << endl;
+                thread->stack_on_suspend_idx = thread->translator.translate(frame_list, sample);
+                //cerr << gettid() << " suspended! Stack size:" << thread->stack_on_suspend.size() << endl;
             }
 
-            thread.set_state(new_state);
+            thread->set_state(new_state);
 
-            if (thread.state == Thread::State::RUNNING) {
-                thread.pthread_id = pthread_self();
-                thread.native_tid = get_native_thread_id();
+            if (thread->state == Thread::State::RUNNING) {
+                thread->pthread_id = pthread_self();
+                thread->native_tid = get_native_thread_id();
             } else {
-                thread.pthread_id = 0;
-                thread.native_tid = 0;
+                thread->pthread_id = 0;
+                thread->native_tid = 0;
             }
         }
-
-        bool thread_equal(VALUE a, VALUE b) {
-            return a == b;
-        }
 };
 
 class BaseCollector {
@@ -696,6 +703,9 @@ class BaseCollector {
     }
     virtual ~BaseCollector() {}
 
+    BaseCollector(const BaseCollector &) = delete;
+    BaseCollector &operator=(const BaseCollector &) = delete;
+
     virtual bool start() {
         if (running) {
             return false;
@@ -751,6 +761,9 @@ class GlobalSignalHandler {
     static LiveSample *live_sample;
 
     public:
+        GlobalSignalHandler(const GlobalSignalHandler &) = delete;
+        GlobalSignalHandler &operator=(const GlobalSignalHandler &) = delete;
+
         static GlobalSignalHandler *get_instance() {
             static GlobalSignalHandler instance;
             return &instance;
@@ -773,7 +786,7 @@ class GlobalSignalHandler {
         bool record_sample(LiveSample &sample, pthread_t pthread_id) {
             const std::lock_guard<std::mutex> lock(mutex);
 
-            assert(pthread_id);
+            VERNIER_ASSERT_ALWAYS(pthread_id);
 
             live_sample = &sample;
             int rc = pthread_kill(pthread_id, SIGPROF);
@@ -789,11 +802,13 @@ class GlobalSignalHandler {
         }
 
     private:
+        GlobalSignalHandler() = default;
+
         std::mutex mutex;
-        int count;
+        int count = 0;
 
         static void signal_handler(int sig, siginfo_t* sinfo, void* ucontext) {
-            assert(live_sample);
+            VERNIER_ASSERT_ALWAYS(live_sample);
             live_sample->sample_current_thread();
         }
 
@@ -819,7 +834,7 @@ class TimeCollector : public BaseCollector {
     class TimeCollectorThread : public PeriodicThread {
         TimeCollector &time_collector;
 
-        void run_iteration() {
+        void run_iteration() override {
             time_collector.run_iteration();
         }
 
@@ -863,32 +878,26 @@ class TimeCollector : public BaseCollector {
         }
         allocation_tick = 0;
 
-        VALUE current_thread = rb_thread_current();
         threads.mutex.lock();
-        for (auto &threadptr : threads.list) {
-            auto &thread = *threadptr;
-            if (current_thread == thread.ruby_thread) {
-                thread.record_newobj(obj, threads.frame_list);
-                break;
-            }
+        Thread *thread = threads.find_thread(rb_thread_current());
+        if (thread) {
+            thread->record_newobj(obj, threads.frame_list);
         }
         threads.mutex.unlock();
 
     }
 
     void record_fiber(VALUE th, VALUE fiber) {
+        VALUE fiber_id = rb_obj_id(fiber);
         threads.mutex.lock();
-        for (auto &threadptr : threads.list) {
-            auto &thread = *threadptr;
-            if (th == thread.ruby_thread) {
-                thread.record_fiber(fiber, threads.frame_list);
-                break;
-            }
+        Thread *thread = threads.find_thread(th);
+        if (thread) {
+            thread->record_fiber(fiber_id, threads.frame_list);
         }
         threads.mutex.unlock();
     }
 
-    void write_meta(VALUE meta, VALUE result) {
+    void write_meta(VALUE meta, VALUE result) override {
         BaseCollector::write_meta(meta, result);
         rb_hash_aset(meta, sym("interval"), ULL2NUM(interval.microseconds()));
         rb_hash_aset(meta, sym("allocation_interval"), ULL2NUM(allocation_interval));
@@ -958,6 +967,7 @@ class TimeCollector : public BaseCollector {
                 collector->record_fiber(rb_thread_current(), rb_fiber_current());
                 break;
             case RUBY_EVENT_THREAD_BEGIN:
+                collector->threads.add(self);
                 collector->threads.started(self);
                 break;
             case RUBY_EVENT_THREAD_END:
@@ -990,17 +1000,7 @@ class TimeCollector : public BaseCollector {
 
     static void internal_thread_event_cb(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
         TimeCollector *collector = static_cast<TimeCollector *>(data);
-        VALUE thread = Qnil;
-
-#if HAVE_RB_INTERNAL_THREAD_EVENT_DATA_T_THREAD
-        thread = event_data->thread;
-#else
-        // We may arrive here when starting a thread with
-        // RUBY_INTERNAL_THREAD_EVENT_READY before the thread is actually set up.
-        if (!ruby_native_thread_p()) return;
-
-        thread = rb_thread_current();
-#endif
+        VALUE thread = event_data->thread;
 
         auto native_tid = get_native_thread_id();
         //cerr << "internal thread event" << event << " at " << TimeStamp::Now() << endl;
@@ -1029,7 +1029,7 @@ class TimeCollector : public BaseCollector {
 
     rb_internal_thread_event_hook_t *thread_hook;
 
-    bool start() {
+    bool start() override {
         if (!BaseCollector::start()) {
             return false;
         }
@@ -1038,7 +1038,9 @@ class TimeCollector : public BaseCollector {
         VALUE all_threads = rb_funcall(rb_path2class("Thread"), rb_intern("list"), 0);
         for (int i = 0; i < RARRAY_LEN(all_threads); i++) {
             VALUE thread = RARRAY_AREF(all_threads, i);
-            this->threads.initial(thread);
+            Thread *record = this->threads.add(thread);
+            record->is_main = thread == rb_thread_main();
+            record->is_start = thread == start_thread;
         }
 
         if (allocation_interval > 0) {
@@ -1066,7 +1068,7 @@ class TimeCollector : public BaseCollector {
         return true;
     }
 
-    VALUE stop() {
+    VALUE stop() override {
         BaseCollector::stop();
 
         collector_thread.stop();
@@ -1091,7 +1093,7 @@ class TimeCollector : public BaseCollector {
         return result;
     }
 
-    VALUE build_collector_result() {
+    VALUE build_collector_result() override {
         VALUE result = BaseCollector::build_collector_result();
 
         VALUE threads = rb_hash_new();
@@ -1109,16 +1111,22 @@ class TimeCollector : public BaseCollector {
             if (!thread->stopped_at.zero()) {
                 rb_hash_aset(hash, sym("stopped_at"), ULL2NUM(thread->stopped_at.nanoseconds()));
             }
-            rb_hash_aset(hash, sym("is_main"), thread->is_main() ? Qtrue : Qfalse);
-            rb_hash_aset(hash, sym("is_start"), thread->is_start(BaseCollector::start_thread) ? Qtrue : Qfalse);
-
-            rb_hash_aset(threads, thread->ruby_thread_id, hash);
+            rb_hash_aset(hash, sym("is_main"), thread->is_main ? Qtrue : Qfalse);
+            rb_hash_aset(hash, sym("is_start"), thread->is_start ? Qtrue : Qfalse);
+
+            VALUE ruby_thread_id = thread->ruby_thread_id;
+            if (NIL_P(ruby_thread_id)) {
+                // We only take object_ids of threads in this Ractor
+                ruby_thread_id = LONG2NUM(-(long)thread->serial);
+                rb_hash_aset(hash, sym("name"), rb_sprintf("thread %lu", (unsigned long)thread->serial));
+            }
+            rb_hash_aset(threads, ruby_thread_id, hash);
         }
 
         return result;
     }
 
-    void mark() {
+    void mark() override {
         stack_table->mark_frames();
         rb_gc_mark(stack_table_value);
         threads.mark();
@@ -1242,6 +1250,8 @@ Init_vernier(void)
     sym_fiber_id = sym("fiber_id");
     rb_gc_latest_gc_info(sym_state); // HACK: needs to be warmed so that it can be called during GC
 
+    thread_serial_key = rb_internal_thread_specific_key_create();
+
   rb_mVernier = rb_define_module("Vernier");
   rb_cVernierResult = rb_define_class_under(rb_mVernier, "Result", rb_cObject);
   VALUE rb_mVernierMarker = rb_define_module_under(rb_mVernier, "Marker");

data/ext/vernier/vernier.hh

@@ -2,6 +2,18 @@
 #define VERNIER_H 1
 
 #include "ruby.h"
+#include "ruby/assert.h"
+
+// VERNIER_ASSERT is RUBY_ASSERT, which is only active when Ruby itself was
+// built with RUBY_DEBUG. Building with VERNIER_ALWAYS_ASSERT (see extconf.rb)
+// makes it RUBY_ASSERT_ALWAYS. Use VERNIER_ASSERT_ALWAYS for checks that must
+// run in every build.
+#ifdef VERNIER_ALWAYS_ASSERT
+# define VERNIER_ASSERT RUBY_ASSERT_ALWAYS
+#else
+# define VERNIER_ASSERT RUBY_ASSERT
+#endif
+#define VERNIER_ASSERT_ALWAYS RUBY_ASSERT_ALWAYS
 
 // HACK: This isn't public, but the objspace ext uses it
 extern "C" size_t rb_obj_memsize_of(VALUE);

data/lib/vernier/autorun.rb

@@ -20,6 +20,7 @@ module Vernier
       interval = options.fetch(:interval, 500).to_i
       allocation_interval = options.fetch(:allocation_interval, 0).to_i
       hooks = options.fetch(:hooks, "").split(",")
+      hide_anonymous_threads = options[:hide_anonymous_threads] || false
       metadata = if options[:metadata]
         JSON.parse(@options[:metadata].unpack1("m")).to_h { |k, v| [k.to_sym, v] }
       else
@@ -28,7 +29,7 @@ module Vernier
 
       STDERR.puts("starting profiler with interval #{interval} and allocation interval #{allocation_interval}")
 
-      @collector = Vernier::Collector.new(:wall, interval:, allocation_interval:, hooks:, metadata:)
+      @collector = Vernier::Collector.new(:wall, interval:, allocation_interval:, hooks:, metadata:, hide_anonymous_threads:)
       @collector.start
     end
 

data/lib/vernier/collector.rb

@@ -29,6 +29,7 @@ module Vernier
         result.instance_variable_set(:@threads, {
           0 => {
             tid: 0,
+            is_main: true,
             name: "custom",
             started_at: @started_at,
             samples: @samples,
@@ -80,6 +81,7 @@ module Vernier
         result.instance_variable_set(:@threads, {
           0 => {
             tid: 0,
+            is_main: true,
             name: "retained memory",
             started_at: @started_at,
             samples: samples,
@@ -116,6 +118,7 @@ module Vernier
       @mode = mode
       @out = options[:out]
       @format = options[:format]
+      @hide_anonymous_threads = options[:hide_anonymous_threads]
 
       @markers = []
       @hooks = []
@@ -193,6 +196,7 @@ module Vernier
       result.meta[:out] = @out
       result.meta[:gc] = @gc
       result.meta[:user_metadata] = @user_metadata
+      result.meta[:hide_anonymous_threads] = @hide_anonymous_threads
 
       result.stack_table = stack_table
       @thread_names.finish
@@ -203,6 +207,7 @@ module Vernier
 
       result.threads.each do |obj_id, thread|
         thread[:name] ||= @thread_names[obj_id]
+        thread[:anonymous] ||= @thread_names.anonymous?(obj_id)
       end
 
       result.hooks = @hooks