vernier 0.2.0 → 0.3.0

data/lib/vernier.rb

@@ -2,6 +2,7 @@
 
 require_relative "vernier/version"
 require_relative "vernier/collector"
+require_relative "vernier/result"
 require_relative "vernier/vernier"
 require_relative "vernier/output/firefox"
 require_relative "vernier/output/top"
@@ -9,135 +10,13 @@ require_relative "vernier/output/top"
 module Vernier
   class Error < StandardError; end
 
-  class Result
-    attr_reader :weights, :samples, :stack_table, :frame_table, :func_table
-    attr_reader :timestamps, :sample_threads, :sample_categories
-    attr_reader :markers
-
-    attr_accessor :pid, :start_time, :end_time
-    attr_accessor :threads
-    attr_accessor :meta
-
-    def started_at
-      meta[:started_at]
-    end
-
-    def to_gecko
-      Output::Firefox.new(self).output
-    end
-
-    def write(out:)
-      File.write(out, to_gecko)
-    end
-
-    def each_sample
-      return enum_for(__method__) unless block_given?
-      @samples.size.times do |sample_idx|
-        weight = @weights[sample_idx]
-        stack_idx = @samples[sample_idx]
-        yield stack(stack_idx), weight
-      end
-    end
-
-    class BaseType
-      attr_reader :result, :idx
-      def initialize(result, idx)
-        @result = result
-        @idx = idx
-      end
-
-      def to_s
-        idx.to_s
-      end
-
-      def inspect
-        "#<#{self.class}\n#{to_s}>"
-      end
-    end
-
-    class Func < BaseType
-      def label
-        result.func_table[:name][idx]
-      end
-      alias name label
-
-      def filename
-        result.func_table[:filename][idx]
-      end
-
-      def to_s
-        "#{name} at #{filename}"
-      end
-    end
-
-    class Frame < BaseType
-      def label; func.label; end
-      def filename; func.filename; end
-      alias name label
-
-      def func
-        func_idx = result.frame_table[:func][idx]
-        Func.new(result, func_idx)
-      end
-
-      def line
-        result.frame_table[:line][idx]
-      end
-
-      def to_s
-        "#{func}:#{line}"
-      end
-    end
-
-    class Stack < BaseType
-      def each_frame
-        return enum_for(__method__) unless block_given?
-
-        stack_idx = idx
-        while stack_idx
-          frame_idx = result.stack_table[:frame][stack_idx]
-          yield Frame.new(result, frame_idx)
-          stack_idx = result.stack_table[:parent][stack_idx]
-        end
-      end
-
-      def leaf_frame_idx
-        result.stack_table[:frame][idx]
-      end
-
-      def leaf_frame
-        Frame.new(result, leaf_frame_idx)
-      end
-
-      def frames
-        each_frame.to_a
-      end
-
-      def to_s
-        arr = []
-        each_frame do |frame|
-          arr << frame.to_s
-        end
-        arr.join("\n")
-      end
-    end
-
-    def stack(idx)
-      Stack.new(self, idx)
-    end
-
-    def total_bytes
-      @weights.sum
-    end
-  end
-
   def self.trace(mode: :wall, out: nil, interval: nil)
     collector = Vernier::Collector.new(mode, { interval: })
     collector.start
 
     result = nil
     begin
-      yield
+      yield collector
     ensure
       result = collector.stop
     end
@@ -151,20 +30,14 @@ module Vernier
   def self.trace_retained(out: nil, gc: true)
     3.times { GC.start } if gc
 
-    start_time = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
-
     collector = Vernier::Collector.new(:retained)
     collector.start
 
     result = nil
     begin
-      yield
+      yield collector
     ensure
       result = collector.stop
-      end_time = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
-      result.pid = Process.pid
-      result.start_time = start_time
-      result.end_time = end_time
     end
 
     if out

metadata

@@ -1,19 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: vernier
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-04 00:00:00.000000000 Z
+date: 2023-08-29 00:00:00.000000000 Z
 dependencies: []
 description: An experimental profiler
 email:
 - john@hawthorn.email
-executables: []
+executables:
+- vernier
 extensions:
 - ext/vernier/extconf.rb
 extra_rdoc_files: []
@@ -25,19 +26,24 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/vernier
+- examples/minitest.rb
+- examples/ractor.rb
+- examples/rails.rb
 - examples/threaded_http_requests.rb
+- exe/vernier
 - ext/vernier/extconf.rb
 - ext/vernier/ruby_type_names.h
-- ext/vernier/stack.hh
 - ext/vernier/vernier.cc
 - ext/vernier/vernier.hh
 - lib/vernier.rb
+- lib/vernier/autorun.rb
 - lib/vernier/collector.rb
 - lib/vernier/marker.rb
 - lib/vernier/output/firefox.rb
 - lib/vernier/output/top.rb
+- lib/vernier/result.rb
 - lib/vernier/version.rb
-- sig/vernier.rbs
 - vernier.gemspec
 homepage: https://github.com/jhawthorn/vernier
 licenses:

data/ext/vernier/stack.hh

@@ -1,155 +0,0 @@
-#pragma once
-
-#include "ruby/debug.h"
-
-#include <iostream>
-#include <vector>
-#include <memory>
-#include <algorithm>
-
-struct FrameInfo {
-    static const char *label_cstr(VALUE frame) {
-        VALUE label = rb_profile_frame_full_label(frame);
-        return StringValueCStr(label);
-    }
-
-    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);
-        }
-    }
-
-    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);
-    }
-
-    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;
-    }
-};
-
-
-struct Frame {
-    VALUE frame;
-    int line;
-
-    FrameInfo info() const {
-        return FrameInfo(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 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;
-
-    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]);
-    }
-
-    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]};
-    }
-};
-
-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]);
-}
-
-// https://xoshiro.di.unimi.it/splitmix64.c
-// https://nullprogram.com/blog/2018/07/31/
-uint64_t
-hash64(uint64_t x)
-{
-    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;
-    }
-};

data/sig/vernier.rbs

@@ -1,4 +0,0 @@
-module Vernier
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end