calleree 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbb6acebd17bc68a5547ccd29c14e41a359aec189a08dbdeca7ab19088a00a8e
-  data.tar.gz: 7e364534c22b4d4d6184fba2dc472939bb578b379fe508d1292e538f27391383
+  metadata.gz: efe0a24448e4190f50b98f29915cce53ab119f58d47794ef096389c36283b9a2
+  data.tar.gz: a17ca6a2f922d7bed7930bca47e52aa8ca32556c66d3f41e4a69472ae11cb452
 SHA512:
-  metadata.gz: 0a1be7bce4337c46c1bb6e45c1dc62d8801379a07167b0784dfa5c36e0595e5fd2bbcf939b27ca7e6ba41f006f6a6b3a31807f52a5d67861fb9ad314903ec209
-  data.tar.gz: c5c6695fe51447599341bb541a903964380e1b6f1579856101739d14a6e6443fb04f4accd7859ef7d12ca2b8146989507475984ae7bd428cc27d05427b65a4fb
+  metadata.gz: 6bc549831417fcf325e61da2f4cbd9f5bf9cfa17a8f7921281bc104689e8e8ad40e294e5e29b1670cb0a66e4f036de45dcd64b875c6609dd7069917f0c434e04
+  data.tar.gz: a84916439baa9a7aa05f673709562d203b9eeae1632421bf1196ee16a19e848ba97ce1c53cd50d9e2c90ad177629d8e5e491aa64d28aa7f12cd29fa8a7ae441a

data/.github/workflows/ruby.yml

@@ -0,0 +1,34 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0', 'head', 'debug']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/Gemfile

@@ -3,6 +3,6 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in calleree.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
+gem "rake"
 gem "rake-compiler"
-gem "minitest", "~> 5.0"
+gem "minitest"

data/README.md

@@ -1,3 +1,5 @@
+[![Ruby](https://github.com/ko1/calleree/actions/workflows/ruby.yml/badge.svg)](https://github.com/ko1/calleree/actions/workflows/ruby.yml)
+
 # Calleree
 
 Calleree helps to analyze Ruby's caller-callee relationships.
@@ -35,7 +37,7 @@ Or install it yourself as:
     11
     12  Calleree.start
     13
-    14  foo
+    14  bar
     15
     16  pp Calleree.result
 ```
@@ -43,18 +45,95 @@ Or install it yourself as:
 And this program shows:
 
 ```
-[[["test.rb", 14], ["test.rb", 5], 1],
- [["test.rb", 16], ["/mnt/c/ko1/src/rb/calleree/lib/calleree.rb", 24], 1]]
-...
+[[["test.rb", 14], ["test.rb", 9], 1],
+ [["test.rb", 9], ["test.rb", 5], 1],
+ [["test.rb", 16], ["/mnt/c/ko1/src/rb/calleree/lib/calleree.rb", 23], 1]]
+```
 
 The `Calleree.result` method returns an array of arrays which contains `[[caller_path, caller_line], [callee_path, callee_line], called_caount]`.
 
-In this case, `foo` at `["test.rb", 5]` is called at `["test.rb", 14]` only once.
+In this case:
+
+* A method `bar` at `["test.rb", 9]` is called from `["test.rb", 14]` only once.
+* A method `foo` at `["test.rb", 5]` is called from `bar` at  `["test.rb", 9]` once.
+* A method `Calleree.result` at `["...calleree.rb", 23]` is called from `["test.rb", 16]`.
+
+Additional usage:
 
-* You can stop the analisys with `Calleree.stop`. `Calleree.start` will continue the analysis.
 * You can use block with `Calleree.start do ... end`.
+* You can stop the analisys with `Calleree.stop`. `Calleree.start` will continue the analysis.
 * You can clear the result if `Calleree.result(clear: true)` is passed.
 
+## Performance
+
+The feature of this library can be implemented by Ruby (see `manual` method in the following code).
+The difference is the performance.
+
+```ruby
+require 'calleree'
+
+def foo
+  :foo
+end
+
+def bar
+  foo
+end
+
+def demo
+  100_000.times{
+    bar
+  }
+end
+
+def manual
+  result = Hash.new(0)
+  TracePoint.new(:call){
+    callee, caller = caller_locations(1, 2).map{|loc| [loc.path, loc.lineno]}
+    result[[caller, callee]] += 1
+  }.enable{
+    yield
+  }
+  result
+end
+
+require 'benchmark'
+
+Benchmark.bm(10){|x|
+  x.report('none'){ demo }
+  x.report('manual'){ manual{ demo } }
+  x.report('calleree'){ Calleree.start{ demo } }
+}
+```
+
+The result of above benchmark is:
+
+```
+                 user     system      total        real
+none         0.004860   0.000972   0.005832 (  0.005828)
+manual       0.864746   0.000000   0.864746 (  0.864833) # about x175
+calleree     0.031616   0.000000   0.031616 (  0.031620) # about x6
+```
+
+The called method `foo` and `bar` don't do anything so the above result shows the almost worst case.
+
+For example if we introduce the allocation by changing the definition of `foo` with:
+
+```ruby
+def foo
+  :foo.to_s
+end
+```
+
+The result becomes more moderated.
+
+```
+                 user     system      total        real
+none         0.012348   0.001953   0.014301 (  0.014328)
+manual       0.858473   0.000650   0.859123 (  0.859259) # about x61
+calleree     0.038204   0.000000   0.038204 (  0.038214) # about x2.7
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/ext/calleree/calleree.c

@@ -2,16 +2,19 @@
 #include "ruby/debug.h"
 #include "ruby/st.h"
 
+#define USE_LOCINDEX 0 // Ruby 3.1 feature trial
+
 VALUE rb_mCalleree;
 
 struct eree_data {
     VALUE tp; // TracePoint.new(:call)
-    VALUE files; // name -> [ {[fname, 1], ... } ]
-    struct st_table* caller_callee;  // [posnum | posnum] -> cnt
+    VALUE files; // name -> [ nil, posnum1, posnum,2 ... ]
+    struct st_table* caller_callee;  // { (posnumX | posnumY) => cnt, ... }
     int last_posnum;
 } eree_data;
 
-static int
+#if !USE_LOCINDEX
+static unsigned int
 posnum(struct eree_data *data, VALUE path, int line)
 {
     VALUE lines, posnumv;
@@ -20,10 +23,13 @@ posnum(struct eree_data *data, VALUE path, int line)
         rb_hash_aset(data->files, path, lines = rb_ary_new());
     }
     if (NIL_P(posnumv = rb_ary_entry(lines, line))) {
-        rb_ary_store(lines, line, posnumv = INT2FIX(data->last_posnum++));
+        int posnum = ++data->last_posnum;
+        if (RB_UNLIKELY(posnum == 0)) rb_raise(rb_eRuntimeError, "posnum overflow");
+        rb_ary_store(lines, line, posnumv = INT2FIX(posnum));
     }
-    return FIX2INT(posnumv);
+    return (unsigned int)FIX2INT(posnumv);
 }
+#endif
 
 static int
 increment_i(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
@@ -33,26 +39,41 @@ increment_i(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
 }
 
 static void
-erree_called(VALUE tpval, void *ptr)
+eree_called(VALUE tpval, void *ptr)
 {
     struct eree_data *data = ptr;
+
+#if !USE_LOCINDEX
     VALUE frames[2];
     int lines[2];
     // int start, int limit, VALUE *buff, int *lines);
-    rb_profile_frames(1, 2, frames, lines);
-    int callee_posnum = posnum(data, rb_profile_frame_path(frames[0]), lines[0]);
-    int caller_posnum = posnum(data, rb_profile_frame_path(frames[1]), lines[1]);
-    // rb_p(rb_profile_frame_path(frames[1]));
-    st_data_t eree_pair = (((VALUE)caller_posnum << 32) | ((VALUE)callee_posnum));
+    int r = rb_profile_frames(1, 2, frames, lines);
+
+    if (r >= 2) {
+        unsigned int callee_posnum = posnum(data, rb_profile_frame_absolute_path(frames[0]), lines[0]);
+        unsigned int caller_posnum = posnum(data, rb_profile_frame_absolute_path(frames[1]), lines[1]);
 
-    st_update(data->caller_callee, eree_pair, increment_i, 0);
+        st_data_t eree_pair = (((VALUE)caller_posnum << 32) | ((VALUE)callee_posnum));
+        st_update(data->caller_callee, eree_pair, increment_i, 0);
+    }
+#else
+    unsigned int locs[2];
+    int r = rb_profile_locindex(0, 2, locs, 0);
+    if (r >= 2) {
+        unsigned int callee_posnum = locs[0];// posnum(data, rb_profile_frame_absolute_path (frames[0]), lines[0]);
+        unsigned int caller_posnum = locs[1];// posnum(data, rb_profile_frame_absolute_path (frames[1]), lines[1]);
+        st_data_t eree_pair = (((VALUE)caller_posnum << 32) | ((VALUE)callee_posnum));
+        st_update(data->caller_callee, eree_pair, increment_i, 0);
+    }
+#endif
 }
 
 static VALUE
 eree_start(VALUE self)
 {
     if (!eree_data.tp) {
-        eree_data.tp = rb_tracepoint_new(0, RUBY_EVENT_CALL, erree_called, &eree_data);
+        eree_data.tp = rb_tracepoint_new(0, RUBY_EVENT_CALL, eree_called, &eree_data);
+        rb_gc_register_mark_object(eree_data.tp);
         eree_data.caller_callee = st_init_numtable();
     }
     rb_tracepoint_enable(eree_data.tp);
@@ -72,9 +93,21 @@ static int
 raw_result_i(st_data_t key, st_data_t val, st_data_t data)
 {
     VALUE ary = (VALUE)data;
-    int callee_posnum = (int)(key & 0xffffffff);
-    int caller_posnum = (int)(key >> 32);
-    rb_ary_push(ary, rb_ary_new_from_args(3, INT2FIX(caller_posnum), INT2FIX(callee_posnum), INT2FIX((int)val)));
+    unsigned int callee_posnum = (unsigned int)(key & 0xffffffff);
+    unsigned int caller_posnum = (unsigned int)(key >> 32);
+#if !USE_LOCINDEX
+    rb_ary_push(ary, rb_ary_new_from_args(3, UINT2NUM(caller_posnum), UINT2NUM(callee_posnum), INT2FIX((int)val)));
+#else
+    VALUE er_path, ee_path;
+    int er_line, ee_line;
+    rb_locindex_resolve(callee_posnum, &ee_path, &ee_line);
+    rb_locindex_resolve(caller_posnum, &er_path, &er_line);
+
+    rb_ary_push(ary, rb_ary_new_from_args(3,
+                                          rb_ary_new_from_args(2, er_path, INT2FIX(er_line)),
+                                          rb_ary_new_from_args(2, ee_path, INT2FIX(ee_line)),
+                                          INT2FIX((int)val)));
+#endif
     return ST_CONTINUE;
 }
 
@@ -92,21 +125,27 @@ eree_raw_result(VALUE self, VALUE clear_p)
     return ary;
 }
 
+#if !USE_LOCINDEX
 static VALUE
 eree_raw_posmap(VALUE self)
 {
     return eree_data.files;
 }
+#endif
 
 void
 Init_calleree(void)
 {
     eree_data.files = rb_hash_new();
+    rb_funcall(eree_data.files, rb_intern("compare_by_identity"), 0);
     rb_gc_register_mark_object(eree_data.files);
 
     rb_mCalleree = rb_define_module("Calleree");
     rb_define_singleton_method(rb_mCalleree, "_start", eree_start, 0);
     rb_define_singleton_method(rb_mCalleree, "_stop", eree_stop, 0);
     rb_define_singleton_method(rb_mCalleree, "raw_result", eree_raw_result, 1);
+
+#if !USE_LOCINDEX
     rb_define_singleton_method(rb_mCalleree, "raw_posmap", eree_raw_posmap, 0);
+#endif
 }

data/lib/calleree/version.rb

@@ -1,3 +1,3 @@
 module Calleree
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/calleree.rb

@@ -20,19 +20,24 @@ module Calleree
   end
 
   def self.result clear: false
-    posnum_set = []
-    Calleree.raw_posmap.each{|file, lines|
-      lines.each_with_index{|posnum, line|
-        posnum_set[posnum] = [file, line] if posnum
+    if respond_to? :raw_posmap
+      posnum_set = []
+      Calleree.raw_posmap.each{|file, lines|
+        lines.each_with_index{|posnum, line|
+          posnum_set[posnum] = [file, line] if posnum
+        }
       }
-    }
-    # pp posnum_set
-    rs = []
-    Calleree.raw_result(clear).each{|i, j, cnt|
-      er = posnum_set[i]
-      ee = posnum_set[j]
-      rs << [er, ee, cnt] if er && ee
-    }
-    rs
+      # pp posnum_set
+      rs = []
+      Calleree.raw_result(clear).each{|i, j, cnt|
+        er = posnum_set[i]
+        ee = posnum_set[j]
+        rs << [er, ee, cnt] if er && ee
+      }
+      rs
+    else
+      # USE_LOCINDEX version
+      Calleree.raw_result(clear)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: calleree
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Koichi Sasada
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-17 00:00:00.000000000 Z
+date: 2022-10-03 00:00:00.000000000 Z
 dependencies: []
 description: Calleree helps to analyze Ruby's caller-callee relationships.
 email:
@@ -18,6 +18,7 @@ extensions:
 - ext/calleree/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".travis.yml"
 - Gemfile
@@ -53,7 +54,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: Calleree helps to analyze Ruby's caller-callee relationships.