vernier 0.5.1 → 0.7.0

data/ext/vernier/vernier.cc

@@ -57,6 +57,7 @@ static VALUE rb_mVernier;
 static VALUE rb_cVernierResult;
 static VALUE rb_mVernierMarkerType;
 static VALUE rb_cVernierCollector;
+static VALUE rb_cStackTable;
 
 static const char *gvl_event_name(rb_event_flag_t event) {
     switch (event) {
@@ -197,6 +198,7 @@ std::ostream& operator<<(std::ostream& os, const TimeStamp& info) {
     return os;
 }
 
+// TODO: Rename FuncInfo
 struct FrameInfo {
     static const char *label_cstr(VALUE frame) {
         VALUE label = rb_profile_frame_full_label(frame);
@@ -239,10 +241,6 @@ bool operator==(const FrameInfo& lhs, const FrameInfo& rhs) noexcept {
 struct Frame {
     VALUE frame;
     int line;
-
-    FrameInfo info() const {
-        return FrameInfo(frame);
-    }
 };
 
 bool operator==(const Frame& lhs, const Frame& rhs) noexcept {
@@ -266,7 +264,7 @@ namespace std {
 
 // A basic semaphore built on sem_wait/sem_post
 // post() is guaranteed to be async-signal-safe
-class SamplerSemaphore {
+class SignalSafeSemaphore {
 #ifdef __APPLE__
     dispatch_semaphore_t sem;
 #else
@@ -275,7 +273,7 @@ class SamplerSemaphore {
 
     public:
 
-    SamplerSemaphore(unsigned int value = 0) {
+    SignalSafeSemaphore(unsigned int value = 0) {
 #ifdef __APPLE__
         sem = dispatch_semaphore_create(value);
 #else
@@ -283,7 +281,7 @@ class SamplerSemaphore {
 #endif
     };
 
-    ~SamplerSemaphore() {
+    ~SignalSafeSemaphore() {
 #ifdef __APPLE__
         dispatch_release(sem);
 #else
@@ -316,17 +314,25 @@ class SamplerSemaphore {
     }
 };
 
-struct RawSample {
+class RawSample {
+    public:
+
     constexpr static int MAX_LEN = 2048;
+
+    private:
+
     VALUE frames[MAX_LEN];
     int lines[MAX_LEN];
     int len;
+    int offset;
     bool gc;
 
-    RawSample() : len(0), gc(false) { }
+    public:
+
+    RawSample() : len(0), gc(false), offset(0) { }
 
     int size() const {
-        return len;
+        return len - offset;
     }
 
     Frame frame(int i) const {
@@ -336,7 +342,7 @@ struct RawSample {
         return frame;
     }
 
-    void sample() {
+    void sample(int offset = 0) {
         clear();
 
         if (!ruby_native_thread_p()) {
@@ -347,16 +353,18 @@ struct RawSample {
           gc = true;
         } else {
           len = rb_profile_frames(0, MAX_LEN, frames, lines);
+          this->offset = std::min(offset, len);
         }
     }
 
     void clear() {
         len = 0;
+        offset = 0;
         gc = false;
     }
 
     bool empty() const {
-        return len == 0;
+        return len <= offset;
     }
 };
 
@@ -366,7 +374,7 @@ struct RawSample {
 struct LiveSample {
     RawSample sample;
 
-    SamplerSemaphore sem_complete;
+    SignalSafeSemaphore sem_complete;
 
     // Wait for a sample to be collected by the signal handler on another thread
     void wait() {
@@ -393,41 +401,51 @@ struct LiveSample {
     }
 };
 
-struct FrameList {
-    std::unordered_map<std::string, int> string_to_idx;
-    std::vector<std::string> string_list;
+template <typename K>
+class IndexMap {
+    public:
+        std::unordered_map<K, int> to_idx;
+        std::vector<K> list;
 
-    int string_index(const std::string str) {
-        auto it = string_to_idx.find(str);
-        if (it == string_to_idx.end()) {
-            int idx = string_list.size();
-            string_list.push_back(str);
+        const K& operator[](int i) const noexcept {
+            return list[i];
+        }
 
-            auto result = string_to_idx.insert({str, idx});
-            it = result.first;
+        size_t size() const noexcept {
+            return list.size();
         }
 
-        return it->second;
-    }
+        int index(const K key) {
+            auto it = to_idx.find(key);
+            if (it == to_idx.end()) {
+                int idx = list.size();
+                list.push_back(key);
+
+                auto result = to_idx.insert({key, idx});
+                it = result.first;
+            }
+
+            return it->second;
+        }
+
+        void clear() {
+            list.clear();
+            to_idx.clear();
+        }
+};
+
+struct StackTable {
+    private:
 
     struct FrameWithInfo {
         Frame frame;
         FrameInfo info;
     };
 
-    std::unordered_map<Frame, int> frame_to_idx;
-    std::vector<Frame> frame_list;
-    std::vector<FrameWithInfo> frame_with_info_list;
-    int frame_index(const Frame frame) {
-        auto it = frame_to_idx.find(frame);
-        if (it == frame_to_idx.end()) {
-            int idx = frame_list.size();
-            frame_list.push_back(frame);
-            auto result = frame_to_idx.insert({frame, idx});
-            it = result.first;
-        }
-        return it->second;
-    }
+    IndexMap<Frame> frame_map;
+
+    IndexMap<VALUE> func_map;
+    std::vector<FrameInfo> func_info_list;
 
     struct StackNode {
         std::unordered_map<Frame, int> children;
@@ -441,21 +459,13 @@ struct FrameList {
         StackNode() : frame(Frame{0, 0}), index(-1), parent(-1) {}
     };
 
+    // This mutex guards the StackNodes only. The rest of the maps and vectors
+    // should be guarded by the GVL
+    std::mutex stack_mutex;
+
     StackNode root_stack_node;
     vector<StackNode> stack_node_list;
-
-    int stack_index(const RawSample &stack) {
-        if (stack.empty()) {
-            throw std::runtime_error("VERNIER BUG: empty stack");
-        }
-
-        StackNode *node = &root_stack_node;
-        for (int i = 0; i < stack.size(); i++) {
-            Frame frame = stack.frame(i);
-            node = next_stack_node(node, frame);
-        }
-        return node->index;
-    }
+    int stack_node_list_finalized_idx = 0;
 
     StackNode *next_stack_node(StackNode *node, Frame frame) {
         auto search = node->children.find(frame);
@@ -475,83 +485,267 @@ struct FrameList {
         }
     }
 
+    public:
+
+    int stack_index(const RawSample &stack) {
+        if (stack.empty()) {
+            throw std::runtime_error("VERNIER BUG: empty stack");
+        }
+
+        const std::lock_guard<std::mutex> lock(stack_mutex);
+
+        StackNode *node = &root_stack_node;
+        for (int i = 0; i < stack.size(); i++) {
+            Frame frame = stack.frame(i);
+            node = next_stack_node(node, frame);
+        }
+        return node->index;
+    }
+
+    int stack_parent(int stack_idx) {
+        const std::lock_guard<std::mutex> lock(stack_mutex);
+        if (stack_idx < 0 || stack_idx >= stack_node_list.size()) {
+            return -1;
+        } else {
+            return stack_node_list[stack_idx].parent;
+        }
+    }
+
+    int stack_frame(int stack_idx) {
+        const std::lock_guard<std::mutex> lock(stack_mutex);
+        if (stack_idx < 0 || stack_idx >= stack_node_list.size()) {
+            return -1;
+        } else {
+            return frame_map.index(stack_node_list[stack_idx].frame);
+        }
+    }
+
     // Converts Frames from stacks other tables. "Symbolicates" the frames
     // which allocates.
     void finalize() {
-        for (const auto &stack_node : stack_node_list) {
-            frame_index(stack_node.frame);
+        {
+            const std::lock_guard<std::mutex> lock(stack_mutex);
+            for (int i = stack_node_list_finalized_idx; i < stack_node_list.size(); i++) {
+                const auto &stack_node = stack_node_list[i];
+                frame_map.index(stack_node.frame);
+                func_map.index(stack_node.frame.frame);
+                stack_node_list_finalized_idx = i;
+            }
         }
-        for (const auto &frame : frame_list) {
-            frame_with_info_list.push_back(FrameWithInfo{frame, frame.info()});
+
+        for (int i = func_info_list.size(); i < func_map.size(); i++) {
+            const auto &func = func_map[i];
+            // must not hold a mutex here
+            func_info_list.push_back(FrameInfo(func));
         }
     }
 
     void mark_frames() {
+        const std::lock_guard<std::mutex> lock(stack_mutex);
+
         for (auto stack_node: stack_node_list) {
             rb_gc_mark(stack_node.frame.frame);
         }
     }
 
+    // FIXME: probably should remove
     void clear() {
-        string_list.clear();
-        frame_list.clear();
-        stack_node_list.clear();
-        frame_with_info_list.clear();
-
-        string_to_idx.clear();
-        frame_to_idx.clear();
-        root_stack_node.children.clear();
-    }
-
-    void write_result(VALUE result) {
-        FrameList &frame_list = *this;
-
-        VALUE stack_table = rb_hash_new();
-        rb_ivar_set(result, rb_intern("@stack_table"), stack_table);
-        VALUE stack_table_parent = rb_ary_new();
-        VALUE stack_table_frame = rb_ary_new();
-        rb_hash_aset(stack_table, sym("parent"), stack_table_parent);
-        rb_hash_aset(stack_table, sym("frame"), stack_table_frame);
-        for (const auto &stack : frame_list.stack_node_list) {
-            VALUE parent_val = stack.parent == -1 ? Qnil : INT2NUM(stack.parent);
-            rb_ary_push(stack_table_parent, parent_val);
-            rb_ary_push(stack_table_frame, INT2NUM(frame_list.frame_index(stack.frame)));
-        }
-
-        VALUE frame_table = rb_hash_new();
-        rb_ivar_set(result, rb_intern("@frame_table"), frame_table);
-        VALUE frame_table_func = rb_ary_new();
-        VALUE frame_table_line = rb_ary_new();
-        rb_hash_aset(frame_table, sym("func"), frame_table_func);
-        rb_hash_aset(frame_table, sym("line"), frame_table_line);
-        //for (const auto &frame : frame_list.frame_list) {
-        for (int i = 0; i < frame_list.frame_with_info_list.size(); i++) {
-            const auto &frame = frame_list.frame_with_info_list[i];
-            rb_ary_push(frame_table_func, INT2NUM(i));
-            rb_ary_push(frame_table_line, INT2NUM(frame.frame.line));
-        }
-
-        // TODO: dedup funcs before this step
-        VALUE func_table = rb_hash_new();
-        rb_ivar_set(result, rb_intern("@func_table"), func_table);
-        VALUE func_table_name = rb_ary_new();
-        VALUE func_table_filename = rb_ary_new();
-        VALUE func_table_first_line = rb_ary_new();
-        rb_hash_aset(func_table, sym("name"), func_table_name);
-        rb_hash_aset(func_table, sym("filename"), func_table_filename);
-        rb_hash_aset(func_table, sym("first_line"), func_table_first_line);
-        for (const auto &frame : frame_list.frame_with_info_list) {
-            const std::string label = frame.info.label;
-            const std::string filename = frame.info.file;
-            const int first_line = frame.info.first_lineno;
-
-            rb_ary_push(func_table_name, rb_str_new(label.c_str(), label.length()));
-            rb_ary_push(func_table_filename, rb_str_new(filename.c_str(), filename.length()));
-            rb_ary_push(func_table_first_line, INT2NUM(first_line));
+        frame_map.clear();
+        func_map.clear();
+        func_info_list.clear();
+
+        {
+            const std::lock_guard<std::mutex> lock(stack_mutex);
+            stack_node_list.clear();
+            root_stack_node.children.clear();
         }
     }
+
+    static VALUE stack_table_stack_count(VALUE self);
+    static VALUE stack_table_frame_count(VALUE self);
+    static VALUE stack_table_func_count(VALUE self);
+
+    static VALUE stack_table_frame_line_no(VALUE self, VALUE idxval);
+    static VALUE stack_table_frame_func_idx(VALUE self, VALUE idxval);
+    static VALUE stack_table_func_name(VALUE self, VALUE idxval);
+    static VALUE stack_table_func_filename(VALUE self, VALUE idxval);
+    static VALUE stack_table_func_first_lineno(VALUE self, VALUE idxval);
+
+    friend class SampleTranslator;
+};
+
+static void
+stack_table_mark(void *data) {
+    StackTable *stack_table = static_cast<StackTable *>(data);
+    stack_table->mark_frames();
+}
+
+static void
+stack_table_free(void *data) {
+    StackTable *stack_table = static_cast<StackTable *>(data);
+    delete stack_table;
+}
+
+static const rb_data_type_t rb_stack_table_type = {
+    .wrap_struct_name = "vernier/stack_table",
+    .function = {
+        //.dmemsize = rb_collector_memsize,
+        .dmark = stack_table_mark,
+        .dfree = stack_table_free,
+    },
 };
 
+static VALUE
+stack_table_new(VALUE self) {
+    StackTable *stack_table = new StackTable();
+    VALUE obj = TypedData_Wrap_Struct(self, &rb_stack_table_type, stack_table);
+    return obj;
+}
+
+static StackTable *get_stack_table(VALUE obj) {
+    StackTable *stack_table;
+    TypedData_Get_Struct(obj, StackTable, &rb_stack_table_type, stack_table);
+    return stack_table;
+}
+
+static VALUE
+stack_table_current_stack(int argc, VALUE *argv, VALUE self) {
+    int offset;
+    VALUE offset_v;
+
+    rb_scan_args(argc, argv, "01", &offset_v);
+    if (argc > 0) {
+        offset = NUM2INT(offset_v) + 1;
+    } else {
+        offset = 1;
+    }
+
+    StackTable *stack_table = get_stack_table(self);
+    RawSample stack;
+    stack.sample(offset);
+    int stack_index = stack_table->stack_index(stack);
+    return INT2NUM(stack_index);
+}
+
+static VALUE
+stack_table_stack_parent_idx(VALUE self, VALUE idxval) {
+    StackTable *stack_table = get_stack_table(self);
+    int idx = NUM2INT(idxval);
+    int parent_idx = stack_table->stack_parent(idx);
+    if (parent_idx < 0) {
+        return Qnil;
+    } else {
+        return INT2NUM(parent_idx);
+    }
+}
+
+static VALUE
+stack_table_stack_frame_idx(VALUE self, VALUE idxval) {
+    StackTable *stack_table = get_stack_table(self);
+    //stack_table->finalize();
+    int idx = NUM2INT(idxval);
+    int frame_idx = stack_table->stack_frame(idx);
+    return frame_idx < 0 ? Qnil : INT2NUM(frame_idx);
+}
+
+VALUE
+StackTable::stack_table_stack_count(VALUE self) {
+    StackTable *stack_table = get_stack_table(self);
+    int count;
+    {
+        const std::lock_guard<std::mutex> lock(stack_table->stack_mutex);
+        count = stack_table->stack_node_list.size();
+    }
+    return INT2NUM(count);
+}
+
+VALUE
+StackTable::stack_table_frame_count(VALUE self) {
+    StackTable *stack_table = get_stack_table(self);
+    stack_table->finalize();
+    int count = stack_table->frame_map.size();
+    return INT2NUM(count);
+}
+
+VALUE
+StackTable::stack_table_func_count(VALUE self) {
+    StackTable *stack_table = get_stack_table(self);
+    stack_table->finalize();
+    int count = stack_table->func_map.size();
+    return INT2NUM(count);
+}
+
+VALUE
+StackTable::stack_table_frame_line_no(VALUE self, VALUE idxval) {
+    StackTable *stack_table = get_stack_table(self);
+    stack_table->finalize();
+    int idx = NUM2INT(idxval);
+    if (idx < 0 || idx >= stack_table->frame_map.size()) {
+        return Qnil;
+    } else {
+        const auto &frame = stack_table->frame_map[idx];
+        return INT2NUM(frame.line);
+    }
+}
+
+VALUE
+StackTable::stack_table_frame_func_idx(VALUE self, VALUE idxval) {
+    StackTable *stack_table = get_stack_table(self);
+    stack_table->finalize();
+    int idx = NUM2INT(idxval);
+    if (idx < 0 || idx >= stack_table->frame_map.size()) {
+        return Qnil;
+    } else {
+        const auto &frame = stack_table->frame_map[idx];
+        int func_idx = stack_table->func_map.index(frame.frame);
+        return INT2NUM(func_idx);
+    }
+}
+
+VALUE
+StackTable::stack_table_func_name(VALUE self, VALUE idxval) {
+    StackTable *stack_table = get_stack_table(self);
+    stack_table->finalize();
+    int idx = NUM2INT(idxval);
+    auto &table = stack_table->func_info_list;
+    if (idx < 0 || idx >= table.size()) {
+        return Qnil;
+    } else {
+        const auto &func_info = table[idx];
+        const std::string &label = func_info.label;
+        return rb_interned_str(label.c_str(), label.length());
+    }
+}
+
+VALUE
+StackTable::stack_table_func_filename(VALUE self, VALUE idxval) {
+    StackTable *stack_table = get_stack_table(self);
+    stack_table->finalize();
+    int idx = NUM2INT(idxval);
+    auto &table = stack_table->func_info_list;
+    if (idx < 0 || idx >= table.size()) {
+        return Qnil;
+    } else {
+        const auto &func_info = table[idx];
+        const std::string &filename = func_info.file;
+        return rb_interned_str(filename.c_str(), filename.length());
+    }
+}
+
+VALUE
+StackTable::stack_table_func_first_lineno(VALUE self, VALUE idxval) {
+    StackTable *stack_table = get_stack_table(self);
+    stack_table->finalize();
+    int idx = NUM2INT(idxval);
+    auto &table = stack_table->func_info_list;
+    if (idx < 0 || idx >= table.size()) {
+        return Qnil;
+    } else {
+        const auto &func_info = table[idx];
+        return INT2NUM(func_info.first_lineno);
+    }
+}
+
 class SampleTranslator {
     public:
         int last_stack_index;
@@ -563,7 +757,7 @@ class SampleTranslator {
         SampleTranslator() : len(0), last_stack_index(-1) {
         }
 
-        int translate(FrameList &frame_list, const RawSample &sample) {
+        int translate(StackTable &frame_list, const RawSample &sample) {
             int i = 0;
             for (; i < len && i < sample.size(); i++) {
                 if (frames[i] != sample.frame(i)) {
@@ -571,7 +765,8 @@ class SampleTranslator {
                 }
             }
 
-            FrameList::StackNode *node = i == 0 ? &frame_list.root_stack_node : &frame_list.stack_node_list[frame_indexes[i - 1]];
+            const std::lock_guard<std::mutex> lock(frame_list.stack_mutex);
+            StackTable::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);
@@ -693,12 +888,56 @@ enum Category{
 	CATEGORY_IDLE
 };
 
+class ObjectSampleList {
+    public:
+
+        std::vector<int> stacks;
+        std::vector<TimeStamp> timestamps;
+        std::vector<int> weights;
+
+        size_t size() {
+            return stacks.size();
+        }
+
+        bool empty() {
+            return size() == 0;
+        }
+
+        void record_sample(int stack_index, TimeStamp time, int weight) {
+            stacks.push_back(stack_index);
+            timestamps.push_back(time);
+            weights.push_back(1);
+        }
+
+        void write_result(VALUE result) const {
+            VALUE allocations = rb_hash_new();
+            rb_hash_aset(result, sym("allocations"), allocations);
+
+            VALUE samples = rb_ary_new();
+            rb_hash_aset(allocations, sym("samples"), samples);
+            for (auto& stack_index: this->stacks) {
+                rb_ary_push(samples, INT2NUM(stack_index));
+            }
+
+            VALUE weights = rb_ary_new();
+            rb_hash_aset(allocations, sym("weights"), weights);
+            for (auto& weight: this->weights) {
+                rb_ary_push(weights, INT2NUM(weight));
+            }
+
+            VALUE timestamps = rb_ary_new();
+            rb_hash_aset(allocations, sym("timestamps"), timestamps);
+            for (auto& timestamp: this->timestamps) {
+                rb_ary_push(timestamps, ULL2NUM(timestamp.nanoseconds()));
+            }
+        }
+};
+
 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;
 
@@ -710,11 +949,10 @@ class SampleList {
             return size() == 0;
         }
 
-        void record_sample(int stack_index, TimeStamp time, native_thread_id_t thread_id, Category category) {
+        void record_sample(int stack_index, TimeStamp time, Category category) {
             if (
                     !empty() &&
                     stacks.back() == stack_index &&
-                    threads.back() == thread_id &&
                     categories.back() == category)
             {
                 // We don't compare timestamps for de-duplication
@@ -722,7 +960,6 @@ class SampleList {
             } else {
                 stacks.push_back(stack_index);
                 timestamps.push_back(time);
-                threads.push_back(thread_id);
                 categories.push_back(category);
                 weights.push_back(1);
             }
@@ -758,6 +995,7 @@ class SampleList {
 class Thread {
     public:
         SampleList samples;
+        ObjectSampleList allocation_samples;
 
         enum State {
             STARTED,
@@ -782,15 +1020,12 @@ class Thread {
 
         unique_ptr<MarkerTable> markers;
 
-        std::string name;
-
         // FIXME: don't use pthread at start
         Thread(State state, pthread_t pthread_id, VALUE ruby_thread) : pthread_id(pthread_id), ruby_thread(ruby_thread), state(state), stack_on_suspend_idx(-1) {
             ruby_thread_id = rb_obj_id(ruby_thread);
             //ruby_thread_id = ULL2NUM(ruby_thread);
             native_tid = get_native_thread_id();
             started_at = state_changed_at = TimeStamp::Now();
-            name = "";
             markers = std::make_unique<MarkerTable>();
 
             if (state == State::STARTED) {
@@ -798,6 +1033,14 @@ class Thread {
             }
         }
 
+        void record_newobj(VALUE obj, StackTable &frame_list) {
+            RawSample sample;
+            sample.sample();
+
+            int stack_idx = translator.translate(frame_list, sample);
+            allocation_samples.record_sample(stack_idx, TimeStamp::Now(), 1);
+        }
+
         void set_state(State new_state) {
             if (state == Thread::State::STOPPED) {
                 return;
@@ -866,6 +1109,10 @@ class Thread {
             state_changed_at = now;
         }
 
+        bool is_main() {
+            return rb_thread_main() == ruby_thread;
+        }
+
         bool running() {
             return state != State::STOPPED;
         }
@@ -876,12 +1123,12 @@ class Thread {
 
 class ThreadTable {
     public:
-        FrameList &frame_list;
+        StackTable &frame_list;
 
         std::vector<std::unique_ptr<Thread> > list;
         std::mutex mutex;
 
-        ThreadTable(FrameList &frame_list) : frame_list(frame_list) {
+        ThreadTable(StackTable &frame_list) : frame_list(frame_list) {
         }
 
         void mark() {
@@ -962,15 +1209,17 @@ class BaseCollector {
     protected:
 
     virtual void reset() {
-        frame_list.clear();
     }
 
     public:
     bool running = false;
-    FrameList frame_list;
+    StackTable *stack_table;
+    VALUE stack_table_value;
 
     TimeStamp started_at;
 
+    BaseCollector(VALUE stack_table_value) : stack_table_value(stack_table_value), stack_table(get_stack_table(stack_table_value)) {
+    }
     virtual ~BaseCollector() {}
 
     virtual bool start() {
@@ -1013,7 +1262,8 @@ class BaseCollector {
     };
 
     virtual void mark() {
-        frame_list.mark_frames();
+        //frame_list.mark_frames();
+        rb_gc_mark(stack_table_value);
     };
 
     virtual VALUE get_markers() {
@@ -1027,16 +1277,15 @@ class CustomCollector : public BaseCollector {
     void sample() {
         RawSample sample;
         sample.sample();
-        int stack_index = frame_list.stack_index(sample);
+        int stack_index = stack_table->stack_index(sample);
 
-	native_thread_id_t thread_id = 0;
-        samples.record_sample(stack_index, TimeStamp::Now(), thread_id, CATEGORY_NORMAL);
+        samples.record_sample(stack_index, TimeStamp::Now(), CATEGORY_NORMAL);
     }
 
     VALUE stop() {
         BaseCollector::stop();
 
-        frame_list.finalize();
+        stack_table->finalize();
 
         VALUE result = build_collector_result();
 
@@ -1057,10 +1306,12 @@ class CustomCollector : public BaseCollector {
 	rb_hash_aset(threads, ULL2NUM(0), thread_hash);
 	rb_hash_aset(thread_hash, sym("tid"), ULL2NUM(0));
 
-        frame_list.write_result(result);
-
         return result;
     }
+
+    public:
+
+    CustomCollector(VALUE stack_table) : BaseCollector(stack_table) { }
 };
 
 class RetainedCollector : public BaseCollector {
@@ -1080,7 +1331,7 @@ class RetainedCollector : public BaseCollector {
             // Ideally we'd allow empty samples to be represented
             return;
         }
-        int stack_index = frame_list.stack_index(sample);
+        int stack_index = stack_table->stack_index(sample);
 
         object_list.push_back(obj);
         object_frames.emplace(obj, stack_index);
@@ -1110,6 +1361,8 @@ class RetainedCollector : public BaseCollector {
 
     public:
 
+    RetainedCollector(VALUE stack_table) : BaseCollector(stack_table) { }
+
     bool start() {
         if (!BaseCollector::start()) {
             return false;
@@ -1136,7 +1389,7 @@ class RetainedCollector : public BaseCollector {
         rb_tracepoint_disable(tp_newobj);
         tp_newobj = Qnil;
 
-        frame_list.finalize();
+        stack_table->finalize();
 
         // We should have collected info for all our frames, so no need to continue
         // marking them
@@ -1158,7 +1411,7 @@ class RetainedCollector : public BaseCollector {
 
     VALUE build_collector_result() {
         RetainedCollector *collector = this;
-        FrameList &frame_list = collector->frame_list;
+        StackTable &frame_list = *collector->stack_table;
 
         VALUE result = BaseCollector::build_collector_result();
 
@@ -1186,8 +1439,6 @@ class RetainedCollector : public BaseCollector {
             }
         }
 
-        frame_list.write_result(result);
-
         return result;
     }
 
@@ -1196,7 +1447,8 @@ class RetainedCollector : public BaseCollector {
         // can be garbage collected.
         // When we stop collection we will stringify the remaining frames, and then
         // clear them from the set, allowing them to be removed from out output.
-        frame_list.mark_frames();
+        stack_table->mark_frames();
+        rb_gc_mark(stack_table_value);
 
         rb_gc_mark(tp_newobj);
         rb_gc_mark(tp_freeobj);
@@ -1278,23 +1530,53 @@ class TimeCollector : public BaseCollector {
     pthread_t sample_thread;
 
     atomic_bool running;
-    SamplerSemaphore thread_stopped;
+    SignalSafeSemaphore thread_stopped;
 
     TimeStamp interval;
+    unsigned int allocation_sample_rate;
+    unsigned int allocation_sample_tick = 0;
+
+    VALUE tp_newobj = Qnil;
+
+    static void newobj_i(VALUE tpval, void *data) {
+        TimeCollector *collector = static_cast<TimeCollector *>(data);
+        rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+        VALUE obj = rb_tracearg_object(tparg);
+
+        collector->record_newobj(obj);
+    }
 
     public:
-    TimeCollector(TimeStamp interval) : interval(interval), threads(frame_list) {
+    TimeCollector(VALUE stack_table, TimeStamp interval, unsigned int allocation_sample_rate) : BaseCollector(stack_table), interval(interval), allocation_sample_rate(allocation_sample_rate), threads(*get_stack_table(stack_table)) {
+    }
+
+    void record_newobj(VALUE obj) {
+        if (++allocation_sample_tick < allocation_sample_rate) {
+            return;
+        }
+        allocation_sample_tick = 0;
+
+        VALUE current_thread = rb_thread_current();
+        threads.mutex.lock();
+        for (auto &threadptr : threads.list) {
+            auto &thread = *threadptr;
+            if (current_thread == thread.ruby_thread) {
+                thread.record_newobj(obj, threads.frame_list);
+                break;
+            }
+        }
+        threads.mutex.unlock();
+
     }
 
     private:
 
     void record_sample(const RawSample &sample, TimeStamp time, Thread &thread, Category category) {
         if (!sample.empty()) {
-            int stack_index = thread.translator.translate(frame_list, sample);
+            int stack_index = thread.translator.translate(*stack_table, sample);
             thread.samples.record_sample(
                     stack_index,
                     time,
-                    thread.native_tid,
                     category
                     );
         }
@@ -1344,7 +1626,7 @@ class TimeCollector : public BaseCollector {
                         // 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.gc) {
+                    } else if (sample.sample.empty()) {
                         // fprintf(stderr, "skipping GC sample\n");
                     } else {
                         record_sample(sample.sample, sample_start, thread, CATEGORY_NORMAL);
@@ -1353,7 +1635,6 @@ class TimeCollector : public BaseCollector {
                     thread.samples.record_sample(
                             thread.stack_on_suspend_idx,
                             sample_start,
-                            thread.native_tid,
                             CATEGORY_IDLE);
                 } else {
                 }
@@ -1470,6 +1751,11 @@ class TimeCollector : public BaseCollector {
             return false;
         }
 
+        if (allocation_sample_rate > 0) {
+            tp_newobj = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, this);
+            rb_tracepoint_enable(tp_newobj);
+        }
+
         GlobalSignalHandler::get_instance()->install();
 
         running = true;
@@ -1502,11 +1788,16 @@ class TimeCollector : public BaseCollector {
 
         GlobalSignalHandler::get_instance()->uninstall();
 
+        if (RTEST(tp_newobj)) {
+            rb_tracepoint_disable(tp_newobj);
+            tp_newobj = Qnil;
+        }
+
         rb_internal_thread_remove_event_hook(thread_hook);
         rb_remove_event_hook(internal_gc_event_cb);
         rb_remove_event_hook(internal_thread_event_cb);
 
-        frame_list.finalize();
+        stack_table->finalize();
 
         VALUE result = build_collector_result();
 
@@ -1524,6 +1815,7 @@ class TimeCollector : public BaseCollector {
         for (const auto& thread: this->threads.list) {
             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("tid"), ULL2NUM(thread->native_tid));
@@ -1531,17 +1823,16 @@ class TimeCollector : public BaseCollector {
             if (!thread->stopped_at.zero()) {
                 rb_hash_aset(hash, sym("stopped_at"), ULL2NUM(thread->stopped_at.nanoseconds()));
             }
-            rb_hash_aset(hash, sym("name"), rb_str_new(thread->name.data(), thread->name.length()));
+            rb_hash_aset(hash, sym("is_main"), thread->is_main() ? Qtrue : Qfalse);
 
         }
 
-        frame_list.write_result(result);
-
         return result;
     }
 
     void mark() {
-        frame_list.mark_frames();
+        stack_table->mark_frames();
+        rb_gc_mark(stack_table_value);
         threads.mark();
 
         //for (int i = 0; i < queued_length; i++) {
@@ -1613,12 +1904,21 @@ collector_sample(VALUE self) {
     return Qtrue;
 }
 
+static VALUE
+collector_stack_table(VALUE self) {
+    auto *collector = get_collector(self);
+
+    return collector->stack_table_value;
+}
+
 static VALUE collector_new(VALUE self, VALUE mode, VALUE options) {
     BaseCollector *collector;
+
+    VALUE stack_table = stack_table_new(rb_cStackTable);
     if (mode == sym("retained")) {
-        collector = new RetainedCollector();
+        collector = new RetainedCollector(stack_table);
     } else if (mode == sym("custom")) {
-        collector = new CustomCollector();
+        collector = new CustomCollector(stack_table);
     } else if (mode == sym("wall")) {
         VALUE intervalv = rb_hash_aref(options, sym("interval"));
         TimeStamp interval;
@@ -1627,12 +1927,20 @@ static VALUE collector_new(VALUE self, VALUE mode, VALUE options) {
         } else {
             interval = TimeStamp::from_microseconds(NUM2UINT(intervalv));
         }
-        collector = new TimeCollector(interval);
+
+        VALUE allocation_sample_ratev = rb_hash_aref(options, sym("allocation_sample_rate"));
+        unsigned int allocation_sample_rate;
+        if (NIL_P(allocation_sample_ratev)) {
+            allocation_sample_rate = 0;
+        } else {
+            allocation_sample_rate = NUM2UINT(allocation_sample_ratev);
+        }
+        collector = new TimeCollector(stack_table, interval, allocation_sample_rate);
     } else {
         rb_raise(rb_eArgError, "invalid mode");
     }
     VALUE obj = TypedData_Wrap_Struct(self, &rb_collector_type, collector);
-    rb_funcall(obj, rb_intern("initialize"), 1, mode);
+    rb_funcall(obj, rb_intern("initialize"), 2, mode, options);
     return obj;
 }
 
@@ -1681,9 +1989,25 @@ Init_vernier(void)
   rb_define_singleton_method(rb_cVernierCollector, "_new", collector_new, 2);
   rb_define_method(rb_cVernierCollector, "start", collector_start, 0);
   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);
+  rb_define_singleton_method(rb_cStackTable, "new", stack_table_new, 0);
+  rb_define_method(rb_cStackTable, "current_stack", stack_table_current_stack, -1);
+  rb_define_method(rb_cStackTable, "stack_parent_idx", stack_table_stack_parent_idx, 1);
+  rb_define_method(rb_cStackTable, "stack_frame_idx", stack_table_stack_frame_idx, 1);
+  rb_define_method(rb_cStackTable, "frame_line_no", StackTable::stack_table_frame_line_no, 1);
+  rb_define_method(rb_cStackTable, "frame_func_idx", StackTable::stack_table_frame_func_idx, 1);
+  rb_define_method(rb_cStackTable, "func_name", StackTable::stack_table_func_name, 1);
+  rb_define_method(rb_cStackTable, "func_filename", StackTable::stack_table_func_filename, 1);
+  rb_define_method(rb_cStackTable, "func_first_lineno", StackTable::stack_table_func_first_lineno, 1);
+  rb_define_method(rb_cStackTable, "stack_count", StackTable::stack_table_stack_count, 0);
+  rb_define_method(rb_cStackTable, "frame_count", StackTable::stack_table_frame_count, 0);
+  rb_define_method(rb_cStackTable, "func_count", StackTable::stack_table_func_count, 0);
+
   Init_consts(rb_mVernierMarkerPhase);
 
   //static VALUE gc_hook = Data_Wrap_Struct(rb_cObject, collector_mark, NULL, &_collector);