ruby_memprofiler_pprof 0.0.3 → 0.0.4

data/ext/ruby_memprofiler_pprof_ext/ruby_memprofiler_pprof.h

@@ -0,0 +1,183 @@
+#ifndef __RUBY_MEMPROFILER_PPROF_H
+#define __RUBY_MEMPROFILER_PPROF_H
+
+#include "extconf.h"
+
+#include <pthread.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <time.h>
+
+#include <backtracie.h>
+#include <ruby.h>
+
+// UPB header files trip up a BUNCH of -Wshorten-64-to-32
+// Also ignore -Wpragmas so that if -Wshorten-64-to-32 isn't present
+// (it's a clang only thing), GCC doesn't warn about the unknown warning.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Wshorten-64-to-32"
+#include "pprof.upb.h"
+#include <upb/upb.h>
+#pragma GCC diagnostic pop
+
+// ======== COMPAT DECLARATIONS ========
+
+// For handling differences in ruby versions
+#ifndef HAVE_RB_GC_MARK_MOVABLE
+#define rb_gc_mark_movable(v) rb_gc_mark(v)
+#endif
+
+#ifndef RB_PASS_KEYWORDS
+#define RB_SCAN_ARGS_LAST_HASH_KEYWORDS 3
+#define rb_scan_args_kw(kw, c, v, s, ...) rb_scan_args(c, v, s, __VA_ARGS__)
+#endif
+
+#ifndef HAVE_RB_EXT_RACTOR_SAFE
+#define rb_ext_ractor_safe(x)                                                                                          \
+  do {                                                                                                                 \
+  } while (0)
+#endif
+
+// Apparently "I just want a random number, without thinking about whether it's
+// threadsafe, without thinking about whether some other part of the process needs
+// the global seed to be set to some deterministic value, and without calling into
+// the kernel every time" is... too much to ask for.
+// BSD has arc4random(3) for this, but for glibc we have to use one of the threadsafe
+// RNG's and seed a global instance of it, guarded by a mutex....
+// These methods wrap all that rubbish up.
+uint32_t mpp_rand();
+void mpp_rand_init();
+
+// Wrapper to get monotonic time. Pre-sierra MacOS doesn't have clock_gettime, so we need a wrapper for this.
+// (n.b. - I haven't actually _implemented_ a fallback for pre-Sierra, but this is where we'd do it)
+// Returns time in nanoseconds.
+struct timespec mpp_gettime_monotonic();
+int64_t mpp_time_delta_nsec(struct timespec t1, struct timespec t2);
+
+// These declarations just wrap some things from the standard library that should "always succeed", but call
+// our assertion macro if they fail to abort the program.
+void *mpp_xmalloc(size_t sz);
+void *mpp_realloc(void *mem, size_t newsz);
+void mpp_free(void *mem);
+void mpp_pthread_mutex_lock(pthread_mutex_t *m);
+void mpp_pthread_mutex_unlock(pthread_mutex_t *m);
+int mpp_pthread_mutex_trylock(pthread_mutex_t *m);
+void mpp_pthread_mutex_init(pthread_mutex_t *m, const pthread_mutexattr_t *attr);
+void mpp_pthread_mutex_destroy(pthread_mutex_t *m);
+void mpp_pthread_mutexattr_init(pthread_mutexattr_t *a);
+void mpp_pthread_mutexattr_destroy(pthread_mutexattr_t *a);
+void mpp_pthread_mutexattr_settype(pthread_mutexattr_t *a, int type);
+void mpp_pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
+
+// Need a handy assertion macro. It would be nice to re-use rb_bug for some of this, but that actually
+// requires the GVL (it walks the Ruby stack frames, for one) and we (want to) run some code outside
+// the GVL, so this assertion macro has to be threadsafe. So we just implement it in pretty much a
+// similar way to how stdlib's assert() works (plus some stuff to prefix the gem name to the abort message
+// so users know who is at fault).
+#define MPP_ASSERT_STRINGIFY1(x) #x
+#define MPP_ASSERT_STRINGIFY2(x) MPP_ASSERT_STRINGIFY1(x)
+#define MPP_ASSERT__LINE MPP_ASSERT_STRINGIFY2(__LINE__)
+__attribute__((noreturn)) void mpp_assert_fail(const char *msg, const char *assertion, const char *file,
+                                               const char *line, const char *fn);
+#define MPP_ASSERT_MSG(expr, msg)                                                                                      \
+  do {                                                                                                                 \
+    if ((expr) == 0) {                                                                                                 \
+      mpp_assert_fail((msg), #expr, __FILE__, MPP_ASSERT__LINE, __func__);                                             \
+    }                                                                                                                  \
+  } while (0)
+#define MPP_ASSERT_FAIL(msg) MPP_ASSERT_MSG(0, msg)
+
+// Log a debug message to "somewhere". This could be smarter in future, but for now, this'll do.
+// The implementation here does not depend on holding the GVL.
+// Will automatically add a trailing newline.
+void mpp_log_debug(const char *pattern, ...);
+
+// ======== RUBY HACKS DECLARATIONS ========
+
+// An implementation of rb_gc_disable_no_rest; disables the GC without itself triggering
+// the finalisation of the current sweep phase of the GC.
+VALUE mpp_rb_gc_disable_no_rest();
+// An implementation of rb_obj_memsize_of; tells us how big an object is.
+VALUE mpp_rb_obj_memsize_of(VALUE obj);
+// Tells us whether the given VALUE is valid enough still for rb_obj_memsize_of to
+// work on it.
+bool mpp_is_value_still_validish(VALUE obj);
+// Is some other thread blocked waiting for the GVL?
+bool mpp_is_someone_else_waiting_for_gvl();
+// Like rb_ivar_set, but ignore frozen status.
+VALUE mpp_rb_ivar_set_ignore_frozen(VALUE obj, ID key, VALUE value);
+
+// ======== SAMPLE DECLARATIONS ========
+
+// The struct mpp_sample is the core type for the data collected by ruby_memprofiler_pprof.
+
+struct mpp_sample {
+  // VALUE of the sampled object that was allocated, or Qundef it it's freed.
+  VALUE allocated_value_weak;
+  size_t allocated_value_objsize;
+  size_t frames_count;
+  size_t frames_capacity;
+  unsigned int flush_epoch;
+  minimal_location_t frames[];
+};
+
+// Captures a backtrace for a sample using Backtracie. The resulting sample contains VALUES inside
+// the raw_location struct whcih need to be marked.
+struct mpp_sample *mpp_sample_capture(VALUE allocated_value_weak);
+// Total size of all things owned by the sample, for accounting purposes
+size_t mpp_sample_memsize(struct mpp_sample *sample);
+// free the sample
+void mpp_sample_free(struct mpp_sample *sample);
+// Fill in a provided buffer with the name of a frame.
+size_t mpp_sample_frame_function_name(struct mpp_sample *sample, int frame_index, char *outbuf, size_t outbuf_len);
+// Fill in a provided buffer with the filename of a frame
+size_t mpp_sample_frame_file_name(struct mpp_sample *sample, int frame_index, char *outbuf, size_t outbuf_len);
+// Get the line number of a frame.
+int mpp_sample_frame_line_number(struct mpp_sample *sample, int frame_index);
+
+// ======== PROTO SERIALIZATION ROUTINES ========
+struct mpp_pprof_serctx {
+  // Defines the allocation routine & memory arena used by this serialisation context. When the ctx
+  // is destroyed, we free the entire arena, so no other (protobuf) memory needs to be individually
+  // freed.
+  upb_alloc allocator;
+  upb_Arena *arena;
+  // Map of function ID -> function protobuf
+  st_table *function_pbs;
+  // Map of (function ID, line number) -> location protobufs
+  st_table *location_pbs;
+  // Map of (function name string ID, file name string ID) -> function ID
+  st_table *function_ids;
+  // Counter for assigning location IDs
+  uint64_t loc_counter;
+  // Counter for assigning function IDs
+  uint64_t function_id_counter;
+  // Map of (string, len) -> string table index
+  st_table *strings;
+  // Counter for assigning string table indexes.
+  int strings_counter;
+  // The protobuf representation we are building up.
+  perftools_profiles_Profile *profile_proto;
+
+  // A buffer which, if non-NULL, points into the upb arena and can be stolen for interning strings.
+  char *scratch_buffer;
+  size_t scratch_buffer_strlen;
+  size_t scratch_buffer_capa;
+
+  // Toggle to interrupt (toggled from Ruby's GVL unblocking function)
+  uint8_t interrupt;
+};
+
+struct mpp_pprof_serctx *mpp_pprof_serctx_new(char *errbuf, size_t errbuflen);
+void mpp_pprof_serctx_destroy(struct mpp_pprof_serctx *ctx);
+int mpp_pprof_serctx_add_sample(struct mpp_pprof_serctx *ctx, struct mpp_sample *sample, char *errbuf,
+                                size_t errbuflen);
+int mpp_pprof_serctx_serialize(struct mpp_pprof_serctx *ctx, char **buf_out, size_t *buflen_out, char *errbuf,
+                               size_t errbuflen);
+
+// ======== COLLECTOR RUBY CLASS ========
+void mpp_setup_collector_class();
+
+#endif

data/ext/ruby_memprofiler_pprof_ext/ruby_private/ruby26/gc_private.h

@@ -0,0 +1,324 @@
+#ifndef GC_PRIVATE_H
+#define GC_PRIVATE_H
+
+
+typedef struct RVALUE {
+    union {
+	struct {
+	    VALUE flags;		/* always 0 for freed obj */
+	    struct RVALUE *next;
+	} free;
+	struct RBasic  basic;
+	struct RObject object;
+	struct RClass  klass;
+	struct RFloat  flonum;
+	struct RString string;
+	struct RArray  array;
+	struct RRegexp regexp;
+	struct RHash   hash;
+	struct RData   data;
+	struct RTypedData   typeddata;
+	struct RStruct rstruct;
+	struct RBignum bignum;
+	struct RFile   file;
+	struct RMatch  match;
+	struct RRational rational;
+	struct RComplex complex;
+	union {
+	    rb_cref_t cref;
+	    struct vm_svar svar;
+	    struct vm_throw_data throw_data;
+	    struct vm_ifunc ifunc;
+	    struct MEMO memo;
+	    struct rb_method_entry_struct ment;
+	    const rb_iseq_t iseq;
+	    rb_env_t env;
+	    struct rb_imemo_tmpbuf_struct alloc;
+	    rb_ast_t ast;
+	} imemo;
+	struct {
+	    struct RBasic basic;
+	    VALUE v1;
+	    VALUE v2;
+	    VALUE v3;
+	} values;
+    } as;
+#if GC_DEBUG
+    const char *file;
+    int line;
+#endif
+} RVALUE;
+
+#define RANY(o) ((RVALUE*)(o))
+#define STACK_CHUNK_SIZE 500
+
+typedef struct stack_chunk {
+    VALUE data[STACK_CHUNK_SIZE];
+    struct stack_chunk *next;
+} stack_chunk_t;
+
+typedef struct mark_stack {
+    stack_chunk_t *chunk;
+    stack_chunk_t *cache;
+    int index;
+    int limit;
+    size_t cache_size;
+    size_t unused_cache_size;
+} mark_stack_t;
+
+typedef struct rb_heap_struct {
+    RVALUE *freelist;
+
+    struct heap_page *free_pages;
+    struct heap_page *using_page;
+    struct list_head pages;
+    struct heap_page *sweeping_page; /* iterator for .pages */
+#if GC_ENABLE_INCREMENTAL_MARK
+    struct heap_page *pooled_pages;
+#endif
+    size_t total_pages;      /* total page count in a heap */
+    size_t total_slots;      /* total slot count (about total_pages * HEAP_PAGE_OBJ_LIMIT) */
+} rb_heap_t;
+
+typedef uintptr_t bits_t;
+enum {
+    BITS_SIZE = sizeof(bits_t),
+    BITS_BITLENGTH = ( BITS_SIZE * CHAR_BIT )
+};
+
+struct heap_page_header {
+    struct heap_page *page;
+};
+
+struct heap_page_body {
+    struct heap_page_header header;
+    /* char gap[];      */
+    /* RVALUE values[]; */
+};
+
+
+/* default tiny heap size: 16KB */
+#define HEAP_PAGE_ALIGN_LOG 14
+#define CEILDIV(i, mod) (((i) + (mod) - 1)/(mod))
+enum {
+    HEAP_PAGE_ALIGN = (1UL << HEAP_PAGE_ALIGN_LOG),
+    HEAP_PAGE_ALIGN_MASK = (~(~0UL << HEAP_PAGE_ALIGN_LOG)),
+    REQUIRED_SIZE_BY_MALLOC = (sizeof(size_t) * 5),
+    HEAP_PAGE_SIZE = (HEAP_PAGE_ALIGN - REQUIRED_SIZE_BY_MALLOC),
+    HEAP_PAGE_OBJ_LIMIT = (unsigned int)((HEAP_PAGE_SIZE - sizeof(struct heap_page_header))/sizeof(struct RVALUE)),
+    HEAP_PAGE_BITMAP_LIMIT = CEILDIV(CEILDIV(HEAP_PAGE_SIZE, sizeof(struct RVALUE)), BITS_BITLENGTH),
+    HEAP_PAGE_BITMAP_SIZE = (BITS_SIZE * HEAP_PAGE_BITMAP_LIMIT),
+    HEAP_PAGE_BITMAP_PLANES = USE_RGENGC ? 4 : 1 /* RGENGC: mark, unprotected, uncollectible, marking */
+};
+
+struct heap_page {
+    short total_slots;
+    short free_slots;
+    short final_slots;
+    struct {
+        unsigned int before_sweep: 1;
+        unsigned int has_remembered_objects: 1;
+        unsigned int has_uncollectible_shady_objects: 1;
+        unsigned int in_tomb: 1;
+    } flags;
+
+    struct heap_page *free_next;
+    RVALUE *start;
+    RVALUE *freelist;
+    struct list_node page_node;
+
+#if USE_RGENGC
+    bits_t wb_unprotected_bits[HEAP_PAGE_BITMAP_LIMIT];
+#endif
+    /* the following three bitmaps are cleared at the beginning of full GC */
+    bits_t mark_bits[HEAP_PAGE_BITMAP_LIMIT];
+#if USE_RGENGC
+    bits_t uncollectible_bits[HEAP_PAGE_BITMAP_LIMIT];
+    bits_t marking_bits[HEAP_PAGE_BITMAP_LIMIT];
+#endif
+};
+
+typedef struct gc_profile_record {
+    int flags;
+
+    double gc_time;
+    double gc_invoke_time;
+
+    size_t heap_total_objects;
+    size_t heap_use_size;
+    size_t heap_total_size;
+
+#if GC_PROFILE_MORE_DETAIL
+    double gc_mark_time;
+    double gc_sweep_time;
+
+    size_t heap_use_pages;
+    size_t heap_live_objects;
+    size_t heap_free_objects;
+
+    size_t allocate_increase;
+    size_t allocate_limit;
+
+    double prepare_time;
+    size_t removing_objects;
+    size_t empty_objects;
+#if GC_PROFILE_DETAIL_MEMORY
+    long maxrss;
+    long minflt;
+    long majflt;
+#endif
+#endif
+#if MALLOC_ALLOCATED_SIZE
+    size_t allocated_size;
+#endif
+
+#if RGENGC_PROFILE > 0
+    size_t old_objects;
+    size_t remembered_normal_objects;
+    size_t remembered_shady_objects;
+#endif
+} gc_profile_record;
+
+typedef struct rb_objspace {
+    struct {
+	size_t limit;
+	size_t increase;
+#if MALLOC_ALLOCATED_SIZE
+	size_t allocated_size;
+	size_t allocations;
+#endif
+    } malloc_params;
+
+    struct {
+	unsigned int mode : 2;
+	unsigned int immediate_sweep : 1;
+	unsigned int dont_gc : 1;
+	unsigned int dont_incremental : 1;
+	unsigned int during_gc : 1;
+	unsigned int gc_stressful: 1;
+	unsigned int has_hook: 1;
+#if USE_RGENGC
+	unsigned int during_minor_gc : 1;
+#endif
+#if GC_ENABLE_INCREMENTAL_MARK
+	unsigned int during_incremental_marking : 1;
+#endif
+    } flags;
+
+    rb_event_flag_t hook_events;
+    size_t total_allocated_objects;
+
+    rb_heap_t eden_heap;
+    rb_heap_t tomb_heap; /* heap for zombies and ghosts */
+
+    struct {
+	rb_atomic_t finalizing;
+    } atomic_flags;
+
+    struct mark_func_data_struct {
+	void *data;
+	void (*mark_func)(VALUE v, void *data);
+    } *mark_func_data;
+
+    mark_stack_t mark_stack;
+    size_t marked_slots;
+
+    struct {
+	struct heap_page **sorted;
+	size_t allocated_pages;
+	size_t allocatable_pages;
+	size_t sorted_length;
+	RVALUE *range[2];
+	size_t freeable_pages;
+
+	/* final */
+	size_t final_slots;
+	VALUE deferred_final;
+    } heap_pages;
+
+    st_table *finalizer_table;
+
+    struct {
+	int run;
+	int latest_gc_info;
+	gc_profile_record *records;
+	gc_profile_record *current_record;
+	size_t next_index;
+	size_t size;
+
+#if GC_PROFILE_MORE_DETAIL
+	double prepare_time;
+#endif
+	double invoke_time;
+
+#if USE_RGENGC
+	size_t minor_gc_count;
+	size_t major_gc_count;
+#if RGENGC_PROFILE > 0
+	size_t total_generated_normal_object_count;
+	size_t total_generated_shady_object_count;
+	size_t total_shade_operation_count;
+	size_t total_promoted_count;
+	size_t total_remembered_normal_object_count;
+	size_t total_remembered_shady_object_count;
+
+#if RGENGC_PROFILE >= 2
+	size_t generated_normal_object_count_types[RUBY_T_MASK];
+	size_t generated_shady_object_count_types[RUBY_T_MASK];
+	size_t shade_operation_count_types[RUBY_T_MASK];
+	size_t promoted_types[RUBY_T_MASK];
+	size_t remembered_normal_object_count_types[RUBY_T_MASK];
+	size_t remembered_shady_object_count_types[RUBY_T_MASK];
+#endif
+#endif /* RGENGC_PROFILE */
+#endif /* USE_RGENGC */
+
+	/* temporary profiling space */
+	double gc_sweep_start_time;
+	size_t total_allocated_objects_at_gc_start;
+	size_t heap_used_at_gc_start;
+
+	/* basic statistics */
+	size_t count;
+	size_t total_freed_objects;
+	size_t total_allocated_pages;
+	size_t total_freed_pages;
+    } profile;
+    struct gc_list *global_list;
+
+    VALUE gc_stress_mode;
+
+#if USE_RGENGC
+    struct {
+	VALUE parent_object;
+	int need_major_gc;
+	size_t last_major_gc;
+	size_t uncollectible_wb_unprotected_objects;
+	size_t uncollectible_wb_unprotected_objects_limit;
+	size_t old_objects;
+	size_t old_objects_limit;
+
+#if RGENGC_ESTIMATE_OLDMALLOC
+	size_t oldmalloc_increase;
+	size_t oldmalloc_increase_limit;
+#endif
+
+#if RGENGC_CHECK_MODE >= 2
+	struct st_table *allrefs_table;
+	size_t error_count;
+#endif
+    } rgengc;
+#if GC_ENABLE_INCREMENTAL_MARK
+    struct {
+	size_t pooled_slots;
+	size_t step_slots;
+    } rincgc;
+#endif
+#endif /* USE_RGENGC */
+
+#if GC_DEBUG_STRESS_TO_CLASS
+    VALUE stress_to_class;
+#endif
+} rb_objspace_t;
+
+#endif