vernier 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: faf587f758e0b9a68adc377bf27c0f35eb0605703b088e3e122f969f513c864d
-  data.tar.gz: 6cbefbfa78fb3ef1e92c7cfdd5ba0dd43f59b1f63cce6583fe18f4e667fd61db
+  metadata.gz: b3847eff8849b364e1cd777058a720d4960e7058c4895c86ded9c5f98d053e76
+  data.tar.gz: 306275958737222981ec6fd45846b210b757bc858feee84533dbc45b3997d471
 SHA512:
-  metadata.gz: 402ce92fbe0f408906fe368e0e2edc637dd68f08476a690877166cb1628068fd6bbfd11878d625276e8f3f785c20adc49ef19494d9e81162d201930b4c64c81f
-  data.tar.gz: 8b7d6c687873ed991b23a508231471b445d6960b47bac2045f1f9eee9f5d82584490a0278f2344d0001e3f5367fffcdfc29fbc284bed448c4155e4381aa26292
+  metadata.gz: 803e19370d96f59ddf2668fadd2c4f0318c98d60576ad9f34a7a229495c6c9185d5fa5bc461b998722ca83979fb05a9007120efeaa206a734eff05bb0e3b864e
+  data.tar.gz: 3bab21c2bcb0cdaf82287cd7fbe9a619bba3bdf0658d6ec3cdd7d9b7cdae6feec5f43f1cc2056dd86af31fdf19794173e12d651fd26620f5e05304f7aa1ecf5b

data/README.md

@@ -22,7 +22,7 @@ Rails benchmark - lobste.rs (time)
 
 ## Installation
 
-Vernier requires Ruby version 3.2.1 or greater.
+Vernier requires Ruby version 3.2.1 or greater and a Unix-like operating system.
 
 ```ruby
 gem "vernier", "~> 1.0"
@@ -30,7 +30,7 @@ gem "vernier", "~> 1.0"
 
 ## Usage
 
-The output can be viewed in the web app at https://vernier.prof, locally using the [`profile-viewer` gem](https://github.com/tenderlove/profiler/tree/ruby) (both lightly customized versions of the firefox profiler frontend, which profiles are also compatible with) or by using the `vernier view` command in the CLI.
+The output can be viewed in the web app at https://vernier.prof, locally using the [`profile-viewer` gem](https://github.com/tenderlove/profiler/tree/ruby) (both lightly customized versions of the firefox profiler frontend which profiles are compatible with), or by using the `vernier view` command in the CLI.
 
 - **Flame Graph**: Shows proportionally how much time is spent within particular stack frames. Frames are grouped together, which means that x-axis / left-to-right order is not meaningful.
 - **Stack Chart**: Shows the stack at each sample with the x-axis representing time and can be read left-to-right.
@@ -41,14 +41,14 @@ The output can be viewed in the web app at https://vernier.prof, locally using t
 
 The easiest way to record a program or script is via the CLI:
 
-```
+```sh
 $ vernier run -- ruby -e 'sleep 1'
 starting profiler with interval 500 and allocation interval 0
 #<Vernier::Result 1.001589 seconds, 1 threads, 1 samples, 1 unique>
 written to /tmp/profile20240328-82441-gkzffc.vernier.json.gz
 ```
 
-```
+```sh
 $ vernier run --interval 100 --allocation-interval 10 -- ruby -e '10.times { Object.new }'
 starting profiler with interval 100 and allocation interval 10
 #<Vernier::Result 0.00067 seconds, 1 threads, 1 samples, 1 unique>
@@ -85,13 +85,39 @@ some_other_slow_method
 Vernier.stop_profile
 ```
 
+#### Rack middleware
+
+You can also use `Vernier::Middleware` to profile a Rack application:
+
+```ruby
+# config.ru
+
+require "vernier"
+
+use Vernier::Middleware
+
+run ->(env) { [200, { "Content-Type" => "text/plain" }, ["Hello, Profiling World!"]] }
+```
+
+If you're using Rails, you can add the middleware to your `config/application.rb`:
+
+```ruby
+config.middleware.use Vernier::Middleware, permit: ->(env) { env["PATH_INFO"].start_with?("/api") }
+```
+
+You can then enable profiling and configure options with query parameters:
+
+```sh
+curl http://localhost:3000?vernier=true&vernier_interval=100&vernier_allocation_interval=10
+```
+
 ### Retained memory
 
 #### Block of code
 
 Record a flamegraph of all **retained** allocations from loading `irb`:
 
-```
+```sh
 ruby -r vernier -e 'Vernier.trace_retained(out: "irb_profile.json") { require "irb" }'
 ```
 
@@ -100,13 +126,13 @@ ruby -r vernier -e 'Vernier.trace_retained(out: "irb_profile.json") { require "i
 
 ### Options
 
-Option | Description
-:- | :-
-`mode` | The sampling mode to use. One of `:wall`, `:retained` or `:custom`. Default is `:wall`.
-`out` | The file to write the profile to.
-`interval` | The sampling interval in microseconds. Default is `500`. Only available in `:wall` mode.
-`allocation_interval` | The allocation sampling interval in number of allocations. Default is `0` (disabled). Only available in `:wall` mode.
-`gc` | Initiate a full and immediate garbage collection cycle before profiling. Default is `true`. Only available in `:retained` mode.
+| Option                | Middleware Param              | Description                                                   | Default (Middleware Default) |
+|-----------------------|-------------------------------|---------------------------------------------------------------|------------------------------|
+| `mode`                | N/A                           | Sampling mode: `:wall`, `:retained`, or `:custom`.            | `:wall` (`:wall`)            |
+| `out`                 | N/A                           | File to write the profile to.                                 | N/A (Auto-generated)         |
+| `interval`            | `vernier_interval`            | Sampling interval (µs). Only in `:wall` mode.                 | `500` (`200`)                |
+| `allocation_interval` | `vernier_allocation_interval` | Allocation sampling interval. Only in `:wall` mode.           | `0` (disabled) (`200`)       |
+| `gc`                  | N/A                           | Run full GC cycle before profiling. Only in `:retained` mode. | `true` (N/A)                 |
 
 ## Development
 

data/examples/fiber_stalls.rb

@@ -0,0 +1,51 @@
+require "bundler/inline"
+gemfile do
+  source 'https://rubygems.org'
+
+  gem "async"
+end
+
+require "async"
+require "async/queue"
+
+def measure
+  x = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  yield
+  Process.clock_gettime(Process::CLOCK_MONOTONIC) - x
+end
+
+def fib(n)
+  if n < 2
+    n
+  else
+    fib(n-2) + fib(n-1)
+  end
+end
+
+# find fib that takes ~50ms
+fib_i = 50.times.find { |i| measure { fib(i) } >= 0.05 }
+sleep_i = measure { fib(fib_i) }
+
+Async {
+  latch = Async::Queue.new
+
+  workers = [
+    Async {
+      latch.pop # block until ready to measure
+
+      100.times {
+        sleep(sleep_i)
+        # stalls happen here. This worker wants to be scheduled so it can
+        # continue the loop, but will be blocked by another worker executing fib
+      }
+    },
+    Async {
+      latch.pop # block until ready to measure
+
+      100.times { fib(fib_i) }
+    },
+  ]
+
+  2.times { latch << nil }
+  workers.each(&:wait)
+}

data/exe/vernier

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
 require "optparse"
 require "vernier/version"
 
@@ -18,6 +20,9 @@ FLAGS:
         o.on('--output [FILENAME]', String, "output filename") do |s|
           options[:output] = s
         end
+        o.on('--output-dir [DIRECTORY]', String, "output directory (default .)") do |s|
+          options[:output_dir] = s
+        end
         o.on('--interval [MICROSECONDS]', Integer, "sampling interval (default 500)") do |i|
           options[:interval] = i
         end
@@ -52,60 +57,14 @@ FLAGS:
 
     def self.inverted_tree(top, file)
       # Print the inverted tree from a Vernier profile
-      require "json"
-
-      is_gzip = File.binread(file, 2) == "\x1F\x8B".b # check for gzip header
-
-      json = if is_gzip
-        require "zlib"
-        Zlib::GzipReader.open(file) { |gz| gz.read }
-      else
-        File.read file
-      end
-
-      info = JSON.load json
-
-      main = info["threads"].find { |thread| thread["isMainThread"] }
-
-      weight_by_frame = Hash.new(0)
-
-      stack_frames = main["stackTable"]["frame"]
-      frame_table = main["frameTable"]["func"]
-      func_table = main["funcTable"]["name"]
-      string_array = main["stringArray"]
+      require "vernier/parsed_profile"
+      require "vernier/output/top"
+      require "vernier/output/file_listing"
 
-      main["samples"]["stack"].zip(main["samples"]["weight"]).each do |stack, weight|
-        top_frame_index = stack_frames[stack]
-        func_index = frame_table[top_frame_index]
-        string_index = func_table[func_index]
-        str = string_array[string_index]
-        weight_by_frame[str] += weight
-      end
-
-      total = weight_by_frame.values.inject :+
-
-      header = ["Samples", "%", ""]
-      widths = header.map(&:bytesize)
-
-      columns = weight_by_frame.sort_by { |k,v| v }.reverse.first(top).map { |k,v|
-        entry = [v.to_s, ((v / total.to_f) * 100).round(1).to_s, k]
-        entry.each_with_index { |str, i| widths[i] = str.bytesize if widths[i] < str.bytesize }
-        entry
-      }
-
-      print_separator widths
-      print_row header, widths
-      print_separator widths
-      columns.each { print_row(_1, widths) }
-      print_separator widths
-    end
-
-    def self.print_row(list, widths)
-      puts("|" + list.map.with_index { |str, i| " " + str.ljust(widths[i] + 1) }.join("|") + "|")
-    end
+      parsed_profile = Vernier::ParsedProfile.read_file(file)
 
-    def self.print_separator(widths)
-      puts("+" + widths.map { |i| "-" * (i + 2) }.join("+") + "+")
+      puts Vernier::Output::Top.new(parsed_profile).output
+      puts Vernier::Output::FileListing.new(parsed_profile).output
     end
   end
 end

data/ext/vernier/extconf.rb

@@ -2,6 +2,7 @@
 
 require "mkmf"
 
+$CXXFLAGS += " -fvisibility=hidden "
 $CXXFLAGS += " -std=c++14 "
 $CXXFLAGS += " -ggdb3 -Og "
 
@@ -11,5 +12,6 @@ have_struct_member("rb_internal_thread_event_data_t", "thread", ["ruby/thread.h"
 have_func("rb_profile_thread_frames", "ruby/debug.h")
 
 have_func("pthread_setname_np")
+have_func("pthread_condattr_setclock")
 
 create_makefile("vernier/vernier")

data/ext/vernier/memory.cc

@@ -0,0 +1,144 @@
+#include <mutex>
+#include <stdio.h>
+#include <unistd.h>
+#include <vector>
+
+#include "vernier.hh"
+#include "timestamp.hh"
+#include "periodic_thread.hh"
+
+#if defined(__APPLE__)
+
+// Based loosely on https://github.com/zombocom/get_process_mem
+#include <libproc.h>
+
+uint64_t memory_rss() {
+    pid_t pid = getpid();
+
+    struct proc_taskinfo tinfo;
+    int st = proc_pidinfo(pid, PROC_PIDTASKINFO, 0,
+                         &tinfo, sizeof(tinfo));
+
+    if (st != sizeof(tinfo)) {
+        fprintf(stderr, "VERNIER: warning: proc_pidinfo failed\n");
+        return 0;
+    }
+
+    return tinfo.pti_resident_size;
+}
+
+#elif defined(__linux__)
+
+uint64_t memory_rss() {
+    long rss = 0;
+
+    // I'd heard that you shouldn't read /proc/*/smaps with fopen and family,
+    // but maybe it's fine for statm which is much smaller and will almost
+    // certainly fit in any internal buffer.
+    FILE *file = fopen("/proc/self/statm", "r");
+    if (!file) return 0;
+    if (fscanf(file, "%*s%ld", &rss) != 1) {
+        fclose(file);
+        return 0;
+    }
+    fclose(file);
+    return rss * sysconf(_SC_PAGESIZE);
+}
+
+#else
+
+// Unsupported
+uint64_t memory_rss() {
+    return 0;
+}
+
+#endif
+
+VALUE rb_cMemoryTracker;
+
+static VALUE rb_memory_rss(VALUE self) {
+    return ULL2NUM(memory_rss());
+}
+
+class MemoryTracker : public PeriodicThread {
+    public:
+        struct Record {
+            TimeStamp timestamp;
+            uint64_t memory_rss;
+        };
+        std::vector<Record> results;
+        std::mutex mutex;
+
+        MemoryTracker() : PeriodicThread(TimeStamp::from_milliseconds(10)) {
+        }
+
+        void run_iteration() {
+            record();
+        }
+
+        void record() {
+            const std::lock_guard<std::mutex> lock(mutex);
+            results.push_back(Record{TimeStamp::Now(), memory_rss()});
+        }
+};
+
+static const rb_data_type_t rb_memory_tracker_type = {
+    .wrap_struct_name = "vernier/memory_tracker",
+    .function = {
+        //.dmemsize = memory_tracker_memsize,
+        //.dmark = memory_tracker_mark,
+        //.dfree = memory_tracker_free,
+    },
+};
+
+VALUE memory_tracker_start(VALUE self) {
+    MemoryTracker *memory_tracker;
+    TypedData_Get_Struct(self, MemoryTracker, &rb_memory_tracker_type, memory_tracker);
+    memory_tracker->start();
+    return self;
+}
+
+VALUE memory_tracker_stop(VALUE self) {
+    MemoryTracker *memory_tracker;
+    TypedData_Get_Struct(self, MemoryTracker, &rb_memory_tracker_type, memory_tracker);
+
+    memory_tracker->stop();
+    return self;
+}
+
+VALUE memory_tracker_record(VALUE self) {
+    MemoryTracker *memory_tracker;
+    TypedData_Get_Struct(self, MemoryTracker, &rb_memory_tracker_type, memory_tracker);
+    memory_tracker->record();
+    return self;
+}
+
+VALUE memory_tracker_results(VALUE self) {
+    MemoryTracker *memory_tracker;
+    TypedData_Get_Struct(self, MemoryTracker, &rb_memory_tracker_type, memory_tracker);
+    VALUE timestamps = rb_ary_new();
+    VALUE memory = rb_ary_new();
+    for (const auto& record: memory_tracker->results) {
+        rb_ary_push(timestamps, ULL2NUM(record.timestamp.nanoseconds()));
+        rb_ary_push(memory, ULL2NUM(record.memory_rss));
+    }
+    return rb_ary_new_from_args(2, timestamps, memory);
+}
+
+VALUE memory_tracker_alloc(VALUE self) {
+    auto memory_tracker = new MemoryTracker();
+    VALUE obj = TypedData_Wrap_Struct(self, &rb_memory_tracker_type, memory_tracker);
+    return obj;
+}
+
+void Init_memory() {
+  rb_cMemoryTracker = rb_define_class_under(rb_mVernier, "MemoryTracker", rb_cObject);
+  rb_define_alloc_func(rb_cMemoryTracker, memory_tracker_alloc);
+
+  rb_define_method(rb_cMemoryTracker, "start", memory_tracker_start, 0);
+  rb_define_method(rb_cMemoryTracker, "stop", memory_tracker_stop, 0);
+  rb_define_method(rb_cMemoryTracker, "results", memory_tracker_results, 0);
+  rb_define_method(rb_cMemoryTracker, "record", memory_tracker_record, 0);
+
+  rb_define_singleton_method(rb_mVernier, "memory_rss", rb_memory_rss, 0);
+}

data/ext/vernier/periodic_thread.hh

@@ -0,0 +1,141 @@
+#include "ruby.h"
+
+#include <atomic>
+#include "timestamp.hh"
+
+#ifdef __APPLE__
+
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#include <pthread.h>
+
+// https://developer.apple.com/library/archive/technotes/tn2169/_index.html
+inline void upgrade_thread_priority(pthread_t pthread) {
+    mach_timebase_info_data_t timebase_info;
+    mach_timebase_info(&timebase_info);
+
+    const uint64_t NANOS_PER_MSEC = 1000000ULL;
+    double clock2abs = ((double)timebase_info.denom / (double)timebase_info.numer) * NANOS_PER_MSEC;
+
+    thread_time_constraint_policy_data_t policy;
+    policy.period      = 0;
+
+    // FIXME: I really don't know what these value should be
+    policy.computation = (uint32_t)(5 * clock2abs); // 5 ms of work
+    policy.constraint  = (uint32_t)(10 * clock2abs);
+    policy.preemptible = FALSE;
+
+    int kr = thread_policy_set(pthread_mach_thread_np(pthread_self()),
+                   THREAD_TIME_CONSTRAINT_POLICY,
+                   (thread_policy_t)&policy,
+                   THREAD_TIME_CONSTRAINT_POLICY_COUNT);
+
+    if (kr != KERN_SUCCESS) {
+        mach_error("thread_policy_set:", kr);
+        exit(1);
+    }
+}
+#else
+inline void upgrade_thread_priority(pthread_t pthread) {
+}
+#endif
+
+class PeriodicThread {
+    pthread_t pthread;
+    TimeStamp interval;
+
+    pthread_mutex_t running_mutex = PTHREAD_MUTEX_INITIALIZER;
+    pthread_cond_t running_cv;
+    std::atomic_bool running;
+
+    public:
+        PeriodicThread(TimeStamp interval) : interval(interval), running(false) {
+            pthread_condattr_t attr;
+            pthread_condattr_init(&attr);
+#if HAVE_PTHREAD_CONDATTR_SETCLOCK
+            pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
+#endif
+            pthread_cond_init(&running_cv, &attr);
+        }
+
+        void set_interval(TimeStamp timestamp) {
+            interval = timestamp;
+        }
+
+        static void *thread_entrypoint(void *arg) {
+            upgrade_thread_priority(pthread_self());
+
+            static_cast<PeriodicThread *>(arg)->run();
+            return NULL;
+        }
+
+        void run() {
+#if HAVE_PTHREAD_SETNAME_NP
+#ifdef __APPLE__
+        pthread_setname_np("Vernier profiler");
+#else
+        pthread_setname_np(pthread_self(), "Vernier profiler");
+#endif
+#endif
+
+            TimeStamp next_sample_schedule = TimeStamp::Now();
+            bool done = false;
+            while (!done) {
+                TimeStamp sample_complete = TimeStamp::Now();
+
+                run_iteration();
+
+                next_sample_schedule += interval;
+
+                if (next_sample_schedule < sample_complete) {
+                    next_sample_schedule = sample_complete + interval;
+                }
+
+                pthread_mutex_lock(&running_mutex);
+                if (running) {
+#if HAVE_PTHREAD_CONDATTR_SETCLOCK
+                    struct timespec next_sample_ts = next_sample_schedule.timespec();
+#else
+                    auto offset = TimeStamp::NowRealtime() - TimeStamp::Now();
+                    struct timespec next_sample_ts = (next_sample_schedule + offset).timespec();
+#endif
+                    int ret;
+                    do {
+                        ret = pthread_cond_timedwait(&running_cv, &running_mutex, &next_sample_ts);
+                    } while(running && ret == EINTR);
+                }
+                done = !running;
+                pthread_mutex_unlock(&running_mutex);
+            }
+        }
+
+        virtual void run_iteration() = 0;
+
+        void start() {
+            pthread_mutex_lock(&running_mutex);
+            if (!running) {
+                running = true;
+
+                int ret = pthread_create(&pthread, NULL, &thread_entrypoint, this);
+                if (ret != 0) {
+                    perror("pthread_create");
+                    rb_bug("VERNIER: pthread_create failed");
+                }
+            }
+            pthread_mutex_unlock(&running_mutex);
+        }
+
+        void stop() {
+            pthread_mutex_lock(&running_mutex);
+            bool was_running = running;
+            if (running) {
+                running = false;
+                pthread_cond_broadcast(&running_cv);
+            }
+            pthread_mutex_unlock(&running_mutex);
+            if (was_running)
+                pthread_join(pthread, NULL);
+            pthread = 0;
+        }
+};
+

data/ext/vernier/signal_safe_semaphore.hh

@@ -0,0 +1,72 @@
+#ifndef SIGNAL_SAFE_SEMAPHORE_HH
+#define SIGNAL_SAFE_SEMAPHORE_HH
+
+#if defined(__APPLE__)
+/* macOS */
+#include <dispatch/dispatch.h>
+#elif defined(__FreeBSD__)
+/* FreeBSD */
+#include <pthread_np.h>
+#include <semaphore.h>
+#else
+/* Linux */
+#include <semaphore.h>
+#include <sys/syscall.h> /* for SYS_gettid */
+#endif
+
+// A basic semaphore built on sem_wait/sem_post
+// post() is guaranteed to be async-signal-safe
+class SignalSafeSemaphore {
+#ifdef __APPLE__
+    dispatch_semaphore_t sem;
+#else
+    sem_t sem;
+#endif
+
+    public:
+
+    SignalSafeSemaphore(unsigned int value = 0) {
+#ifdef __APPLE__
+        sem = dispatch_semaphore_create(value);
+#else
+        sem_init(&sem, 0, value);
+#endif
+    };
+
+    ~SignalSafeSemaphore() {
+#ifdef __APPLE__
+        dispatch_release(sem);
+#else
+        sem_destroy(&sem);
+#endif
+    };
+
+    void wait() {
+#ifdef __APPLE__
+        dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+#else
+        // Use sem_timedwait so that we get a crash instead of a deadlock for
+        // easier debugging
+        struct timespec ts = (TimeStamp::NowRealtime() + TimeStamp::from_seconds(5)).timespec();
+
+        int ret;
+        do {
+            ret = sem_timedwait(&sem, &ts);
+        } while (ret && errno == EINTR);
+        if (ret != 0) {
+            rb_bug("VERNIER: sem_timedwait waited over 5 seconds");
+        }
+        assert(ret == 0);
+#endif
+    }
+
+    void post() {
+#ifdef __APPLE__
+        dispatch_semaphore_signal(sem);
+#else
+        sem_post(&sem);
+#endif
+    }
+};
+
+#endif