vernier 1.4.0 → 1.5.0

data/ext/vernier/vernier.cc

@@ -14,20 +14,11 @@
 
 #include <sys/time.h>
 #include <signal.h>
-#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
 
 #include "vernier.hh"
+#include "timestamp.hh"
+#include "periodic_thread.hh"
+#include "signal_safe_semaphore.hh"
 
 #include "ruby/ruby.h"
 #include "ruby/encoding.h"
@@ -49,6 +40,7 @@
 
 #define RUBY_NORMAL_EVENTS \
   RUBY_EVENT_THREAD_BEGIN | \
+  RUBY_EVENT_FIBER_SWITCH | \
   RUBY_EVENT_THREAD_END
 
 #define sym(name) ID2SYM(rb_intern_const(name))
@@ -58,13 +50,13 @@ extern "C" size_t rb_obj_memsize_of(VALUE);
 
 using namespace std;
 
-static VALUE rb_mVernier;
+VALUE rb_mVernier;
 static VALUE rb_cVernierResult;
 static VALUE rb_mVernierMarkerType;
 static VALUE rb_cVernierCollector;
 static VALUE rb_cStackTable;
 
-static VALUE sym_state, sym_gc_by;
+static VALUE sym_state, sym_gc_by, sym_fiber_id;
 
 static const char *gvl_event_name(rb_event_flag_t event) {
     switch (event) {
@@ -82,129 +74,6 @@ static const char *gvl_event_name(rb_event_flag_t event) {
     return "no-event";
 }
 
-class TimeStamp {
-    static const uint64_t nanoseconds_per_second = 1000000000;
-    uint64_t value_ns;
-
-    TimeStamp(uint64_t value_ns) : value_ns(value_ns) {}
-
-    public:
-    TimeStamp() : value_ns(0) {}
-
-    static TimeStamp Now() {
-        struct timespec ts;
-        clock_gettime(CLOCK_MONOTONIC, &ts);
-        return TimeStamp(ts.tv_sec * nanoseconds_per_second + ts.tv_nsec);
-    }
-
-    static TimeStamp Zero() {
-        return TimeStamp(0);
-    }
-
-    // SleepUntil a specified timestamp
-    // Highly accurate manual sleep time
-    static void SleepUntil(const TimeStamp &target_time) {
-        if (target_time.zero()) return;
-        struct timespec ts = target_time.timespec();
-
-        int res;
-        do {
-            // do nothing until it's time :)
-            sleep(0);
-        } while (target_time > TimeStamp::Now());
-    }
-
-    static TimeStamp from_seconds(uint64_t s) {
-        return TimeStamp::from_milliseconds(s * 1000);
-    }
-
-    static TimeStamp from_milliseconds(uint64_t ms) {
-        return TimeStamp::from_microseconds(ms * 1000);
-    }
-
-    static TimeStamp from_microseconds(uint64_t us) {
-        return TimeStamp::from_nanoseconds(us * 1000);
-    }
-
-    static TimeStamp from_nanoseconds(uint64_t ns) {
-        return TimeStamp(ns);
-    }
-
-    TimeStamp operator-(const TimeStamp &other) const {
-        TimeStamp result = *this;
-        return result -= other;
-    }
-
-    TimeStamp &operator-=(const TimeStamp &other) {
-        if (value_ns > other.value_ns) {
-            value_ns = value_ns - other.value_ns;
-        } else {
-            // underflow
-            value_ns = 0;
-        }
-        return *this;
-    }
-
-    TimeStamp operator+(const TimeStamp &other) const {
-        TimeStamp result = *this;
-        return result += other;
-    }
-
-    TimeStamp &operator+=(const TimeStamp &other) {
-        uint64_t new_value = value_ns + other.value_ns;
-        value_ns = new_value;
-        return *this;
-    }
-
-    bool operator<(const TimeStamp &other) const {
-        return value_ns < other.value_ns;
-    }
-
-    bool operator<=(const TimeStamp &other) const {
-        return value_ns <= other.value_ns;
-    }
-
-    bool operator>(const TimeStamp &other) const {
-        return value_ns > other.value_ns;
-    }
-
-    bool operator>=(const TimeStamp &other) const {
-        return value_ns >= other.value_ns;
-    }
-
-    bool operator==(const TimeStamp &other) const {
-        return value_ns == other.value_ns;
-    }
-
-    bool operator!=(const TimeStamp &other) const {
-        return value_ns != other.value_ns;
-    }
-
-    uint64_t nanoseconds() const {
-        return value_ns;
-    }
-
-    uint64_t microseconds() const {
-        return value_ns / 1000;
-    }
-
-    bool zero() const {
-        return value_ns == 0;
-    }
-
-    struct timespec timespec() const {
-        struct timespec ts;
-        ts.tv_sec = nanoseconds() / nanoseconds_per_second;
-        ts.tv_nsec = (nanoseconds() % nanoseconds_per_second);
-        return ts;
-    }
-};
-
-std::ostream& operator<<(std::ostream& os, const TimeStamp& info) {
-    os << info.nanoseconds() << "ns";
-    return os;
-}
-
 // TODO: Rename FuncInfo
 struct FrameInfo {
     static const char *label_cstr(VALUE frame) {
@@ -269,58 +138,6 @@ namespace std {
     };
 }
 
-// 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
-        auto ts = (TimeStamp::Now() + TimeStamp::from_seconds(5)).timespec();
-
-        int ret;
-        do {
-            ret = sem_wait(&sem);
-        } while (ret && errno == EINTR);
-        assert(ret == 0);
-#endif
-    }
-
-    void post() {
-#ifdef __APPLE__
-        dispatch_semaphore_signal(sem);
-#else
-        sem_post(&sem);
-#endif
-    }
-};
-
 class RawSample {
     public:
 
@@ -854,25 +671,35 @@ union MarkerInfo {
         VALUE gc_by;
         VALUE gc_state;
     } gc_data;
+    struct {
+        VALUE fiber_id;
+    } fiber_data;
 };
 
+#define EACH_MARKER(XX) \
+    XX(GVL_THREAD_STARTED) \
+    XX(GVL_THREAD_EXITED) \
+\
+    XX(GC_START) \
+    XX(GC_END_MARK) \
+    XX(GC_END_SWEEP) \
+    XX(GC_ENTER) \
+    XX(GC_EXIT) \
+    XX(GC_PAUSE) \
+\
+    XX(THREAD_RUNNING) \
+    XX(THREAD_STALLED) \
+    XX(THREAD_SUSPENDED) \
+\
+    XX(FIBER_SWITCH)
+
+
 class Marker {
     public:
     enum Type {
-        MARKER_GVL_THREAD_STARTED,
-        MARKER_GVL_THREAD_EXITED,
-
-        MARKER_GC_START,
-        MARKER_GC_END_MARK,
-        MARKER_GC_END_SWEEP,
-        MARKER_GC_ENTER,
-        MARKER_GC_EXIT,
-        MARKER_GC_PAUSE,
-
-        MARKER_THREAD_RUNNING,
-        MARKER_THREAD_STALLED,
-        MARKER_THREAD_SUSPENDED,
-
+#define XX(name) MARKER_ ## name,
+        EACH_MARKER(XX)
+#undef XX
         MARKER_MAX,
     };
 
@@ -894,29 +721,33 @@ class Marker {
 
     MarkerInfo extra_info;
 
-    VALUE to_array() {
-        VALUE record[7] = {0};
-        record[0] = Qnil; // FIXME
-        record[1] = INT2NUM(type);
-        record[2] = INT2NUM(phase);
-        record[3] = ULL2NUM(timestamp.nanoseconds());
+    VALUE to_array() const {
+        VALUE record[6] = {0};
+        record[0] = INT2NUM(type);
+        record[1] = INT2NUM(phase);
+        record[2] = ULL2NUM(timestamp.nanoseconds());
 
         if (phase == Marker::Phase::INTERVAL) {
-            record[4] = ULL2NUM(finish.nanoseconds());
+            record[3] = ULL2NUM(finish.nanoseconds());
         }
         else {
-            record[4] = Qnil;
+            record[3] = Qnil;
         }
-        record[5] = stack_index == -1 ? Qnil : INT2NUM(stack_index);
+        record[4] = stack_index == -1 ? Qnil : INT2NUM(stack_index);
 
         if (type == Marker::MARKER_GC_PAUSE) {
             VALUE hash = rb_hash_new();
-            record[6] = hash;
+            record[5] = hash;
 
             rb_hash_aset(hash, sym_gc_by, extra_info.gc_data.gc_by);
             rb_hash_aset(hash, sym_state, extra_info.gc_data.gc_state);
+        } else if (type == Marker::MARKER_FIBER_SWITCH) {
+            VALUE hash = rb_hash_new();
+            record[5] = hash;
+
+            rb_hash_aset(hash, sym_fiber_id, extra_info.fiber_data.fiber_id);
         }
-        return rb_ary_new_from_values(7, record);
+        return rb_ary_new_from_values(6, record);
     }
 };
 
@@ -934,7 +765,15 @@ class MarkerTable {
         void record(Marker::Type type, int stack_index = -1, MarkerInfo extra_info = {}) {
             const std::lock_guard<std::mutex> lock(mutex);
 
-            list.push_back({ type, Marker::INSTANT, TimeStamp::Now(), TimeStamp(), stack_index });
+            list.push_back({ type, Marker::INSTANT, TimeStamp::Now(), TimeStamp(), stack_index, extra_info });
+        }
+
+        VALUE to_array() const {
+            VALUE ary = rb_ary_new();
+            for (auto& marker: list) {
+                rb_ary_push(ary, marker.to_array());
+            }
+            return ary;
         }
 };
 
@@ -1139,6 +978,15 @@ class Thread {
             }
         }
 
+        void record_fiber(VALUE fiber, StackTable &frame_list) {
+            RawSample sample;
+            sample.sample();
+
+            int stack_idx = translator.translate(frame_list, sample);
+            VALUE fiber_id = rb_obj_id(fiber);
+            markers->record(Marker::Type::MARKER_FIBER_SWITCH, stack_idx, { .fiber_data = { .fiber_id = fiber_id } });
+        }
+
         void set_state(State new_state) {
             if (state == Thread::State::STOPPED) {
                 return;
@@ -1380,10 +1228,6 @@ class BaseCollector {
 
     virtual void compact() {
     };
-
-    virtual VALUE get_markers() {
-        return rb_ary_new();
-    };
 };
 
 class CustomCollector : public BaseCollector {
@@ -1658,6 +1502,19 @@ class GlobalSignalHandler {
 LiveSample *GlobalSignalHandler::live_sample;
 
 class TimeCollector : public BaseCollector {
+    class TimeCollectorThread : public PeriodicThread {
+        TimeCollector &time_collector;
+
+        void run_iteration() {
+            time_collector.run_iteration();
+        }
+
+        public:
+
+        TimeCollectorThread(TimeCollector &tc, TimeStamp interval) : PeriodicThread(interval), time_collector(tc) {
+        };
+    };
+
     GCMarkerTable gc_markers;
     ThreadTable threads;
 
@@ -1680,8 +1537,10 @@ class TimeCollector : public BaseCollector {
         collector->record_newobj(obj);
     }
 
+    TimeCollectorThread collector_thread;
+
     public:
-    TimeCollector(VALUE stack_table, TimeStamp interval, unsigned int allocation_interval) : BaseCollector(stack_table), interval(interval), allocation_interval(allocation_interval), threads(*get_stack_table(stack_table)) {
+    TimeCollector(VALUE stack_table, TimeStamp interval, unsigned int allocation_interval) : BaseCollector(stack_table), interval(interval), allocation_interval(allocation_interval), threads(*get_stack_table(stack_table)), collector_thread(*this, interval) {
     }
 
     void record_newobj(VALUE obj) {
@@ -1703,6 +1562,18 @@ class TimeCollector : public BaseCollector {
 
     }
 
+    void record_fiber(VALUE th, VALUE fiber) {
+        threads.mutex.lock();
+        for (auto &threadptr : threads.list) {
+            auto &thread = *threadptr;
+            if (th == thread.ruby_thread) {
+                thread.record_fiber(fiber, threads.frame_list);
+                break;
+            }
+        }
+        threads.mutex.unlock();
+    }
+
     void write_meta(VALUE meta, VALUE result) {
         BaseCollector::write_meta(meta, result);
         rb_hash_aset(meta, sym("interval"), ULL2NUM(interval.microseconds()));
@@ -1723,103 +1594,55 @@ class TimeCollector : public BaseCollector {
         }
     }
 
-    VALUE get_markers() {
-        VALUE list = rb_ary_new();
-        VALUE main_thread = rb_thread_main();
-        VALUE main_thread_id = rb_obj_id(main_thread);
-
-        for (auto& marker: this->gc_markers.list) {
-            VALUE ary = marker.to_array();
+    void run_iteration() {
+        TimeStamp sample_start = TimeStamp::Now();
 
-            RARRAY_ASET(ary, 0, main_thread_id);
-            rb_ary_push(list, ary);
-        }
-        for (auto &thread : threads.list) {
-            for (auto& marker: thread->markers->list) {
-                VALUE ary = marker.to_array();
-                RARRAY_ASET(ary, 0, thread->ruby_thread_id);
-                rb_ary_push(list, ary);
-            }
-        }
-
-        return list;
-    }
-
-    void sample_thread_run() {
         LiveSample sample;
 
-        TimeStamp next_sample_schedule = TimeStamp::Now();
-        while (running) {
-            TimeStamp sample_start = TimeStamp::Now();
-
-            threads.mutex.lock();
-            for (auto &threadptr : threads.list) {
-                auto &thread = *threadptr;
+        threads.mutex.lock();
+        for (auto &threadptr : threads.list) {
+            auto &thread = *threadptr;
 
-                //if (thread.state == Thread::State::RUNNING) {
-                //if (thread.state == Thread::State::RUNNING || (thread.state == Thread::State::SUSPENDED && thread.stack_on_suspend_idx < 0)) {
-                if (thread.state == Thread::State::RUNNING) {
-                    //fprintf(stderr, "sampling %p on tid:%i\n", thread.ruby_thread, thread.native_tid);
-                    bool signal_sent = GlobalSignalHandler::get_instance()->record_sample(sample, thread.pthread_id);
-
-                    if (!signal_sent) {
-                        // The thread has died. We probably should have caught
-                        // that by the GVL instrumentation, but let's try to get
-                        // it to a consistent state and stop profiling it.
-                        thread.set_state(Thread::State::STOPPED);
-                    } else if (sample.sample.empty()) {
-                        // fprintf(stderr, "skipping GC sample\n");
-                    } else {
-                        record_sample(sample.sample, sample_start, thread, CATEGORY_NORMAL);
-                    }
-                } else if (thread.state == Thread::State::SUSPENDED) {
-                    thread.samples.record_sample(
-                            thread.stack_on_suspend_idx,
-                            sample_start,
-                            CATEGORY_IDLE);
-                } else if (thread.state == Thread::State::READY) {
-                    thread.samples.record_sample(
-                            thread.stack_on_suspend_idx,
-                            sample_start,
-                            CATEGORY_STALLED);
+            //if (thread.state == Thread::State::RUNNING) {
+            //if (thread.state == Thread::State::RUNNING || (thread.state == Thread::State::SUSPENDED && thread.stack_on_suspend_idx < 0)) {
+            if (thread.state == Thread::State::RUNNING) {
+                //fprintf(stderr, "sampling %p on tid:%i\n", thread.ruby_thread, thread.native_tid);
+                bool signal_sent = GlobalSignalHandler::get_instance()->record_sample(sample, thread.pthread_id);
+
+                if (!signal_sent) {
+                    // The thread has died. We probably should have caught
+                    // that by the GVL instrumentation, but let's try to get
+                    // it to a consistent state and stop profiling it.
+                    thread.set_state(Thread::State::STOPPED);
+                } else if (sample.sample.empty()) {
+                    // fprintf(stderr, "skipping GC sample\n");
                 } else {
+                    record_sample(sample.sample, sample_start, thread, CATEGORY_NORMAL);
                 }
+            } else if (thread.state == Thread::State::SUSPENDED) {
+                thread.samples.record_sample(
+                        thread.stack_on_suspend_idx,
+                        sample_start,
+                        CATEGORY_IDLE);
+            } else if (thread.state == Thread::State::READY) {
+                thread.samples.record_sample(
+                        thread.stack_on_suspend_idx,
+                        sample_start,
+                        CATEGORY_STALLED);
+            } else {
             }
-
-            threads.mutex.unlock();
-
-            TimeStamp sample_complete = TimeStamp::Now();
-
-            next_sample_schedule += interval;
-
-            // If sampling falls behind, restart, and check in another interval
-            if (next_sample_schedule < sample_complete) {
-                next_sample_schedule = sample_complete + interval;
-            }
-
-            TimeStamp::SleepUntil(next_sample_schedule);
         }
 
-        thread_stopped.post();
-    }
-
-    static void *sample_thread_entry(void *arg) {
-#if HAVE_PTHREAD_SETNAME_NP
-#ifdef __APPLE__
-        pthread_setname_np("Vernier profiler");
-#else
-        pthread_setname_np(pthread_self(), "Vernier profiler");
-#endif
-#endif
-        TimeCollector *collector = static_cast<TimeCollector *>(arg);
-        collector->sample_thread_run();
-        return NULL;
+        threads.mutex.unlock();
     }
 
     static void internal_thread_event_cb(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass) {
         TimeCollector *collector = static_cast<TimeCollector *>((void *)NUM2ULL(data));
 
         switch (event) {
+            case RUBY_EVENT_FIBER_SWITCH:
+                collector->record_fiber(rb_thread_current(), rb_fiber_current());
+                break;
             case RUBY_EVENT_THREAD_BEGIN:
                 collector->threads.started(self);
                 break;
@@ -1913,11 +1736,7 @@ class TimeCollector : public BaseCollector {
 
         running = true;
 
-        int ret = pthread_create(&sample_thread, NULL, &sample_thread_entry, this);
-        if (ret != 0) {
-            perror("pthread_create");
-            rb_bug("VERNIER: pthread_create failed");
-        }
+        collector_thread.start();
 
         // Set the state of the current Ruby thread to RUNNING, which we know it
         // is as it must have held the GVL to start the collector. We want to
@@ -1936,8 +1755,7 @@ class TimeCollector : public BaseCollector {
     VALUE stop() {
         BaseCollector::stop();
 
-        running = false;
-        thread_stopped.wait();
+        collector_thread.stop();
 
         GlobalSignalHandler::get_instance()->uninstall();
 
@@ -1962,6 +1780,8 @@ class TimeCollector : public BaseCollector {
     VALUE build_collector_result() {
         VALUE result = BaseCollector::build_collector_result();
 
+        rb_ivar_set(result, rb_intern("@gc_markers"), this->gc_markers.to_array());
+
         VALUE threads = rb_hash_new();
         rb_ivar_set(result, rb_intern("@threads"), threads);
 
@@ -1969,8 +1789,7 @@ class TimeCollector : public BaseCollector {
             VALUE hash = rb_hash_new();
             thread->samples.write_result(hash);
             thread->allocation_samples.write_result(hash);
-
-            rb_hash_aset(threads, thread->ruby_thread_id, hash);
+            rb_hash_aset(hash, sym("markers"), thread->markers->to_array());
             rb_hash_aset(hash, sym("tid"), ULL2NUM(thread->native_tid));
             rb_hash_aset(hash, sym("started_at"), ULL2NUM(thread->started_at.nanoseconds()));
             if (!thread->stopped_at.zero()) {
@@ -1979,6 +1798,7 @@ class TimeCollector : public BaseCollector {
             rb_hash_aset(hash, sym("is_main"), thread->is_main() ? Qtrue : Qfalse);
             rb_hash_aset(hash, sym("is_start"), thread->is_start(BaseCollector::start_thread) ? Qtrue : Qfalse);
 
+            rb_hash_aset(threads, thread->ruby_thread_id, hash);
         }
 
         return result;
@@ -2051,13 +1871,6 @@ collector_stop(VALUE self) {
     return result;
 }
 
-static VALUE
-markers(VALUE self) {
-    auto *collector = get_collector(self);
-
-    return collector->get_markers();
-}
-
 static VALUE
 collector_sample(VALUE self) {
     auto *collector = get_collector(self);
@@ -2111,24 +1924,10 @@ static VALUE collector_new(VALUE self, VALUE mode, VALUE options) {
 
 static void
 Init_consts(VALUE rb_mVernierMarkerPhase) {
-#define MARKER_CONST(name) \
-    rb_define_const(rb_mVernierMarkerType, #name, INT2NUM(Marker::Type::MARKER_##name))
-
-    MARKER_CONST(GVL_THREAD_STARTED);
-    MARKER_CONST(GVL_THREAD_EXITED);
-
-    MARKER_CONST(GC_START);
-    MARKER_CONST(GC_END_MARK);
-    MARKER_CONST(GC_END_SWEEP);
-    MARKER_CONST(GC_ENTER);
-    MARKER_CONST(GC_EXIT);
-    MARKER_CONST(GC_PAUSE);
-
-    MARKER_CONST(THREAD_RUNNING);
-    MARKER_CONST(THREAD_STALLED);
-    MARKER_CONST(THREAD_SUSPENDED);
-
-#undef MARKER_CONST
+#define XX(name) \
+    rb_define_const(rb_mVernierMarkerType, #name, INT2NUM(Marker::Type::MARKER_##name));
+    EACH_MARKER(XX)
+#undef XX
 
 #define PHASE_CONST(name) \
     rb_define_const(rb_mVernierMarkerPhase, #name, INT2NUM(Marker::Phase::name))
@@ -2140,11 +1939,12 @@ Init_consts(VALUE rb_mVernierMarkerPhase) {
 #undef PHASE_CONST
 }
 
-extern "C" void
+extern "C" __attribute__ ((__visibility__("default"))) void
 Init_vernier(void)
 {
     sym_state = sym("state");
     sym_gc_by = sym("gc_by");
+    sym_fiber_id = sym("fiber_id");
     rb_gc_latest_gc_info(sym_state); // HACK: needs to be warmed so that it can be called during GC
 
   rb_mVernier = rb_define_module("Vernier");
@@ -2160,7 +1960,6 @@ Init_vernier(void)
   rb_define_method(rb_cVernierCollector, "sample", collector_sample, 0);
   rb_define_method(rb_cVernierCollector, "stack_table", collector_stack_table, 0);
   rb_define_private_method(rb_cVernierCollector, "finish",  collector_stop, 0);
-  rb_define_private_method(rb_cVernierCollector, "markers",  markers, 0);
 
   rb_cStackTable = rb_define_class_under(rb_mVernier, "StackTable", rb_cObject);
   rb_undef_alloc_func(rb_cStackTable);
@@ -2179,6 +1978,7 @@ Init_vernier(void)
   rb_define_method(rb_cStackTable, "func_count", StackTable::stack_table_func_count, 0);
 
   Init_consts(rb_mVernierMarkerPhase);
+  Init_memory();
 
   //static VALUE gc_hook = Data_Wrap_Struct(rb_cObject, collector_mark, NULL, &_collector);
   //rb_global_variable(&gc_hook);

data/ext/vernier/vernier.hh

@@ -3,4 +3,8 @@
 
 #include "ruby.h"
 
+extern VALUE rb_mVernier;
+
+void Init_memory();
+
 #endif /* VERNIER_H */