vernier 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb417258dead5051e93582f97ab76914610d5b76a401fca448726e030a0a87ea
-  data.tar.gz: 44e4270b2bbd665a464094b6484d7c3a3be41eebfab288c4258ab01038f73aab
+  metadata.gz: 97eadc619870ae964e5bf61e925791d4399c0480775aadc5af31597535ae0374
+  data.tar.gz: 5327fd25cfac20752905f89126e8f6a4422e8cc90c134bab98a47b7132f7909d
 SHA512:
-  metadata.gz: 56c65be290cfbb04be65159dc166e54902d9b4ecb1b2870247c60c7e8c8a4bd9a107ef824ae29dd0279001765e9b24ae0acc4df1991375312dec92d477a5ce64
-  data.tar.gz: e4bebe5150e4cd3c8e67ee67907f061e404be84d3f6c202e3466b33e267861b8d5a2e6e573dbdc05801a500bf003182dd542063506e91986805de8c76856094f
+  metadata.gz: f0fd5a598a03f41a0d5984d4652f3f85dece310ca83c015b554b85271cda220ca2535c198d4d62dad39532861ff38c858cb1048e46c29a43ce25c4fcb318ba7f
+  data.tar.gz: d7e0462723a56f1e7a1cef5c96f2a86958df9b129442defa7814c2b5dc8d2844a1507abf0ea486d7a0458257347e9cf243d6f369568258bbdde0fa374a9d7268

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    vernier (0.0.0)
+    vernier (0.1.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,28 +1,25 @@
 # Vernier
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/vernier`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Experimental Ruby profiling tool
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
 ```ruby
 gem 'vernier'
 ```
 
-And then execute:
+## Usage
 
-    $ bundle install
+Record a flamegraph of all **retained** allocations from requiring `irb`.
 
-Or install it yourself as:
+```
+ruby -r vernier -e 'Vernier.trace_retained(out: "irb.stackcollapse") { require "irb" }'
+```
 
-    $ gem install vernier
+The output can then be viewed in speedscope or other flamegraph tools
 
-## Usage
+<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">
 
-TODO: Write usage instructions here
 
 ## Development
 

data/ext/vernier/extconf.rb

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

data/ext/vernier/stack.hh

@@ -0,0 +1,78 @@
+#pragma once
+
+#include "ruby/debug.h"
+
+#include <iostream>
+#include <vector>
+#include <memory>
+#include <algorithm>
+
+struct Frame {
+    VALUE frame;
+    int line;
+
+    VALUE full_label() const {
+        return rb_profile_frame_full_label(frame);
+    }
+
+    VALUE absolute_path() const {
+        return rb_profile_frame_absolute_path(frame);
+    }
+
+    VALUE path() const {
+        return rb_profile_frame_path(frame);
+    }
+
+    VALUE file() const {
+        VALUE file = absolute_path();
+        return NIL_P(file) ? path() : file;
+    }
+
+    VALUE first_lineno() const {
+        return rb_profile_frame_first_lineno(frame);
+    }
+};
+
+struct Stack {
+    std::unique_ptr<VALUE[]> frames;
+    std::unique_ptr<int[]> lines;
+    int _size = 0;
+
+    int size() const {
+        return _size;
+    }
+
+    Stack(const VALUE *_frames, const int *_lines, int size) :
+        _size(size),
+        frames(std::make_unique<VALUE[]>(size)),
+        lines(std::make_unique<int[]>(size))
+    {
+        std::copy_n(_frames, size, &frames[0]);
+        std::copy_n(_lines, 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;
+}
+
+std::ostream& operator<<(std::ostream& os, const Stack& stack)
+{
+    for (int i = 0; i < stack.size(); i++) {
+        Frame frame = stack.frame(i);
+        os << frame << "\n";
+    }
+
+    return os;
+}
+

data/ext/vernier/vernier.cc

@@ -0,0 +1,188 @@
+#include <iostream>
+#include <vector>
+#include <memory>
+#include <algorithm>
+#include <sstream>
+#include <unordered_map>
+
+#include "vernier.hh"
+#include "stack.hh"
+#include "ruby/debug.h"
+
+using namespace std;
+
+#define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
+
+static VALUE rb_mVernier;
+
+struct retained_collector {
+    int allocated_objects = 0;
+    int freed_objects = 0;
+
+    std::unordered_map<VALUE, std::unique_ptr<Stack>> object_frames;
+};
+
+struct TraceArg {
+    rb_trace_arg_t *tparg;
+    VALUE obj;
+    VALUE path;
+    VALUE line;
+    VALUE mid;
+    VALUE klass;
+
+    TraceArg(VALUE tpval) {
+        tparg = rb_tracearg_from_tracepoint(tpval);
+        obj = rb_tracearg_object(tparg);
+        path = rb_tracearg_path(tparg);
+        line = rb_tracearg_lineno(tparg);
+        mid = rb_tracearg_method_id(tparg);
+        klass = rb_tracearg_defined_class(tparg);
+    }
+};
+
+static retained_collector _collector;
+
+static VALUE tp_newobj;
+static VALUE tp_freeobj;
+static void
+newobj_i(VALUE tpval, void *data) {
+    retained_collector *collector = static_cast<retained_collector *>(data);
+    TraceArg tp(tpval);
+    collector->allocated_objects++;
+
+    VALUE frames_buffer[2048];
+    int lines_buffer[2048];
+    int n = rb_profile_frames(0, 2048, frames_buffer, lines_buffer);
+
+    collector->object_frames.emplace(
+            tp.obj,
+            make_unique<Stack>(frames_buffer, lines_buffer, n)
+            );
+}
+
+static void
+freeobj_i(VALUE tpval, void *data) {
+    retained_collector *collector = static_cast<retained_collector *>(data);
+    TraceArg tp(tpval);
+    collector->freed_objects++;
+
+    collector->object_frames.erase(tp.obj);
+}
+
+
+static VALUE
+trace_retained_start(VALUE self) {
+    retained_collector *collector = &_collector;
+
+    tp_newobj = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, collector);
+    tp_freeobj = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_FREEOBJ, freeobj_i, collector);
+
+    rb_tracepoint_enable(tp_newobj);
+    rb_tracepoint_enable(tp_freeobj);
+
+    return Qtrue;
+}
+
+#define sym(name) ID2SYM(rb_intern_const(name))
+
+// HACK: This isn't public, but the objspace ext uses it
+extern "C" size_t rb_obj_memsize_of(VALUE);
+
+static 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
+}
+
+static VALUE
+trace_retained_stop(VALUE self) {
+    rb_tracepoint_disable(tp_newobj);
+    rb_tracepoint_disable(tp_freeobj);
+
+    retained_collector *collector = &_collector;
+
+    std::stringstream ss;
+
+    for (auto& it: collector->object_frames) {
+        VALUE obj = it.first;
+        const Stack &stack = *it.second;
+
+        for (int i = stack.size() - 1; i >= 0; i--) {
+            const Frame &frame = stack.frame(i);
+            ss << frame;
+            if (i > 0) ss << ";";
+        }
+        ss << ";" << ruby_object_type_name(obj);
+        ss << " " << rb_obj_memsize_of(obj) << endl;
+    }
+
+    std::string s = ss.str();
+    VALUE str = rb_str_new(s.c_str(), s.size());
+
+    return str;
+}
+
+static void
+retained_collector_mark(void *data) {
+    retained_collector *collector = static_cast<retained_collector *>(data);
+
+    // We don't mark the objects, but we MUST mark the frames, otherwise they
+    // can be garbage collected.
+    // This may lead to method entries being unnecessarily retained.
+    for (auto& it: collector->object_frames) {
+        const Stack &stack = *it.second;
+
+        for (int i = 0; i < stack.size(); i++) {
+            rb_gc_mark(stack.frames[i]);
+        }
+    }
+}
+
+extern "C" void
+Init_vernier(void)
+{
+  rb_mVernier = rb_define_module("Vernier");
+
+  rb_define_module_function(rb_mVernier, "trace_retained_start", trace_retained_start, 0);
+  rb_define_module_function(rb_mVernier, "trace_retained_stop", trace_retained_stop, 0);
+
+  static VALUE gc_hook = Data_Wrap_Struct(rb_cObject, retained_collector_mark, NULL, &_collector);
+  rb_global_variable(&gc_hook);
+}

data/lib/vernier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Vernier
-  VERSION = "0.0.0"
+  VERSION = "0.1.0"
 end

data/lib/vernier.rb

@@ -5,5 +5,15 @@ require_relative "vernier/vernier"
 
 module Vernier
   class Error < StandardError; end
-  # Your code goes here...
+
+  def self.trace_retained(out: nil, gc: true)
+    3.times { GC.start } if gc
+    Vernier.trace_retained_start
+    yield
+    3.times { GC.start } if gc
+    result = Vernier.trace_retained_stop
+
+    File.write(out, result) if out
+    result
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vernier
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-26 00:00:00.000000000 Z
+date: 2022-04-27 00:00:00.000000000 Z
 dependencies: []
 description: An experimental profiler
 email:
@@ -27,8 +27,9 @@ files:
 - bin/console
 - bin/setup
 - ext/vernier/extconf.rb
-- ext/vernier/vernier.c
-- ext/vernier/vernier.h
+- ext/vernier/stack.hh
+- ext/vernier/vernier.cc
+- ext/vernier/vernier.hh
 - lib/vernier.rb
 - lib/vernier/version.rb
 - sig/vernier.rbs

data/ext/vernier/vernier.c

@@ -1,9 +0,0 @@
-#include "vernier.h"
-
-VALUE rb_mVernier;
-
-void
-Init_vernier(void)
-{
-  rb_mVernier = rb_define_module("Vernier");
-}