vernier 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f738e495accaaab1af3f33a806a7b20467aa8f2a93f4b7bf8d7300fdaf88ad
-  data.tar.gz: e6877e7315fb990e8db9482b940a96068770987989fec85a804c75ce79b62022
+  metadata.gz: c3190b81748262d9620de74e12f6adca9b2c4126741781f9860076d96c96a123
+  data.tar.gz: b54848781f0b17c16074fd630d0aae6b6ea206e47679713ce858e6e3f08525a5
 SHA512:
-  metadata.gz: 4dcf1c2ebcbfcfd1b5a456fbc9ffbfd82da1f96622b8dc889d9ece105a9f461768dd688b6e0ee73102db104bff527a9c940f6d74689d520005ea216823444cbe
-  data.tar.gz: 97e0116ec7de5ee084512520debd37d0262555ca6a09d427b9147c3e08303492c925e8b1f81c9299915aff6322122a82e8737d1ef22823da8689aab2ce63aa6f
+  metadata.gz: de91010589471c0b4a7cfddb37bab92262392ef33da2af44930cdab848a6fd290468abe76c147485ba032d89cdac33b631937eea01bd15af8e89b03a5200e69e
+  data.tar.gz: 82b40e4d93685ab8c560a995df31421c06ff00f8c27f33d6b37296bed96ca5b37cacda3be60e64464f535dd52d273f80d4885705f591e7246d7b3fb2269c151f

data/README.md

@@ -1,33 +1,55 @@
 # Vernier
 
-Experimental 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
+
+[Livestreamed demo: Pairin' with Aaron (YouTube)](https://www.youtube.com/watch?v=9nvX3OHykGQ#t=27m43)
+
+Sidekiq jobs from Mastodon (time, threded)
+: https://share.firefox.dev/44jZRf3
+
+Puma web requests from Mastodon (time, threded)
+: https://share.firefox.dev/48FOTnF
+
+Rails benchmark - lobste.rs (time)
+: https://share.firefox.dev/3Ld89id
+
+`require "irb"` (retained memory)
+: https://share.firefox.dev/3DhLsFa
 
 ## Installation
 
+Vernier requires Ruby version 3.2.1 or greater
+
 ```ruby
 gem 'vernier'
 ```
 
 ## Usage
 
-### Retained memory
 
-Record a flamegraph of all **retained** allocations from loading `irb`.
+### Time
 
 ```
-ruby -r vernier -e 'Vernier.trace_retained(out: "irb_profile.json") { require "irb" }'
+Vernier.trace(out: "time_profile.json") { some_slow_method }
 ```
 
-The output can then be viewed in the [Firefox Profiler (demo)](https://share.firefox.dev/3DhLsFa) or the [`profile-viewer` gem](https://github.com/tenderlove/profiler/tree/ruby) (a Ruby-customized version of the firefox profiler.
+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.
 
-![Screenshot 2023-07-16 at 21-06-19 Ruby_Vernier – 1970-01-01 12 00 00 a m  UTC – Firefox Profiler](https://github.com/jhawthorn/vernier/assets/131752/9ca0b593-70fb-4c8b-aed9-cb33e0e0bc06)
+- **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.
 
-### Time
+### Retained memory
+
+Record a flamegraph of all **retained** allocations from loading `irb`.
 
 ```
-Vernier.trace(out: "time_profile.json") { some_slow_method }
+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
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

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;
@@ -72,17 +93,29 @@ class TimeStamp {
         return TimeStamp(0);
     }
 
-    static void Sleep(const TimeStamp &time) {
-        struct timespec ts = time.timespec();
+    // SleepUntil a specified timestamp
+    // Highly accurate manual sleep time
+    static void SleepUntil(const TimeStamp &target_time) {
+        if (target_time.zero()) return;
+        struct timespec ts = target_time.timespec();
 
         int res;
         do {
-            res = nanosleep(&ts, &ts);
-        } while (res && errno == EINTR);
+            // do nothing until it's time :)
+            sleep(0);
+        } 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) {
@@ -262,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);
@@ -300,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);
         }
     }
@@ -598,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());
@@ -621,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 });
         }
 };
 
@@ -727,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;
@@ -738,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();
@@ -760,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.
@@ -779,23 +839,25 @@ 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);
                     markers->record_interval(Marker::Type::MARKER_THREAD_RUNNING, from, now);
+                    markers->record(Marker::Type::MARKER_GVL_THREAD_EXITED);
+
                     stopped_at = now;
                     capture_name();
 
@@ -811,10 +873,13 @@ class Thread {
         }
 
         void capture_name() {
-            char buf[128];
-            int rc = pthread_getname_np(pthread_id, buf, sizeof(buf));
-            if (rc == 0)
-                name = std::string(buf);
+            //char buf[128];
+            //int rc = pthread_getname_np(pthread_id, buf, sizeof(buf));
+            //if (rc == 0)
+            //    name = std::string(buf);
+        }
+
+        void mark() {
         }
 };
 
@@ -828,40 +893,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;
@@ -871,14 +942,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;
         }
 };
 
@@ -1091,6 +1175,9 @@ class RetainedCollector : public BaseCollector {
         VALUE weights = rb_ary_new();
         rb_hash_aset(thread_hash, sym("weights"), weights);
 
+        rb_hash_aset(thread_hash, sym("name"), rb_str_new_cstr("retained memory"));
+        rb_hash_aset(thread_hash, sym("started_at"), ULL2NUM(collector->started_at.nanoseconds()));
+
         for (auto& obj: collector->object_list) {
             const auto search = collector->object_frames.find(obj);
             if (search != collector->object_frames.end()) {
@@ -1144,6 +1231,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");
@@ -1180,7 +1269,7 @@ class GlobalSignalHandler {
 LiveSample *GlobalSignalHandler::live_sample;
 
 class TimeCollector : public BaseCollector {
-    MarkerTable markers;
+    GCMarkerTable gc_markers;
     ThreadTable threads;
 
     pthread_t sample_thread;
@@ -1209,10 +1298,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;
@@ -1228,7 +1329,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) {
@@ -1252,19 +1355,25 @@ class TimeCollector : public BaseCollector {
 
             next_sample_schedule += interval;
 
+            // If sampling falls behind, restart, and check in another interval
             if (next_sample_schedule < sample_complete) {
-                //fprintf(stderr, "fell behind by %ius\n", (sample_complete - next_sample_schedule).microseconds());
                 next_sample_schedule = sample_complete + interval;
             }
 
-            TimeStamp sleep_time = next_sample_schedule - sample_complete;
-            TimeStamp::Sleep(sleep_time);
+            TimeStamp::SleepUntil(next_sample_schedule);
         }
 
         thread_stopped.post();
     }
 
     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;
@@ -1275,10 +1384,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;
         }
     }
@@ -1288,36 +1397,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;
 
         }
@@ -1345,7 +1475,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));
@@ -1392,7 +1522,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()) {
@@ -1409,6 +1539,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,14 +158,16 @@ module Vernier
       class Thread
         attr_reader :profile
 
-        def initialize(profile, categorizer, name:, tid:, samples:, weights:, timestamps:, sample_categories:, 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
 
+          timestamps ||= [0] * samples.size
           @samples, @weights, @timestamps = samples, weights, timestamps
-          @sample_categories = sample_categories
+          @sample_categories = sample_categories || ([0] * samples.size)
           @markers = markers
 
           @started_at, @stopped_at = started_at, stopped_at
@@ -211,7 +214,7 @@ module Vernier
         def data
           {
             name: @name,
-            isMainThread: @tid == ::Thread.main.native_thread_id,
+            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,
@@ -237,8 +240,6 @@ module Vernier
         end
 
         def markers_table
-          size = @markers.size
-
           string_indexes = []
           start_times = []
           end_times = []
@@ -292,7 +293,6 @@ module Vernier
             times = (0...size).to_a
           end
 
-          raise unless samples.size == size
           raise unless weights.size == size
           raise unless times.size == size
 

data/lib/vernier/version.rb

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

data/lib/vernier.rb

@@ -19,11 +19,11 @@ module Vernier
       yield collector
     ensure
       result = collector.stop
+      if out
+        File.write(out, Output::Firefox.new(result).output)
+      end
     end
 
-    if out
-      File.write(out, Output::Firefox.new(result).output)
-    end
     result
   end
 

data/vernier.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = spec.summary
   spec.homepage = "https://github.com/jhawthorn/vernier"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.2.0"
+  spec.required_ruby_version = ">= 3.2.1"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vernier
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-29 00:00:00.000000000 Z
+date: 2024-01-15 00:00:00.000000000 Z
 dependencies: []
 description: An experimental profiler
 email:
@@ -60,7 +60,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.2.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="