vernier 0.2.0 → 0.3.0

data/ext/vernier/vernier.cc

@@ -9,31 +9,38 @@
 #include <cassert>
 #include <atomic>
 #include <mutex>
-#include <optional>
 
 #include <sys/time.h>
 #include <signal.h>
 #ifdef __APPLE__
+/* macOS */
 #include <dispatch/dispatch.h>
 #else
+/* Linux */
 #include <semaphore.h>
+#include <sys/syscall.h> /* for SYS_gettid */
 #endif
 
 #include "vernier.hh"
-#include "stack.hh"
 
 #include "ruby/ruby.h"
 #include "ruby/debug.h"
 #include "ruby/thread.h"
 
-// GC event's we'll monitor during profiling
-#define RUBY_GC_PHASE_EVENTS \
+# define PTR2NUM(x)   (rb_int2inum((intptr_t)(void *)(x)))
+
+// Internal TracePoint events we'll monitor during profiling
+#define RUBY_INTERNAL_EVENTS \
   RUBY_INTERNAL_EVENT_GC_START | \
   RUBY_INTERNAL_EVENT_GC_END_MARK | \
   RUBY_INTERNAL_EVENT_GC_END_SWEEP | \
   RUBY_INTERNAL_EVENT_GC_ENTER | \
   RUBY_INTERNAL_EVENT_GC_EXIT
 
+#define RUBY_NORMAL_EVENTS \
+  RUBY_EVENT_THREAD_BEGIN | \
+  RUBY_EVENT_THREAD_END
+
 #define sym(name) ID2SYM(rb_intern_const(name))
 
 // HACK: This isn't public, but the objspace ext uses it
@@ -124,6 +131,14 @@ class TimeStamp {
         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;
     }
@@ -149,6 +164,73 @@ std::ostream& operator<<(std::ostream& os, const TimeStamp& info) {
     return os;
 }
 
+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;
+}
+
+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;
+}
+
+bool operator!=(const Frame& lhs, const Frame& rhs) noexcept {
+    return !(lhs == rhs);
+}
+
+namespace std {
+    template<>
+    struct hash<Frame>
+    {
+        std::size_t operator()(Frame const& s) const noexcept
+        {
+            return s.frame ^ s.line;
+        }
+    };
+}
+
 // A basic semaphore built on sem_wait/sem_post
 // post() is guaranteed to be async-signal-safe
 class SamplerSemaphore {
@@ -211,7 +293,9 @@ struct RawSample {
     }
 
     Frame frame(int i) const {
-        const Frame frame = {frames[i], lines[i]};
+        int idx = len - i - 1;
+        if (idx < 0) throw std::out_of_range("out of range");
+        const Frame frame = {frames[idx], lines[idx]};
         return frame;
     }
 
@@ -273,24 +357,6 @@ struct LiveSample {
     }
 };
 
-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);
-    }
-};
-
 struct FrameList {
     std::unordered_map<std::string, int> string_to_idx;
     std::vector<std::string> string_list;
@@ -348,27 +414,29 @@ struct FrameList {
         }
 
         StackNode *node = &root_stack_node;
-        for (int i = stack.size() - 1; i >= 0; i--) {
-            const Frame &frame = stack.frame(i);
+        for (int i = 0; i < stack.size(); i++) {
+            Frame frame = stack.frame(i);
             node = next_stack_node(node, frame);
         }
         return node->index;
     }
 
-    StackNode *next_stack_node(StackNode *node, const Frame &frame) {
-        int next_node_idx = node->children[frame];
-        if (next_node_idx == 0) {
+    StackNode *next_stack_node(StackNode *node, Frame frame) {
+        auto search = node->children.find(frame);
+        if (search == node->children.end()) {
             // insert a new node
-            next_node_idx = stack_node_list.size();
+            int next_node_idx = stack_node_list.size();
             node->children[frame] = next_node_idx;
             stack_node_list.emplace_back(
                     frame,
                     next_node_idx,
                     node->index
                     );
+            return &stack_node_list[next_node_idx];
+        } else {
+            int node_idx = search->second;
+            return &stack_node_list[node_idx];
         }
-
-        return &stack_node_list[next_node_idx];
     }
 
     // Converts Frames from stacks other tables. "Symbolicates" the frames
@@ -448,6 +516,372 @@ struct FrameList {
     }
 };
 
+class SampleTranslator {
+    public:
+        int last_stack_index;
+
+        Frame frames[RawSample::MAX_LEN];
+        int frame_indexes[RawSample::MAX_LEN];
+        int len;
+
+        SampleTranslator() : len(0), last_stack_index(-1) {
+        }
+
+        int translate(FrameList &frame_list, const RawSample &sample) {
+            int i = 0;
+            for (; i < len && i < sample.size(); i++) {
+                if (frames[i] != sample.frame(i)) {
+                    break;
+                }
+            }
+
+            FrameList::StackNode *node = i == 0 ? &frame_list.root_stack_node : &frame_list.stack_node_list[frame_indexes[i - 1]];
+
+            for (; i < sample.size(); i++) {
+                Frame frame = sample.frame(i);
+                node = frame_list.next_stack_node(node, frame);
+
+                frames[i] = frame;
+                frame_indexes[i] = node->index;
+            }
+            len = i;
+
+            last_stack_index = node->index;
+            return last_stack_index;
+        }
+};
+
+typedef uint64_t native_thread_id_t;
+static native_thread_id_t get_native_thread_id() {
+#ifdef __APPLE__
+    uint64_t thread_id;
+    int e = pthread_threadid_np(pthread_self(), &thread_id);
+    if (e != 0) rb_syserr_fail(e, "pthread_threadid_np");
+    return thread_id;
+#else
+    // gettid() is only available as of glibc 2.30
+    pid_t tid = syscall(SYS_gettid);
+    return tid;
+#endif
+}
+
+
+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,
+
+        MARKER_MAX,
+    };
+
+    // Must match phase types from Gecko
+    enum Phase {
+      INSTANT,
+      INTERVAL,
+      INTERVAL_START,
+      INTERVAL_END
+    };
+
+    Type type;
+    Phase phase;
+    TimeStamp timestamp;
+    TimeStamp finish;
+    native_thread_id_t thread_id;
+    int stack_index = -1;
+
+    VALUE to_array() {
+        VALUE record[6] = {0};
+        record[0] = ULL2NUM(thread_id);
+        record[1] = INT2NUM(type);
+        record[2] = INT2NUM(phase);
+        record[3] = ULL2NUM(timestamp.nanoseconds());
+
+        if (phase == Marker::Phase::INTERVAL) {
+            record[4] = ULL2NUM(finish.nanoseconds());
+        }
+        else {
+            record[4] = Qnil;
+        }
+        record[5] = stack_index == -1 ? Qnil : INT2NUM(stack_index);
+
+        return rb_ary_new_from_values(6, record);
+    }
+};
+
+class MarkerTable {
+    TimeStamp last_gc_entry;
+
+    public:
+        std::vector<Marker> list;
+        std::mutex mutex;
+
+        void record_gc_entered() {
+          last_gc_entry = TimeStamp::Now();
+        }
+
+        void record_gc_leave() {
+          list.push_back({ Marker::MARKER_GC_PAUSE, Marker::INTERVAL, last_gc_entry, TimeStamp::Now(), get_native_thread_id(), -1 });
+        }
+
+        void record_interval(Marker::Type type, TimeStamp from, TimeStamp to, int stack_index = -1) {
+            const std::lock_guard<std::mutex> lock(mutex);
+
+            list.push_back({ type, Marker::INTERVAL, from, to, get_native_thread_id(), stack_index });
+        }
+
+        void record(Marker::Type type, int stack_index = -1) {
+            const std::lock_guard<std::mutex> lock(mutex);
+
+            list.push_back({ type, Marker::INSTANT, TimeStamp::Now(), TimeStamp(), get_native_thread_id(), stack_index });
+        }
+};
+
+enum Category{
+	CATEGORY_NORMAL,
+	CATEGORY_IDLE
+};
+
+class SampleList {
+    public:
+
+        std::vector<int> stacks;
+        std::vector<TimeStamp> timestamps;
+        std::vector<native_thread_id_t> threads;
+        std::vector<Category> categories;
+        std::vector<int> weights;
+
+        size_t size() {
+            return stacks.size();
+        }
+
+        bool empty() {
+            return size() == 0;
+        }
+
+        void record_sample(int stack_index, TimeStamp time, native_thread_id_t thread_id, Category category) {
+            if (
+                    !empty() &&
+                    stacks.back() == stack_index &&
+                    threads.back() == thread_id &&
+                    categories.back() == category)
+            {
+                // We don't compare timestamps for de-duplication
+                weights.back() += 1;
+            } else {
+                stacks.push_back(stack_index);
+                timestamps.push_back(time);
+                threads.push_back(thread_id);
+                categories.push_back(category);
+                weights.push_back(1);
+            }
+        }
+
+        void write_result(VALUE result) const {
+            VALUE samples = rb_ary_new();
+            rb_hash_aset(result, sym("samples"), samples);
+            for (auto& stack_index: this->stacks) {
+                rb_ary_push(samples, INT2NUM(stack_index));
+            }
+
+            VALUE weights = rb_ary_new();
+            rb_hash_aset(result, sym("weights"), weights);
+            for (auto& weight: this->weights) {
+                rb_ary_push(weights, INT2NUM(weight));
+            }
+
+            VALUE timestamps = rb_ary_new();
+            rb_hash_aset(result, sym("timestamps"), timestamps);
+            for (auto& timestamp: this->timestamps) {
+                rb_ary_push(timestamps, ULL2NUM(timestamp.nanoseconds()));
+            }
+
+            VALUE sample_categories = rb_ary_new();
+            rb_hash_aset(result, sym("sample_categories"), sample_categories);
+            for (auto& cat: this->categories) {
+                rb_ary_push(sample_categories, INT2NUM(cat));
+            }
+        }
+};
+
+class Thread {
+    public:
+        SampleList samples;
+
+        enum State {
+            STARTED,
+            RUNNING,
+            READY,
+            SUSPENDED,
+            STOPPED
+        };
+
+        pthread_t pthread_id;
+        native_thread_id_t native_tid;
+        State state;
+
+        TimeStamp state_changed_at;
+        TimeStamp started_at;
+        TimeStamp stopped_at;
+
+        int stack_on_suspend_idx;
+        SampleTranslator translator;
+
+        std::string name;
+
+        Thread(State state) : state(state), stack_on_suspend_idx(-1) {
+            pthread_id = pthread_self();
+            native_tid = get_native_thread_id();
+            started_at = state_changed_at = TimeStamp::Now();
+        }
+
+        void set_state(State new_state, MarkerTable *markers) {
+            if (state == Thread::State::STOPPED) {
+                return;
+            }
+
+            TimeStamp from = state_changed_at;
+            auto now = TimeStamp::Now();
+
+            if (started_at.zero()) {
+                started_at = now;
+            }
+
+            switch (new_state) {
+                case State::STARTED:
+                    new_state = State::RUNNING;
+                    break;
+                case State::RUNNING:
+                    assert(state == State::READY);
+
+                    // If the GVL is immediately ready, and we measure no times
+                    // stalled, skip emitting the interval.
+                    if (from != now) {
+                        markers->record_interval(Marker::Type::MARKER_THREAD_STALLED, from, now);
+                    }
+                    break;
+                case State::READY:
+                    // The ready state means "I would like to do some work, but I can't
+                    // do it right now either because I blocked on IO and now I want the GVL back,
+                    // or because the VM timer put me to sleep"
+                    //
+                    // Threads can be preempted, which means they will have been in "Running"
+                    // state, and then the VM was like "no I need to stop you from working,
+                    // so I'll put you in the 'ready' (or stalled) state"
+                    assert(state == State::SUSPENDED || state == State::RUNNING);
+                    if (state == State::SUSPENDED) {
+                        markers->record_interval(Marker::Type::MARKER_THREAD_SUSPENDED, from, now, stack_on_suspend_idx);
+                    }
+                    else {
+                        markers->record_interval(Marker::Type::MARKER_THREAD_RUNNING, from, now);
+                    }
+                    break;
+                case State::SUSPENDED:
+                    // We can go from RUNNING or STARTED to SUSPENDED
+                    assert(state == State::RUNNING || state == State::STARTED);
+                    markers->record_interval(Marker::Type::MARKER_THREAD_RUNNING, from, now);
+                    break;
+                case State::STOPPED:
+                    // We can go from RUNNING or STARTED to STOPPED
+                    assert(state == State::RUNNING || state == State::STARTED);
+                    markers->record_interval(Marker::Type::MARKER_THREAD_RUNNING, from, now);
+                    stopped_at = now;
+                    capture_name();
+
+                    break;
+            }
+
+            state = new_state;
+            state_changed_at = now;
+        }
+
+        bool running() {
+            return state != State::STOPPED;
+        }
+
+        void capture_name() {
+            char buf[128];
+            int rc = pthread_getname_np(pthread_id, buf, sizeof(buf));
+            if (rc == 0)
+                name = std::string(buf);
+        }
+};
+
+class ThreadTable {
+    public:
+        FrameList &frame_list;
+
+        std::vector<Thread> list;
+        std::mutex mutex;
+
+        ThreadTable(FrameList &frame_list) : frame_list(frame_list) {
+        }
+
+        void started(MarkerTable *markers) {
+            //const std::lock_guard<std::mutex> lock(mutex);
+
+            //list.push_back(Thread{pthread_self(), Thread::State::SUSPENDED});
+            markers->record(Marker::Type::MARKER_GVL_THREAD_STARTED);
+            set_state(Thread::State::STARTED, markers);
+        }
+
+        void ready(MarkerTable *markers) {
+            set_state(Thread::State::READY, markers);
+        }
+
+        void resumed(MarkerTable *markers) {
+            set_state(Thread::State::RUNNING, markers);
+        }
+
+        void suspended(MarkerTable *markers) {
+            set_state(Thread::State::SUSPENDED, markers);
+        }
+
+        void stopped(MarkerTable *markers) {
+            markers->record(Marker::Type::MARKER_GVL_THREAD_EXITED);
+            set_state(Thread::State::STOPPED, markers);
+        }
+
+    private:
+        void set_state(Thread::State new_state, MarkerTable *markers) {
+            const std::lock_guard<std::mutex> lock(mutex);
+
+            pthread_t current_thread = pthread_self();
+            //cerr << "set state=" << new_state << " thread=" << gettid() << endl;
+
+            for (auto &thread : list) {
+                if (pthread_equal(current_thread, thread.pthread_id)) {
+                    if (new_state == Thread::State::SUSPENDED) {
+
+                        RawSample sample;
+                        sample.sample();
+
+                        thread.stack_on_suspend_idx = thread.translator.translate(frame_list, sample);
+                        //cerr << gettid() << " suspended! Stack size:" << thread.stack_on_suspend.size() << endl;
+                    }
+
+                    thread.set_state(new_state, markers);
+
+                    return;
+                }
+            }
+
+            pid_t native_tid = get_native_thread_id();
+            list.emplace_back(new_state);
+        }
+};
+
 class BaseCollector {
     protected:
 
@@ -459,13 +893,19 @@ class BaseCollector {
     bool running = false;
     FrameList frame_list;
 
+    TimeStamp started_at;
+
+    virtual ~BaseCollector() {}
+
     virtual bool start() {
         if (running) {
             return false;
-        } else {
-            running = true;
-            return true;
         }
+
+        started_at = TimeStamp::Now();
+
+        running = true;
+        return true;
     }
 
     virtual VALUE stop() {
@@ -477,6 +917,21 @@ class BaseCollector {
         return Qnil;
     }
 
+    void write_meta(VALUE result) {
+        VALUE meta = rb_hash_new();
+        rb_ivar_set(result, rb_intern("@meta"), meta);
+        rb_hash_aset(meta, sym("started_at"), ULL2NUM(started_at.nanoseconds()));
+
+    }
+
+    virtual VALUE build_collector_result() {
+        VALUE result = rb_obj_alloc(rb_cVernierResult);
+
+        write_meta(result);
+
+        return result;
+    }
+
     virtual void sample() {
         rb_raise(rb_eRuntimeError, "collector doesn't support manual sampling");
     };
@@ -491,14 +946,15 @@ class BaseCollector {
 };
 
 class CustomCollector : public BaseCollector {
-    std::vector<int> samples;
+    SampleList samples;
 
     void sample() {
         RawSample sample;
         sample.sample();
         int stack_index = frame_list.stack_index(sample);
 
-        samples.push_back(stack_index);
+	native_thread_id_t thread_id = 0;
+        samples.record_sample(stack_index, TimeStamp::Now(), thread_id, CATEGORY_NORMAL);
     }
 
     VALUE stop() {
@@ -514,17 +970,16 @@ class CustomCollector : public BaseCollector {
     }
 
     VALUE build_collector_result() {
-        VALUE result = rb_obj_alloc(rb_cVernierResult);
+        VALUE result = BaseCollector::build_collector_result();
 
-        VALUE samples = rb_ary_new();
-        rb_ivar_set(result, rb_intern("@samples"), samples);
-        VALUE weights = rb_ary_new();
-        rb_ivar_set(result, rb_intern("@weights"), weights);
+        VALUE threads = rb_hash_new();
+        rb_ivar_set(result, rb_intern("@threads"), threads);
 
-        for (auto& stack_index: this->samples) {
-            rb_ary_push(samples, INT2NUM(stack_index));
-            rb_ary_push(weights, INT2NUM(1));
-        }
+	VALUE thread_hash = rb_hash_new();
+	samples.write_result(thread_hash);
+
+	rb_hash_aset(threads, ULL2NUM(0), thread_hash);
+	rb_hash_aset(thread_hash, sym("tid"), ULL2NUM(0));
 
         frame_list.write_result(result);
 
@@ -557,16 +1012,18 @@ class RetainedCollector : public BaseCollector {
 
     static void newobj_i(VALUE tpval, void *data) {
         RetainedCollector *collector = static_cast<RetainedCollector *>(data);
-        TraceArg tp(tpval);
+        rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+        VALUE obj = rb_tracearg_object(tparg);
 
-        collector->record(tp.obj);
+        collector->record(obj);
     }
 
     static void freeobj_i(VALUE tpval, void *data) {
         RetainedCollector *collector = static_cast<RetainedCollector *>(data);
-        TraceArg tp(tpval);
+        rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+        VALUE obj = rb_tracearg_object(tparg);
 
-        collector->object_frames.erase(tp.obj);
+        collector->object_frames.erase(obj);
     }
 
     public:
@@ -621,12 +1078,18 @@ class RetainedCollector : public BaseCollector {
         RetainedCollector *collector = this;
         FrameList &frame_list = collector->frame_list;
 
-        VALUE result = rb_obj_alloc(rb_cVernierResult);
+        VALUE result = BaseCollector::build_collector_result();
 
+        VALUE threads = rb_hash_new();
+        rb_ivar_set(result, rb_intern("@threads"), threads);
+        VALUE thread_hash = rb_hash_new();
+        rb_hash_aset(threads, ULL2NUM(0), thread_hash);
+
+        rb_hash_aset(thread_hash, sym("tid"), ULL2NUM(0));
         VALUE samples = rb_ary_new();
-        rb_ivar_set(result, rb_intern("@samples"), samples);
+        rb_hash_aset(thread_hash, sym("samples"), samples);
         VALUE weights = rb_ary_new();
-        rb_ivar_set(result, rb_intern("@weights"), weights);
+        rb_hash_aset(thread_hash, sym("weights"), weights);
 
         for (auto& obj: collector->object_list) {
             const auto search = collector->object_frames.find(obj);
@@ -655,160 +1118,68 @@ class RetainedCollector : public BaseCollector {
     }
 };
 
-typedef uint64_t native_thread_id_t;
+class GlobalSignalHandler {
+    static LiveSample *live_sample;
 
-class Thread {
     public:
-        static native_thread_id_t get_native_thread_id() {
-#ifdef __APPLE__
-            uint64_t thread_id;
-            int e = pthread_threadid_np(pthread_self(), &thread_id);
-            if (e != 0) rb_syserr_fail(e, "pthread_threadid_np");
-            return thread_id;
-#else
-            return gettid();
-#endif
+        static GlobalSignalHandler *get_instance() {
+            static GlobalSignalHandler instance;
+            return &instance;
         }
 
-        enum State {
-            STARTED,
-            RUNNING,
-            SUSPENDED,
-            STOPPED
-        };
-
-        pthread_t pthread_id;
-        native_thread_id_t native_tid;
-        State state;
-
-        TimeStamp state_changed_at;
-        TimeStamp started_at;
-        TimeStamp stopped_at;
-
-        RawSample stack_on_suspend;
-
-        std::string name;
-
-        Thread(State state) : state(state) {
-            pthread_id = pthread_self();
-            native_tid = get_native_thread_id();
-            started_at = state_changed_at = TimeStamp::Now();
-        }
-
-        void set_state(State new_state) {
-            if (state == Thread::State::STOPPED) {
-                return;
-            }
-
-            auto now = TimeStamp::Now();
-
-            state = new_state;
-            state_changed_at = now;
-            if (new_state == State::STARTED) {
-                if (started_at.zero()) {
-                    started_at = now;
-                }
-            } else if (new_state == State::STOPPED) {
-                stopped_at = now;
+        void install() {
+            const std::lock_guard<std::mutex> lock(mutex);
+            count++;
 
-                capture_name();
-            }
+            if (count == 1) setup_signal_handler();
         }
 
-        bool running() {
-            return state != State::STOPPED;
-        }
+        void uninstall() {
+            const std::lock_guard<std::mutex> lock(mutex);
+            count--;
 
-        void capture_name() {
-            char buf[128];
-            int rc = pthread_getname_np(pthread_id, buf, sizeof(buf));
-            if (rc == 0)
-                name = std::string(buf);
+            if (count == 0) clear_signal_handler();
         }
-};
-
-class Marker {
-    public:
-    enum Type {
-        MARKER_GVL_THREAD_STARTED,
-        MARKER_GVL_THREAD_READY,
-        MARKER_GVL_THREAD_RESUMED,
-        MARKER_GVL_THREAD_SUSPENDED,
-        MARKER_GVL_THREAD_EXITED,
-
-        MARKER_GC_START,
-        MARKER_GC_END_MARK,
-        MARKER_GC_END_SWEEP,
-        MARKER_GC_ENTER,
-        MARKER_GC_EXIT,
 
-        MARKER_MAX,
-    };
-    Type type;
-    TimeStamp timestamp;
-    native_thread_id_t thread_id;
-};
-
-class MarkerTable {
-    public:
-        std::vector<Marker> list;
-        std::mutex mutex;
-
-        void record(Marker::Type type) {
+        void record_sample(LiveSample &sample, pthread_t pthread_id) {
             const std::lock_guard<std::mutex> lock(mutex);
 
-            list.push_back({ type, TimeStamp::Now(), Thread::get_native_thread_id() });
+            live_sample = &sample;
+            if (pthread_kill(pthread_id, SIGPROF)) {
+                rb_bug("pthread_kill failed");
+            }
+            sample.wait();
+            live_sample = NULL;
         }
-};
-
-extern "C" int ruby_thread_has_gvl_p(void);
 
-class ThreadTable {
-    public:
-        std::vector<Thread> list;
+    private:
         std::mutex mutex;
+        int count;
 
-        void started() {
-            //const std::lock_guard<std::mutex> lock(mutex);
-
-            //list.push_back(Thread{pthread_self(), Thread::State::SUSPENDED});
-            set_state(Thread::State::STARTED);
+        static void signal_handler(int sig, siginfo_t* sinfo, void* ucontext) {
+            assert(live_sample);
+            live_sample->sample_current_thread();
         }
 
-        void set_state(Thread::State new_state) {
-            const std::lock_guard<std::mutex> lock(mutex);
-
-            pthread_t current_thread = pthread_self();
-            //cerr << "set state=" << new_state << " thread=" << gettid() << endl;
-
-            for (auto &thread : list) {
-                if (pthread_equal(current_thread, thread.pthread_id)) {
-                    thread.set_state(new_state);
-
-                    if (new_state == Thread::State::SUSPENDED) {
-                        thread.stack_on_suspend.sample();
-                        //cerr << gettid() << " suspended! Stack size:" << thread.stack_on_suspend.size() << endl;
-                    }
-                    return;
-                }
-            }
-
-            pid_t native_tid = Thread::get_native_thread_id();
-            list.emplace_back(new_state);
+        void setup_signal_handler() {
+            struct sigaction sa;
+            sa.sa_sigaction = signal_handler;
+            sa.sa_flags = SA_RESTART | SA_SIGINFO;
+            sigemptyset(&sa.sa_mask);
+            sigaction(SIGPROF, &sa, NULL);
         }
-};
 
-enum Category{
-	CATEGORY_NORMAL,
-	CATEGORY_IDLE
+        void clear_signal_handler() {
+            struct sigaction sa;
+            sa.sa_handler = SIG_IGN;
+            sa.sa_flags = SA_RESTART;
+            sigemptyset(&sa.sa_mask);
+            sigaction(SIGPROF, &sa, NULL);
+        }
 };
+LiveSample *GlobalSignalHandler::live_sample;
 
 class TimeCollector : public BaseCollector {
-    std::vector<int> samples;
-    std::vector<TimeStamp> timestamps;
-    std::vector<native_thread_id_t> sample_threads;
-    std::vector<Category> sample_categories;
-
     MarkerTable markers;
     ThreadTable threads;
 
@@ -817,41 +1188,31 @@ class TimeCollector : public BaseCollector {
     atomic_bool running;
     SamplerSemaphore thread_stopped;
 
-    static inline LiveSample *live_sample;
-
-    TimeStamp started_at;
     TimeStamp interval;
 
     public:
-    TimeCollector(TimeStamp interval) : interval(interval) {
+    TimeCollector(TimeStamp interval) : interval(interval), threads(frame_list) {
     }
 
     private:
 
-    void record_sample(const RawSample &sample, TimeStamp time, const Thread &thread, Category category) {
+    void record_sample(const RawSample &sample, TimeStamp time, Thread &thread, Category category) {
         if (!sample.empty()) {
-            int stack_index = frame_list.stack_index(sample);
-            samples.push_back(stack_index);
-            timestamps.push_back(time);
-            sample_threads.push_back(thread.native_tid);
-            sample_categories.push_back(category);
+            int stack_index = thread.translator.translate(frame_list, sample);
+            thread.samples.record_sample(
+                    stack_index,
+                    time,
+                    thread.native_tid,
+                    category
+                    );
         }
     }
 
-    static void signal_handler(int sig, siginfo_t* sinfo, void* ucontext) {
-        assert(live_sample);
-        live_sample->sample_current_thread();
-    }
-
     VALUE get_markers() {
-        VALUE list = rb_ary_new();
+        VALUE list = rb_ary_new2(this->markers.list.size());
 
         for (auto& marker: this->markers.list) {
-            VALUE record[3] = {0};
-            record[0] = ULL2NUM(marker.thread_id);
-            record[1] = INT2NUM(marker.type);
-            record[2] = ULL2NUM(marker.timestamp.nanoseconds());
-            rb_ary_push(list, rb_ary_new_from_values(3, record));
+            rb_ary_push(list, marker.to_array());
         }
 
         return list;
@@ -859,20 +1220,16 @@ class TimeCollector : public BaseCollector {
 
     void sample_thread_run() {
         LiveSample sample;
-        live_sample = &sample;
 
         TimeStamp next_sample_schedule = TimeStamp::Now();
         while (running) {
             TimeStamp sample_start = TimeStamp::Now();
 
             threads.mutex.lock();
-            for (auto thread : threads.list) {
+            for (auto &thread : threads.list) {
                 //if (thread.state == Thread::State::RUNNING) {
-                if (thread.state == Thread::State::RUNNING || (thread.state == Thread::State::SUSPENDED && thread.stack_on_suspend.size() == 0)) {
-                    if (pthread_kill(thread.pthread_id, SIGPROF)) {
-                        rb_bug("pthread_kill failed");
-                    }
-                    sample.wait();
+                if (thread.state == Thread::State::RUNNING || (thread.state == Thread::State::SUSPENDED && thread.stack_on_suspend_idx < 0)) {
+                    GlobalSignalHandler::get_instance()->record_sample(sample, thread.pthread_id);
 
                     if (sample.sample.gc) {
                         // fprintf(stderr, "skipping GC sample\n");
@@ -880,10 +1237,15 @@ class TimeCollector : public BaseCollector {
                         record_sample(sample.sample, sample_start, thread, CATEGORY_NORMAL);
                     }
                 } else if (thread.state == Thread::State::SUSPENDED) {
-                    record_sample(thread.stack_on_suspend, sample_start, thread, CATEGORY_IDLE);
+                    thread.samples.record_sample(
+                            thread.stack_on_suspend_idx,
+                            sample_start,
+                            thread.native_tid,
+                            CATEGORY_IDLE);
                 } else {
                 }
             }
+
             threads.mutex.unlock();
 
             TimeStamp sample_complete = TimeStamp::Now();
@@ -899,8 +1261,6 @@ class TimeCollector : public BaseCollector {
             TimeStamp::Sleep(sleep_time);
         }
 
-        live_sample = NULL;
-
         thread_stopped.post();
     }
 
@@ -910,10 +1270,21 @@ class TimeCollector : public BaseCollector {
         return NULL;
     }
 
-    static void internal_gc_event_cb(VALUE tpval, void *data) {
-        TimeCollector *collector = static_cast<TimeCollector *>(data);
-        rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
-        int event = rb_tracearg_event_flag(tparg);
+    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_THREAD_BEGIN:
+                collector->threads.started(&collector->markers);
+                break;
+            case RUBY_EVENT_THREAD_END:
+                collector->threads.stopped(&collector->markers);
+                break;
+        }
+    }
+
+    static void internal_gc_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_INTERNAL_EVENT_GC_START:
@@ -926,10 +1297,10 @@ class TimeCollector : public BaseCollector {
                 collector->markers.record(Marker::Type::MARKER_GC_END_SWEEP);
                 break;
             case RUBY_INTERNAL_EVENT_GC_ENTER:
-                collector->markers.record(Marker::Type::MARKER_GC_ENTER);
+                collector->markers.record_gc_entered();
                 break;
             case RUBY_INTERNAL_EVENT_GC_EXIT:
-                collector->markers.record(Marker::Type::MARKER_GC_EXIT);
+                collector->markers.record_gc_leave();
                 break;
         }
     }
@@ -939,44 +1310,27 @@ class TimeCollector : public BaseCollector {
         //cerr << "internal thread event" << event << " at " << TimeStamp::Now() << endl;
 
         switch (event) {
-            case RUBY_INTERNAL_THREAD_EVENT_STARTED:
-                collector->markers.record(Marker::Type::MARKER_GVL_THREAD_STARTED);
-                collector->threads.started();
-                break;
             case RUBY_INTERNAL_THREAD_EVENT_READY:
-                collector->markers.record(Marker::Type::MARKER_GVL_THREAD_READY);
+                collector->threads.ready(&collector->markers);
                 break;
             case RUBY_INTERNAL_THREAD_EVENT_RESUMED:
-                collector->markers.record(Marker::Type::MARKER_GVL_THREAD_RESUMED);
-                collector->threads.set_state(Thread::State::RUNNING);
+                collector->threads.resumed(&collector->markers);
                 break;
             case RUBY_INTERNAL_THREAD_EVENT_SUSPENDED:
-                collector->markers.record(Marker::Type::MARKER_GVL_THREAD_SUSPENDED);
-                collector->threads.set_state(Thread::State::SUSPENDED);
-                break;
-            case RUBY_INTERNAL_THREAD_EVENT_EXITED:
-                collector->markers.record(Marker::Type::MARKER_GVL_THREAD_EXITED);
-                collector->threads.set_state(Thread::State::STOPPED);
+                collector->threads.suspended(&collector->markers);
                 break;
 
         }
     }
 
     rb_internal_thread_event_hook_t *thread_hook;
-    VALUE gc_hook;
 
     bool start() {
         if (!BaseCollector::start()) {
             return false;
         }
 
-	started_at = TimeStamp::Now();
-
-        struct sigaction sa;
-        sa.sa_sigaction = signal_handler;
-        sa.sa_flags = SA_RESTART | SA_SIGINFO;
-        sigemptyset(&sa.sa_mask);
-        sigaction(SIGPROF, &sa, NULL);
+        GlobalSignalHandler::get_instance()->install();
 
         running = true;
 
@@ -986,15 +1340,16 @@ class TimeCollector : public BaseCollector {
             rb_bug("pthread_create");
         }
 
-        // Set the state of the current Ruby thread to RUNNING.
-        // We want to have at least one thread in our thread list because it's
-        // possible that the profile might be such that we don't get any
-        // thread switch events and we need at least one
-        this->threads.set_state(Thread::State::RUNNING);
+        // 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
+        // have at least one thread in our thread list because it's possible
+        // that the profile might be such that we don't get any thread switch
+        // events and we need at least one
+        this->threads.resumed(&this->markers);
 
         thread_hook = rb_internal_thread_add_event_hook(internal_thread_event_cb, RUBY_INTERNAL_THREAD_EVENT_MASK, this);
-        gc_hook = rb_tracepoint_new(0, RUBY_GC_PHASE_EVENTS, internal_gc_event_cb, (void *)this);
-        rb_tracepoint_enable(gc_hook);
+        rb_add_event_hook(internal_gc_event_cb, RUBY_INTERNAL_EVENTS, PTR2NUM((void *)this));
+        rb_add_event_hook(internal_thread_event_cb, RUBY_NORMAL_EVENTS, PTR2NUM((void *)this));
 
         return true;
     }
@@ -1005,14 +1360,11 @@ class TimeCollector : public BaseCollector {
         running = false;
         thread_stopped.wait();
 
-        struct sigaction sa;
-        sa.sa_handler = SIG_IGN;
-        sa.sa_flags = SA_RESTART;
-        sigemptyset(&sa.sa_mask);
-        sigaction(SIGPROF, &sa, NULL);
+        GlobalSignalHandler::get_instance()->uninstall();
 
         rb_internal_thread_remove_event_hook(thread_hook);
-        rb_tracepoint_disable(gc_hook);
+        rb_remove_event_hook(internal_gc_event_cb);
+        rb_remove_event_hook(internal_thread_event_cb);
 
         // capture thread names
         for (auto& thread: this->threads.list) {
@@ -1031,45 +1383,15 @@ class TimeCollector : public BaseCollector {
     }
 
     VALUE build_collector_result() {
-        VALUE result = rb_obj_alloc(rb_cVernierResult);
-
-        VALUE meta = rb_hash_new();
-        rb_ivar_set(result, rb_intern("@meta"), meta);
-        rb_hash_aset(meta, sym("started_at"), ULL2NUM(started_at.nanoseconds()));
-
-        VALUE samples = rb_ary_new();
-        rb_ivar_set(result, rb_intern("@samples"), samples);
-        VALUE weights = rb_ary_new();
-        rb_ivar_set(result, rb_intern("@weights"), weights);
-        for (auto& stack_index: this->samples) {
-            rb_ary_push(samples, INT2NUM(stack_index));
-            rb_ary_push(weights, INT2NUM(1));
-        }
-
-        VALUE timestamps = rb_ary_new();
-        rb_ivar_set(result, rb_intern("@timestamps"), timestamps);
-
-        for (auto& timestamp: this->timestamps) {
-            rb_ary_push(timestamps, ULL2NUM(timestamp.nanoseconds()));
-        }
-
-        VALUE sample_threads = rb_ary_new();
-        rb_ivar_set(result, rb_intern("@sample_threads"), sample_threads);
-        for (auto& thread: this->sample_threads) {
-            rb_ary_push(sample_threads, ULL2NUM(thread));
-        }
-
-        VALUE sample_categories = rb_ary_new();
-        rb_ivar_set(result, rb_intern("@sample_categories"), sample_categories);
-        for (auto& cat: this->sample_categories) {
-            rb_ary_push(sample_categories, INT2NUM(cat));
-        }
+        VALUE result = BaseCollector::build_collector_result();
 
         VALUE threads = rb_hash_new();
         rb_ivar_set(result, rb_intern("@threads"), threads);
 
         for (const auto& thread: this->threads.list) {
             VALUE hash = rb_hash_new();
+            thread.samples.write_result(hash);
+
             rb_hash_aset(threads, ULL2NUM(thread.native_tid), hash);
             rb_hash_aset(hash, sym("tid"), ULL2NUM(thread.native_tid));
             rb_hash_aset(hash, sym("started_at"), ULL2NUM(thread.started_at.nanoseconds()));
@@ -1087,7 +1409,6 @@ class TimeCollector : public BaseCollector {
 
     void mark() {
         frame_list.mark_frames();
-        rb_gc_mark(gc_hook);
 
         //for (int i = 0; i < queued_length; i++) {
         //    rb_gc_mark(queued_frames[i]);
@@ -1182,14 +1503,11 @@ static VALUE collector_new(VALUE self, VALUE mode, VALUE options) {
 }
 
 static void
-Init_consts() {
+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_READY);
-    MARKER_CONST(GVL_THREAD_RESUMED);
-    MARKER_CONST(GVL_THREAD_SUSPENDED);
     MARKER_CONST(GVL_THREAD_EXITED);
 
     MARKER_CONST(GC_START);
@@ -1197,8 +1515,22 @@ Init_consts() {
     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 PHASE_CONST(name) \
+    rb_define_const(rb_mVernierMarkerPhase, #name, INT2NUM(Marker::Phase::name))
+
+    PHASE_CONST(INSTANT);
+    PHASE_CONST(INTERVAL);
+    PHASE_CONST(INTERVAL_START);
+    PHASE_CONST(INTERVAL_END);
+#undef PHASE_CONST
 }
 
 extern "C" void
@@ -1207,6 +1539,7 @@ Init_vernier(void)
   rb_mVernier = rb_define_module("Vernier");
   rb_cVernierResult = rb_define_class_under(rb_mVernier, "Result", rb_cObject);
   VALUE rb_mVernierMarker = rb_define_module_under(rb_mVernier, "Marker");
+  VALUE rb_mVernierMarkerPhase = rb_define_module_under(rb_mVernierMarker, "Phase");
   rb_mVernierMarkerType = rb_define_module_under(rb_mVernierMarker, "Type");
 
   rb_cVernierCollector = rb_define_class_under(rb_mVernier, "Collector", rb_cObject);
@@ -1217,7 +1550,7 @@ Init_vernier(void)
   rb_define_private_method(rb_cVernierCollector, "finish",  collector_stop, 0);
   rb_define_private_method(rb_cVernierCollector, "markers",  markers, 0);
 
-  Init_consts();
+  Init_consts(rb_mVernierMarkerPhase);
 
   //static VALUE gc_hook = Data_Wrap_Struct(rb_cObject, collector_mark, NULL, &_collector);
   //rb_global_variable(&gc_hook);