memprof 0.3.2 → 0.3.3

data/ext/mmap.h

@@ -0,0 +1,73 @@
+/*
+ * Following code taken from http://thebends.googlecode.com/svn/trunk/mach-o/mmap.c
+ * Copyright: Allen Porter <allen@thebends.org>
+ */
+#ifndef __MMAP_H__
+#define __MMAP_H__
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <mach/vm_param.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+/*
+ * Simple utililty methods for mmaping files.
+ */
+
+struct mmap_info {
+  const char *name; /* filename */
+  int fd;           /* file descriptor */
+  size_t data_size; /* size of file */
+  void* data;       /* mmap'd writable contents of file */
+};
+
+/*
+ * Open a file, memory map its contents, and populate mmap_info. Requires a
+ * filename.
+ */
+int mmap_file_open(struct mmap_info *file_info) {
+  assert(file_info != NULL);
+  file_info->fd = open(file_info->name, O_RDONLY);
+  if (file_info->fd < 0) {
+    perror("open");
+    return -1;
+  }
+  struct stat sb;
+  if (fstat(file_info->fd, &sb) < 0) {
+    perror("fstat");
+    return -1;
+  }
+  file_info->data_size = (size_t)sb.st_size;
+  size_t map_size = file_info->data_size;
+  file_info->data = mmap(0, map_size,
+                         PROT_READ,
+                         MAP_FILE | MAP_SHARED,
+                         file_info->fd, /* offset */0);
+  if (file_info->data == MAP_FAILED) {
+    perror("mmap");
+    return -1;
+  }
+  return 0;
+}
+
+/*
+ * Unmemory map and close the file in file_info.
+ */
+int munmap_file(struct mmap_info *file_info) {
+  if (munmap(file_info->data, file_info->data_size) < 0) {
+    perror("munmap");
+    return -1;
+  }
+  if (close(file_info->fd) < 0) {
+    perror("close");
+    return -1;
+  }
+  return 0;
+}
+
+#endif  /* __MMAP_H__ */

data/ext/tracer.c

@@ -1,10 +1,14 @@
 #include <assert.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "json.h"
 #include "tracer.h"
 #include "util.h"
 
+static json_gen tracing_json_gen = NULL;
+
 /*
    XXX if we ever need a linked list for anything else ever, remove this crap
        and switch to a generic macro-based linked list implementation
@@ -38,7 +42,6 @@ trace_remove(const char *id)
   while (tmp) {
     if (strcmp(id, tmp->tracer->id) == 0) {
       tmp->next = tmp->next;
-      free(tmp->tracer->id);
       free(tmp->tracer);
       free(tmp);
       return 0;
@@ -64,7 +67,10 @@ do_trace_invoke(struct tracer *trace, trace_fn fn)
       trace->reset();
       break;
     case TRACE_DUMP:
-      trace->dump();
+      json_gen_cstr(tracing_json_gen, trace->id);
+      json_gen_map_open(tracing_json_gen);
+      trace->dump(tracing_json_gen);
+      json_gen_map_close(tracing_json_gen);
       break;
     default:
       dbg_printf("invoked a non-existant trace function type: %d", fn);
@@ -97,3 +103,15 @@ trace_invoke(const char *id, trace_fn fn)
   }
   return 0;
 }
+
+void
+trace_set_output(json_gen gen)
+{
+  tracing_json_gen = gen;
+}
+
+json_gen
+trace_get_output()
+{
+  return tracing_json_gen;
+}

data/ext/tracer.h

@@ -1,12 +1,14 @@
 #if !defined(__TRACER__H_)
 #define __TRACER__H_
 
+#include "json.h"
+
 struct tracer {
   char *id;
   void (*start)();
   void (*stop)();
   void (*reset)();
-  void (*dump)();
+  void (*dump)(json_gen);
 };
 
 typedef enum {
@@ -28,6 +30,17 @@ trace_invoke_all(trace_fn fn);
 int
 trace_invoke(const char *id, trace_fn fn);
 
+void
+trace_set_output(json_gen gen);
+
+json_gen
+trace_get_output();
+
 /* for now, these will live here */
 extern void install_malloc_tracer();
+extern void install_gc_tracer();
+extern void install_fd_tracer();
+extern void install_mysql_tracer();
+extern void install_objects_tracer();
+extern void install_memcache_tracer();
 #endif

data/ext/tracers/fd.c

@@ -0,0 +1,204 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "arch.h"
+#include "bin_api.h"
+#include "json.h"
+#include "tracer.h"
+#include "tramp.h"
+#include "util.h"
+
+struct memprof_fd_stats {
+  size_t read_calls;
+  double read_time;
+  size_t read_requested_bytes;
+  size_t read_actual_bytes;
+
+  size_t write_calls;
+  double write_time;
+  size_t write_requested_bytes;
+  size_t write_actual_bytes;
+
+  size_t connect_calls;
+  double connect_time;
+
+  size_t select_calls;
+  double select_time;
+};
+
+static struct tracer tracer;
+static struct memprof_fd_stats stats;
+
+static ssize_t
+read_tramp(int fildes, void *buf, size_t nbyte) {
+  double secs = 0;
+  int err;
+  ssize_t ret;
+
+  secs = timeofday();
+  ret = read(fildes, buf, nbyte);
+  err = errno;
+  secs = timeofday() - secs;
+
+  stats.read_time += secs;
+  stats.read_calls++;
+  stats.read_requested_bytes += nbyte;
+  if (ret > 0)
+    stats.read_actual_bytes += ret;
+
+  errno = err;
+  return ret;
+}
+
+static ssize_t
+write_tramp(int fildes, const void *buf, size_t nbyte) {
+  double secs = 0;
+  int err;
+  ssize_t ret;
+
+  secs = timeofday();
+  ret = write(fildes, buf, nbyte);
+  err = errno;
+  secs = timeofday() - secs;
+
+  stats.write_time += secs;
+  stats.write_calls++;
+  stats.write_requested_bytes += nbyte;
+  if (ret > 0)
+    stats.write_actual_bytes += ret;
+
+  errno = err;
+  return ret;
+}
+
+static int
+connect_tramp(int socket, const struct sockaddr *address, socklen_t address_len) {
+  double secs = 0;
+  int err, ret;
+
+  secs = timeofday();
+  ret = connect(socket, address, address_len);
+  err = errno;
+  secs = timeofday() - secs;
+
+  stats.connect_time += secs;
+  stats.connect_calls++;
+
+  errno = err;
+  return ret;
+}
+
+static int
+select_tramp(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout)
+{
+  double secs = 0;
+  int ret, err;
+
+  secs = timeofday();
+  ret = select(nfds, readfds, writefds, errorfds, timeout);
+  err = errno;
+  secs = timeofday() - secs;
+
+  stats.select_time += secs;
+  stats.select_calls++;
+
+  errno = err;
+  return ret;
+}
+
+static void
+fd_trace_start() {
+  static int inserted = 0;
+
+  if (!inserted)
+    inserted = 1;
+  else
+    return;
+
+  insert_tramp("read", read_tramp);
+  insert_tramp("write", write_tramp);
+  insert_tramp("connect", connect_tramp);
+  #ifdef HAVE_MACH
+  insert_tramp("select$DARWIN_EXTSN", select_tramp);
+  #else
+  insert_tramp("select", select_tramp);
+  #endif
+}
+
+static void
+fd_trace_stop() {
+}
+
+static void
+fd_trace_reset() {
+  memset(&stats, 0, sizeof(stats));
+}
+
+static void
+fd_trace_dump(json_gen gen) {
+  if (stats.read_calls > 0) {
+    json_gen_cstr(gen, "read");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.read_calls);
+    json_gen_cstr(gen, "time");
+    json_gen_double(gen, stats.read_time);
+    json_gen_cstr(gen, "requested");
+    json_gen_integer(gen, stats.read_requested_bytes);
+    json_gen_cstr(gen, "actual");
+    json_gen_integer(gen, stats.read_actual_bytes);
+    json_gen_map_close(gen);
+  }
+
+  if (stats.write_calls > 0) {
+    json_gen_cstr(gen, "write");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.write_calls);
+    json_gen_cstr(gen, "time");
+    json_gen_double(gen, stats.write_time);
+    json_gen_cstr(gen, "requested");
+    json_gen_integer(gen, stats.write_requested_bytes);
+    json_gen_cstr(gen, "actual");
+    json_gen_integer(gen, stats.write_actual_bytes);
+    json_gen_map_close(gen);
+  }
+
+  if (stats.connect_calls > 0) {
+    json_gen_cstr(gen, "connect");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.connect_calls);
+    json_gen_cstr(gen, "time");
+    json_gen_double(gen, stats.connect_time);
+    json_gen_map_close(gen);
+  }
+
+  if (stats.select_calls > 0) {
+    json_gen_cstr(gen, "select");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.select_calls);
+    json_gen_cstr(gen, "time");
+    json_gen_double(gen, stats.select_time);
+    json_gen_map_close(gen);
+  }
+}
+
+void install_fd_tracer()
+{
+  tracer.start = fd_trace_start;
+  tracer.stop = fd_trace_stop;
+  tracer.reset = fd_trace_reset;
+  tracer.dump = fd_trace_dump;
+  tracer.id = "fd";
+
+  trace_insert(&tracer);
+}

data/ext/tracers/gc.c

@@ -0,0 +1,79 @@
+#include <assert.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_gc_stats {
+  size_t gc_calls;
+  double gc_time;
+};
+
+static struct tracer tracer;
+static struct memprof_gc_stats stats;
+static void (*orig_garbage_collect)();
+
+static void
+gc_tramp()
+{
+  double secs = 0;
+
+  secs = timeofday();
+  orig_garbage_collect();
+  secs = timeofday() - secs;
+
+  stats.gc_time += secs;
+  stats.gc_calls++;
+}
+
+static void
+gc_trace_start() {
+  static int inserted = 0;
+
+  if (!inserted)
+    inserted = 1;
+  else
+    return;
+
+  orig_garbage_collect = bin_find_symbol("garbage_collect", NULL, 0);
+  assert(orig_garbage_collect != NULL);
+  dbg_printf("orig_garbage_collect: %p\n", orig_garbage_collect);
+
+  insert_tramp("garbage_collect", gc_tramp);
+}
+
+static void
+gc_trace_stop() {
+}
+
+static void
+gc_trace_reset() {
+  memset(&stats, 0, sizeof(stats));
+}
+
+static void
+gc_trace_dump(json_gen gen) {
+  json_gen_cstr(gen, "calls");
+  json_gen_integer(gen, stats.gc_calls);
+
+  json_gen_cstr(gen, "time");
+  json_gen_double(gen, stats.gc_time);
+}
+
+void install_gc_tracer()
+{
+  tracer.start = gc_trace_start;
+  tracer.stop = gc_trace_stop;
+  tracer.reset = gc_trace_reset;
+  tracer.dump = gc_trace_dump;
+  tracer.id = "gc";
+
+  trace_insert(&tracer);
+}

data/ext/tracers/memcache.c

@@ -0,0 +1,136 @@
+#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_memcache_stats {
+  size_t get_calls;
+  size_t get_responses[45];
+
+  size_t set_calls;
+  size_t set_responses[45];
+};
+
+static struct tracer tracer;
+static struct memprof_memcache_stats stats;
+static const char* (*_memcached_lib_version)(void);
+static char* (*_memcached_get)(void *ptr, const char *key, size_t key_length, size_t *value_length, uint32_t *flags, void *error);
+static int (*_memcached_set)(void *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
+
+static char*
+memcached_get_tramp(void *ptr, const char *key, size_t key_length, size_t *value_length, uint32_t *flags, void *error)
+{
+  char* ret = _memcached_get(ptr, key, key_length, value_length, flags, error);
+  stats.get_calls++;
+  int err = *(int*)error;
+  stats.get_responses[err > 42 ? 44 : err]++;
+  return ret;
+}
+
+static int
+memcached_set_tramp(void *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags)
+{
+  int ret = _memcached_set(ptr, key, key_length, value, value_length, expiration, flags);
+  stats.set_calls++;
+  stats.set_responses[ret > 42 ? 44 : ret]++;
+  return ret;
+}
+
+static void
+memcache_trace_start() {
+  static int inserted = 0;
+
+  if (!inserted)
+    inserted = 1;
+  else
+    return;
+
+  _memcached_lib_version = bin_find_symbol("memcached_lib_version", NULL, 1);
+  if (_memcached_lib_version) {
+    const char *version = _memcached_lib_version();
+    if (strcmp(version, "0.32") == 0) {
+      _memcached_get = bin_find_symbol("memcached_get", NULL, 1);
+      insert_tramp("memcached_get", memcached_get_tramp);
+
+      _memcached_set = bin_find_symbol("memcached_set", NULL, 1);
+      insert_tramp("memcached_set", memcached_set_tramp);
+    }
+  }
+}
+
+static void
+memcache_trace_stop() {
+}
+
+static void
+memcache_trace_reset() {
+  memset(&stats, 0, sizeof(stats));
+}
+
+static void
+memcache_trace_dump_results(json_gen gen, size_t responses[])
+{
+  int i;
+  json_gen_cstr(gen, "responses");
+  json_gen_map_open(gen);
+  for (i=0; i < 45; i++) {
+    if (responses[i]) {
+      switch (i) {
+        case 0:
+          json_gen_cstr(gen, "success");
+          break;
+        case 16:
+          json_gen_cstr(gen, "notfound");
+          break;
+        case 44:
+          json_gen_cstr(gen, "unknown");
+          break;
+        default:
+          json_gen_format(gen, "%d", i);
+      }
+      json_gen_integer(gen, responses[i]);
+    }
+  }
+  json_gen_map_close(gen);
+}
+
+static void
+memcache_trace_dump(json_gen gen) {
+  if (stats.get_calls > 0) {
+    json_gen_cstr(gen, "get");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.get_calls);
+    memcache_trace_dump_results(gen, stats.get_responses);
+    json_gen_map_close(gen);
+  }
+
+  if (stats.set_calls > 0) {
+    json_gen_cstr(gen, "set");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.set_calls);
+    memcache_trace_dump_results(gen, stats.set_responses);
+    json_gen_map_close(gen);
+  }
+}
+
+void install_memcache_tracer()
+{
+  tracer.start = memcache_trace_start;
+  tracer.stop = memcache_trace_stop;
+  tracer.reset = memcache_trace_reset;
+  tracer.dump = memcache_trace_dump;
+  tracer.id = "memcache";
+
+  trace_insert(&tracer);
+}