sampling_prof 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA1: 
-  metadata.gz: 9788852fedbd8c4a9fc1d38ccef911e8a94e6376
-  data.tar.gz: 90beb461326396ebf9def203708553b1b06afbb0
-SHA512: 
-  metadata.gz: 0aaed78d0c76cb5f3b7d9a263a843db6751fda97375850e7d61e34a1fd046489b53cd0e632eea661d47e271bd2c13e70089f98bb9d8c67f1cc1e614b41e2e82f
-  data.tar.gz: 3c9af4039b08d98d72b35ae45bfbb3883744684e6c00f9db20c405c5f2ff81a4a9f75ea97bd9b180c33dff8ebfd17748351f6b3c0a133e65f92734fe237e71fd
+---
+SHA1:
+  metadata.gz: b3d5e9f4030836370938d494ceb34b7c6a153531
+  data.tar.gz: c39ad8399c81faa1dc45bbdcb8c99d910e22a6c0
+SHA512:
+  metadata.gz: 313981a2ed4edb5cea888052515eb87b7e2fe62271ad951960f8517580a5fb4983ffaddd370152d4e11e0f7a3193f8678b740d80427779c8fb64ec6cbc6d9637
+  data.tar.gz: 1ae6f1690779efd29ec5633a827a048e5622d9157ea0ef67688838ace40f54b33669060675be3069758e1a88a66257adccdbac34c4b1fdf05b117919767201b3

data/README.md

@@ -1,51 +1,45 @@
 SamplingProf
 ===============
 
-SamplingProf is a profiling tool that operates by sampling your running thread stacktrace. The result is statistical approximation, but it allows your code to run near full speed.
+SamplingProf is a statistical profiler or sampling profiler that operates by sampling your running thread stacktrace. The result is statistical approximation, but it allows your code to run near full speed.
 
 Quick start
 ---------------
 
 For single thread profiling, start with default options:
 
-  prof = SamplingProf.new
-  prof.profile do
-  ... your code ...
-  end
+    prof = SamplingProf.new
+    prof.profile do
+      ... your code ...
+    end
+    at_exit { prof.terminate }
 
 After profiling finished, the output will be write to file SamplingProf::DEFAULT_OUTPUT_FILE
 
 Options
 ---------------
 
-SamplingProf class initializer takes 3 arguments:
+SamplingProf class initializer takes 1 argument:
 
 1. sampling interval: seconds
-2. multithreading: boolean
-3. output interval: seconds
 
 SamplingProf class also takes block as another option to overwite default output handler, the default output handler will write output data to a local file defined by output_file attribute, which is default to SamplingProf::DEFAULT_OUTPUT_FILE
 
+When a SamplingProf is initialized, a thread will be started to handle sampling process.
+So you need call SamplingProf#terminate to shutdown the sampling thread after everything is done.
+
 ### Sampling interval
 
 This is an interval to control how frequent SamplingProf should take sample of target thread stacktrace.
 The default value is 0.1 seconds.
 
-### Multithreading mode
-
-When running SamplingProf in multithreading environment (e.g. Rails multithreading production environment), you need turn on multithreading mode so that you can profile all requests processing at same time cross threads.
-
-For performance concerns, multithreading mode will only take limit number of threads' sample while profiling. The default max samples of the threads is 4, you can change it by set max_sampling_threads.
-
-Since we randomly find max_sampling_threads number of threads in profiling threads, the result is still a statistical approximation.
+### Multithreading
 
-### output interval
+When running SamplingProf in multithreading environment (e.g. Rails multithreading production environment), it can profile all requests processing at same time cross threads.
 
-Output interval controls how frequent SamplingProf should call output handler to flush out cached data.
-The default value of output interval is depend on the option of multithreading.
-When multithreading is off, the default value is nil, because single thread mode is more likely only need to do once data output when the profiling finished.
+For performance concerns, you should controll how many number of threads' sample while profiling.
 
-When multithreading is on, the default value is 60 seconds, means every 60 seconds SamplingProf will call output handler once to flush out data and restart to cumulate data.
+Randomly select some threads for profiling, the result is still a statistical approximation.
 
 Output data format
 ---------------
@@ -93,7 +87,7 @@ SamplingProf collects count of each call element at runtime. There are 2 type of
 
 Same with call element id map, we use comma to separate data, and one line represents one call element data.
 Here we use call element id instead of call element string to reference the call element.
-The line looks like this: <call element id>,<self count>,<total count>
+The line looks like this: [call element id],[self count],[total count]
 
 ### call graph
 
@@ -101,8 +95,8 @@ SamplingProf collects counts of function calls. One function call is A call elem
 
 The call graph stores the counts of function calls.
 Every line is one function call data.
-the line looks like this: <call element id1>,<call element id2>,<count>
+the line looks like this: [call element id1],[call element id2],[count]
 
-Direct recursive calls are recorded as: <call element id1>,<call element id1>,<count>
+Direct recursive calls are recorded as: [call element id1],[call element id1],[count]
 
 Indirect recursive calls are ignored as function call only have direct call info. Hence the data maybe odd when there are indirect recursive calls.

data/lib/sampling_prof.rb

@@ -11,17 +11,9 @@ class SamplingProf
 
   # options:
   #   sampling_interval: default to 0.1 second
-  #   multithreading: default to false
-  #   output_interval: default to (multithreading ? 60 : nil)
   #   &output_handler: default to write into output_file
   def initialize(*args, &output_handler)
     self.sampling_interval = args[0] || 0.1
-    self.multithreading = args[1] || false
-    if args.length > 2
-      self.output_interval = args[2]
-    else
-      self.output_interval = multithreading ? 60 : nil
-    end
     self.output_handler = block_given? ? output_handler : default_output_handler
     internal_initialize if respond_to?(:internal_initialize)
   end

data/lib/sampling_prof/internal.rb

@@ -3,11 +3,10 @@ require 'thread'
 
 class SamplingProf
   class Sampling
-    def initialize(threads)
+    def initialize
       @samples = Hash.new{|h,k| h[k] = [0, 0] }
       @call_graph = Hash.new{|h,k| h[k] = 0}
       @nodes = {}
-      @threads = threads
       @start_at = Time.now
     end
 
@@ -20,37 +19,35 @@ class SamplingProf
     end
 
     def result
-      ret = [@threads.sampling_runtime * 1000]
+      ret = [runtime * 1000]
       ret << @nodes.map {|node| node.join(',')}.join("\n")
       ret << @samples.map {|count| count.flatten.join(',')}.join("\n")
       ret << @call_graph.map {|v| v.flatten.join(',')}.join("\n")
       "#{ret.join("\n\n")}\n"
     end
 
-    def process
-      @threads.sample_threads.each do |thread|
-        locations = thread.backtrace_locations
-        from = -1
-        paths = []
-        calls = []
-        top_index = locations.size - 1
-        locations.reverse.each_with_index do |loc, i|
-          node_id = node_id(loc)
-          if i == top_index
-            @samples[node_id][0] += 1
-          end
-
-          path = [from, node_id]
-          if !paths.include?(path)
-            paths << path
-            @call_graph[path] += 1
-          end
-          if !calls.include?(node_id)
-            calls << node_id
-            @samples[node_id][1] += 1
-          end
-          from = node_id
+    def process(thread)
+      locations = thread.backtrace_locations
+      from = -1
+      paths = []
+      calls = []
+      top_index = locations.size - 1
+      locations.reverse.each_with_index do |loc, i|
+        node_id = node_id(loc)
+        if i == top_index
+          @samples[node_id][0] += 1
+        end
+
+        path = [from, node_id]
+        if !paths.include?(path)
+          paths << path
+          @call_graph[path] += 1
         end
+        if !calls.include?(node_id)
+          calls << node_id
+          @samples[node_id][1] += 1
+        end
+        from = node_id
       end
     end
 
@@ -63,100 +60,63 @@ class SamplingProf
     end
   end
 
-  class Threads
-    attr_accessor :max
-
-    def initialize
-      @hash = {}
-      @mutex = Mutex.new
-      @remain_sampling_time = 0
-      @max = 4
-    end
-
-    def sample_threads
-      @mutex.synchronize { @hash.keys.dup.shuffle[0..@max] }
-    end
-
-    def add(obj, time=Time.now)
-      @mutex.synchronize { @hash[obj] = time }
-    end
-
-    def sampling_runtime
-      now = Time.now
-      @mutex.synchronize do
-        ret, @remain_sampling_time = @remain_sampling_time, 0
-        @hash.keys.each do |k|
-          ret += now - @hash[k]
-          @hash[k] = now
-        end
-        ret
-      end
-    end
-
-    def delete(obj)
-      @mutex.synchronize do
-        start = @hash.delete(obj)
-        @remain_sampling_time += Time.now - start
-      end
-    end
-  end
-
-  attr_accessor :sampling_interval, :multithreading, :output_interval, :output_handler
+  attr_accessor :sampling_interval, :output_handler
 
   def internal_initialize
-    @running = false
-    @sampling_thread = nil
-    @threads = Threads.new
-  end
-
-  def max_sampling_threads=(max)
-    @threads.max = max
+    @samplings = {}
+    start_sampling_thread
   end
 
   def start
-    if @multithreading || !@running
-      @running = true
-      @threads.add(Thread.current)
-      @sampling_thread ||= Thread.start do
-        loop do
-          sampling = Sampling.new(@threads)
-          loop do
-            break unless @running
-            if @multithreading
-              break if output_interval < sampling.runtime
-            end
-            sampling.process
-            sleep @sampling_interval
-          end
-          if sampling.sampling_data?
-            @output_handler.call(sampling.result)
-          end
-          break unless @running
-        end
-      end
+    unless @samplings.has_key?(Thread.current)
+      @samplings[Thread.current] = Sampling.new
       true
     end
   end
 
   def stop
     if @running
-      if @multithreading
-        @threads.delete(Thread.current)
-      else
-        terminate
+      if sampling = @samplings.delete(Thread.current)
+        output(sampling)
+        true
       end
-      true
     end
   end
 
   def terminate
+    return false unless @running
     @running = false
     @sampling_thread.join
     @sampling_thread = nil
+    @samplings = {}
     true
   end
 
   def profiling?
-    !!@sampling_thread
+    !!@sampling_thread && @samplings.has_key?(Thread.current)
+  end
+
+  private
+  def start_sampling_thread
+    return if @running
+    @running = true
+    @sampling_thread ||= Thread.start do
+      loop do
+        @samplings.dup.each do |t, s|
+          s.process(t)
+        end
+        sleep @sampling_interval
+        break unless @running
+      end
+      @samplings.each do |sampling|
+        output(sampling)
+      end
+    end
+  end
+
+  def output(sampling)
+    if sampling.sampling_data?
+      @output_handler.call(sampling.result)
+    end
   end
 end

metadata

@@ -1,70 +1,69 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: sampling_prof
-version: !ruby/object:Gem::Version 
-  version: 0.3.4
+version: !ruby/object:Gem::Version
+  version: 0.4.0
 platform: ruby
-authors: 
-  - Xiao Li
+authors:
+- Xiao Li
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-04-11 00:00:00 Z
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: rake-compiler
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ~>
-          - !ruby/object:Gem::Version 
-            version: "0.9"
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: 0.9.2
-    type: :development
-    version_requirements: *id001
+date: 2014-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.2
 description: |
   SamplingProf is a profiling tool that operates by sampling your running thread stacktrace. The result is statistical approximation, but it allows your code to run near full speed
-
-email: 
-  - swing1979@gmail.com
+email:
+- swing1979@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - README.md
-  - lib/sampling_prof.jar
-  - lib/sampling_prof.rb
-  - lib/sampling_prof/internal.rb
+files:
+- README.md
+- lib/sampling_prof.jar
+- lib/sampling_prof.rb
+- lib/sampling_prof/internal.rb
 homepage: https://github.com/xli/sampling_prof
-licenses: 
-  - MIT
+licenses:
+- MIT
 metadata: {}
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-    - &id002 
-      - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-    - *id002
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 2.1.9
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Simple sampling profiler for ruby
 test_files: []
-