vernier 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d826cc1605b081bf6784ff46e1e49b09958f3c2626637d3d994b967bc52b391
-  data.tar.gz: 743a02e32629c961795ab0a4b62f839e5bf905e3a4f339f6534157cd257f2e7a
+  metadata.gz: da6d8fafb453c25b5f1127a33c53401150cb91bf604a37db971c952ec490d900
+  data.tar.gz: 97cc5b3435335fe97c531122d5692a3af3264c5abeb34eafb1a1808743b017fe
 SHA512:
-  metadata.gz: ac4dc6ea1e3f9c32ba223e96aa7eae35c62f4a4e3d503efdee643b44984f5d03638b42a4d2e25fe991e8bc49240f75541da0c0791b525782f827969f1926d50c
-  data.tar.gz: 4321e93946c0c2155f79326f9bf29f00bf0fab24785c1c7238b8fdf46570706d8906bf70e80241a7dadd1d1531f8c44e12b4b47584b6024cf7d47fa9fa0a432d
+  metadata.gz: 92529d7331c8a015c900227f1d28b093322dfb386ce99213c4a22dea168d433f9e0d9ae221c3171ea7e3c91fd67753a9da668140af97f62e0edec08341cb4f63
+  data.tar.gz: bdd0baaf24abdbed97f603da42e827fa10442f4f702f15a5ee2f01e2b25eb893465d8b313bcd3dec84a402d76554aa58d28547e2bad401db2c4dbb24797a2414

data/README.md

@@ -1,6 +1,6 @@
 # Vernier
 
-Experimental Ruby profiling tool
+Experimental next-generation Ruby profiler.
 
 ## Installation
 
@@ -10,16 +10,23 @@ gem 'vernier'
 
 ## Usage
 
-Record a flamegraph of all **retained** allocations from requiring `irb`.
+### Retained memory
+
+Record a flamegraph of all **retained** allocations from loading `irb`.
 
 ```
-ruby -r vernier -e 'Vernier.trace_retained(out: "irb.stackcollapse") { require "irb" }'
+ruby -r vernier -e 'Vernier.trace_retained(out: "irb_profile.json") { require "irb" }'
 ```
 
-The output can then be viewed in speedscope or other flamegraph tools
+The output can then be viewed in the [Firefox Profiler (demo)](https://share.firefox.dev/3DhLsFa)
+
+![Screenshot 2023-07-16 at 21-06-19 Ruby_Vernier – 1970-01-01 12 00 00 a m  UTC – Firefox Profiler](https://github.com/jhawthorn/vernier/assets/131752/9ca0b593-70fb-4c8b-aed9-cb33e0e0bc06)
 
-<img width="1082" alt="Screen Shot 2022-04-26 at 8 11 19 PM" src="https://user-images.githubusercontent.com/131752/165440422-3a11f5cc-3018-4455-8918-887c2afa6d6e.png">
+### Time
 
+```
+Vernier.trace(out: "time_profile.json") { some_slow_method }
+```
 
 ## Development
 
@@ -31,6 +38,13 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/jhawthorn/vernier. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/jhawthorn/vernier/blob/main/CODE_OF_CONDUCT.md).
 
+### Resources
+
+* https://profiler.firefox.com/docs/#/
+* https://github.com/firefox-devtools/profiler/tree/main/docs-developer
+* https://github.com/tmm1/stackprof
+* https://github.com/ruby/ruby/pull/5500
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -9,6 +9,10 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/test_*.rb"]
 end
 
+task :console => :compile do
+  sh "irb -r vernier"
+end
+
 require "rake/extensiontask"
 
 task build: :compile

data/examples/threaded_http_requests.rb

@@ -0,0 +1,38 @@
+require "vernier"
+
+Vernier.trace(out: "http_requests.json") do
+
+require "net/http"
+require "uri"
+require "openssl"
+
+urls = Queue.new
+received = Queue.new
+
+threads = 2.times.map do
+  Thread.new do
+    while url = urls.pop
+      uri = URI.parse(url)
+      response = Net::HTTP.get_response(uri)
+
+      received << [url, response.code]
+    end
+  end
+end
+
+Thread.new do
+  threads.each(&:join)
+  received.close
+end
+
+urls << "http://example.com"
+urls << "https://www.johnhawthorn.com"
+urls << "https://tenderlovemaking.com/"
+urls.close
+
+while x = received.pop
+  url, code = *x
+  puts "#{url} #{code}"
+end
+
+end

data/ext/vernier/extconf.rb

@@ -2,7 +2,7 @@
 
 require "mkmf"
 
-$CXXFLAGS += " -std=c++14 "
+$CXXFLAGS += " -std=c++17 "
 $CXXFLAGS += " -ggdb3 -Og "
 
 create_makefile("vernier/vernier")

data/ext/vernier/ruby_type_names.h

@@ -0,0 +1,44 @@
+#pragma once
+
+inline const char *
+ruby_object_type_name(VALUE obj) {
+    enum ruby_value_type type = rb_type(obj);
+
+#define TYPE_CASE(x) case (x): return (#x)
+
+    // Many of these are impossible, but it's easier to just include them
+    switch (type) {
+        TYPE_CASE(T_OBJECT);
+        TYPE_CASE(T_CLASS);
+        TYPE_CASE(T_MODULE);
+        TYPE_CASE(T_FLOAT);
+        TYPE_CASE(T_STRING);
+        TYPE_CASE(T_REGEXP);
+        TYPE_CASE(T_ARRAY);
+        TYPE_CASE(T_HASH);
+        TYPE_CASE(T_STRUCT);
+        TYPE_CASE(T_BIGNUM);
+        TYPE_CASE(T_FILE);
+        TYPE_CASE(T_DATA);
+        TYPE_CASE(T_MATCH);
+        TYPE_CASE(T_COMPLEX);
+        TYPE_CASE(T_RATIONAL);
+
+        TYPE_CASE(T_NIL);
+        TYPE_CASE(T_TRUE);
+        TYPE_CASE(T_FALSE);
+        TYPE_CASE(T_SYMBOL);
+        TYPE_CASE(T_FIXNUM);
+        TYPE_CASE(T_UNDEF);
+
+        TYPE_CASE(T_IMEMO);
+        TYPE_CASE(T_NODE);
+        TYPE_CASE(T_ICLASS);
+        TYPE_CASE(T_ZOMBIE);
+        TYPE_CASE(T_MOVED);
+
+        default:
+        return "unknown type";
+    }
+#undef TYPE_CASE
+}

data/ext/vernier/stack.hh

@@ -7,33 +7,87 @@
 #include <memory>
 #include <algorithm>
 
-struct Frame {
-    VALUE frame;
-    int line;
+struct FrameInfo {
+    static const char *label_cstr(VALUE frame) {
+        VALUE label = rb_profile_frame_full_label(frame);
+        return StringValueCStr(label);
+    }
 
-    VALUE full_label() const {
-        return rb_profile_frame_full_label(frame);
+    static const char *file_cstr(VALUE frame) {
+        VALUE file = rb_profile_frame_absolute_path(frame);
+        if (NIL_P(file))
+            file = rb_profile_frame_path(frame);
+        if (NIL_P(file)) {
+            return "";
+        } else {
+            return StringValueCStr(file);
+        }
     }
 
-    VALUE absolute_path() const {
-        return rb_profile_frame_absolute_path(frame);
+    static int first_lineno_int(VALUE frame) {
+        VALUE first_lineno = rb_profile_frame_first_lineno(frame);
+        return NIL_P(first_lineno) ? 0 : FIX2INT(first_lineno);
     }
 
-    VALUE path() const {
-        return rb_profile_frame_path(frame);
+    FrameInfo(VALUE frame) :
+        label(label_cstr(frame)),
+        file(file_cstr(frame)),
+        first_lineno(first_lineno_int(frame)) { }
+
+    std::string label;
+    std::string file;
+    int first_lineno;
+};
+
+bool operator==(const FrameInfo& lhs, const FrameInfo& rhs) noexcept {
+    return
+        lhs.label == rhs.label &&
+        lhs.file == rhs.file &&
+        lhs.first_lineno == rhs.first_lineno;
+}
+
+template<>
+struct std::hash<FrameInfo>
+{
+    std::size_t operator()(FrameInfo const& f) const noexcept
+    {
+        return
+            std::hash<std::string>{}(f.label) ^
+            std::hash<std::string>{}(f.file) ^
+            f.first_lineno;
     }
+};
 
-    VALUE file() const {
-        VALUE file = absolute_path();
-        return NIL_P(file) ? path() : file;
+
+struct Frame {
+    VALUE frame;
+    int line;
+
+    FrameInfo info() const {
+        return FrameInfo(frame);
     }
+};
 
-    VALUE first_lineno() const {
-        return rb_profile_frame_first_lineno(frame);
+bool operator==(const Frame& lhs, const Frame& rhs) noexcept {
+    return lhs.frame == rhs.frame && lhs.line == rhs.line;
+}
+
+template<>
+struct std::hash<Frame>
+{
+    std::size_t operator()(Frame const& s) const noexcept
+    {
+        return s.frame ^ s.line;
     }
 };
 
-struct Stack {
+struct BaseStack {
+    virtual ~BaseStack() {};
+
+    virtual int size() const = 0;
+};
+
+struct Stack : public BaseStack {
     std::unique_ptr<VALUE[]> frames;
     std::unique_ptr<int[]> lines;
     int _size = 0;
@@ -51,28 +105,51 @@ struct Stack {
         std::copy_n(_lines, size, &lines[0]);
     }
 
+    Stack(const Stack &s) :
+        _size(s.size()),
+        frames(std::make_unique<VALUE[]>(s.size())),
+        lines(std::make_unique<int[]>(s.size()))
+    {
+        std::copy_n(&s.frames[0], s.size(), &frames[0]);
+        std::copy_n(&s.lines[0], s.size(), &lines[0]);
+    }
+
     Frame frame(int i) const {
         if (i >= size()) throw std::out_of_range("nope");
         return Frame{frames[i], lines[i]};
     }
 };
 
-std::ostream& operator<<(std::ostream& os, const Frame& frame)
-{
-    VALUE label = frame.full_label();
-    VALUE file = frame.absolute_path();
-    const char *file_cstr = NIL_P(file) ? "" : StringValueCStr(file);
-    os << file_cstr << ":" << frame.line << ":in `" << StringValueCStr(label) << "'";
-    return os;
+bool operator==(const Stack& lhs, const Stack& rhs) noexcept {
+    return lhs.size() == rhs.size() &&
+        std::equal(&lhs.frames[0], &lhs.frames[lhs.size()], &rhs.frames[0]) &&
+        std::equal(&lhs.lines[0], &lhs.lines[lhs.size()], &rhs.lines[0]);
 }
 
-std::ostream& operator<<(std::ostream& os, const Stack& stack)
+// https://xoshiro.di.unimi.it/splitmix64.c
+// https://nullprogram.com/blog/2018/07/31/
+uint64_t
+hash64(uint64_t x)
 {
-    for (int i = 0; i < stack.size(); i++) {
-        Frame frame = stack.frame(i);
-        os << frame << "\n";
-    }
-
-    return os;
+    x ^= x >> 16;
+    x *= 0x7feb352dU;
+    x ^= x >> 15;
+    x *= 0x846ca68bU;
+    x ^= x >> 16;
+    return x;
 }
 
+template<>
+struct std::hash<Stack>
+{
+    std::size_t operator()(Stack const& s) const noexcept
+    {
+        size_t hash = 0;
+        for (int i = 0; i < s.size(); i++) {
+            VALUE frame = s.frames[i];
+            hash ^= frame;
+            hash = hash64(hash);
+        }
+        return hash;
+    }
+};