ruby_memprofiler_pprof 0.0.3 → 0.0.4

data/lib/ruby_memprofiler_pprof/atfork.rb

@@ -21,6 +21,7 @@ module MemprofilerPprof
     end
 
     module_function
+
     def at_fork_handlers
       @@at_fork_handlers ||= []
     end
@@ -56,7 +57,6 @@ module MemprofilerPprof
       # Trigger correct callbacks depending on whether we're in the parent or child.
       # If we're in the fork, result = nil: trigger child callbacks.
       # If we're in the parent, result = fork PID: trigger parent callbacks.
-      # rubocop:disable Style/IfInsideElse
       if result.nil?
         # Trigger :child callback
         at_fork_handlers.select { |h| h.stage == :child }.each(&:call)

data/lib/ruby_memprofiler_pprof/block_flusher.rb

@@ -4,22 +4,39 @@ module MemprofilerPprof
   class BlockFlusher
     attr_reader :collector
 
-    def initialize(collector, interval: 30, logger: nil, on_flush: nil)
+    def initialize(
+      collector, interval: 30, logger: nil, on_flush: nil, priority: nil,
+      yield_gvl: false, proactively_yield_gvl: false
+    )
       @collector = collector
       @interval = interval
       @logger = logger
       @thread = nil
       @on_flush = on_flush
+      @status_mutex = Mutex.new
+      @status_cvar = ConditionVariable.new
+      @status = :not_started
+      @priority = priority
+      @yield_gvl = yield_gvl
+      @proactively_yield_gvl = proactively_yield_gvl
     end
 
     def start!
       stop!
+      @status = :running
+      @is_paused = false
       @thread = Thread.new { flusher_thread }
+      if !@priority.nil?
+        @thread.priority = @priority
+      end
       @atfork_handler = MemprofilerPprof::Atfork.at_fork(:child, &method(:at_fork_in_child))
     end
 
     def stop!
-      @thread&.kill
+      @status_mutex.synchronize do
+        @status = :stop
+        @status_cvar.broadcast
+      end
       @thread&.join
       @thread = nil
       @atfork_handler&.remove!
@@ -35,15 +52,42 @@ module MemprofilerPprof
       end
     end
 
+    def pause
+      @status_mutex.synchronize do
+        @is_paused = true
+        @status_cvar.broadcast
+      end
+    end
+
+    def unpause
+      @status_mutex.synchronize do
+        @is_paused = false
+        @status_cvar.broadcast
+      end
+    end
+
     private
 
     def flusher_thread
       prev_flush_duration = 0
       loop do
-        sleep([0, @interval - prev_flush_duration].max)
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        wait_until = now + [0, @interval - prev_flush_duration].max
+
+        @status_mutex.synchronize do
+          loop do
+            return if @status != :running
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            break if now >= wait_until && !@is_paused
+            @status_cvar.wait(@status_mutex, wait_until - now)
+          end
+        end
+
         t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         begin
-          profile_data = @collector.flush
+          profile_data = @collector.flush(
+            yield_gvl: @yield_gvl, proactively_yield_gvl: @proactively_yield_gvl
+          )
           @on_flush&.call(profile_data)
         rescue => e
           @logger&.error("BaseFlusher: failed to flush profiling data: #{e.inspect}")

data/lib/ruby_memprofiler_pprof/file_flusher.rb

@@ -1,17 +1,24 @@
 # frozen_string_literal: true
 
-require 'fileutils'
-require 'forwardable'
+require "fileutils"
+require "forwardable"
 
 module MemprofilerPprof
   class FileFlusher
     extend Forwardable
 
-    def initialize(collector, pattern: 'tmp/profiles/mem-%{pid}-%{isotime}.pprof', interval: 30, logger: nil)
+    def initialize(
+      collector, pattern: "tmp/profiles/mem-%{pid}-%{isotime}.pprof", interval: 30, logger: nil, priority: nil,
+      yield_gvl: false, proactively_yield_gvl: false
+    )
       @logger = logger
       @pattern = pattern
       @profile_counter = 0
-      @block_flusher = BlockFlusher.new(collector, interval: interval, logger: logger, on_flush: method(:on_flush))
+      @block_flusher = BlockFlusher.new(
+        collector, interval: interval, logger: logger, priority: priority,
+        yield_gvl: yield_gvl, proactively_yield_gvl: proactively_yield_gvl,
+        on_flush: method(:on_flush)
+      )
     end
 
     def_delegators :@block_flusher, :start!, :stop!, :run
@@ -26,7 +33,7 @@ module MemprofilerPprof
       # Need to explicitly specify the encoding, because some applications might do exotic
       # things to File#default_external/#default_internal that would attempt to convert
       # our protobuf to UTF-8.
-      File.write(template_string(@pattern), profile_data.pprof_data, encoding: 'ASCII-8BIT')
+      File.write(template_string(@pattern), profile_data.pprof_data, encoding: "ASCII-8BIT")
       @profile_counter += 1
     rescue => e
       @logger&.error("FileFlusher: failed to flush profiling data: #{e.inspect}")
@@ -37,7 +44,7 @@ module MemprofilerPprof
         pid: Process.pid,
         isotime: Time.now.iso8601,
         unixtime: Time.now.to_i,
-        index: @profile_counter,
+        index: @profile_counter
       }
       sprintf(tmpl, vars)
     end

data/lib/ruby_memprofiler_pprof/profile_app.rb

@@ -5,24 +5,20 @@
 # process _before_ any of the app code is run. Our job here is to set up
 # heap profiling in some default way.
 
-require 'logger'
-require 'ruby_memprofiler_pprof'
+require "logger"
+require "ruby_memprofiler_pprof"
 
 collector = MemprofilerPprof::Collector.new
-collector.sample_rate = ENV.fetch('RUBY_MEMPROFILER_PPROF_SAMPLE_RATE', '1').to_f
-collector.allocation_retain_rate = ENV.fetch('RUBY_MEMPROFILER_PPROF_ALLOC_RETAIN_RATE', '1').to_f
-if ENV.key?('RUBY_MEMPROFILER_PPROF_MAX_ALLOC_SAMPLES')
-  collector.max_allocation_samples = ENV['RUBY_MEMPROFILER_PPROF_MAX_ALLOC_SAMPLES'].to_i
-end
-if ENV.key?('RUBY_MEMPROFILER_PPROF_MAX_HEAP_SAMPLES')
-  collector.max_heap_samples = ENV['RUBY_MEMPROFILER_PPROF_MAX_HEAP_SAMPLES'].to_i
+collector.sample_rate = ENV.fetch("RUBY_MEMPROFILER_PPROF_SAMPLE_RATE", "1").to_f
+if ENV.key?("RUBY_MEMPROFILER_PPROF_MAX_HEAP_SAMPLES")
+  collector.max_heap_samples = ENV["RUBY_MEMPROFILER_PPROF_MAX_HEAP_SAMPLES"].to_i
 end
 
 kwargs = {
-  logger: Logger.new(STDERR)
+  logger: Logger.new($stderr)
 }
-if ENV.key?('RUBY_MEMPROFILER_PPROF_FILE_PATTERN')
-  kwargs[:pattern] = ENV['RUBY_MEMPROFILER_PPROF_FILE_PATTERN']
+if ENV.key?("RUBY_MEMPROFILER_PPROF_FILE_PATTERN")
+  kwargs[:pattern] = ENV["RUBY_MEMPROFILER_PPROF_FILE_PATTERN"]
 end
 
 flusher = MemprofilerPprof::FileFlusher.new(collector, **kwargs)

data/lib/ruby_memprofiler_pprof/profile_data.rb

@@ -2,16 +2,15 @@
 
 module MemprofilerPprof
   class ProfileData
-    attr_accessor :pprof_data, :allocation_samples_count, :heap_samples_count,
-      :dropped_samples_nolock, :dropped_samples_allocation_bufsize, :dropped_samples_heap_bufsize
+    attr_accessor :pprof_data, :heap_samples_count, :dropped_samples_heap_bufsize,
+      :flush_duration_nsecs, :pprof_serialization_nsecs, :sample_add_nsecs,
+      :sample_add_without_gvl_nsecs,
+      :gvl_proactive_yield_count, :gvl_proactive_check_yield_count,
 
     def to_s
-      "<MemprofilerPprof::ProfileData:#{object_id.to_s(16)} (sample counts: " +
-        "allocation=#{allocation_samples_count}, " +
-        "heap=#{heap_samples_count}, " +
-        "dropped_nolock=#{dropped_samples_nolock}, " +
-        "dropped_allocation_bufsize=#{dropped_samples_allocation_bufsize}, " +
-        "dropped_heap_bufsize=#{dropped_samples_heap_bufsize}" +
+      "<MemprofilerPprof::ProfileData:#{object_id.to_s(16)} (sample counts: " \
+        "heap=#{heap_samples_count}, " \
+        "dropped_heap_bufsize=#{dropped_samples_heap_bufsize}" \
         ")>"
     end
   end

data/lib/ruby_memprofiler_pprof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MemprofilerPprof
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/ruby_memprofiler_pprof.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
+require 'backtracie'
 require "ruby_memprofiler_pprof/version"
 require "ruby_memprofiler_pprof/profile_data"
-require "ruby_memprofiler_pprof/ruby_memprofiler_pprof_ext"
-require 'ruby_memprofiler_pprof/atfork'
-require 'ruby_memprofiler_pprof/block_flusher'
-require 'ruby_memprofiler_pprof/file_flusher'
+require "ruby_memprofiler_pprof_ext"
+require "ruby_memprofiler_pprof/atfork"
+require "ruby_memprofiler_pprof/block_flusher"
+require "ruby_memprofiler_pprof/file_flusher"

data/libexec/ruby_memprofiler_pprof_profile

@@ -4,13 +4,13 @@
 # Simply starts the provided program as-is, but sets RUBYLIB so that it will be
 # profiled by ruby_memprofiler_pprof.
 
-require 'shellwords'
+require "shellwords"
 
 base_path = File.expand_path("../lib", __dir__)
-profile_lib = File.join(base_path, 'ruby_memprofiler_pprof', 'profile_app.rb')
+profile_lib = File.join(base_path, "ruby_memprofiler_pprof", "profile_app.rb")
 opts = [
-    "-I#{Shellwords.escape base_path}",
-    "-r#{Shellwords.escape profile_lib}"
+  "-I#{Shellwords.escape base_path}",
+  "-r#{Shellwords.escape profile_lib}"
 ]
-ENV['RUBYOPT'] = ([ENV.fetch('RUBYOPT', nil)] + opts).compact.join(" ")
-exec *ARGV
+ENV["RUBYOPT"] = ([ENV.fetch("RUBYOPT", nil)] + opts).compact.join(" ")
+exec(*ARGV)