vernier 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6050bca74116d0e90f98025fe23d7fbd40c6107c085e3f768d606d4f418ebc60
-  data.tar.gz: e302542d8b06852d28d0ec1e2528f23bba46d5ef9ea9a828c9dbcdb985a292a3
+  metadata.gz: f552d6fe2d529de743412cbc9975bfbd4ac87b894777a44ce26ef07dddc8e032
+  data.tar.gz: b9ddcd3e4ce0acb5ac53363e041d1bd9e3a2d4c5bf21b2bbe56c48ed5fef4cdd
 SHA512:
-  metadata.gz: 9d20e5f9d9c894a253bc4aeb6b9da6cb35d916e881abedf996ce19757a9cd92efe43bcc76fda0aa4ce5e334be36582adf7c716a998c4c5e1f403dc57364fb5ab
-  data.tar.gz: 7cf03df7bcb4f961b5b456eb781fd5818de7e18501baa01592ce17528f5eae7b272e90dcff200f861495ebb1a83c87f9146306db66ce20a9d56467ab87bce3c6
+  metadata.gz: 1b0808ee6ae8e64866e81e7ba8ed4847788421a00517c00e7aacb54c2fdff16287f92eb10132b5802fcb93955c3e4cf1a8fe4cfc97f4a9742a8130341bea75f7
+  data.tar.gz: 686a7397043be44451cccf9380473cda1e350ee342878ca2428d8bcd6c69aeea36244d15c92e3f998d4b6245c46c37d74ac3aac18ed58c783c288501d0cf7243

data/README.md

@@ -1,6 +1,6 @@
 # Vernier
 
-Next-generation Ruby sampling profiler. Tracks multiple threads, GVL activity, GC pauses, idle time, and more.
+Next-generation Ruby 3.2.1+ sampling profiler. Tracks multiple threads, GVL activity, GC pauses, idle time, and more.
 
 ## Examples
 
@@ -20,6 +20,8 @@ Rails benchmark - lobste.rs (time)
 
 ## Installation
 
+Vernier requires Ruby version 3.2.1 or greater
+
 ```ruby
 gem 'vernier'
 ```
@@ -35,6 +37,9 @@ Vernier.trace(out: "time_profile.json") { some_slow_method }
 
 The output can then be viewed in the Firefox Profiler (demo) or the [`profile-viewer` gem](https://github.com/tenderlove/profiler/tree/ruby) (a Ruby-customized version of the firefox profiler.
 
+- **Flame Graph**: Shows proportionally how much time is spent within particular stack frames. Frames are grouped together, which means that x-axis / left-to-right order is not meaningful.
+- **Stack Chart**: Shows the stack at each sample with the x-axis representing time and can be read left-to-right.
+
 ### Retained memory
 
 Record a flamegraph of all **retained** allocations from loading `irb`.
@@ -43,6 +48,7 @@ Record a flamegraph of all **retained** allocations from loading `irb`.
 ruby -r vernier -e 'Vernier.trace_retained(out: "irb_profile.json") { require "irb" }'
 ```
 
+Retained-memory flamegraphs must be interpreted a little differently than a typical profiling flamegraph. In a retained-memory flamegraph, the x-axis represents a proportion of memory in bytes,  _not time or samples_ The topmost boxes on the y-axis represent the retained objects, with their stacktrace below; their width represents the percentage of overall retained memory each object occupies.
 
 ## Development
 

data/ext/vernier/extconf.rb

@@ -5,4 +5,11 @@ require "mkmf"
 $CXXFLAGS += " -std=c++14 "
 $CXXFLAGS += " -ggdb3 -Og "
 
+have_header("ruby/thread.h")
+have_struct_member("rb_internal_thread_event_data_t", "thread", ["ruby/thread.h"])
+
+have_func("rb_profile_thread_frames", "ruby/debug.h")
+
+have_func("pthread_setname_np")
+
 create_makefile("vernier/vernier")

data/ext/vernier/vernier.cc

@@ -1,3 +1,5 @@
+// vim: expandtab:ts=4:sw=4
+
 #include <iostream>
 #include <iomanip>
 #include <vector>
@@ -27,6 +29,9 @@
 #include "ruby/debug.h"
 #include "ruby/thread.h"
 
+#undef assert
+#define assert RUBY_ASSERT_ALWAYS
+
 # define PTR2NUM(x)   (rb_int2inum((intptr_t)(void *)(x)))
 
 // Internal TracePoint events we'll monitor during profiling
@@ -53,6 +58,22 @@ static VALUE rb_cVernierResult;
 static VALUE rb_mVernierMarkerType;
 static VALUE rb_cVernierCollector;
 
+static const char *gvl_event_name(rb_event_flag_t event) {
+    switch (event) {
+      case RUBY_INTERNAL_THREAD_EVENT_STARTED:
+        return "started";
+      case RUBY_INTERNAL_THREAD_EVENT_READY:
+        return "ready";
+      case RUBY_INTERNAL_THREAD_EVENT_RESUMED:
+        return "resumed";
+      case RUBY_INTERNAL_THREAD_EVENT_SUSPENDED:
+        return "suspended";
+      case RUBY_INTERNAL_THREAD_EVENT_EXITED:
+        return "exited";
+    }
+    return "no-event";
+}
+
 class TimeStamp {
     static const uint64_t nanoseconds_per_second = 1000000000;
     uint64_t value_ns;
@@ -85,8 +106,16 @@ class TimeStamp {
         } while (target_time > TimeStamp::Now());
     }
 
+    static TimeStamp from_seconds(uint64_t s) {
+        return TimeStamp::from_milliseconds(s * 1000);
+    }
+
+    static TimeStamp from_milliseconds(uint64_t ms) {
+        return TimeStamp::from_microseconds(ms * 1000);
+    }
+
     static TimeStamp from_microseconds(uint64_t us) {
-        return TimeStamp(us * 1000);
+        return TimeStamp::from_nanoseconds(us * 1000);
     }
 
     static TimeStamp from_nanoseconds(uint64_t ns) {
@@ -266,6 +295,10 @@ class SamplerSemaphore {
 #ifdef __APPLE__
         dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
 #else
+        // Use sem_timedwait so that we get a crash instead of a deadlock for
+        // easier debugging
+        auto ts = (TimeStamp::Now() + TimeStamp::from_seconds(5)).timespec();
+
         int ret;
         do {
             ret = sem_wait(&sem);
@@ -304,16 +337,15 @@ struct RawSample {
     }
 
     void sample() {
+        clear();
+
         if (!ruby_native_thread_p()) {
-            clear();
             return;
         }
 
         if (rb_during_gc()) {
           gc = true;
-          len = 0;
         } else {
-          gc = false;
           len = rb_profile_frames(0, MAX_LEN, frames, lines);
         }
     }
@@ -602,12 +634,13 @@ class Marker {
     Phase phase;
     TimeStamp timestamp;
     TimeStamp finish;
-    native_thread_id_t thread_id;
+    // VALUE ruby_thread_id;
+    //native_thread_id_t thread_id;
     int stack_index = -1;
 
     VALUE to_array() {
         VALUE record[6] = {0};
-        record[0] = ULL2NUM(thread_id);
+        record[0] = Qnil; // FIXME
         record[1] = INT2NUM(type);
         record[2] = INT2NUM(phase);
         record[3] = ULL2NUM(timestamp.nanoseconds());
@@ -625,30 +658,33 @@ class Marker {
 };
 
 class MarkerTable {
-    TimeStamp last_gc_entry;
-
     public:
         std::vector<Marker> list;
         std::mutex mutex;
 
-        void record_gc_entered() {
-          last_gc_entry = TimeStamp::Now();
-        }
-
-        void record_gc_leave() {
-          list.push_back({ Marker::MARKER_GC_PAUSE, Marker::INTERVAL, last_gc_entry, TimeStamp::Now(), get_native_thread_id(), -1 });
-        }
-
         void record_interval(Marker::Type type, TimeStamp from, TimeStamp to, int stack_index = -1) {
             const std::lock_guard<std::mutex> lock(mutex);
 
-            list.push_back({ type, Marker::INTERVAL, from, to, get_native_thread_id(), stack_index });
+            list.push_back({ type, Marker::INTERVAL, from, to, stack_index });
         }
 
         void record(Marker::Type type, int stack_index = -1) {
             const std::lock_guard<std::mutex> lock(mutex);
 
-            list.push_back({ type, Marker::INSTANT, TimeStamp::Now(), TimeStamp(), get_native_thread_id(), stack_index });
+            list.push_back({ type, Marker::INSTANT, TimeStamp::Now(), TimeStamp(), stack_index });
+        }
+};
+
+class GCMarkerTable: public MarkerTable {
+    TimeStamp last_gc_entry;
+
+    public:
+        void record_gc_entered() {
+          last_gc_entry = TimeStamp::Now();
+        }
+
+        void record_gc_leave() {
+          list.push_back({ Marker::MARKER_GC_PAUSE, Marker::INTERVAL, last_gc_entry, TimeStamp::Now(), -1 });
         }
 };
 
@@ -731,6 +767,8 @@ class Thread {
             STOPPED
         };
 
+        VALUE ruby_thread;
+        VALUE ruby_thread_id;
         pthread_t pthread_id;
         native_thread_id_t native_tid;
         State state;
@@ -742,18 +780,33 @@ class Thread {
         int stack_on_suspend_idx;
         SampleTranslator translator;
 
-        std::string name;
+        MarkerTable *markers;
+
+	std::string name;
 
-        Thread(State state) : state(state), stack_on_suspend_idx(-1) {
-            pthread_id = pthread_self();
+	// FIXME: don't use pthread at start
+        Thread(State state, pthread_t pthread_id, VALUE ruby_thread) : pthread_id(pthread_id), ruby_thread(ruby_thread), state(state), stack_on_suspend_idx(-1) {
+            name = Qnil;
+            ruby_thread_id = rb_obj_id(ruby_thread);
+	    //ruby_thread_id = ULL2NUM(ruby_thread);
             native_tid = get_native_thread_id();
             started_at = state_changed_at = TimeStamp::Now();
+            name = "";
+            markers = new MarkerTable();
+
+            if (state == State::STARTED) {
+                markers->record(Marker::Type::MARKER_GVL_THREAD_STARTED);
+            }
         }
 
-        void set_state(State new_state, MarkerTable *markers) {
+        void set_state(State new_state) {
             if (state == Thread::State::STOPPED) {
                 return;
             }
+            if (new_state == Thread::State::SUSPENDED && state == new_state) {
+                // on Ruby 3.2 (only?) we may see duplicate suspended states
+                return;
+            }
 
             TimeStamp from = state_changed_at;
             auto now = TimeStamp::Now();
@@ -764,10 +817,13 @@ class Thread {
 
             switch (new_state) {
                 case State::STARTED:
-                    new_state = State::RUNNING;
+                    markers->record(Marker::Type::MARKER_GVL_THREAD_STARTED);
+                    return; // no mutation of current state
                     break;
                 case State::RUNNING:
-                    assert(state == State::READY);
+                    assert(state == State::READY || state == State::RUNNING);
+                    pthread_id = pthread_self();
+                    native_tid = get_native_thread_id();
 
                     // If the GVL is immediately ready, and we measure no times
                     // stalled, skip emitting the interval.
@@ -783,25 +839,26 @@ class Thread {
                     // 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::SUSPENDED || state == State::RUNNING);
+                    assert(state == State::STARTED || state == State::SUSPENDED || state == State::RUNNING);
                     if (state == State::SUSPENDED) {
                         markers->record_interval(Marker::Type::MARKER_THREAD_SUSPENDED, from, now, stack_on_suspend_idx);
                     }
-                    else {
+                    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::RUNNING || state == State::STARTED);
+                    assert(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 to STOPPED
-                    assert(state == State::RUNNING || state == State::STARTED);
+                    // We can go from RUNNING or STARTED or SUSPENDED to STOPPED
+                    assert(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);
+
                     stopped_at = now;
-                    capture_name();
 
                     break;
             }
@@ -814,11 +871,7 @@ class Thread {
             return state != State::STOPPED;
         }
 
-        void capture_name() {
-            char buf[128];
-            int rc = pthread_getname_np(pthread_id, buf, sizeof(buf));
-            if (rc == 0)
-                name = std::string(buf);
+        void mark() {
         }
 };
 
@@ -832,40 +885,46 @@ class ThreadTable {
         ThreadTable(FrameList &frame_list) : frame_list(frame_list) {
         }
 
-        void started(MarkerTable *markers) {
-            //const std::lock_guard<std::mutex> lock(mutex);
+        void mark() {
+            for (auto &thread : list) {
+                thread.mark();
+            }
+        }
 
+        void started(VALUE th) {
             //list.push_back(Thread{pthread_self(), Thread::State::SUSPENDED});
-            markers->record(Marker::Type::MARKER_GVL_THREAD_STARTED);
-            set_state(Thread::State::STARTED, markers);
+            set_state(Thread::State::STARTED, th);
         }
 
-        void ready(MarkerTable *markers) {
-            set_state(Thread::State::READY, markers);
+        void ready(VALUE th) {
+            set_state(Thread::State::READY, th);
         }
 
-        void resumed(MarkerTable *markers) {
-            set_state(Thread::State::RUNNING, markers);
+        void resumed(VALUE th) {
+            set_state(Thread::State::RUNNING, th);
         }
 
-        void suspended(MarkerTable *markers) {
-            set_state(Thread::State::SUSPENDED, markers);
+        void suspended(VALUE th) {
+            set_state(Thread::State::SUSPENDED, th);
         }
 
-        void stopped(MarkerTable *markers) {
-            markers->record(Marker::Type::MARKER_GVL_THREAD_EXITED);
-            set_state(Thread::State::STOPPED, markers);
+        void stopped(VALUE th) {
+            set_state(Thread::State::STOPPED, th);
         }
 
     private:
-        void set_state(Thread::State new_state, MarkerTable *markers) {
+        void set_state(Thread::State new_state, VALUE th) {
             const std::lock_guard<std::mutex> lock(mutex);
 
-            pthread_t current_thread = pthread_self();
             //cerr << "set state=" << new_state << " thread=" << gettid() << endl;
 
+            pid_t native_tid = get_native_thread_id();
+            pthread_t pthread_id = pthread_self();
+
+            //fprintf(stderr, "th %p (tid: %i) from %s to %s\n", (void *)th, native_tid, gvl_event_name(state), gvl_event_name(new_state));
+
             for (auto &thread : list) {
-                if (pthread_equal(current_thread, thread.pthread_id)) {
+                if (thread_equal(th, thread.ruby_thread)) {
                     if (new_state == Thread::State::SUSPENDED) {
 
                         RawSample sample;
@@ -875,14 +934,27 @@ class ThreadTable {
                         //cerr << gettid() << " suspended! Stack size:" << thread.stack_on_suspend.size() << endl;
                     }
 
-                    thread.set_state(new_state, markers);
+                    thread.set_state(new_state);
+
+                    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;
+                    }
+
 
                     return;
                 }
             }
 
-            pid_t native_tid = get_native_thread_id();
-            list.emplace_back(new_state);
+            //fprintf(stderr, "NEW THREAD: th: %p, state: %i\n", th, new_state);
+            list.emplace_back(new_state, pthread_self(), th);
+        }
+
+        bool thread_equal(VALUE a, VALUE b) {
+            return a == b;
         }
 };
 
@@ -1002,6 +1074,12 @@ class RetainedCollector : public BaseCollector {
     void record(VALUE obj) {
         RawSample sample;
         sample.sample();
+        if (sample.empty()) {
+            // During thread allocation we allocate one object without a frame
+            // (as of Ruby 3.3)
+            // Ideally we'd allow empty samples to be represented
+            return;
+        }
         int stack_index = frame_list.stack_index(sample);
 
         object_list.push_back(obj);
@@ -1151,6 +1229,8 @@ class GlobalSignalHandler {
         void record_sample(LiveSample &sample, pthread_t pthread_id) {
             const std::lock_guard<std::mutex> lock(mutex);
 
+            assert(pthread_id);
+
             live_sample = &sample;
             if (pthread_kill(pthread_id, SIGPROF)) {
                 rb_bug("pthread_kill failed");
@@ -1187,7 +1267,7 @@ class GlobalSignalHandler {
 LiveSample *GlobalSignalHandler::live_sample;
 
 class TimeCollector : public BaseCollector {
-    MarkerTable markers;
+    GCMarkerTable gc_markers;
     ThreadTable threads;
 
     pthread_t sample_thread;
@@ -1216,10 +1296,22 @@ class TimeCollector : public BaseCollector {
     }
 
     VALUE get_markers() {
-        VALUE list = rb_ary_new2(this->markers.list.size());
+        VALUE list = rb_ary_new();
+        VALUE main_thread = rb_thread_main();
+        VALUE main_thread_id = rb_obj_id(main_thread);
+
+        for (auto& marker: this->gc_markers.list) {
+            VALUE ary = marker.to_array();
 
-        for (auto& marker: this->markers.list) {
-            rb_ary_push(list, marker.to_array());
+            RARRAY_ASET(ary, 0, main_thread_id);
+            rb_ary_push(list, ary);
+        }
+        for (auto &thread : threads.list) {
+            for (auto& marker: thread.markers->list) {
+                VALUE ary = marker.to_array();
+                RARRAY_ASET(ary, 0, thread.ruby_thread_id);
+                rb_ary_push(list, ary);
+            }
         }
 
         return list;
@@ -1235,7 +1327,9 @@ class TimeCollector : public BaseCollector {
             threads.mutex.lock();
             for (auto &thread : threads.list) {
                 //if (thread.state == Thread::State::RUNNING) {
-                if (thread.state == Thread::State::RUNNING || (thread.state == Thread::State::SUSPENDED && thread.stack_on_suspend_idx < 0)) {
+                //if (thread.state == Thread::State::RUNNING || (thread.state == Thread::State::SUSPENDED && thread.stack_on_suspend_idx < 0)) {
+                if (thread.state == Thread::State::RUNNING) {
+                    //fprintf(stderr, "sampling %p on tid:%i\n", thread.ruby_thread, thread.native_tid);
                     GlobalSignalHandler::get_instance()->record_sample(sample, thread.pthread_id);
 
                     if (sample.sample.gc) {
@@ -1271,6 +1365,13 @@ class TimeCollector : public BaseCollector {
     }
 
     static void *sample_thread_entry(void *arg) {
+#if HAVE_PTHREAD_SETNAME_NP
+#ifdef __APPLE__
+        pthread_setname_np("Vernier profiler");
+#else
+        pthread_setname_np(pthread_self(), "Vernier profiler");
+#endif
+#endif
         TimeCollector *collector = static_cast<TimeCollector *>(arg);
         collector->sample_thread_run();
         return NULL;
@@ -1281,10 +1382,10 @@ class TimeCollector : public BaseCollector {
 
         switch (event) {
             case RUBY_EVENT_THREAD_BEGIN:
-                collector->threads.started(&collector->markers);
+                collector->threads.started(self);
                 break;
             case RUBY_EVENT_THREAD_END:
-                collector->threads.stopped(&collector->markers);
+                collector->threads.stopped(self);
                 break;
         }
     }
@@ -1294,36 +1395,57 @@ class TimeCollector : public BaseCollector {
 
         switch (event) {
             case RUBY_INTERNAL_EVENT_GC_START:
-                collector->markers.record(Marker::Type::MARKER_GC_START);
+                collector->gc_markers.record(Marker::Type::MARKER_GC_START);
                 break;
             case RUBY_INTERNAL_EVENT_GC_END_MARK:
-                collector->markers.record(Marker::Type::MARKER_GC_END_MARK);
+                collector->gc_markers.record(Marker::Type::MARKER_GC_END_MARK);
                 break;
             case RUBY_INTERNAL_EVENT_GC_END_SWEEP:
-                collector->markers.record(Marker::Type::MARKER_GC_END_SWEEP);
+                collector->gc_markers.record(Marker::Type::MARKER_GC_END_SWEEP);
                 break;
             case RUBY_INTERNAL_EVENT_GC_ENTER:
-                collector->markers.record_gc_entered();
+                collector->gc_markers.record_gc_entered();
                 break;
             case RUBY_INTERNAL_EVENT_GC_EXIT:
-                collector->markers.record_gc_leave();
+                collector->gc_markers.record_gc_leave();
                 break;
         }
     }
 
     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
+
+        auto native_tid = get_native_thread_id();
         //cerr << "internal thread event" << event << " at " << TimeStamp::Now() << endl;
+        //fprintf(stderr, "(%i) th %p to %s\n", native_tid, (void *)thread, gvl_event_name(event));
+
 
         switch (event) {
+            case RUBY_INTERNAL_THREAD_EVENT_STARTED:
+                collector->threads.started(thread);
+                break;
+            case RUBY_INTERNAL_THREAD_EVENT_EXITED:
+                collector->threads.stopped(thread);
+                break;
             case RUBY_INTERNAL_THREAD_EVENT_READY:
-                collector->threads.ready(&collector->markers);
+                collector->threads.ready(thread);
                 break;
             case RUBY_INTERNAL_THREAD_EVENT_RESUMED:
-                collector->threads.resumed(&collector->markers);
+                collector->threads.resumed(thread);
                 break;
             case RUBY_INTERNAL_THREAD_EVENT_SUSPENDED:
-                collector->threads.suspended(&collector->markers);
+                collector->threads.suspended(thread);
                 break;
 
         }
@@ -1351,7 +1473,7 @@ class TimeCollector : public BaseCollector {
         // have at least one thread in our thread list because it's possible
         // that the profile might be such that we don't get any thread switch
         // events and we need at least one
-        this->threads.resumed(&this->markers);
+        this->threads.resumed(rb_thread_current());
 
         thread_hook = rb_internal_thread_add_event_hook(internal_thread_event_cb, RUBY_INTERNAL_THREAD_EVENT_MASK, this);
         rb_add_event_hook(internal_gc_event_cb, RUBY_INTERNAL_EVENTS, PTR2NUM((void *)this));
@@ -1372,13 +1494,6 @@ class TimeCollector : public BaseCollector {
         rb_remove_event_hook(internal_gc_event_cb);
         rb_remove_event_hook(internal_thread_event_cb);
 
-        // capture thread names
-        for (auto& thread: this->threads.list) {
-            if (thread.running()) {
-                thread.capture_name();
-            }
-        }
-
         frame_list.finalize();
 
         VALUE result = build_collector_result();
@@ -1398,7 +1513,7 @@ class TimeCollector : public BaseCollector {
             VALUE hash = rb_hash_new();
             thread.samples.write_result(hash);
 
-            rb_hash_aset(threads, ULL2NUM(thread.native_tid), hash);
+            rb_hash_aset(threads, thread.ruby_thread_id, hash);
             rb_hash_aset(hash, sym("tid"), ULL2NUM(thread.native_tid));
             rb_hash_aset(hash, sym("started_at"), ULL2NUM(thread.started_at.nanoseconds()));
             if (!thread.stopped_at.zero()) {
@@ -1415,6 +1530,7 @@ class TimeCollector : public BaseCollector {
 
     void mark() {
         frame_list.mark_frames();
+        threads.mark();
 
         //for (int i = 0; i < queued_length; i++) {
         //    rb_gc_mark(queued_frames[i]);

data/lib/vernier/collector.rb

@@ -19,7 +19,7 @@ module Vernier
       Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
     end
 
-    def add_marker(name:, start:, finish:, thread: Thread.current.native_thread_id, phase: Marker::Phase::INTERVAL, data: nil)
+    def add_marker(name:, start:, finish:, thread: Thread.current.object_id, phase: Marker::Phase::INTERVAL, data: nil)
       @markers << [thread,
                    name,
                    start,
@@ -39,7 +39,7 @@ module Vernier
         start:,
         finish: current_time,
         phase: Marker::Phase::INTERVAL,
-        thread: Thread.current.native_thread_id,
+        thread: Thread.current.object_id,
         data: { :type => 'UserTiming', :entryType => 'measure', :name => name }
       )
     end

data/lib/vernier/output/firefox.rb

@@ -99,9 +99,10 @@ module Vernier
       def data
         markers_by_thread = profile.markers.group_by { |marker| marker[0] }
 
-        thread_data = profile.threads.map do |tid, thread_info|
-          markers = markers_by_thread[tid] || []
+        thread_data = profile.threads.map do |ruby_thread_id, thread_info|
+          markers = markers_by_thread[ruby_thread_id] || []
           Thread.new(
+            ruby_thread_id,
             profile,
             @categorizer,
             markers: markers,
@@ -157,11 +158,12 @@ module Vernier
       class Thread
         attr_reader :profile
 
-        def initialize(profile, categorizer, name:, tid:, samples:, weights:, timestamps: nil, sample_categories: nil, markers:, started_at:, stopped_at: nil)
+        def initialize(ruby_thread_id, profile, categorizer, name:, tid:, samples:, weights:, timestamps: nil, sample_categories: nil, markers:, started_at:, stopped_at: nil)
+          @ruby_thread_id = ruby_thread_id
           @profile = profile
           @categorizer = categorizer
           @tid = tid
-          @name = name
+          @name = pretty_name(name)
 
           timestamps ||= [0] * samples.size
           @samples, @weights, @timestamps = samples, weights, timestamps
@@ -212,7 +214,7 @@ module Vernier
         def data
           {
             name: @name,
-            isMainThread: (@tid == ::Thread.main.native_thread_id) || (profile.threads.size == 1),
+            isMainThread: @ruby_thread_id == ::Thread.main.object_id || (profile.threads.size == 1),
             processStartupTime: 0, # FIXME
             processShutdownTime: nil, # FIXME
             registerTime: (@started_at - 0) / 1_000_000.0,
@@ -383,6 +385,25 @@ module Vernier
 
         private
 
+        def pretty_name(name)
+          if name.empty?
+            begin
+              tr = ObjectSpace._id2ref(@ruby_thread_id)
+              name = tr.inspect if tr
+            rescue RangeError
+              # Thread was already GC'd
+            end
+          end
+          return name unless name.start_with?("#<Thread")
+          pretty = []
+          obj_address = name[/Thread:(0x\w+)/,1]
+          best_id = name[/\#<Thread:0x\w+@?\s?(.*)\s+\S+>/,1] || ""
+          Gem.path.each { |gem_dir| best_id = best_id.gsub(gem_dir, "...") }
+          pretty << best_id unless best_id.empty?
+          pretty << "(#{obj_address})"
+          pretty.join(' ')
+        end
+
         def gc_category
           @categorizer.get_category("GC")
         end

data/lib/vernier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Vernier
-  VERSION = "0.3.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vernier
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-05 00:00:00.000000000 Z
+date: 2024-02-27 00:00:00.000000000 Z
 dependencies: []
 description: An experimental profiler
 email: