gvl-tracing 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5ec59682543834d531647bea2601457de0d8f8d57fe039181375891ef29ae60
-  data.tar.gz: ebfa80876458868eb9780bdf655c75ff7c3b649f0661799533e6dcd12f5b06ea
+  metadata.gz: 9640e68d58cfbda91dc7c034982b3e43eec6048729d0ca61c8498495ad8f4277
+  data.tar.gz: ab154e734bfb085aff5615837efda1b7836784019fd689051b21db483f86c62b
 SHA512:
-  metadata.gz: 259ae5c91f2d750ed61ec938a3eb3f92fc813391393420648288626d824408f1678a534de2185c73a6ea8fc2a695aa46135f5529a8fa9bd32e00c0f878b5a538
-  data.tar.gz: ead5ce15933a39684675705a60983dbcd5fc8afb7752822103799261d05d5e3b3f6da8562ca496b9929f7bebf9ed203c31ccc5b778be59bf2c724f7bab9c4d49
+  metadata.gz: a87a874de0373814d27f9e567c19fa4d36f5c2cdb5db2f3a6d7a7ce3280917dd8ecf0fc85b130f3573aa496cc5633427b92780f48ab00dc9cac8e6649763502a
+  data.tar.gz: c5ef422b98a1cf2835f62d0769c0e0ea2b7d0f6af36888f05617795e4667a0bf4bbcf404e0e860fbdf319ae2be8e41fd84f09c2168282e6a0adfbee92a252840

data/.ruby-version

@@ -1 +1 @@
-ruby-3.2.0
+ruby-3.2.2

data/.standard.yml

@@ -3,3 +3,7 @@ ruby_version: 3.2
 ignore:
   - 'examples/example1.rb':
     - Style/InfiniteLoop
+  - 'examples/example5.rb':
+    - Style/InfiniteLoop
+  - 'lib/gvl_tracing/sleep_tracking.rb':
+    - Style/MixinUsage

data/README.adoc

@@ -8,9 +8,9 @@ A Ruby gem for getting a timeline view of Global VM Lock usage in your Ruby app
 
 image::preview.png[]
 
-See my blog post https://ivoanjo.me/blog/2022/07/17/tracing-ruby-global-vm-lock/[tracing ruby's (global) vm lock] for more details!
+For instructions and examples on how to use it, see my https://ivoanjo.me/blog/2023/07/23/understanding-the-ruby-global-vm-lock-by-observing-it/[RubyKaigi 2023 talk on "Understanding the Ruby Global VM Lock by observing it"].
 
-NOTE: This gem only works on Ruby 3.2 and above because it depends on the https://github.com/ruby/ruby/pull/5500[GVL Instrumentation API].
+NOTE: This gem only works on Ruby 3.2 and above because it depends on the https://github.com/ruby/ruby/pull/5500[GVL Instrumentation API]. Furthermore, the GVL Instrumentation API does not (as of Ruby 3.2 and 3.3) currently work on Microsoft Windows.
 
 == Quickest start
 
@@ -76,7 +76,9 @@ This way you can actually link from your dashboards and similar pages directly t
 
 == Development
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to https://rubygems.org[rubygems.org].
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to https://rubygems.org[rubygems.org]. To run specs, run `bundle exec rake spec`.
+
+To run all actions (build the extension, check linting, and run specs), run `bundle exec rake`.
 
 == Contributing
 

data/Rakefile

@@ -28,7 +28,9 @@
 require "bundler/gem_tasks"
 require "standard/rake"
 require "rake/extensiontask"
+require "rspec/core/rake_task"
 
 Rake::ExtensionTask.new("gvl_tracing_native_extension")
+RSpec::Core::RakeTask.new(:spec)
 
-task default: [:compile, :"standard:fix"]
+task default: [:compile, :"standard:fix", :spec]

data/ext/gvl_tracing_native_extension/extconf.rb

@@ -30,18 +30,27 @@ if ["jruby", "truffleruby"].include?(RUBY_ENGINE)
     "Perhaps a #{RUBY_ENGINE} equivalent could be created -- help is welcome! :)\n#{"-" * 80}"
 end
 
+if Gem.win_platform?
+  raise \
+    "\n#{"-" * 80}\nSorry! This gem is currently unsupported on Microsoft Windows. That's because Ruby's GVL " \
+    "instrumentation API, which it relies on, also doesn't work on Windows.\n" \
+    "Hint: This gem does work on WSL."
+end
+
 require "mkmf"
 
 have_func("gettid", "unistd.h")
 have_header("pthread.h")
 have_func("pthread_getname_np", "pthread.h")
 have_func("pthread_threadid_np", "pthread.h")
+have_func("rb_internal_thread_specific_get", "ruby/thread.h") # 3.3+
+
 append_cflags("-Werror-implicit-function-declaration")
 append_cflags("-Wunused-parameter")
 append_cflags("-Wold-style-definition")
 append_cflags("-Wall")
 append_cflags("-Wextra")
-append_cflags("-Werror") if ENV['ENABLE_WERROR'] == 'true'
+append_cflags("-Werror") if ENV["ENABLE_WERROR"] == "true"
 
 create_header
 create_makefile "gvl_tracing_native_extension"

data/ext/gvl_tracing_native_extension/gvl_tracing.c

@@ -31,6 +31,7 @@
 #include <inttypes.h>
 #include <stdbool.h>
 #include <sys/types.h>
+#include <threads.h>
 
 #include "extconf.h"
 
@@ -49,18 +50,22 @@
   #define UNUSED_ARG
 #endif
 
-static VALUE tracing_start(VALUE _self, VALUE output_path);
-static VALUE tracing_stop(VALUE _self);
-static double timestamp_microseconds(void);
-static void set_native_thread_id(void);
-static void render_event(const char *event_name);
-static void on_thread_event(rb_event_flag_t event, const rb_internal_thread_event_data_t *_unused1, void *_unused2);
-static void on_gc_event(VALUE tpval, void *_unused1);
+#ifdef HAVE_RB_INTERNAL_THREAD_SPECIFIC_GET
+  #define RUBY_3_3_PLUS
+#else
+  #define RUBY_3_2
+#endif
 
-// Thread-local state
-static _Thread_local bool current_thread_seen = false;
-static _Thread_local unsigned int current_thread_serial = 0;
-static _Thread_local uint64_t thread_id = 0;
+typedef struct {
+  bool initialized;
+  int32_t current_thread_serial;
+  #ifdef RUBY_3_2
+    int32_t native_thread_id;
+  #endif
+  VALUE thread;
+  rb_event_flag_t previous_state; // Used to coalesce similar events
+  bool sleeping; // Used to track when a thread is sleeping
+} thread_local_state;
 
 // Global mutable state
 static rb_atomic_t thread_serial = 0;
@@ -69,46 +74,119 @@ static rb_internal_thread_event_hook_t *current_hook = NULL;
 static double started_tracing_at_microseconds = 0;
 static int64_t process_id = 0;
 static VALUE gc_tracepoint = Qnil;
+#pragma GCC diagnostic ignored "-Wunused-variable"
+static int thread_storage_key = 0;
+static VALUE all_seen_threads = Qnil;
+static mtx_t all_seen_threads_mutex;
+
+static VALUE tracing_init_local_storage(VALUE, VALUE);
+static VALUE tracing_start(VALUE _self, VALUE output_path);
+static VALUE tracing_stop(VALUE _self);
+static double timestamp_microseconds(void);
+static void render_event(thread_local_state *, const char *event_name);
+static void on_thread_event(rb_event_flag_t event, const rb_internal_thread_event_data_t *_unused1, void *_unused2);
+static void on_gc_event(VALUE tpval, void *_unused1);
+static VALUE mark_sleeping(VALUE _self);
+static size_t thread_local_state_memsize(UNUSED_ARG const void *_unused);
+static void thread_local_state_mark(void *data);
+static inline int32_t thread_id_for(thread_local_state *state);
+static VALUE ruby_thread_id_for(UNUSED_ARG VALUE _self, VALUE thread);
+static VALUE trim_all_seen_threads(UNUSED_ARG VALUE _self);
+
+#pragma GCC diagnostic ignored "-Wunused-const-variable"
+static const rb_data_type_t thread_local_state_type = {
+  .wrap_struct_name = "GvlTracing::__threadLocal",
+  .function = {
+    .dmark = thread_local_state_mark,
+    .dfree = RUBY_DEFAULT_FREE,
+    .dsize = thread_local_state_memsize,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+#ifdef RUBY_3_3_PLUS
+  static inline thread_local_state *GT_LOCAL_STATE(VALUE thread, bool allocate);
+  #define GT_EVENT_LOCAL_STATE(event_data, allocate) GT_LOCAL_STATE(event_data->thread, allocate)
+  // Must only be called from a thread holding the GVL
+  #define GT_CURRENT_THREAD_LOCAL_STATE() GT_LOCAL_STATE(rb_thread_current(), true)
+#else
+  // Thread-local state
+  static _Thread_local thread_local_state __thread_local_state = { 0 };
+
+  static inline thread_local_state *GT_CURRENT_THREAD_LOCAL_STATE(void);
+  #define GT_LOCAL_STATE(thread, allocate) GT_CURRENT_THREAD_LOCAL_STATE()
+  #define GT_EVENT_LOCAL_STATE(event_data, allocate) GT_CURRENT_THREAD_LOCAL_STATE()
+#endif
 
 void Init_gvl_tracing_native_extension(void) {
+  #ifdef RUBY_3_3_PLUS
+    thread_storage_key = rb_internal_thread_specific_key_create();
+  #endif
+
   rb_global_variable(&gc_tracepoint);
+  rb_global_variable(&all_seen_threads);
+
+  all_seen_threads = rb_ary_new();
+
+  if (mtx_init(&all_seen_threads_mutex, mtx_plain) != thrd_success) rb_raise(rb_eRuntimeError, "Failed to initialize GvlTracing mutex");
 
   VALUE gvl_tracing_module = rb_define_module("GvlTracing");
 
+  rb_define_singleton_method(gvl_tracing_module, "_init_local_storage", tracing_init_local_storage, 1);
   rb_define_singleton_method(gvl_tracing_module, "_start", tracing_start, 1);
   rb_define_singleton_method(gvl_tracing_module, "_stop", tracing_stop, 0);
+  rb_define_singleton_method(gvl_tracing_module, "mark_sleeping", mark_sleeping, 0);
+  rb_define_singleton_method(gvl_tracing_module, "_thread_id_for", ruby_thread_id_for, 1);
+  rb_define_singleton_method(gvl_tracing_module, "trim_all_seen_threads", trim_all_seen_threads, 0);
 }
 
-static inline void initialize_thread_id(void) {
-  current_thread_seen = true;
-  current_thread_serial = RUBY_ATOMIC_FETCH_ADD(thread_serial, 1);
-  set_native_thread_id();
-}
+static inline void initialize_thread_local_state(thread_local_state *state) {
+  state->initialized = true;
+  state->current_thread_serial = RUBY_ATOMIC_FETCH_ADD(thread_serial, 1);
 
-static inline void render_thread_metadata(void) {
-  char native_thread_name_buffer[64] = "(unnamed)";
+  #ifdef RUBY_3_2
+    uint32_t native_thread_id = 0;
 
-  #ifdef HAVE_PTHREAD_GETNAME_NP
-    pthread_getname_np(pthread_self(), native_thread_name_buffer, sizeof(native_thread_name_buffer));
+    #ifdef HAVE_PTHREAD_THREADID_NP
+      pthread_threadid_np(pthread_self(), &native_thread_id);
+    #elif HAVE_GETTID
+      native_thread_id = gettid();
+    #else
+      // Note: We could use the current_thread_serial as a crappy fallback, but this would make getting thread names
+      // not work very well
+      #error No native thread id available?
+    #endif
+
+    state->native_thread_id = native_thread_id;
   #endif
+}
 
-  fprintf(output_file,
-    "  {\"ph\": \"M\", \"pid\": %"PRId64", \"tid\": %"PRIu64", \"name\": \"thread_name\", \"args\": {\"name\": \"%s\"}},\n",
-    process_id, thread_id, native_thread_name_buffer);
+static VALUE tracing_init_local_storage(UNUSED_ARG VALUE _self, VALUE threads) {
+  #ifdef RUBY_3_3_PLUS
+    for (long i = 0, len = RARRAY_LEN(threads); i < len; i++) {
+        VALUE thread = RARRAY_AREF(threads, i);
+        GT_LOCAL_STATE(thread, true);
+    }
+  #endif
+  return Qtrue;
 }
 
 static VALUE tracing_start(UNUSED_ARG VALUE _self, VALUE output_path) {
   Check_Type(output_path, T_STRING);
 
+  trim_all_seen_threads(Qnil);
+
   if (output_file != NULL) rb_raise(rb_eRuntimeError, "Already started");
   output_file = fopen(StringValuePtr(output_path), "w");
   if (output_file == NULL) rb_syserr_fail(errno, "Failed to open GvlTracing output file");
 
+  fprintf(output_file, "[\n");
+
+  thread_local_state *state = GT_CURRENT_THREAD_LOCAL_STATE();
   started_tracing_at_microseconds = timestamp_microseconds();
   process_id = getpid();
 
-  fprintf(output_file, "[\n");
-  render_event("started_tracing");
+  render_event(state, "started_tracing");
 
   current_hook = rb_internal_thread_add_event_hook(
     on_thread_event,
@@ -122,15 +200,8 @@ static VALUE tracing_start(UNUSED_ARG VALUE _self, VALUE output_path) {
     NULL
   );
 
-  gc_tracepoint = rb_tracepoint_new(
-    0,
-    (
-      RUBY_INTERNAL_EVENT_GC_ENTER |
-      RUBY_INTERNAL_EVENT_GC_EXIT
-    ),
-    on_gc_event,
-    (void *) NULL
-  );
+  gc_tracepoint = rb_tracepoint_new(0, (RUBY_INTERNAL_EVENT_GC_ENTER | RUBY_INTERNAL_EVENT_GC_EXIT), on_gc_event, NULL);
+
   rb_tracepoint_enable(gc_tracepoint);
 
   return Qtrue;
@@ -139,18 +210,23 @@ static VALUE tracing_start(UNUSED_ARG VALUE _self, VALUE output_path) {
 static VALUE tracing_stop(UNUSED_ARG VALUE _self) {
   if (output_file == NULL) rb_raise(rb_eRuntimeError, "Tracing not running");
 
+  thread_local_state *state = GT_CURRENT_THREAD_LOCAL_STATE();
   rb_internal_thread_remove_event_hook(current_hook);
   rb_tracepoint_disable(gc_tracepoint);
   gc_tracepoint = Qnil;
 
-  render_event("stopped_tracing");
+  render_event(state, "stopped_tracing");
   // closing the json syntax in the output file is handled in GvlTracing.stop code
 
   if (fclose(output_file) != 0) rb_syserr_fail(errno, "Failed to close GvlTracing output file");
 
   output_file = NULL;
 
-  return Qtrue;
+  #ifdef RUBY_3_3_PLUS
+    return all_seen_threads;
+  #else
+    return rb_funcall(rb_cThread, rb_intern("list"), 0);
+  #endif
 }
 
 static double timestamp_microseconds(void) {
@@ -159,31 +235,12 @@ static double timestamp_microseconds(void) {
   return (current_monotonic.tv_nsec / 1000.0) + (current_monotonic.tv_sec * 1000.0 * 1000.0);
 }
 
-static void set_native_thread_id(void) {
-  uint64_t native_thread_id = 0;
-
-  #ifdef HAVE_PTHREAD_THREADID_NP
-    pthread_threadid_np(pthread_self(), &native_thread_id);
-  #elif HAVE_GETTID
-    native_thread_id = gettid();
-  #else
-    native_thread_id = current_thread_serial; // TODO: Better fallback for Windows?
-  #endif
-
-  thread_id = native_thread_id;
-}
-
 // Render output using trace event format for perfetto:
 // https://chromium.googlesource.com/catapult/+/refs/heads/main/docs/trace-event-format.md
-static void render_event(const char *event_name) {
+static void render_event(thread_local_state *state, const char *event_name) {
   // Event data
   double now_microseconds = timestamp_microseconds() - started_tracing_at_microseconds;
 
-  if (!current_thread_seen) {
-    initialize_thread_id();
-    render_thread_metadata();
-  }
-
   // Each event is converted into two events in the output: one that signals the end of the previous event
   // (whatever it was), and one that signals the start of the actual event we're processing.
   // Yes, this seems to be slightly bending the intention of the output format, but it seemed easier to do this way.
@@ -193,17 +250,41 @@ static void render_event(const char *event_name) {
 
   fprintf(output_file,
     // Finish previous duration
-    "  {\"ph\": \"E\", \"pid\": %"PRId64", \"tid\": %"PRIu64", \"ts\": %f},\n" \
+    "  {\"ph\": \"E\", \"pid\": %"PRId64", \"tid\": %d, \"ts\": %f},\n" \
     // Current event
-    "  {\"ph\": \"B\", \"pid\": %"PRId64", \"tid\": %"PRIu64", \"ts\": %f, \"name\": \"%s\"},\n",
+    "  {\"ph\": \"B\", \"pid\": %"PRId64", \"tid\": %d, \"ts\": %f, \"name\": \"%s\"},\n",
     // Args for first line
-    process_id, thread_id, now_microseconds,
+    process_id, thread_id_for(state), now_microseconds,
     // Args for second line
-    process_id, thread_id, now_microseconds, event_name
+    process_id, thread_id_for(state), now_microseconds, event_name
   );
 }
 
-static void on_thread_event(rb_event_flag_t event_id, UNUSED_ARG const rb_internal_thread_event_data_t *_unused1, UNUSED_ARG void *_unused2) {
+static void on_thread_event(rb_event_flag_t event_id, const rb_internal_thread_event_data_t *event_data, UNUSED_ARG void *_unused2) {
+  thread_local_state *state = GT_EVENT_LOCAL_STATE(event_data,
+    // These events are guaranteed to hold the GVL, so they can allocate
+    event_id & (RUBY_INTERNAL_THREAD_EVENT_STARTED | RUBY_INTERNAL_THREAD_EVENT_RESUMED));
+  if (!state) return;
+  #ifdef RUBY_3_3_PLUS
+    if (!state->thread) state->thread = event_data->thread;
+  #endif
+  // In some cases, Ruby seems to emit multiple suspended events for the same thread in a row (e.g. when multiple threads)
+  // are waiting on a Thread::ConditionVariable.new that gets signaled. We coalesce these events to make the resulting
+  // timeline easier to see.
+  //
+  // I haven't observed other situations where we'd want to coalesce events, but we may apply this to all events in the
+  // future. One annoying thing to remember when generalizing this is how to reset the `previous_state` across multiple
+  // start/stop calls to GvlTracing.
+  if (event_id == RUBY_INTERNAL_THREAD_EVENT_SUSPENDED && event_id == state->previous_state) return;
+  state->previous_state = event_id;
+
+  if (event_id == RUBY_INTERNAL_THREAD_EVENT_SUSPENDED && state->sleeping) {
+    render_event(state, "sleeping");
+    return;
+  } else {
+    state->sleeping = false;
+  }
+
   const char* event_name = "bug_unknown_event";
   switch (event_id) {
     case RUBY_INTERNAL_THREAD_EVENT_READY:     event_name = "wants_gvl"; break;
@@ -212,15 +293,106 @@ static void on_thread_event(rb_event_flag_t event_id, UNUSED_ARG const rb_intern
     case RUBY_INTERNAL_THREAD_EVENT_STARTED:   event_name = "started";   break;
     case RUBY_INTERNAL_THREAD_EVENT_EXITED:    event_name = "died";      break;
   };
-  render_event(event_name);
+  render_event(state, event_name);
 }
 
 static void on_gc_event(VALUE tpval, UNUSED_ARG void *_unused1) {
   const char* event_name = "bug_unknown_event";
+  thread_local_state *state = GT_LOCAL_STATE(rb_thread_current(), false); // no alloc during GC
   switch (rb_tracearg_event_flag(rb_tracearg_from_tracepoint(tpval))) {
     case RUBY_INTERNAL_EVENT_GC_ENTER: event_name = "gc"; break;
     // TODO: is it possible the thread wasn't running? Might need to save the last state.
     case RUBY_INTERNAL_EVENT_GC_EXIT: event_name = "running"; break;
   }
-  render_event(event_name);
+  render_event(state, event_name);
+}
+
+static VALUE mark_sleeping(UNUSED_ARG VALUE _self) {
+  GT_CURRENT_THREAD_LOCAL_STATE()->sleeping = true;
+  return Qnil;
+}
+
+static size_t thread_local_state_memsize(UNUSED_ARG const void *_unused) { return sizeof(thread_local_state); }
+
+static void thread_local_state_mark(void *data) {
+  thread_local_state *state = (thread_local_state *)data;
+  rb_gc_mark(state->thread); // Marking thread to make sure it stays pinned
+}
+
+#ifdef RUBY_3_3_PLUS
+  static inline thread_local_state *GT_LOCAL_STATE(VALUE thread, bool allocate) {
+    thread_local_state *state = rb_internal_thread_specific_get(thread, thread_storage_key);
+    if (!state && allocate) {
+      VALUE wrapper = TypedData_Make_Struct(rb_cObject, thread_local_state, &thread_local_state_type, state);
+      state->thread = thread;
+      rb_thread_local_aset(thread, rb_intern("__gvl_tracing_local_state"), wrapper);
+      rb_internal_thread_specific_set(thread, thread_storage_key, state);
+      RB_GC_GUARD(wrapper);
+      initialize_thread_local_state(state);
+
+      // Keep thread around, to be able to extract names at the end
+      // We grab a lock here since thread creation can happen in multiple Ractors, and we want to make sure only one
+      // of them is mutating the array at a time. @ivoanjo: I think this is enough to make this safe....?
+      if (mtx_lock(&all_seen_threads_mutex) != thrd_success) rb_raise(rb_eRuntimeError, "Failed to lock GvlTracing mutex");
+      rb_ary_push(all_seen_threads, thread);
+      if (mtx_unlock(&all_seen_threads_mutex) != thrd_success) rb_raise(rb_eRuntimeError, "Failed to unlock GvlTracing mutex");
+    }
+    return state;
+  }
+#endif
+
+#ifdef RUBY_3_2
+  static inline thread_local_state *GT_CURRENT_THREAD_LOCAL_STATE(void) {
+    thread_local_state *state = &__thread_local_state;
+    if (!state->initialized) {
+      initialize_thread_local_state(state);
+    }
+    return state;
+  }
+#endif
+
+static inline int32_t thread_id_for(thread_local_state *state) {
+  // We use different strategies for 3.2 vs 3.3+ to identify threads. This is because:
+  //
+  // 1. On 3.2 we have no way of associating the actual thread VALUE object with the state/serial, so instead we identify
+  //    threads by their native ids. This is not entirely correct, since Ruby can reuse native threads (e.g. if a thread
+  //    dies and another immediately gets created) but it's good enough for our purposes. (Associating the thread VALUE
+  //    object is useful to, e.g. get thread names later.)
+  //
+  // 2. On 3.3 we can associate the state/serial with the thread VALUE object AND additionally with the MN scheduler
+  //    the same thread VALUE can end up executing on different native threads so using the native thread id as an
+  //    identifier would be wrong.
+  #ifdef RUBY_3_3_PLUS
+    return state->current_thread_serial;
+  #else
+    return state->native_thread_id;
+  #endif
+}
+
+static VALUE ruby_thread_id_for(UNUSED_ARG VALUE _self, VALUE thread) {
+  #ifdef RUBY_3_2
+    rb_raise(rb_eRuntimeError, "On Ruby 3.2 we should use the native thread id directly");
+  #endif
+
+  thread_local_state *state = GT_LOCAL_STATE(thread, true);
+  return INT2FIX(thread_id_for(state));
+}
+
+// Can only be called while GvlTracing is not active + while holding the GVL
+static VALUE trim_all_seen_threads(UNUSED_ARG VALUE _self) {
+  if (mtx_lock(&all_seen_threads_mutex) != thrd_success) rb_raise(rb_eRuntimeError, "Failed to lock GvlTracing mutex");
+
+  VALUE alive_threads = rb_ary_new();
+
+  for (long i = 0, len = RARRAY_LEN(all_seen_threads); i < len; i++) {
+    VALUE thread = RARRAY_AREF(all_seen_threads, i);
+    if (rb_funcall(thread, rb_intern("alive?"), 0) == Qtrue) {
+      rb_ary_push(alive_threads, thread);
+    }
+  }
+
+  rb_ary_replace(all_seen_threads, alive_threads);
+
+  if (mtx_unlock(&all_seen_threads_mutex) != thrd_success) rb_raise(rb_eRuntimeError, "Failed to unlock GvlTracing mutex");
+  return Qtrue;
 }

data/gems.rb

@@ -7,5 +7,8 @@ gemspec
 gem "rake", "~> 13.0"
 gem "rake-compiler", "~> 1.2"
 gem "pry"
-gem "standard", "~> 1.12"
+gem "pry-byebug"
+gem "rspec"
+gem "standard", "~> 1.33"
 gem "concurrent-ruby"
+gem "benchmark-ips", "~> 2.13"

data/lib/gvl-tracing.rb

@@ -36,6 +36,7 @@ module GvlTracing
 
     def start(file)
       _start(file)
+      _init_local_storage(Thread.list)
       @path = file
 
       return unless block_given?
@@ -43,24 +44,24 @@ module GvlTracing
       begin
         yield
       ensure
-        _stop
+        stop
       end
     end
 
     def stop
-      thread_list = Thread.list
-
-      _stop
+      thread_list = _stop
 
       append_thread_names(thread_list)
+
+      trim_all_seen_threads
     end
 
     private
 
     def append_thread_names(list)
-      threads_name = aggreate_thread_list(list).join(",\n")
-      File.open(@path, 'a') do |f|
-        f.puts(threads_name)
+      thread_names = aggreate_thread_list(list).join(",\n")
+      File.open(@path, "a") do |f|
+        f.puts(thread_names)
         f.puts("]")
       end
     end
@@ -69,14 +70,14 @@ module GvlTracing
       list.each_with_object([]) do |t, acc|
         next unless t.name || t == Thread.main
 
-        acc << "  {\"ph\": \"M\", \"pid\": #{Process.pid}, \"tid\": #{t.native_thread_id}, \"name\": \"thread_name\", \"args\": {\"name\": \"#{thread_label(t)}\"}}"
+        acc << "  {\"ph\": \"M\", \"pid\": #{Process.pid}, \"tid\": #{thread_id_for(t)}, \"name\": \"thread_name\", \"args\": {\"name\": \"#{thread_label(t)}\"}}"
       end
     end
 
     REGEX = /lib(?!.*lib)\/([a-zA-Z-]+)/
     def thread_label(thread)
       if thread == Thread.main
-        return thread.name ? thread.name : "Main Thread"
+        return thread.name || "Main Thread"
       end
 
       lib_name = thread.to_s.match(REGEX)
@@ -85,5 +86,12 @@ module GvlTracing
 
       "#{thread.name} from #{lib_name[1]}"
     end
+
+    def thread_id_for(t)
+      RUBY_VERSION.start_with?("3.2.") ? t.native_thread_id : _thread_id_for(t)
+    end
   end
 end
+
+# Eagerly initialize context for main thread
+GvlTracing.send(:thread_id_for, Thread.main)

data/lib/gvl_tracing/sleep_tracking.rb

@@ -0,0 +1,12 @@
+# Experimental: This monkey patch when loaded introduces a new state -- "sleeping" -- which is more specific than the
+# regular "waiting". This can be useful to distinguish when waiting is happening based on time, vs for some event to
+# happen.
+
+module GvlTracing::SleepTracking
+  def sleep(...)
+    GvlTracing.mark_sleeping
+    super(...)
+  end
+end
+
+include GvlTracing::SleepTracking

data/lib/gvl_tracing/version.rb

@@ -26,5 +26,5 @@
 # frozen_string_literal: true
 
 module GvlTracing
-  VERSION = "1.3.0"
+  VERSION = "1.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gvl-tracing
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Ivo Anjo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-01 00:00:00.000000000 Z
+date: 2024-03-29 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -30,6 +30,7 @@ files:
 - gems.rb
 - gvl-tracing.gemspec
 - lib/gvl-tracing.rb
+- lib/gvl_tracing/sleep_tracking.rb
 - lib/gvl_tracing/version.rb
 - preview.png
 homepage: https://github.com/ivoanjo/gvl-tracing
@@ -52,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.3
 signing_key: 
 specification_version: 4
 summary: Get a timeline view of Global VM Lock usage in your Ruby app