gvl-tracing 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1eedec6bc1503bdc8fabde77ac69167de69a9fe1cc8c211720ce7fa34d5fd66a
-  data.tar.gz: 6e504dfe9f06f97b3247e00cf5cbc0fa17ffec39136474dfc5e9ff9914a10351
+  metadata.gz: 643b4b237db640d34ecf842459246640517ca9d58118ca891c76a629f1c6ab73
+  data.tar.gz: 10c2613b6b66681b46f7d32a143e5742ed98b969d9aca00e3ceb6b22c5579f4b
 SHA512:
-  metadata.gz: 34fcfe11c2c1dca8307442e026420dea3a630b19c652164c9095143414226227e0198ae69b44f6e53ca3cf5325cd832e8a5450ce824ba7c5a99f37cb9e604300
-  data.tar.gz: 01dc10ae34c5398889d531313f3faceda12bbe37890193cfd64560cd99f352149e3afea3d6ebb553e0d3116aa202bb34b9c7d403cbc0c368e272ed7053e6daad
+  metadata.gz: f3265c1719bd2dd7859f4df78a4b9096277b45f26b9a6bd515c5a3222f3bdb98e56461eef274f5987a61cfb7ec331ac44dac58a94fd8dadf7474a51b9033f3d6
+  data.tar.gz: 40a336509af944962fc2c48ae2f40c2ae40ff133b53b7e006f63f1a453e4106d68f6283e008462088f39afd3c5653556ef064fb6bf312aeffc09cd282ba90ba9

data/ext/gvl_tracing_native_extension/extconf.rb

@@ -36,6 +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("-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,11 +144,11 @@ 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");
 
-  output_file == NULL;
+  output_file = NULL;
 
   return Qtrue;
 }
@@ -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,52 @@ 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
+    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.0"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gvl-tracing
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Ivo Anjo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-16 00:00:00.000000000 Z
+date: 2023-06-06 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -52,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.6
 signing_key: 
 specification_version: 4
 summary: Get a timeline view of Global VM Lock usage in your Ruby app