vernier 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f552d6fe2d529de743412cbc9975bfbd4ac87b894777a44ce26ef07dddc8e032
-  data.tar.gz: b9ddcd3e4ce0acb5ac53363e041d1bd9e3a2d4c5bf21b2bbe56c48ed5fef4cdd
+  metadata.gz: da42588d9f2409a9d82a79439014490ecd81f00cb74c975267d6568a6e343c46
+  data.tar.gz: 921543f2b8cfec4e5803c4a47c8953df1acff567b88ddce2e1a65faad9e7c895
 SHA512:
-  metadata.gz: 1b0808ee6ae8e64866e81e7ba8ed4847788421a00517c00e7aacb54c2fdff16287f92eb10132b5802fcb93955c3e4cf1a8fe4cfc97f4a9742a8130341bea75f7
-  data.tar.gz: 686a7397043be44451cccf9380473cda1e350ee342878ca2428d8bcd6c69aeea36244d15c92e3f998d4b6245c46c37d74ac3aac18ed58c783c288501d0cf7243
+  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);
@@ -879,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();
             }
         }
 
@@ -923,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) {
 
@@ -950,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) {
@@ -1226,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:
@@ -1307,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);
             }
         }
@@ -1325,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);
@@ -1465,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
@@ -1511,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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vernier
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-27 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