stackprof 0.2.25 → 0.2.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b299eb696cf0c2748e931532afab3f90bab1c94447ff1c844bce0eda878a93c6
-  data.tar.gz: bd2c389baa8253fc06beda425abc87762b9bca425c6bc5046655610fb9852e79
+  metadata.gz: 3165c34411b9287741eb15e8c84bec239792a81aaf30695d2e735b0bee41a9d8
+  data.tar.gz: 6cf3bd55b6b14fcd880facfb281ded85e03d1ec9d79fc1b0c4fcb5b592df014d
 SHA512:
-  metadata.gz: 322e506fc77bd964f39e7b3f0c5584e57efdec8e1dcc432cdea924536e334234d916a1d5e1ff085e2e5210a49751897ca36a4b1bd007468a5b16184151129be3
-  data.tar.gz: 3234d4159c78119a9238200d1f4516280cbd1e0cfe3affca1c4fa4827b805ecf154e38857c917fafe7aed042d67525bb7e6c5fce85a039e30cde4672ae08f97e
+  metadata.gz: '086238ddefcd029b17a7de36d0bdce624b8cda367c1dd5ab55348f9332388c49fc326f01ba66d7d11d31d0014210d1474013aa106d1432da4605334551772ba2'
+  data.tar.gz: a4c203dc55aa3da32744114a2f899982d548ce1c4c90daf4da3808bcae725fcff21775a4fee3d303724f96418b5bd1c748807dce7d28e84dcde8fbd61ea90932

data/.github/workflows/ci.yml

@@ -8,7 +8,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ ruby-head, '3.1', '3.0', '2.7', '2.6', '2.5', '2.4', '2.3', '2.2', truffleruby ]
+        ruby: [ ruby-head, '3.2', '3.1', '3.0', '2.7', truffleruby ]
     steps:
       - name: Checkout
         uses: actions/checkout@v2

data/ext/stackprof/stackprof.c

@@ -102,7 +102,7 @@ static struct {
     VALUE metadata;
     int ignore_gc;
 
-    VALUE *raw_samples;
+    uint64_t *raw_samples;
     size_t raw_samples_len;
     size_t raw_samples_capa;
     size_t raw_sample_index;
@@ -120,6 +120,8 @@ static struct {
     size_t unrecorded_gc_sweeping_samples;
     st_table *frames;
 
+    timestamp_t gc_start_timestamp;
+
     VALUE fake_frame_names[TOTAL_FAKE_FRAMES];
     VALUE empty_string;
 
@@ -133,7 +135,7 @@ static struct {
 
 static VALUE sym_object, sym_wall, sym_cpu, sym_custom, sym_name, sym_file, sym_line;
 static VALUE sym_samples, sym_total_samples, sym_missed_samples, sym_edges, sym_lines;
-static VALUE sym_version, sym_mode, sym_interval, sym_raw, sym_metadata, sym_frames, sym_ignore_gc, sym_out;
+static VALUE sym_version, sym_mode, sym_interval, sym_raw, sym_raw_lines, sym_metadata, sym_frames, sym_ignore_gc, sym_out;
 static VALUE sym_aggregate, sym_raw_sample_timestamps, sym_raw_timestamp_deltas, sym_state, sym_marking, sym_sweeping;
 static VALUE sym_gc_samples, objtracer;
 static VALUE gc_hook;
@@ -374,14 +376,23 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 	size_t len, n, o;
 	VALUE raw_sample_timestamps, raw_timestamp_deltas;
 	VALUE raw_samples = rb_ary_new_capa(_stackprof.raw_samples_len);
+	VALUE raw_lines = rb_ary_new_capa(_stackprof.raw_samples_len);
 
 	for (n = 0; n < _stackprof.raw_samples_len; n++) {
 	    len = (size_t)_stackprof.raw_samples[n];
 	    rb_ary_push(raw_samples, SIZET2NUM(len));
+	    rb_ary_push(raw_lines, SIZET2NUM(len));
+
+	    for (o = 0, n++; o < len; n++, o++) {
+		// Line is in the upper 16 bits
+		rb_ary_push(raw_lines, INT2NUM(_stackprof.raw_samples[n] >> 48));
+
+		VALUE frame = _stackprof.raw_samples[n] & ~((uint64_t)0xFFFF << 48);
+		rb_ary_push(raw_samples, PTR2NUM(frame));
+	    }
 
-	    for (o = 0, n++; o < len; n++, o++)
-		rb_ary_push(raw_samples, PTR2NUM(_stackprof.raw_samples[n]));
 	    rb_ary_push(raw_samples, SIZET2NUM((size_t)_stackprof.raw_samples[n]));
+	    rb_ary_push(raw_lines, SIZET2NUM((size_t)_stackprof.raw_samples[n]));
 	}
 
 	free(_stackprof.raw_samples);
@@ -391,6 +402,7 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 	_stackprof.raw_sample_index = 0;
 
 	rb_hash_aset(results, sym_raw, raw_samples);
+	rb_hash_aset(results, sym_raw_lines, raw_lines);
 
 	raw_sample_timestamps = rb_ary_new_capa(_stackprof.raw_sample_times_len);
 	raw_timestamp_deltas = rb_ary_new_capa(_stackprof.raw_sample_times_len);
@@ -520,7 +532,12 @@ stackprof_record_sample_for_stack(int num, uint64_t sample_timestamp, int64_t ti
 	     * in the frames buffer that came from Ruby. */
 	    for (i = num-1, n = 0; i >= 0; i--, n++) {
 		VALUE frame = _stackprof.frames_buffer[i];
-		if (_stackprof.raw_samples[_stackprof.raw_sample_index + 1 + n] != frame)
+		int line = _stackprof.lines_buffer[i];
+
+		// Encode the line in to the upper 16 bits.
+		uint64_t key = ((uint64_t)line << 48) | (uint64_t)frame;
+
+		if (_stackprof.raw_samples[_stackprof.raw_sample_index + 1 + n] != key)
 		    break;
 	    }
 	    if (i == -1) {
@@ -538,7 +555,12 @@ stackprof_record_sample_for_stack(int num, uint64_t sample_timestamp, int64_t ti
 	    _stackprof.raw_samples[_stackprof.raw_samples_len++] = (VALUE)num;
 	    for (i = num-1; i >= 0; i--) {
 		VALUE frame = _stackprof.frames_buffer[i];
-		_stackprof.raw_samples[_stackprof.raw_samples_len++] = frame;
+		int line = _stackprof.lines_buffer[i];
+
+		// Encode the line in to the upper 16 bits.
+		uint64_t key = ((uint64_t)line << 48) | (uint64_t)frame;
+
+		_stackprof.raw_samples[_stackprof.raw_samples_len++] = key;
 	    }
 	    _stackprof.raw_samples[_stackprof.raw_samples_len++] = (VALUE)1;
 	}
@@ -626,6 +648,7 @@ stackprof_buffer_sample(void)
     _stackprof.buffer_time.delta_usec = timestamp_delta;
 }
 
+// Postponed job
 void
 stackprof_record_gc_samples(void)
 {
@@ -633,8 +656,7 @@ stackprof_record_gc_samples(void)
     uint64_t start_timestamp = 0;
     size_t i;
     if (_stackprof.raw) {
-	struct timestamp_t t;
-	capture_timestamp(&t);
+	struct timestamp_t t = _stackprof.gc_start_timestamp;
 	start_timestamp = timestamp_usec(&t);
 
 	// We don't know when the GC samples were actually marked, so let's
@@ -756,6 +778,10 @@ stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
 	} else if (mode == sym_sweeping) {
 	    _stackprof.unrecorded_gc_sweeping_samples++;
 	}
+	if(!_stackprof.unrecorded_gc_samples) {
+	    // record start
+	    capture_timestamp(&_stackprof.gc_start_timestamp);
+	}
 	_stackprof.unrecorded_gc_samples++;
 	rb_postponed_job_register_one(0, stackprof_job_record_gc, (void*)0);
     } else {
@@ -812,11 +838,18 @@ stackprof_gc_mark(void *data)
     if (_stackprof.frames)
 	st_foreach(_stackprof.frames, frame_mark_i, 0);
 
-    for (int i = 0; i < _stackprof.buffer_count; i++) {
+    int i;
+    for (i = 0; i < _stackprof.buffer_count; i++) {
         rb_gc_mark(_stackprof.frames_buffer[i]);
     }
 }
 
+static size_t
+stackprof_memsize(const void *data)
+{
+    return sizeof(_stackprof);
+}
+
 static void
 stackprof_atfork_prepare(void)
 {
@@ -862,6 +895,15 @@ stackprof_at_exit(ruby_vm_t* vm)
     ruby_vm_running = 0;
 }
 
+static const rb_data_type_t stackprof_type = {
+    "StackProf",
+    {
+        stackprof_gc_mark,
+        NULL,
+        stackprof_memsize,
+    }
+};
+
 void
 Init_stackprof(void)
 {
@@ -893,6 +935,7 @@ Init_stackprof(void)
     S(mode);
     S(interval);
     S(raw);
+    S(raw_lines);
     S(raw_sample_timestamps);
     S(raw_timestamp_deltas);
     S(out);
@@ -908,8 +951,8 @@ Init_stackprof(void)
     /* Need to run this to warm the symbol table before we call this during GC */
     rb_gc_latest_gc_info(sym_state);
 
-    gc_hook = Data_Wrap_Struct(rb_cObject, stackprof_gc_mark, NULL, &_stackprof);
     rb_global_variable(&gc_hook);
+    gc_hook = TypedData_Wrap_Struct(rb_cObject, &stackprof_type, &_stackprof);
 
     _stackprof.raw_samples = NULL;
     _stackprof.raw_samples_len = 0;

data/lib/stackprof.rb

@@ -5,7 +5,11 @@ else
 end
 
 if defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
-  StackProf.use_postponed_job!
+  if RUBY_VERSION < "3.3"
+    # On 3.3 we don't need postponed jobs:
+    # https://github.com/ruby/ruby/commit/a1dc1a3de9683daf5a543d6f618e17aabfcb8708
+    StackProf.use_postponed_job!
+  end
 elsif RUBY_VERSION == "3.2.0"
   # 3.2.0 crash is the signal is received at the wrong time.
   # Fixed in https://github.com/ruby/ruby/pull/7116
@@ -14,7 +18,7 @@ elsif RUBY_VERSION == "3.2.0"
 end
 
 module StackProf
-  VERSION = '0.2.25'
+  VERSION = '0.2.26'
 end
 
 StackProf.autoload :Report, "stackprof/report.rb"

data/stackprof.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'stackprof'
-  s.version = '0.2.25'
+  s.version = '0.2.26'
   s.homepage = 'http://github.com/tmm1/stackprof'
 
   s.authors = 'Aman Gupta'
@@ -29,6 +29,5 @@ Gem::Specification.new do |s|
   s.license = 'MIT'
 
   s.add_development_dependency 'rake-compiler', '~> 0.9'
-  s.add_development_dependency 'mocha', '~> 0.14'
   s.add_development_dependency 'minitest', '~> 5.0'
 end

data/test/test_middleware.rb

@@ -2,9 +2,9 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'stackprof'
 require 'stackprof/middleware'
 require 'minitest/autorun'
-require 'mocha/setup'
+require 'tmpdir'
 
-class StackProf::MiddlewareTest < MiniTest::Test
+class StackProf::MiddlewareTest < Minitest::Test
 
   def test_path_default
     StackProf::Middleware.new(Object.new)
@@ -19,23 +19,36 @@ class StackProf::MiddlewareTest < MiniTest::Test
   end
 
   def test_save_default
-    StackProf::Middleware.new(Object.new)
-
-    StackProf.stubs(:results).returns({ mode: 'foo' })
-    FileUtils.expects(:mkdir_p).with('tmp/')
-    File.expects(:open).with(regexp_matches(/^tmp\/stackprof-foo/), 'wb')
-
-    StackProf::Middleware.save
+    middleware = StackProf::Middleware.new(->(env) { 100.times { Object.new } },
+                                          save_every: 1,
+                                          enabled: true)
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) { middleware.call({}) }
+      dir = File.join(dir, "tmp")
+      assert File.directory? dir
+      profile = Dir.entries(dir).reject { |x| File.directory?(x) }.first
+      assert profile
+      assert_equal "stackprof", profile.split("-")[0]
+      assert_equal "cpu", profile.split("-")[1]
+      assert_equal Process.pid.to_s, profile.split("-")[2]
+    end
   end
 
   def test_save_custom
-    StackProf::Middleware.new(Object.new, { path: 'foo/' })
-
-    StackProf.stubs(:results).returns({ mode: 'foo' })
-    FileUtils.expects(:mkdir_p).with('foo/')
-    File.expects(:open).with(regexp_matches(/^foo\/stackprof-foo/), 'wb')
-
-    StackProf::Middleware.save
+    middleware = StackProf::Middleware.new(->(env) { 100.times { Object.new } },
+                                          path: "foo/",
+                                          save_every: 1,
+                                          enabled: true)
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) { middleware.call({}) }
+      dir = File.join(dir, "foo")
+      assert File.directory? dir
+      profile = Dir.entries(dir).reject { |x| File.directory?(x) }.first
+      assert profile
+      assert_equal "stackprof", profile.split("-")[0]
+      assert_equal "cpu", profile.split("-")[1]
+      assert_equal Process.pid.to_s, profile.split("-")[2]
+    end
   end
 
   def test_enabled_should_use_a_proc_if_passed
@@ -70,4 +83,4 @@ class StackProf::MiddlewareTest < MiniTest::Test
     StackProf::Middleware.new(Object.new, metadata: metadata)
     assert_equal metadata, StackProf::Middleware.metadata
   end
-end
+end unless RUBY_ENGINE == 'truffleruby'

data/test/test_report.rb

@@ -2,7 +2,7 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'stackprof'
 require 'minitest/autorun'
 
-class ReportDumpTest < MiniTest::Test
+class ReportDumpTest < Minitest::Test
   require 'stringio'
 
   def test_dump_to_stdout
@@ -33,7 +33,7 @@ class ReportDumpTest < MiniTest::Test
   end
 end
 
-class ReportReadTest < MiniTest::Test
+class ReportReadTest < Minitest::Test
   require 'pathname'
 
   def test_from_file_read_json

data/test/test_stackprof.rb

@@ -4,7 +4,7 @@ require 'minitest/autorun'
 require 'tempfile'
 require 'pathname'
 
-class StackProfTest < MiniTest::Test
+class StackProfTest < Minitest::Test
   def setup
     Object.new # warm some caches to avoid flakiness
   end
@@ -93,6 +93,7 @@ class StackProfTest < MiniTest::Test
   end
 
   def test_walltime
+    GC.disable
     profile = StackProf.run(mode: :wall) do
       idle
     end
@@ -104,6 +105,8 @@ class StackProfTest < MiniTest::Test
       assert_equal "StackProfTest#idle", frame[:name]
     end
     assert_in_delta 200, frame[:samples], 25
+  ensure
+    GC.enable
   end
 
   def test_custom
@@ -142,10 +145,13 @@ class StackProfTest < MiniTest::Test
     after_monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
 
     raw = profile[:raw]
+    raw_lines = profile[:raw_lines]
     assert_equal 10, raw[-1]
     assert_equal raw[0] + 2, raw.size
+    assert_equal 10, raw_lines[-1] # seen 10 times
 
     offset = RUBY_VERSION >= '3' ? -3 : -2
+    assert_equal 140, raw_lines[offset] # sample caller is on 140
     assert_includes profile[:frames][raw[offset]][:name], 'StackProfTest#test_raw'
 
     assert_equal 10, profile[:raw_sample_timestamps].size
@@ -241,8 +247,12 @@ class StackProfTest < MiniTest::Test
     assert marking_frame
     assert sweeping_frame
 
-    assert_equal gc_frame[:total_samples], profile[:gc_samples]
-    assert_equal profile[:gc_samples], [gc_frame, marking_frame, sweeping_frame].map{|x| x[:samples] }.inject(:+)
+    # We can't guarantee a certain number of GCs to run, so just assert
+    # that it's within some kind of delta
+    assert_in_delta gc_frame[:total_samples], profile[:gc_samples], 2
+
+    # Lazy marking / sweeping can cause this math to not add up, so also use a delta
+    assert_in_delta profile[:gc_samples], [gc_frame, marking_frame, sweeping_frame].map{|x| x[:samples] }.inject(:+), 2
 
     assert_operator profile[:gc_samples], :>, 0
     assert_operator profile[:missed_samples], :<=, 25

data/test/test_truffleruby.rb

@@ -3,7 +3,7 @@ require 'stackprof'
 require 'minitest/autorun'
 
 if RUBY_ENGINE == 'truffleruby'
-  class StackProfTruffleRubyTest < MiniTest::Test
+  class StackProfTruffleRubyTest < Minitest::Test
     def test_error
       error = assert_raises RuntimeError do
         StackProf.run(mode: :cpu) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stackprof
 version: !ruby/object:Gem::Version
-  version: 0.2.25
+  version: 0.2.26
 platform: ruby
 authors:
 - Aman Gupta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-06 00:00:00.000000000 Z
+date: 2024-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -99,9 +85,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/tmm1/stackprof/issues
-  changelog_uri: https://github.com/tmm1/stackprof/blob/v0.2.25/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/stackprof/0.2.25
-  source_code_uri: https://github.com/tmm1/stackprof/tree/v0.2.25
+  changelog_uri: https://github.com/tmm1/stackprof/blob/v0.2.26/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/stackprof/0.2.26
+  source_code_uri: https://github.com/tmm1/stackprof/tree/v0.2.26
 post_install_message: 
 rdoc_options: []
 require_paths: