vernier 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3190b81748262d9620de74e12f6adca9b2c4126741781f9860076d96c96a123
-  data.tar.gz: b54848781f0b17c16074fd630d0aae6b6ea206e47679713ce858e6e3f08525a5
+  metadata.gz: da42588d9f2409a9d82a79439014490ecd81f00cb74c975267d6568a6e343c46
+  data.tar.gz: 921543f2b8cfec4e5803c4a47c8953df1acff567b88ddce2e1a65faad9e7c895
 SHA512:
-  metadata.gz: de91010589471c0b4a7cfddb37bab92262392ef33da2af44930cdab848a6fd290468abe76c147485ba032d89cdac33b631937eea01bd15af8e89b03a5200e69e
-  data.tar.gz: 82b40e4d93685ab8c560a995df31421c06ff00f8c27f33d6b37296bed96ca5b37cacda3be60e64464f535dd52d273f80d4885705f591e7246d7b3fb2269c151f
+  metadata.gz: a674536e944ef26f2db5893821d9d643fc8f651d45b7a72923ae9ab7c01f270431f0e5fadea76e3bb3feeabe30edde203b520310cbbbae6a53f03edb148db570
+  data.tar.gz: 1f39e9f04a2fd1c80525a72ce27aca6e8d614dfa9a4ba9f9721beff08f11a41431f6690c6215f0592dcc7923e49e516a4a0ddb812b493820877ceca81b4373ab

data/ext/vernier/vernier.cc

@@ -331,7 +331,7 @@ struct RawSample {
 
     Frame frame(int i) const {
         int idx = len - i - 1;
-        if (idx < 0) throw std::out_of_range("out of range");
+        if (idx < 0) throw std::out_of_range("VERNIER BUG: index out of range");
         const Frame frame = {frames[idx], lines[idx]};
         return frame;
     }
@@ -446,7 +446,7 @@ struct FrameList {
 
     int stack_index(const RawSample &stack) {
         if (stack.empty()) {
-            throw std::runtime_error("empty stack");
+            throw std::runtime_error("VERNIER BUG: empty stack");
         }
 
         StackNode *node = &root_stack_node;
@@ -659,8 +659,8 @@ class Marker {
 
 class MarkerTable {
     public:
-        std::vector<Marker> list;
         std::mutex mutex;
+        std::vector<Marker> list;
 
         void record_interval(Marker::Type type, TimeStamp from, TimeStamp to, int stack_index = -1) {
             const std::lock_guard<std::mutex> lock(mutex);
@@ -780,19 +780,18 @@ class Thread {
         int stack_on_suspend_idx;
         SampleTranslator translator;
 
-        MarkerTable *markers;
+        unique_ptr<MarkerTable> markers;
 
-	std::string name;
+        std::string name;
 
-	// FIXME: don't use pthread at start
+        // 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);
+            //ruby_thread_id = ULL2NUM(ruby_thread);
             native_tid = get_native_thread_id();
             started_at = state_changed_at = TimeStamp::Now();
             name = "";
-            markers = new MarkerTable();
+            markers = std::make_unique<MarkerTable>();
 
             if (state == State::STARTED) {
                 markers->record(Marker::Type::MARKER_GVL_THREAD_STARTED);
@@ -853,13 +852,12 @@ class Thread {
                     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;
             }
@@ -872,13 +870,6 @@ 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() {
         }
 };
@@ -887,15 +878,15 @@ class ThreadTable {
     public:
         FrameList &frame_list;
 
-        std::vector<Thread> list;
+        std::vector<std::unique_ptr<Thread> > list;
         std::mutex mutex;
 
         ThreadTable(FrameList &frame_list) : frame_list(frame_list) {
         }
 
         void mark() {
-            for (auto &thread : list) {
-                thread.mark();
+            for (const auto &thread : list) {
+                thread->mark();
             }
         }
 
@@ -931,7 +922,8 @@ 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));
 
-            for (auto &thread : list) {
+            for (auto &threadptr : list) {
+                auto &thread = *threadptr;
                 if (thread_equal(th, thread.ruby_thread)) {
                     if (new_state == Thread::State::SUSPENDED) {
 
@@ -958,7 +950,7 @@ class ThreadTable {
             }
 
             //fprintf(stderr, "NEW THREAD: th: %p, state: %i\n", th, new_state);
-            list.emplace_back(new_state, pthread_self(), th);
+            list.push_back(std::make_unique<Thread>(new_state, pthread_self(), th));
         }
 
         bool thread_equal(VALUE a, VALUE b) {
@@ -1082,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);
@@ -1228,17 +1226,22 @@ class GlobalSignalHandler {
             if (count == 0) clear_signal_handler();
         }
 
-        void record_sample(LiveSample &sample, pthread_t pthread_id) {
+        bool 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");
+            int rc = pthread_kill(pthread_id, SIGPROF);
+            if (rc) {
+                fprintf(stderr, "VERNIER BUG: pthread_kill of %lu failed (%i)\n", (unsigned long)pthread_id, rc);
+                live_sample = NULL;
+                return false;
+            } else {
+                sample.wait();
+                live_sample = NULL;
+                return true;
             }
-            sample.wait();
-            live_sample = NULL;
         }
 
     private:
@@ -1309,9 +1312,9 @@ class TimeCollector : public BaseCollector {
             rb_ary_push(list, ary);
         }
         for (auto &thread : threads.list) {
-            for (auto& marker: thread.markers->list) {
+            for (auto& marker: thread->markers->list) {
                 VALUE ary = marker.to_array();
-                RARRAY_ASET(ary, 0, thread.ruby_thread_id);
+                RARRAY_ASET(ary, 0, thread->ruby_thread_id);
                 rb_ary_push(list, ary);
             }
         }
@@ -1327,14 +1330,21 @@ class TimeCollector : public BaseCollector {
             TimeStamp sample_start = TimeStamp::Now();
 
             threads.mutex.lock();
-            for (auto &thread : threads.list) {
+            for (auto &threadptr : threads.list) {
+                auto &thread = *threadptr;
+
                 //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) {
                     //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) {
+                    bool signal_sent = GlobalSignalHandler::get_instance()->record_sample(sample, thread.pthread_id);
+
+                    if (!signal_sent) {
+                        // The thread has died. We probably should have caught
+                        // that by the GVL instrumentation, but let's try to get
+                        // it to a consistent state and stop profiling it.
+                        thread.set_state(Thread::State::STOPPED);
+                    } else if (sample.sample.gc) {
                         // fprintf(stderr, "skipping GC sample\n");
                     } else {
                         record_sample(sample.sample, sample_start, thread, CATEGORY_NORMAL);
@@ -1467,7 +1477,7 @@ class TimeCollector : public BaseCollector {
         int ret = pthread_create(&sample_thread, NULL, &sample_thread_entry, this);
         if (ret != 0) {
             perror("pthread_create");
-            rb_bug("pthread_create");
+            rb_bug("VERNIER: pthread_create failed");
         }
 
         // Set the state of the current Ruby thread to RUNNING, which we know it
@@ -1496,13 +1506,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();
@@ -1520,15 +1523,15 @@ class TimeCollector : public BaseCollector {
 
         for (const auto& thread: this->threads.list) {
             VALUE hash = rb_hash_new();
-            thread.samples.write_result(hash);
+            thread->samples.write_result(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()) {
-                rb_hash_aset(hash, sym("stopped_at"), ULL2NUM(thread.stopped_at.nanoseconds()));
+            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()) {
+                rb_hash_aset(hash, sym("stopped_at"), ULL2NUM(thread->stopped_at.nanoseconds()));
             }
-            rb_hash_aset(hash, sym("name"), rb_str_new(thread.name.data(), thread.name.length()));
+            rb_hash_aset(hash, sym("name"), rb_str_new(thread->name.data(), thread->name.length()));
 
         }
 

data/lib/vernier/output/firefox.rb

@@ -163,7 +163,7 @@ module Vernier
           @profile = profile
           @categorizer = categorizer
           @tid = tid
-          @name = name
+          @name = pretty_name(name)
 
           timestamps ||= [0] * samples.size
           @samples, @weights, @timestamps = samples, weights, timestamps
@@ -385,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.4.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vernier
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.1
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-15 00:00:00.000000000 Z
+date: 2024-02-28 00:00:00.000000000 Z
 dependencies: []
 description: An experimental profiler
 email:
@@ -67,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: An experimental profiler