vernier 0.2.1 → 0.3.1

data/lib/vernier/autorun.rb

@@ -0,0 +1,65 @@
+require "tempfile"
+require "vernier"
+
+module Vernier
+  module Autorun
+    class << self
+      attr_accessor :collector
+      attr_reader :options
+    end
+    @collector = nil
+
+    @options = ENV.to_h.select { |k,v| k.start_with?("VERNIER_") }
+    @options.transform_keys! do |key|
+      key.sub(/\AVERNIER_/, "").downcase.to_sym
+    end
+    @options.freeze
+
+    def self.start
+      interval = options.fetch(:interval, 500).to_i
+
+      STDERR.puts("starting profiler with interval #{interval}")
+
+      @collector = Vernier::Collector.new(:wall, interval:)
+      @collector.start
+    end
+
+    def self.stop
+      result = @collector.stop
+      @collector = nil
+      output_path = options[:output]
+      output_path ||= Tempfile.create(["profile", ".vernier.json"]).path
+      File.write(output_path, Vernier::Output::Firefox.new(result).output)
+
+      STDERR.puts(result.inspect)
+      STDERR.puts("written to #{output_path}")
+    end
+
+    def self.running?
+      !!@collector
+    end
+
+    def self.at_exit
+      stop if running?
+    end
+
+    def self.toggle
+      running? ? stop : start
+    end
+  end
+end
+
+unless Vernier::Autorun.options[:start_paused]
+  Vernier::Autorun.start
+end
+
+if signal = Vernier::Autorun.options[:signal]
+  STDERR.puts "to toggle profiler: kill -#{signal} #{Process.pid}"
+  trap(signal) do
+    Vernier::Autorun.toggle
+  end
+end
+
+at_exit do
+  Vernier::Autorun.at_exit
+end

data/lib/vernier/collector.rb

@@ -6,44 +6,63 @@ module Vernier
   class Collector
     def initialize(mode)
       @mode = mode
+      @markers = []
     end
 
-    def stop
-      result = finish
-
-      markers = []
-      marker_list = self.markers
-      size = marker_list.size
-      marker_strings = Marker.name_table
+    ##
+    # Get the current time.
+    #
+    # This method returns the current time from Process.clock_gettime in
+    # integer nanoseconds.  It's the same time used by Vernier internals and
+    # can be used to generate timestamps for custom markers.
+    def current_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+    end
 
-      marker_list.each_with_index do |(tid, id, ts), i|
-        name = marker_strings[id]
-        finish = nil
-        phase = Marker::Phase::INSTANT
+    def add_marker(name:, start:, finish:, thread: Thread.current.native_thread_id, phase: Marker::Phase::INTERVAL, data: nil)
+      @markers << [thread,
+                   name,
+                   start,
+                   finish,
+                   phase,
+                   data]
+    end
 
-        if id == Marker::Type::GC_EXIT
-          # skip because these are incorporated in "GC enter"
-        else
-          if id == Marker::Type::GC_ENTER
-            j = i + 1
+    ##
+    # Record an interval with a category and name.  Yields to a block and
+    # records the amount of time spent in the block as an interval marker.
+    def record_interval(category, name = category)
+      start = current_time
+      yield
+      add_marker(
+        name: category,
+        start:,
+        finish: current_time,
+        phase: Marker::Phase::INTERVAL,
+        thread: Thread.current.native_thread_id,
+        data: { :type => 'UserTiming', :entryType => 'measure', :name => name }
+      )
+    end
 
-            name = "GC pause"
-            phase = Marker::Phase::INTERVAL
+    def stop
+      result = finish
 
-            while j < size
-              if marker_list[j][1] == Marker::Type::GC_EXIT
-                finish = marker_list[j][2]
-                break
-              end
+      end_time = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+      result.pid = Process.pid
+      result.end_time = end_time
 
-              j += 1
-            end
-          end
+      marker_strings = Marker.name_table
 
-          markers << [tid, name, ts, finish, phase]
-        end
+      markers = self.markers.map do |(tid, type, phase, ts, te, stack)|
+        name = marker_strings[type]
+        sym = Marker::MARKER_SYMBOLS[type]
+        data = { type: sym }
+        data[:cause] = { stack: stack } if stack
+        [tid, name, ts, te, phase, data]
       end
 
+      markers.concat @markers
+
       result.instance_variable_set(:@markers, markers)
 
       result

data/lib/vernier/marker.rb

@@ -4,27 +4,27 @@ require_relative "vernier" # Make sure constants are loaded
 
 module Vernier
   module Marker
-    # These are equal to the marker phase types from gecko-profile.js
-    module Phase # :nodoc:
-      INSTANT = 0
-      INTERVAL = 1
-      INTERVAL_START = 2
-      INTERVAL_END = 3
+    MARKER_SYMBOLS = []
+    Type.constants.each do |name|
+      MARKER_SYMBOLS[Type.const_get(name)] = name
     end
+    MARKER_SYMBOLS.freeze
 
     MARKER_STRINGS = []
 
-    MARKER_STRINGS[Type::GVL_THREAD_STARTED] = "thread started"
-    MARKER_STRINGS[Type::GVL_THREAD_READY] = "thread ready"
-    MARKER_STRINGS[Type::GVL_THREAD_RESUMED] = "thread resumed"
-    MARKER_STRINGS[Type::GVL_THREAD_SUSPENDED] = "thread suspended"
-    MARKER_STRINGS[Type::GVL_THREAD_EXITED] = "thread exited"
+    MARKER_STRINGS[Type::GVL_THREAD_STARTED] = "Thread started"
+    MARKER_STRINGS[Type::GVL_THREAD_EXITED] = "Thread exited"
 
     MARKER_STRINGS[Type::GC_START] = "GC start"
     MARKER_STRINGS[Type::GC_END_MARK] = "GC end marking"
     MARKER_STRINGS[Type::GC_END_SWEEP] = "GC end sweeping"
     MARKER_STRINGS[Type::GC_ENTER] = "GC enter"
     MARKER_STRINGS[Type::GC_EXIT] = "GC exit"
+    MARKER_STRINGS[Type::GC_PAUSE] = "GC pause"
+
+    MARKER_STRINGS[Type::THREAD_RUNNING] = "Thread Running"
+    MARKER_STRINGS[Type::THREAD_STALLED] = "Thread Stalled"
+    MARKER_STRINGS[Type::THREAD_SUSPENDED] = "Thread Suspended"
 
     MARKER_STRINGS.freeze
 

data/lib/vernier/output/firefox.rb

@@ -8,13 +8,15 @@ module Vernier
     # https://github.com/firefox-devtools/profiler/blob/main/src/types/profile.js
     class Firefox
       class Categorizer
-        attr_reader :categories, :gc_category, :jit_category
+        attr_reader :categories
         def initialize
           @categories = []
+          @categories_by_name = {}
 
           add_category(name: "Default", color: "grey")
           add_category(name: "Idle", color: "transparent")
-          @gc_category = add_category(name: "GC", color: "red")
+
+          add_category(name: "GC", color: "red")
           add_category(
             name: "stdlib",
             color: "red",
@@ -39,18 +41,21 @@ module Vernier
             name: "Application",
             color: "purple"
           )
-          @jit_category = add_category(
-            name: "JIT",
-            color: "blue"
-          )
+
+          add_category(name: "Thread", color: "grey")
         end
 
-        def add_category(**kw)
-          category = Category.new(@categories.length, **kw)
+        def add_category(name:, **kw)
+          category = Category.new(@categories.length, name: name, **kw)
           @categories << category
+          @categories_by_name[name] = category
           category
         end
 
+        def get_category(name)
+          @categories_by_name[name]
+        end
+
         def starts_with(*paths)
           %r{\A#{Regexp.union(paths)}}
         end
@@ -92,50 +97,30 @@ module Vernier
       attr_reader :profile
 
       def data
-        threads = Hash.new {|h,k| h[k] = {
-          timestamps: [],
-          weights: [],
-          samples: [],
-          categories: [],
-          markers: [],
-        }}
-
-        profile.samples.size.times do |i|
-          tid = profile.sample_threads[i]
-          thread = threads[tid]
-
-          thread[:timestamps] << profile.timestamps[i]
-          thread[:weights] << profile.weights[i]
-          thread[:samples] << profile.samples[i]
-          thread[:categories] << profile.sample_categories[i]
-        end
-
-        profile.markers.each do |marker|
-          threads[marker[0]][:markers] << marker
-        end
+        markers_by_thread = profile.markers.group_by { |marker| marker[0] }
 
         thread_data = profile.threads.map do |tid, thread_info|
-          data = threads[tid]
+          markers = markers_by_thread[tid] || []
           Thread.new(
             profile,
             @categorizer,
+            markers: markers,
             **thread_info,
-            **data
           ).data
         end
 
         {
           meta: {
             interval: 1, # FIXME: memory vs wall
-            startTime: profile.meta[:started_at] / 1_000_000.0,
-            endTime: (profile.timestamps&.max || 0) / 1_000_000.0,
+            startTime: profile.started_at / 1_000_000.0,
+            #endTime: (profile.timestamps&.max || 0) / 1_000_000.0,
             processType: 0,
             product: "Ruby/Vernier",
             stackwalk: 1,
             version: 28,
             preprocessedProfileVersion: 47,
             symbolicated: true,
-            markerSchema: [],
+            markerSchema: marker_schema,
             sampleUnits: {
               time: "ms",
               eventDelay: "ms",
@@ -154,17 +139,33 @@ module Vernier
         }
       end
 
+      def marker_schema
+        [
+          {
+            name: "GVL_THREAD_RESUMED",
+            display: [ "marker-chart", "marker-table" ],
+            data: [
+              {
+                label: "Description",
+                value: "The thread has acquired the GVL and is executing"
+              }
+            ]
+          }
+        ]
+      end
+
       class Thread
         attr_reader :profile
 
-        def initialize(profile, categorizer, name:, tid:, samples:, weights:, timestamps:, categories:, markers:, started_at:, stopped_at: nil)
+        def initialize(profile, categorizer, name:, tid:, samples:, weights:, timestamps: nil, sample_categories: nil, markers:, started_at:, stopped_at: nil)
           @profile = profile
           @categorizer = categorizer
           @tid = tid
           @name = name
 
+          timestamps ||= [0] * samples.size
           @samples, @weights, @timestamps = samples, weights, timestamps
-          @sample_categories = categories
+          @sample_categories = sample_categories || ([0] * samples.size)
           @markers = markers
 
           @started_at, @stopped_at = started_at, stopped_at
@@ -184,6 +185,25 @@ module Vernier
           @filenames = filenames.map do |filename|
             @strings[filename]
           end
+
+          lines = profile.frame_table.fetch(:line)
+
+          @frame_implementations = filenames.zip(lines).map do |filename, line|
+            # Must match strings in `src/profile-logic/profile-data.js`
+            # inside the firefox profiler. See `getFriendlyStackTypeName`
+            if filename == "<cfunc>"
+              @strings["native"]
+            else
+              # FIXME: We need to get upstream support for JIT frames
+              if line == -1
+                @strings["yjit"]
+              else
+                # nil means interpreter
+                nil
+              end
+            end
+          end
+
           @frame_categories = filenames.map do |filename|
             @categorizer.categorize(filename)
           end
@@ -192,7 +212,7 @@ module Vernier
         def data
           {
             name: @name,
-            isMainThread: @tid == ::Thread.main.native_thread_id,
+            isMainThread: (@tid == ::Thread.main.native_thread_id) || (profile.threads.size == 1),
             processStartupTime: 0, # FIXME
             processShutdownTime: nil, # FIXME
             registerTime: (@started_at - 0) / 1_000_000.0,
@@ -218,26 +238,34 @@ module Vernier
         end
 
         def markers_table
-          size = @markers.size
-
           string_indexes = []
           start_times = []
           end_times = []
           phases = []
           categories = []
+          data = []
 
-          @markers.each_with_index do |(_, name, start, finish, phase), i|
+          @markers.each_with_index do |(_, name, start, finish, phase, datum), i|
             string_indexes << @strings[name]
             start_times << (start / 1_000_000.0)
 
             # Please don't hate me. Divide by 1,000,000 only if finish is not nil
             end_times << (finish&./(1_000_000.0))
             phases << phase
-            categories << (name =~ /GC/ ? gc_category.idx : 0)
+
+            category = case name
+            when /\AGC/ then gc_category.idx
+            when /\AThread/ then thread_category.idx
+            else
+              0
+            end
+
+            categories << category
+            data << datum
           end
 
           {
-            data: [nil] * start_times.size,
+            data: data,
             name: string_indexes,
             startTime: start_times,
             endTime: end_times,
@@ -263,7 +291,6 @@ module Vernier
             times = (0...size).to_a
           end
 
-          raise unless samples.size == size
           raise unless weights.size == size
           raise unless times.size == size
 
@@ -325,7 +352,7 @@ module Vernier
             func: funcs,
             nativeSymbol: none,
             innerWindowID: none,
-            implementation: none,
+            implementation: @frame_implementations,
             line: lines,
             column: none,
             length: size
@@ -357,7 +384,11 @@ module Vernier
         private
 
         def gc_category
-          @categorizer.gc_category
+          @categorizer.get_category("GC")
+        end
+
+        def thread_category
+          @categorizer.get_category("Thread")
         end
       end
     end

data/lib/vernier/result.rb

@@ -0,0 +1,139 @@
+module Vernier
+  class Result
+    attr_reader :stack_table, :frame_table, :func_table
+    attr_reader :markers
+
+    attr_accessor :pid, :end_time
+    attr_accessor :threads
+    attr_accessor :meta
+
+    # TODO: remove these
+    def weights; threads.values.flat_map { _1[:weights] }; end
+    def samples; threads.values.flat_map { _1[:samples] }; end
+    def sample_categories; threads.values.flat_map { _1[:sample_categories] }; end
+
+    # Realtime in nanoseconds since the unix epoch
+    def started_at
+      started_at_mono_ns = meta[:started_at]
+      current_time_mono_ns = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+      current_time_real_ns = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+      (current_time_real_ns - current_time_mono_ns + started_at_mono_ns)
+    end
+
+    def to_gecko
+      Output::Firefox.new(self).output
+    end
+
+    def write(out:)
+      File.write(out, to_gecko)
+    end
+
+    def elapsed_seconds
+      (end_time - started_at) / 1_000_000_000.0
+    end
+
+    def inspect
+      "#<#{self.class} #{elapsed_seconds} seconds, #{threads.count} threads, #{weights.sum} samples, #{samples.uniq.size} unique>"
+    end
+
+    def each_sample
+      return enum_for(__method__) unless block_given?
+      samples.size.times do |sample_idx|
+        weight = weights[sample_idx]
+        stack_idx = samples[sample_idx]
+        yield stack(stack_idx), weight
+      end
+    end
+
+    class BaseType
+      attr_reader :result, :idx
+      def initialize(result, idx)
+        @result = result
+        @idx = idx
+      end
+
+      def to_s
+        idx.to_s
+      end
+
+      def inspect
+        "#<#{self.class}\n#{to_s}>"
+      end
+    end
+
+    class Func < BaseType
+      def label
+        result.func_table[:name][idx]
+      end
+      alias name label
+
+      def filename
+        result.func_table[:filename][idx]
+      end
+
+      def to_s
+        "#{name} at #{filename}"
+      end
+    end
+
+    class Frame < BaseType
+      def label; func.label; end
+      def filename; func.filename; end
+      alias name label
+
+      def func
+        func_idx = result.frame_table[:func][idx]
+        Func.new(result, func_idx)
+      end
+
+      def line
+        result.frame_table[:line][idx]
+      end
+
+      def to_s
+        "#{func}:#{line}"
+      end
+    end
+
+    class Stack < BaseType
+      def each_frame
+        return enum_for(__method__) unless block_given?
+
+        stack_idx = idx
+        while stack_idx
+          frame_idx = result.stack_table[:frame][stack_idx]
+          yield Frame.new(result, frame_idx)
+          stack_idx = result.stack_table[:parent][stack_idx]
+        end
+      end
+
+      def leaf_frame_idx
+        result.stack_table[:frame][idx]
+      end
+
+      def leaf_frame
+        Frame.new(result, leaf_frame_idx)
+      end
+
+      def frames
+        each_frame.to_a
+      end
+
+      def to_s
+        arr = []
+        each_frame do |frame|
+          arr << frame.to_s
+        end
+        arr.join("\n")
+      end
+    end
+
+    def stack(idx)
+      Stack.new(self, idx)
+    end
+
+    def total_bytes
+      weights.sum
+    end
+  end
+end

data/lib/vernier/version.rb

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