ruby_memprofiler_pprof 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2436cc3e0be185caaf180f2338b2c2b101cef94264065e5a402f8cc3297086ac
+  data.tar.gz: 9beaf364fe5ec7ebb0933e3176d21bab366a603f7db2335c31cb61a6808f322d
+SHA512:
+  metadata.gz: e680e47549b85ca52746c7f2f4d1fa984f314f3a62cb78ebac391f7cd8291c6d13603cafac35dbba3e34ff65ca65ba53e5b20ce5cf9f424c4c945b2a3c06e0bf
+  data.tar.gz: add142be691cb74dcb6ca86f051471e75bfbee5868d0f44e3adf11aa819c74c3b608448cf176451f9725d3038927185dab70a3406b4199db579c78cc6d41cf82

data/ext/ruby_memprofiler_pprof/backtrace.c

@@ -0,0 +1,429 @@
+// External ruby headers
+#include <ruby.h>
+#include <ruby/debug.h>
+// Also include _INTERNAL_ ruby headers, from the debase-ruby_core_source gem.
+// This will let us reach into the guts of the Ruby interpreter in a very, VERY
+// API-unstable way.
+#include <vm_core.h>
+#include <iseq.h>
+
+#include "ruby_memprofiler_pprof.h"
+
+// We need access to the rb_vm_frame_method_entry method from vm_insnhelper.c; this function
+// gives us the method information for C functions in Ruby backtraces.
+// We have a prototype in vm_core.h, and the implementation in vm_insnhelper.c is "extern"
+// (i.e. it is not "static").
+//
+// That would _normally_ mean we can simply just call it, BUT - Ruby is compiled by default
+// with -fvisibility=hidden. That makes the function callable by other C files in the Ruby
+// source tree, but it's NOT callable from code in other .so files (like our C extension);
+// the linker marks the symbol as STV_HIDDEN in the .so file when it's linked. So, if we
+// simply try to call it, when requiring our extension, the dynamic loader will complain
+// that it can't resolve the symbol rb_vm_frame_method_entry.
+//
+// (In case you were wondering, other Ruby functions that are supposed to be called from
+// C extensions are marked with "#pragma GCC visibility push(default)", which marks the
+// function with "default visibility" and thus overrides -fvisibility=hidden and allows
+// the function to be called).
+//
+// To work around this, I copied the definition of rb_vm_frame_method_entry (and
+// check_method_entry, which it calls) into this file. I checked and the implementation
+// is pretty much identical from Ruby 2.6.0 -> 3.1.0 so this _should_ be OK. Note that
+// we also mark _our_ copy of this function as __attribute__(( visibility("hidden") ))
+// so that we don't export it either.
+
+static rb_callable_method_entry_t *
+check_method_entry(VALUE obj, int can_be_svar)
+{
+    if (obj == Qfalse) return NULL;
+
+#if VM_CHECK_MODE > 0
+    if (!RB_TYPE_P(obj, T_IMEMO)) rb_bug("check_method_entry: unknown type: %s", rb_obj_info(obj));
+#endif
+
+    switch (imemo_type(obj)) {
+        case imemo_ment:
+            return (rb_callable_method_entry_t *)obj;
+        case imemo_cref:
+            return NULL;
+        case imemo_svar:
+            if (can_be_svar) {
+                return check_method_entry(((struct vm_svar *)obj)->cref_or_me, 0);
+            }
+            // falls through
+        default:
+#if VM_CHECK_MODE > 0
+            rb_bug("check_method_entry: svar should not be there:");
+#endif
+            return NULL;
+    }
+}
+
+__attribute__(( visibility("hidden") ))
+const rb_callable_method_entry_t *
+rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
+{
+    const VALUE *ep = cfp->ep;
+    rb_callable_method_entry_t *me;
+
+    while (!VM_ENV_LOCAL_P(ep)) {
+        if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], 0)) != NULL) return me;
+        ep = VM_ENV_PREV_EP(ep);
+    }
+    return check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], 1);
+}
+
+// Allocates, initializes and returns a new location table. A location table keeps track of a mapping
+// of (compact!) location IDs to functions/line numbers. This keeps things in a convenient form for
+// later turning to pprof, but also makes sure that we don't store the same char *'s for function/file
+// names over and over again.
+// Requires a reference to a string interning table, which must be valid for the lifetime of this
+// loctab object.
+struct mpp_rb_loctab *mpp_rb_loctab_new(struct mpp_strtab *strtab) {
+    struct mpp_rb_loctab *loctab = mpp_xmalloc(sizeof(struct mpp_rb_loctab));
+    loctab->strtab = strtab;
+    loctab->functions = st_init_numtable();
+    loctab->locations = st_init_numtable();
+    loctab->function_count = 0;
+    loctab->location_count = 0;
+    return loctab;
+}
+
+// Destroys the loctab, including its own memory.
+void mpp_rb_loctab_destroy(struct mpp_rb_loctab *loctab) {
+    st_free_table(loctab->functions);
+    st_free_table(loctab->locations);
+    mpp_free(loctab);
+}
+
+struct fnloc_st_update_args {
+    struct mpp_rb_loctab *loctab;
+    uint64_t location_id;
+    uint64_t function_id;
+    struct mpp_rb_loctab_location *location;
+    struct mpp_rb_loctab_function *function;
+    VALUE fn_name_value;
+    VALUE file_name_value;
+    uint64_t location_line_number;
+    int64_t function_line_number;
+};
+
+
+static int function_st_update(st_data_t *key, st_data_t *value, st_data_t ctx, int exists) {
+    struct fnloc_st_update_args *args = (struct fnloc_st_update_args *)ctx;
+
+    if (exists) {
+        // Function already exists; put it in our outargs
+        args->function = (struct mpp_rb_loctab_function *)*value;
+    } else {
+        // Function doesn't exist; build it.
+        args->function = mpp_xmalloc(sizeof(struct mpp_rb_loctab_function));
+        *value = (st_data_t)args->function;
+        args->function->refcount = 0; // Will be incrmeented in backtrace_capture
+        args->function->id = args->function_id;
+        args->loctab->function_count++;
+
+        mpp_strtab_intern_rbstr(
+            args->loctab->strtab, args->fn_name_value,
+            &args->function->function_name, &args->function->function_name_len
+        );
+
+        if (RTEST(args->file_name_value)) {
+            mpp_strtab_intern_rbstr(
+                args->loctab->strtab, args->file_name_value,
+                &args->function->file_name, &args->function->file_name_len
+            );
+        } else {
+            mpp_strtab_intern_cstr(
+                args->loctab->strtab, "(unknown filename)",
+                &args->function->file_name, &args->function->file_name_len
+            );
+        }
+        args->function->line_number = args->function_line_number;
+    }
+
+    return ST_CONTINUE;
+}
+
+static int location_st_update(st_data_t *key, st_data_t *value, st_data_t ctx, int exists) {
+    struct fnloc_st_update_args *args = (struct fnloc_st_update_args *)ctx;
+
+    if (exists) {
+        // Location already exists - put it in our outargs.
+        args->location = (struct mpp_rb_loctab_location *)*value;
+        args->function = args->location->function;
+    } else {
+        // Location does not already exist. Make a new one.
+        args->location = mpp_xmalloc(sizeof(struct mpp_rb_loctab_location));
+        *value = (st_data_t)args->location;
+        args->location->refcount = 0; // will be incremented in backtrace_capture
+        args->location->id = args->location_id;
+        args->loctab->location_count++;
+
+        // Need to find a _function_ for it too.
+        st_update(args->loctab->functions, args->function_id, function_st_update, (st_data_t)args);
+        args->location->function = args->function;
+        args->location->line_number = args->location_line_number;
+    }
+
+    return ST_CONTINUE;
+}
+
+static int function_st_deref(st_data_t *key, st_data_t *value, st_data_t ctx, int exists) {
+    struct mpp_rb_loctab *loctab = (struct mpp_rb_loctab *)ctx;
+
+    MPP_ASSERT_MSG(exists, "attempted to decrement refcount on non-existing function");
+    struct mpp_rb_loctab_function *fn = (struct mpp_rb_loctab_function *)*value;
+    MPP_ASSERT_MSG(fn->refcount > 0, "attempted to decrement zero refcount on function");
+    fn->refcount--;
+    if (fn->refcount == 0) {
+        // Unref its string table entries.
+        mpp_strtab_release(loctab->strtab, fn->function_name, fn->function_name_len);
+        mpp_strtab_release(loctab->strtab, fn->file_name, fn->file_name_len);
+        mpp_free(fn);
+        loctab->function_count--;
+        return ST_DELETE;
+    }
+    return ST_CONTINUE;
+}
+
+static int location_st_deref(st_data_t *key, st_data_t *value, st_data_t ctx, int exists) {
+    struct mpp_rb_loctab *loctab = (struct mpp_rb_loctab *)ctx;
+
+    MPP_ASSERT_MSG(exists, "attempted to decrement refcount on non-existing location");
+    struct mpp_rb_loctab_location *loc = (struct mpp_rb_loctab_location *)*value;
+    MPP_ASSERT_MSG(loc->refcount > 0, "attempted to decrement zero refcount on location");
+    loc->refcount--;
+    if (loc->refcount == 0) {
+        // Deref its function too.
+        st_update(loctab->functions, loc->function->id, function_st_deref, (st_data_t)loctab);
+        mpp_free(loc);
+        loctab->location_count--;
+        return ST_DELETE;
+    }
+    return ST_CONTINUE;
+}
+
+// Captures a backtrace!
+//
+// This method uses internal Ruby headers to implement a rough copy of what backtrace_each in vm_backtrace.c
+// does. This is _TREMENDOUSLY_ faster than actually calling rb_make_backtrace, because that creates Ruby
+// VALUE objects to hold its result. Doing so from a newobj tracepoint is legal, AFAICT, but really slow
+// (from my profiling of the profiler, doing this causes the garbage collector to run, _a lot_, in the
+// middle of creating the original object).
+//
+// By poking directly at the VM internal structures, we can stuff the result into C structures and not
+// allocate any ruby VALUEs avoiding this issue. It's a _LOT_ faster - it takes the overhead from ~50%
+// (with 1% of allocations ampled), to < 1%. So it's definitely worthwhile despite how disgusting it is.
+//
+// Also note: This captures backtraces most recent call LAST, which is the opposite order to how the pprof
+// protobuf wants them, so they have to be reversed later. It's not so convenient to just capture it in
+// the correct order because we may have to skip some frames; thus if we filled in the frame array backwards,
+// we might not actually wind up filling frames[0].
+//
+// This method allocates a struct mpp_rb_backtrace and saves it to *bt_out. The reason for this awkward
+// calling convention (as opposed to just returning it) is so that the caller can detect if we got longjmp'd
+// out of here by some of the Ruby calls below, and appropriately destroy *bt_out via a call to destroy.
+void mpp_rb_backtrace_capture(struct mpp_rb_loctab *loctab, struct mpp_rb_backtrace **bt_out) {
+    const rb_control_frame_t *last_cfp = GET_EC()->cfp;
+    const rb_control_frame_t *start_cfp = RUBY_VM_END_CONTROL_FRAME(GET_EC());
+
+    // Allegedly, according to vm_backtrace.c, we need to skip the first two control frames because they
+    // are "dummy frames", whatever that means.
+    start_cfp = RUBY_VM_NEXT_CONTROL_FRAME(start_cfp);
+    start_cfp = RUBY_VM_NEXT_CONTROL_FRAME(start_cfp);
+
+    // Calculate how many frames are in this backtrace.
+    ptrdiff_t max_backtrace_size;
+    if (start_cfp < last_cfp) {
+        max_backtrace_size = 0;
+    } else {
+        max_backtrace_size = start_cfp - last_cfp + 1;
+    }
+
+    *bt_out = mpp_xmalloc(sizeof(struct mpp_rb_backtrace));
+    struct mpp_rb_backtrace *bt = *bt_out;
+    bt->frame_locations = mpp_xmalloc(sizeof(uint64_t) * max_backtrace_size);
+    // Set bt->frames_count to zero, to start with, and only increment it when we see a frame
+    // in the backtrace we can actually understand. We might skip over some of them, so max_backtrace_size
+    // is a maximum of how many frames there might be in the backtrace.
+    bt->frames_count = 0;
+    // But do keep track of the memsize
+    bt->memsize = sizeof(uint64_t) * max_backtrace_size;
+
+    ptrdiff_t i;
+    const rb_control_frame_t *cfp;
+    for (i = 0, cfp = start_cfp; i < max_backtrace_size; i++, cfp = RUBY_VM_NEXT_CONTROL_FRAME(cfp)) {
+
+        // Collect all the information we might need about this frame and store it in this struct
+        struct fnloc_st_update_args frame_args;
+        frame_args.loctab = loctab;
+        if (cfp->iseq && cfp->pc) {
+            // I believe means this backtrace frame is ruby code
+            size_t iseq_pos = (size_t)(cfp->pc - cfp->iseq->body->iseq_encoded);
+            // To quote Ruby:
+            // "use pos-1 because PC points next instruction at the beginning of instruction"
+            if (iseq_pos) iseq_pos--;
+            frame_args.location_line_number = rb_iseq_line_no(cfp->iseq, iseq_pos);
+            frame_args.fn_name_value = rb_iseq_method_name(cfp->iseq);
+            frame_args.file_name_value = rb_iseq_path(cfp->iseq);
+            frame_args.function_line_number = NUM2ULONG(rb_iseq_first_lineno(cfp->iseq));
+
+            // Use the object ID of the function name (which _should_ be interned, right, and so unique?)
+            // as the function ID.
+            frame_args.function_id = NUM2ULONG(rb_obj_id(frame_args.fn_name_value));
+            // Use the lower 48 bits (which is the sizeof an address on x86_64) of the function name,
+            // and the line number in the top 16 bits, as the "location id".
+            // Guess this won't work reliably if your function has more than 16k lines, in which case...
+            // ...just get a better function?
+            frame_args.location_id =
+                (frame_args.location_line_number << 48)  | (frame_args.function_id & 0x0000FFFFFFFFFFFF);
+
+        } else if (RUBYVM_CFUNC_FRAME_P(cfp)) {
+            // I believe means that this backtrace frame is a call to a cfunc
+
+
+            const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
+
+            frame_args.location_line_number = 0;
+            frame_args.function_line_number = 0;
+            frame_args.fn_name_value = rb_id2str(me->def->original_id);
+            frame_args.file_name_value = Qnil;
+
+            // Use the symbol ID of the method name (which is interned forever) as both the function
+            // ID and the location ID (since we have no line numbers).
+            frame_args.location_id = me->def->original_id;
+            frame_args.function_id = me->def->original_id;
+        } else {
+            // No idea what this means. It's silently ignored in vm_backtrace.c. Guess we will too.
+            continue;
+        }
+
+        // Store the location frame.
+        bt->frame_locations[bt->frames_count] = frame_args.location_id;
+        bt->frames_count++;
+
+        // Lookup, or allocate & store, the location/function struct.
+        st_update(loctab->locations, frame_args.location_id, location_st_update, (st_data_t)&frame_args);
+        // Either we created a new one, or looked up an existing one, but either way we need to bump its refcount.
+        frame_args.location->refcount++;
+        frame_args.function->refcount++;
+    }
+}
+
+void mpp_rb_backtrace_capture_slowrb(struct mpp_rb_loctab *loctab, struct mpp_rb_backtrace **bt_out) {
+    VALUE ruby_bt = rb_funcall(rb_thread_current(), rb_intern("backtrace_locations"), 0);
+    int64_t ruby_bt_len = RARRAY_LEN(ruby_bt);
+
+    *bt_out = mpp_xmalloc(sizeof(struct mpp_rb_backtrace));
+    struct mpp_rb_backtrace *bt = *bt_out;
+    bt->frame_locations = mpp_xmalloc(sizeof(uint64_t) * ruby_bt_len);
+    bt->frames_count = 0;
+    bt->memsize = sizeof(uint64_t) * ruby_bt_len;
+
+    for (int64_t i = 0; i < ruby_bt_len; i++) {
+        // The backtrace_locations result is backwards compared to the fast version.
+        VALUE ruby_bt_loc = RARRAY_AREF(ruby_bt, ruby_bt_len - i - 1);
+
+        // Intern the function name as the function ID, and the full string as the loc id.
+        VALUE fn_name = rb_funcall(ruby_bt_loc, rb_intern("base_label"), 0);
+        const char *fn_name_interned;
+        size_t fn_name_interned_len;
+        mpp_strtab_intern_rbstr(loctab->strtab, fn_name, &fn_name_interned, &fn_name_interned_len);
+        VALUE loc_name = rb_funcall(ruby_bt_loc, rb_intern("to_s"), 0);
+        const char *loc_name_interned;
+        size_t loc_name_interned_len;
+        mpp_strtab_intern_rbstr(loctab->strtab, loc_name, &loc_name_interned, &loc_name_interned_len);
+
+        VALUE file_name = rb_funcall(ruby_bt_loc, rb_intern("path"), 0);
+
+        VALUE line_no = rb_funcall(ruby_bt_loc, rb_intern("lineno"), 0);
+        uint64_t line_no_int = 0;
+        if (RTEST(line_no)) {
+            line_no_int = NUM2ULONG(line_no);
+        }
+
+        bt->frame_locations[i] = (uint64_t)loc_name_interned;
+        bt->frames_count++;
+
+        // Lookup, or allocate & store, the location/function struct.
+        struct fnloc_st_update_args frame_args;
+        frame_args.loctab = loctab;
+        frame_args.location_id = (uint64_t)loc_name_interned;
+        frame_args.location_line_number = line_no_int;
+        frame_args.fn_name_value = fn_name;
+        frame_args.file_name_value = file_name;
+        frame_args.function_line_number = 0;
+        frame_args.function_id = (uint64_t)fn_name_interned;
+        st_update(loctab->locations, frame_args.location_id, location_st_update, (st_data_t)&frame_args);
+        frame_args.location->refcount++;
+        frame_args.function->refcount++;
+
+        // We _DEFINITELY_ leak memory here. We interned the function name string/location string to use
+        // as the unique int64 location ID, but we're not freeing it here. This is because we need to keep
+        // it in the table so that it continues to be unique (and some other location doesn't wind up with
+        // the same ID).
+        // Since this method basically exists for benchmarking, and real users should be using the CFP
+        // method, I'll live with the leak for now until I figure out a better unique ID for the function.
+    }
+}
+
+void mpp_rb_backtrace_destroy(struct mpp_rb_loctab *loctab, struct mpp_rb_backtrace *bt) {
+    for (int64_t i = 0; i < bt->frames_count; i++) {
+        st_update(loctab->locations, bt->frame_locations[i], location_st_deref, (st_data_t)loctab);
+    }
+    mpp_free(bt->frame_locations);
+    mpp_free(bt);
+}
+
+size_t mpp_rb_backtrace_memsize(struct mpp_rb_backtrace *bt) {
+    return bt->memsize;
+}
+
+size_t mpp_rb_loctab_memsize(struct mpp_rb_loctab *loctab) {
+    return sizeof(*loctab) +
+        sizeof(struct mpp_rb_loctab_location) * loctab->location_count +
+        sizeof(struct mpp_rb_loctab_function) * loctab->function_count +
+        st_memsize(loctab->locations) +
+        st_memsize(loctab->functions);
+}
+
+struct mpp_rb_loctab_each_location_ctx {
+    mpp_rb_loctab_each_location_cb cb;
+    void *cb_ctx;
+    struct mpp_rb_loctab *loctab;
+};
+
+static int mpp_rb_loctab_each_location_thunk(st_data_t key, st_data_t value, st_data_t ctx) {
+    struct mpp_rb_loctab_each_location_ctx * thunkctx = (struct mpp_rb_loctab_each_location_ctx *)ctx;
+    struct mpp_rb_loctab_location *loc = (struct mpp_rb_loctab_location *)value;
+    return thunkctx->cb(thunkctx->loctab, loc, thunkctx->cb_ctx);
+}
+
+void mpp_rb_loctab_each_location(struct mpp_rb_loctab *loctab, mpp_rb_loctab_each_location_cb cb, void *ctx) {
+    struct mpp_rb_loctab_each_location_ctx thunkctx;
+    thunkctx.loctab = loctab;
+    thunkctx.cb = cb;
+    thunkctx.cb_ctx = ctx;
+    st_foreach(loctab->locations, mpp_rb_loctab_each_location_thunk, (st_data_t)&thunkctx);
+}
+
+struct mpp_rb_loctab_each_function_ctx {
+    mpp_rb_loctab_each_function_cb cb;
+    void *cb_ctx;
+    struct mpp_rb_loctab *loctab;
+};
+
+static int mpp_rb_loctab_each_function_thunk(st_data_t key, st_data_t value, st_data_t ctx) {
+    struct mpp_rb_loctab_each_function_ctx * thunkctx = (struct mpp_rb_loctab_each_function_ctx *)ctx;
+    struct mpp_rb_loctab_function *loc = (struct mpp_rb_loctab_function *)value;
+    return thunkctx->cb(thunkctx->loctab, loc, thunkctx->cb_ctx);
+}
+
+void mpp_rb_loctab_each_function(struct mpp_rb_loctab *loctab, mpp_rb_loctab_each_function_cb cb, void *ctx) {
+    struct mpp_rb_loctab_each_function_ctx thunkctx;
+    thunkctx.loctab = loctab;
+    thunkctx.cb = cb;
+    thunkctx.cb_ctx = ctx;
+    st_foreach(loctab->functions, mpp_rb_loctab_each_function_thunk, (st_data_t)&thunkctx);
+}