memprof 0.3.2 → 0.3.3

data/ext/tracers/memory.c

@@ -0,0 +1,202 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "arch.h"
+#include "bin_api.h"
+#include "json.h"
+#include "tracer.h"
+#include "tramp.h"
+#include "util.h"
+
+struct memprof_memory_stats {
+  size_t malloc_bytes_requested;
+  size_t calloc_bytes_requested;
+  size_t realloc_bytes_requested;
+
+  size_t malloc_bytes_actual;
+  size_t calloc_bytes_actual;
+  size_t realloc_bytes_actual;
+  size_t free_bytes_actual;
+
+  size_t malloc_calls;
+  size_t calloc_calls;
+  size_t realloc_calls;
+  size_t free_calls;
+};
+
+static struct tracer tracer;
+static struct memprof_memory_stats stats;
+static size_t (*malloc_usable_size)(void *ptr);
+
+static void *
+malloc_tramp(size_t size)
+{
+  void *ret = NULL;
+  int err;
+
+  ret = malloc(size);
+  err = errno;
+
+  stats.malloc_bytes_requested += size;
+  stats.malloc_calls++;
+
+  if (ret)
+    stats.malloc_bytes_actual += malloc_usable_size(ret);
+
+  errno = err;
+  return ret;
+}
+
+static void *
+calloc_tramp(size_t nmemb, size_t size)
+{
+  void *ret = NULL;
+  int err;
+
+  ret = calloc(nmemb, size);
+  err = errno;
+
+  stats.calloc_bytes_requested += (nmemb * size);
+  stats.calloc_calls++;
+
+  if (ret)
+    stats.calloc_bytes_actual += malloc_usable_size(ret);
+
+  errno = err;
+  return ret;
+}
+
+static void *
+realloc_tramp(void *ptr, size_t size)
+{
+  void *ret = NULL;
+  int err;
+
+  ret = realloc(ptr, size);
+  err = errno;
+
+  stats.realloc_bytes_requested += size;
+  stats.realloc_calls++;
+
+  if (ret)
+    stats.realloc_bytes_actual += malloc_usable_size(ret);
+
+  errno = err;
+  return ret;
+}
+
+static void
+free_tramp(void *ptr)
+{
+  if (ptr)
+    stats.free_bytes_actual += malloc_usable_size(ptr);
+
+  stats.free_calls++;
+
+  free(ptr);
+}
+
+static void
+malloc_trace_start()
+{
+  static int inserted = 0;
+
+  if (!inserted)
+    inserted = 1;
+  else
+    return;
+
+  if (!malloc_usable_size) {
+    malloc_usable_size = bin_find_symbol("MallocExtension_GetAllocatedSize", NULL, 1);
+    if (!malloc_usable_size) {
+      dbg_printf("tcmalloc was not found...\n");
+      malloc_usable_size = bin_find_symbol("malloc_usable_size", NULL, 1);
+    }
+    if (!malloc_usable_size) {
+      dbg_printf("malloc_usable_size was not found...\n");
+      malloc_usable_size = bin_find_symbol("malloc_size", NULL, 1);
+    }
+    assert(malloc_usable_size != NULL);
+    dbg_printf("malloc_usable_size: %p\n", malloc_usable_size);
+  }
+
+  insert_tramp("malloc", malloc_tramp);
+  insert_tramp("realloc", realloc_tramp);
+  insert_tramp("calloc", calloc_tramp);
+  insert_tramp("free", free_tramp);
+}
+
+static void
+malloc_trace_stop()
+{
+}
+
+static void
+malloc_trace_reset()
+{
+  memset(&stats, 0, sizeof(stats));
+}
+
+static void
+malloc_trace_dump(json_gen gen)
+{
+  if (stats.malloc_calls > 0) {
+    json_gen_cstr(gen, "malloc");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.malloc_calls);
+    json_gen_cstr(gen, "requested");
+    json_gen_integer(gen, stats.malloc_bytes_requested);
+    json_gen_cstr(gen, "actual");
+    json_gen_integer(gen, stats.malloc_bytes_actual);
+    json_gen_map_close(gen);
+  }
+
+  if (stats.realloc_calls > 0) {
+    json_gen_cstr(gen, "realloc");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.realloc_calls);
+    json_gen_cstr(gen, "requested");
+    json_gen_integer(gen, stats.realloc_bytes_requested);
+    json_gen_cstr(gen, "actual");
+    json_gen_integer(gen, stats.realloc_bytes_actual);
+    json_gen_map_close(gen);
+  }
+
+  if (stats.calloc_calls > 0) {
+    json_gen_cstr(gen, "calloc");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.calloc_calls);
+    json_gen_cstr(gen, "requested");
+    json_gen_integer(gen, stats.calloc_bytes_requested);
+    json_gen_cstr(gen, "actual");
+    json_gen_integer(gen, stats.calloc_bytes_actual);
+    json_gen_map_close(gen);
+  }
+
+  if (stats.free_calls > 0) {
+    json_gen_cstr(gen, "free");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.free_calls);
+    json_gen_cstr(gen, "actual");
+    json_gen_integer(gen, stats.free_bytes_actual);
+    json_gen_map_close(gen);
+  }
+}
+
+void install_malloc_tracer()
+{
+  tracer.start = malloc_trace_start;
+  tracer.stop = malloc_trace_stop;
+  tracer.reset = malloc_trace_reset;
+  tracer.dump = malloc_trace_dump;
+  tracer.id = "memory";
+
+  trace_insert(&tracer);
+}

data/ext/tracers/mysql.c

@@ -0,0 +1,82 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+
+#include "arch.h"
+#include "bin_api.h"
+#include "json.h"
+#include "tracer.h"
+#include "tramp.h"
+#include "util.h"
+
+struct memprof_mysql_stats {
+  size_t query_calls;
+  double query_time;
+};
+
+static struct tracer tracer;
+static struct memprof_mysql_stats stats;
+static int (*orig_real_query)(void *mysql, const char *stmt_str, unsigned long length);
+
+static int
+real_query_tramp(void *mysql, const char *stmt_str, unsigned long length) {
+  double secs = 0;
+  int ret;
+
+  secs = timeofday();
+  ret = orig_real_query(mysql, stmt_str, length);
+  secs = timeofday() - secs;
+
+  stats.query_time += secs;
+  stats.query_calls++;
+
+  return ret;
+}
+
+static void
+mysql_trace_start() {
+  static int inserted = 0;
+
+  if (!inserted)
+    inserted = 1;
+  else
+    return;
+
+  orig_real_query = bin_find_symbol("mysql_real_query", NULL, 1);
+  if (orig_real_query)
+    insert_tramp("mysql_real_query", real_query_tramp);
+}
+
+static void
+mysql_trace_stop() {
+}
+
+static void
+mysql_trace_reset() {
+  memset(&stats, 0, sizeof(stats));
+}
+
+static void
+mysql_trace_dump(json_gen gen) {
+  if (stats.query_calls > 0) {
+    json_gen_cstr(gen, "queries");
+    json_gen_integer(gen, stats.query_calls);
+
+    json_gen_cstr(gen, "time");
+    json_gen_double(gen, stats.query_time);
+  }
+}
+
+void install_mysql_tracer()
+{
+  tracer.start = mysql_trace_start;
+  tracer.stop = mysql_trace_stop;
+  tracer.reset = mysql_trace_reset;
+  tracer.dump = mysql_trace_dump;
+  tracer.id = "mysql";
+
+  trace_insert(&tracer);
+}

data/ext/tracers/objects.c

@@ -0,0 +1,160 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "arch.h"
+#include "bin_api.h"
+#include "json.h"
+#include "tracer.h"
+#include "tramp.h"
+#include "util.h"
+#include "ruby.h"
+
+struct memprof_objects_stats {
+  size_t newobj_calls;
+  size_t types[T_MASK+1];
+};
+
+static struct tracer tracer;
+static struct memprof_objects_stats stats;
+static VALUE (*orig_rb_newobj)();
+
+static VALUE last_obj = 0;
+static VALUE gc_hook = 0;
+
+static void
+record_last_obj()
+{
+  if (last_obj) {
+    stats.types[BUILTIN_TYPE(last_obj)]++;
+    last_obj = 0;
+  }
+}
+
+static VALUE
+objects_tramp() {
+  record_last_obj();
+  stats.newobj_calls++;
+  last_obj = orig_rb_newobj();
+  return last_obj;
+}
+
+static void
+objects_trace_start() {
+  static int inserted = 0;
+
+  if (!inserted)
+    inserted = 1;
+  else
+    return;
+
+  orig_rb_newobj = bin_find_symbol("rb_newobj", NULL, 0);
+  assert(orig_rb_newobj != NULL);
+  dbg_printf("orig_rb_newobj: %p\n", orig_rb_newobj);
+
+  insert_tramp("rb_newobj", objects_tramp);
+}
+
+static void
+objects_trace_stop() {
+}
+
+static void
+objects_trace_reset() {
+  memset(&stats, 0, sizeof(stats));
+  last_obj = 0;
+}
+
+static inline char*
+type_string(int type) {
+  switch (type) {
+    case T_NONE:
+      return "none";
+    case T_NIL:
+      return "nil";
+    case T_OBJECT:
+      return "object";
+    case T_CLASS:
+      return "class";
+    case T_ICLASS:
+      return "iclass";
+    case T_MODULE:
+      return "module";
+    case T_FLOAT:
+      return "float";
+    case T_STRING:
+      return "string";
+    case T_REGEXP:
+      return "regexp";
+    case T_ARRAY:
+      return "array";
+    case T_FIXNUM:
+      return "fixnum";
+    case T_HASH:
+      return "hash";
+    case T_STRUCT:
+      return "struct";
+    case T_BIGNUM:
+      return "bignum";
+    case T_FILE:
+      return "file";
+    case T_TRUE:
+      return "true";
+    case T_FALSE:
+      return "false";
+    case T_DATA:
+      return "data";
+    case T_MATCH:
+      return "match";
+    case T_SYMBOL:
+      return "symbol";
+    case T_BLKTAG:
+      return "blktag";
+    case T_UNDEF:
+      return "undef";
+    case T_VARMAP:
+      return "varmap";
+    case T_SCOPE:
+      return "scope";
+    case T_NODE:
+      return "node";
+    default:
+      return "unknown";
+  }
+}
+
+static void
+objects_trace_dump(json_gen gen) {
+  int i;
+  record_last_obj();
+
+  json_gen_cstr(gen, "created");
+  json_gen_integer(gen, stats.newobj_calls);
+
+  json_gen_cstr(gen, "types");
+  json_gen_map_open(gen);
+  for (i=0; i<T_MASK+1; i++) {
+    if (stats.types[i] > 0) {
+      json_gen_cstr(gen, type_string(i));
+      json_gen_integer(gen, stats.types[i]);
+    }
+  }
+  json_gen_map_close(gen);
+}
+
+void install_objects_tracer()
+{
+  if (!gc_hook) {
+    gc_hook = Data_Wrap_Struct(rb_cObject, record_last_obj, NULL, NULL);
+    rb_global_variable(&gc_hook);
+  }
+
+  tracer.start = objects_trace_start;
+  tracer.stop = objects_trace_stop;
+  tracer.reset = objects_trace_reset;
+  tracer.dump = objects_trace_dump;
+  tracer.id = "objects";
+
+  trace_insert(&tracer);
+}

data/ext/tramp.c

@@ -107,7 +107,7 @@ hook_freelist(int entry, void *tramp)
     }
 
     /* if we've looked at all the bytes in this function... */
-    if (((void *)byte - freelist_inliners[i]) >= sizes[i]) {
+    if ((size_t)((void *)byte - freelist_inliners[i]) >= sizes[i]) {
       /* move on to the next function */
       i++;
       byte = freelist_inliners[i];
@@ -123,7 +123,7 @@ hook_freelist(int entry, void *tramp)
 void
 insert_tramp(const char *trampee, void *tramp)
 {
-  void *trampee_addr = bin_find_symbol(trampee, NULL, 0);
+  void *trampee_addr = bin_find_symbol(trampee, NULL, 1);
   int inline_ent = inline_tramp_size;
 
   if (trampee_addr == NULL) {