gvl-tracing 1.1.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a0dac3d832e96a125efe05ac98e4b1129fd0ece7bdbc73dc27c01d07c1f63f8
-  data.tar.gz: 91df78cab18be886527f64b273ed3f149ba75775f3bf9079270e6d59bb5b09b1
+  metadata.gz: a5ec59682543834d531647bea2601457de0d8f8d57fe039181375891ef29ae60
+  data.tar.gz: ebfa80876458868eb9780bdf655c75ff7c3b649f0661799533e6dcd12f5b06ea
 SHA512:
-  metadata.gz: 2b98df0961029daa7ca1680e3a474afde760070216918c2514c76b50af8d62f9da1dcab18201b175e4e996b5bdac72dcd549df3601049a11d7ad636db9741783
-  data.tar.gz: 967bfb4503e5553468598348829aa288eee2e4baac2c3b3f618a57c92cc51cb62ee5bdc5cc798238cf54bbc020d08cce85a5f1fb171e329dc5d6e1d32cc98c14
+  metadata.gz: 259ae5c91f2d750ed61ec938a3eb3f92fc813391393420648288626d824408f1678a534de2185c73a6ea8fc2a695aa46135f5529a8fa9bd32e00c0f878b5a538
+  data.tar.gz: ead5ce15933a39684675705a60983dbcd5fc8afb7752822103799261d05d5e3b3f6da8562ca496b9929f7bebf9ed203c31ccc5b778be59bf2c724f7bab9c4d49

data/README.adoc

@@ -25,17 +25,15 @@ def fib(n)
   fib(n - 1) + fib(n - 2)
 end
 
-GvlTracing.start("example1.json")
+GvlTracing.start("example1.json") do
+  Thread.new { sleep(0.05) while true }
 
-Thread.new { sleep(0.05) while true }
+  sleep(0.05)
 
-sleep(0.05)
+  3.times.map { Thread.new { fib(37) } }.map(&:join)
 
-3.times.map { Thread.new { fib(37) } }.map(&:join)
-
-sleep(0.05)
-
-GvlTracing.stop
+  sleep(0.05)
+end
 ----
 
 To do so:
@@ -65,7 +63,7 @@ Use `require "gvl-tracing"` to load the gem.
 
 This gem only provides a single module (`GvlTracing`) with methods:
 
-* `start(filename)`: Starts tracing, writing the results to the provided filename
+* `start(filename, &block)`: Starts tracing, writing the results to the provided filename. When a block is passed, yields the block and calls stop.
 * `stop`: Stops tracing
 
 The resulting traces can be analyzed by going to https://ui.perfetto.dev/[Perfetto UI].

data/ext/gvl_tracing_native_extension/extconf.rb

@@ -36,11 +36,12 @@ have_func("gettid", "unistd.h")
 have_header("pthread.h")
 have_func("pthread_getname_np", "pthread.h")
 have_func("pthread_threadid_np", "pthread.h")
-append_cflags('-Werror-implicit-function-declaration')
-append_cflags('-Wunused-parameter')
-append_cflags('-Wold-style-definition')
+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'
 
 create_header
 create_makefile "gvl_tracing_native_extension"

data/ext/gvl_tracing_native_extension/gvl_tracing.c

@@ -28,6 +28,7 @@
 #include <ruby/thread.h>
 #include <ruby/atomic.h>
 #include <errno.h>
+#include <inttypes.h>
 #include <stdbool.h>
 #include <sys/types.h>
 
@@ -41,23 +42,32 @@
   #include <unistd.h>
 #endif
 
+// Used to mark function arguments that are deliberately left unused
+#ifdef __GNUC__
+  #define UNUSED_ARG  __attribute__((unused))
+#else
+  #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);
 
 // Thread-local state
-static _Thread_local bool current_thread_serial_set = false;
+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;
 
 // Global mutable state
 static rb_atomic_t thread_serial = 0;
 static FILE *output_file = NULL;
 static rb_internal_thread_event_hook_t *current_hook = NULL;
 static double started_tracing_at_microseconds = 0;
-static pid_t process_id = 0;
+static int64_t process_id = 0;
 static VALUE gc_tracepoint = Qnil;
 
 void Init_gvl_tracing_native_extension(void) {
@@ -65,25 +75,17 @@ void Init_gvl_tracing_native_extension(void) {
 
   VALUE gvl_tracing_module = rb_define_module("GvlTracing");
 
-  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, "_start", tracing_start, 1);
+  rb_define_singleton_method(gvl_tracing_module, "_stop", tracing_stop, 0);
 }
 
 static inline void initialize_thread_id(void) {
-  current_thread_serial_set = true;
+  current_thread_seen = true;
   current_thread_serial = RUBY_ATOMIC_FETCH_ADD(thread_serial, 1);
+  set_native_thread_id();
 }
 
 static inline void render_thread_metadata(void) {
-  uint64_t native_thread_id = 0;
-  #ifdef HAVE_GETTID
-    native_thread_id = gettid();
-  #elif HAVE_PTHREAD_THREADID_NP
-    pthread_threadid_np(pthread_self(), &native_thread_id);
-  #else
-    native_thread_id = current_thread_serial; // TODO: Better fallback for Windows?
-  #endif
-
   char native_thread_name_buffer[64] = "(unnamed)";
 
   #ifdef HAVE_PTHREAD_GETNAME_NP
@@ -91,12 +93,11 @@ static inline void render_thread_metadata(void) {
   #endif
 
   fprintf(output_file,
-    "  {\"ph\": \"M\", \"pid\": %u, \"tid\": %u, \"name\": \"thread_name\", \"args\": {\"name\": \"%lu %s\"}},\n",
-    process_id, current_thread_serial, native_thread_id, native_thread_name_buffer
-  );
+    "  {\"ph\": \"M\", \"pid\": %"PRId64", \"tid\": %"PRIu64", \"name\": \"thread_name\", \"args\": {\"name\": \"%s\"}},\n",
+    process_id, thread_id, native_thread_name_buffer);
 }
 
-static VALUE tracing_start(VALUE _self, VALUE output_path) {
+static VALUE tracing_start(UNUSED_ARG VALUE _self, VALUE output_path) {
   Check_Type(output_path, T_STRING);
 
   if (output_file != NULL) rb_raise(rb_eRuntimeError, "Already started");
@@ -135,7 +136,7 @@ static VALUE tracing_start(VALUE _self, VALUE output_path) {
   return Qtrue;
 }
 
-static VALUE tracing_stop(VALUE _self) {
+static VALUE tracing_stop(UNUSED_ARG VALUE _self) {
   if (output_file == NULL) rb_raise(rb_eRuntimeError, "Tracing not running");
 
   rb_internal_thread_remove_event_hook(current_hook);
@@ -143,7 +144,7 @@ static VALUE tracing_stop(VALUE _self) {
   gc_tracepoint = Qnil;
 
   render_event("stopped_tracing");
-  fprintf(output_file, "]\n");
+  // 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");
 
@@ -158,19 +159,31 @@ 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) {
   // Event data
   double now_microseconds = timestamp_microseconds() - started_tracing_at_microseconds;
 
-  if (!current_thread_serial_set) {
+  if (!current_thread_seen) {
     initialize_thread_id();
     render_thread_metadata();
   }
 
-  unsigned int thread_id = current_thread_serial;
-
   // 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.
@@ -180,9 +193,9 @@ static void render_event(const char *event_name) {
 
   fprintf(output_file,
     // Finish previous duration
-    "  {\"ph\": \"E\", \"pid\": %u, \"tid\": %u, \"ts\": %f},\n" \
+    "  {\"ph\": \"E\", \"pid\": %"PRId64", \"tid\": %"PRIu64", \"ts\": %f},\n" \
     // Current event
-    "  {\"ph\": \"B\", \"pid\": %u, \"tid\": %u, \"ts\": %f, \"name\": \"%s\"},\n",
+    "  {\"ph\": \"B\", \"pid\": %"PRId64", \"tid\": %"PRIu64", \"ts\": %f, \"name\": \"%s\"},\n",
     // Args for first line
     process_id, thread_id, now_microseconds,
     // Args for second line
@@ -190,7 +203,7 @@ static void render_event(const char *event_name) {
   );
 }
 
-static void on_thread_event(rb_event_flag_t event_id, const rb_internal_thread_event_data_t *_unused1, void *_unused2) {
+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) {
   const char* event_name = "bug_unknown_event";
   switch (event_id) {
     case RUBY_INTERNAL_THREAD_EVENT_READY:     event_name = "wants_gvl"; break;
@@ -202,7 +215,7 @@ static void on_thread_event(rb_event_flag_t event_id, const rb_internal_thread_e
   render_event(event_name);
 }
 
-static void on_gc_event(VALUE tpval, void *_unused1) {
+static void on_gc_event(VALUE tpval, UNUSED_ARG void *_unused1) {
   const char* event_name = "bug_unknown_event";
   switch (rb_tracearg_event_flag(rb_tracearg_from_tracepoint(tpval))) {
     case RUBY_INTERNAL_EVENT_GC_ENTER: event_name = "gc"; break;

data/gems.rb

@@ -8,3 +8,4 @@ gem "rake", "~> 13.0"
 gem "rake-compiler", "~> 1.2"
 gem "pry"
 gem "standard", "~> 1.12"
+gem "concurrent-ruby"

data/lib/gvl-tracing.rb

@@ -30,4 +30,60 @@ require_relative "gvl_tracing/version"
 require "gvl_tracing_native_extension"
 
 module GvlTracing
+  class << self
+    private :_start
+    private :_stop
+
+    def start(file)
+      _start(file)
+      @path = file
+
+      return unless block_given?
+
+      begin
+        yield
+      ensure
+        _stop
+      end
+    end
+
+    def stop
+      thread_list = Thread.list
+
+      _stop
+
+      append_thread_names(thread_list)
+    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)
+        f.puts("]")
+      end
+    end
+
+    def aggreate_thread_list(list)
+      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)}\"}}"
+      end
+    end
+
+    REGEX = /lib(?!.*lib)\/([a-zA-Z-]+)/
+    def thread_label(thread)
+      if thread == Thread.main
+        return thread.name ? thread.name : "Main Thread"
+      end
+
+      lib_name = thread.to_s.match(REGEX)
+
+      return thread.name if lib_name.nil?
+
+      "#{thread.name} from #{lib_name[1]}"
+    end
+  end
 end

data/lib/gvl_tracing/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gvl-tracing
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Ivo Anjo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-15 00:00:00.000000000 Z
+date: 2023-07-01 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: