memprof 0.2.1 → 0.2.5

data/.gitignore

@@ -2,3 +2,5 @@
 *.so
 *.bundle
 Makefile
+*.dSYM
+*.log

data/Rakefile

@@ -0,0 +1,9 @@
+task :spec do
+  Dir.chdir('ext') do
+    sh "make clean" rescue nil
+    sh "ruby extconf.rb"
+    sh "make"
+  end
+  sh "ruby spec/memprof_spec.rb"
+end
+task :default => :spec

data/ext/extconf.rb

@@ -1,11 +1,3 @@
-if RUBY_PLATFORM =~ /darwin/
-  STDERR.puts "\n\n"
-  STDERR.puts "***************************************************************************************"
-  STDERR.puts "**************************** osx is not supported (yet) =( ****************************"
-  STDERR.puts "***************************************************************************************"
-  exit(1)
-end
-
 if RUBY_VERSION >= "1.9"
   STDERR.puts "\n\n"
   STDERR.puts "***************************************************************************************"
@@ -52,7 +44,11 @@ unless File.exists?("#{CWD}/dst/lib/libyajl_ext.a")
       sys("#{Config::CONFIG['bindir']}/#{Config::CONFIG['ruby_install_name']} extconf.rb")
 
       sys("make")
-      sys("ar rv libyajl_ext.a #{Dir['*.o'].join(' ')}")
+      if RUBY_PLATFORM =~ /darwin/
+        sys("libtool -static -o libyajl_ext.a #{Dir['*.o'].join(' ')}")
+      else
+        sys("ar rv libyajl_ext.a #{Dir['*.o'].join(' ')}")
+      end
 
       FileUtils.mkdir_p "#{CWD}/dst/lib"
       FileUtils.cp 'libyajl_ext.a', "#{CWD}/dst/lib"
@@ -142,9 +138,46 @@ if RUBY_PLATFORM =~ /linux/
   add_define 'HAVE_DWARF'
 end
 
-if have_header('mach-o/dyld')
+if have_header('mach-o/dyld.h')
   is_macho = true
   add_define 'HAVE_MACH'
+  # XXX How to determine this properly? RUBY_PLATFORM reports "i686-darwin10.2.0" on Snow Leopard.
+  add_define "_ARCH_x86_64_"
+
+  expressions = [
+    [:sizeof__RVALUE, "sizeof(RVALUE)"],
+    [:sizeof__heaps_slot, "sizeof(struct heaps_slot)"],
+    [:offset__heaps_slot__slot, "(int)&(((struct heaps_slot *)0)->slot)"],
+    [:offset__heaps_slot__limit, "(int)&(((struct heaps_slot *)0)->limit)"]
+    # "&add_freelist",
+    # "&rb_newobj",
+    # "&freelist",
+    # "&heaps",
+    # "&heaps_used"
+  ]
+
+  pid = fork{sleep}
+  output = IO.popen('gdb --interpreter=mi --quiet', 'w+') do |io|
+    io.puts "attach #{pid}"
+    expressions.each do |name, expr|
+      io.puts "-data-evaluate-expression #{expr.dump}"
+    end
+    io.puts 'quit'
+    io.puts 'y'
+    io.close_write
+    io.read
+  end
+  Process.kill 9, pid
+
+  attach, *results = output.grep(/^\^/).map{ |l| l.strip }
+  if results.find{ |l| l =~ /^\^error/ }
+    raise "Unsupported platform: #{results.inspect}"
+  end
+
+  values = results.map{ |l| l[/value="(.+?)"/, 1] }
+  vars = Hash[ *expressions.map{|n,e| n }.zip(values).flatten(1) ].each do |name, val|
+    add_define "#{name}=#{val}"
+  end
 end
 
 arch = RUBY_PLATFORM[/(.*)-linux/,1]

data/ext/mach.c

@@ -1,107 +1,335 @@
 #if defined(HAVE_MACH)
 
 #include "bin_api.h"
+#include "arch.h"
 
 #include <limits.h>
 #include <string.h>
 #include <sysexits.h>
 #include <sys/mman.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <dlfcn.h>
+#include <stdlib.h>
 
 #include <mach-o/dyld.h>
 #include <mach-o/getsect.h>
 #include <mach-o/loader.h>
 #include <mach-o/ldsyms.h>
+#include <mach-o/nlist.h>
+
+// The jmp instructions in the dyld stub table are 6 bytes,
+// 2 bytes for the instruction and 4 bytes for the offset operand
+//
+// This jmp does not jump to the offset operand, but instead
+// looks up an absolute address stored at the offset and jumps to that.
+// Offset is the offset from the address of the _next_ instruction sequence.
+//
+// We need to deference the address at this offset to find the real
+// target of the dyld stub entry.
+
+struct dyld_stub_entry {
+  unsigned char jmp[2];
+  uint32_t offset;
+} __attribute((__packed__));
+
+static inline void*
+get_dyld_stub_target(struct dyld_stub_entry *entry) {
+  // If the instructions match up, then dereference the address at the offset
+  if (entry->jmp[0] == 0xff && entry->jmp[1] == 0x25)
+    return *((void**)((void*)(entry + 1) + entry->offset));
+
+  return NULL;
+}
+
+static inline void
+set_dyld_stub_target(struct dyld_stub_entry *entry, void *addr) {
+  *((void**)((void*)(entry + 1) + entry->offset)) = addr;
+}
 
 static void
-set_text_segment(const struct mach_header *header, const char *sectname)
+update_dyld_stub_table(void *table, uint64_t len, void *trampee_addr, struct tramp_st2_entry *tramp)
 {
-  text_segment = getsectdatafromheader_64((const struct mach_header_64*)header, "__TEXT", sectname, (uint64_t*)&text_segment_len);
-  if (!text_segment)
-    errx(EX_UNAVAILABLE, "Failed to locate the %s section", sectname);
+  struct dyld_stub_entry *entry = (struct dyld_stub_entry*) table;
+  void *max_addr = table + len;
+
+  for(; (void*)entry < max_addr; entry++) {
+    void *target = get_dyld_stub_target(entry);
+    if (trampee_addr == target) {
+      set_dyld_stub_target(entry, tramp->addr);
+    }
+  }
+}
+
+
+// This function tells us if the passed stub table address
+// is something that we should try to update (by looking at it's filename)
+
+static inline int
+should_update_stub_table(void *addr) {
+  // Only try to update dyld stub entries in files that match "libruby.dylib" or "*.bundle" (other C gems)
+  Dl_info info;
+
+  if (dladdr(addr, &info)) {
+    size_t len = strlen(info.dli_fname);
+
+    if (len >= 6) {
+      const char *possible_bundle = (info.dli_fname + len - 6);
+      if (strcmp(possible_bundle, "bundle") == 0)
+        return 1;
+    }
+
+    if (len >= 13) {
+      const char *possible_libruby = (info.dli_fname + len - 13);
+      if (strcmp(possible_libruby, "libruby.dylib") == 0)
+        return 1;
+    }
+  }
+  return 0;
 }
 
 static void
-update_dyld_stubs(int entry, void *trampee_addr)
-{
-  char *byte = text_segment;
-  size_t count = 0;
-
-  for(; count < text_segment_len; count++) {
-    if (*byte == '\xff') {
-      int off = *(int *)(byte+2);
-      if (trampee_addr == *((void**)(byte + 6 + off))) {
-        *((void**)(byte + 6 + off)) = tramp_table[entry].addr;
+update_mach_section(const struct mach_header *header, const struct section_64 *sect, intptr_t slide, void *trampee_addr, struct tramp_st2_entry *tramp) {
+  uint64_t len = 0;
+  void *section = getsectdatafromheader_64((const struct mach_header_64*)header, "__TEXT", sect->sectname, &len) + slide;
+
+  if (strncmp(sect->sectname, "__symbol_stub", 13) == 0) {
+    if (should_update_stub_table(section))
+      update_dyld_stub_table(section, sect->size, trampee_addr, tramp);
+  }
+
+  if (strcmp(sect->sectname, "__text") == 0) {
+    size_t count = 0;
+    for(; count < len; section++, count++) {
+      if (arch_insert_st1_tramp(section, trampee_addr, tramp)) {
+        // printf("tramped %p for %s\n", byte, trampee);
+      }
+    }
+  }
+}
+
+static void
+update_bin_for_mach_header(const struct mach_header *header, intptr_t slide, void *trampee_addr, struct tramp_st2_entry *tramp) {
+  int i, j;
+  int lc_count = header->ncmds;
+
+  // this as a char* because we need to step it forward by an arbitrary number of bytes
+  const char *lc = ((const char*) header) + sizeof(struct mach_header_64);
+
+  // Check all the load commands in the object to see if they are segment commands
+  for (i = 0; i < lc_count; i++, lc += ((struct load_command*)lc)->cmdsize) {
+    if (((struct load_command*)lc)->cmd == LC_SEGMENT_64) {
+      const struct segment_command_64 *seg = (const struct segment_command_64 *) lc;
+      const struct section_64 * sect = (const struct section_64*)(lc + sizeof(struct segment_command_64));
+      int section_count = (seg->cmdsize - sizeof(struct segment_command_64)) / sizeof(struct section_64);
+
+      for (j=0; j < section_count; j++, sect++) {
+        update_mach_section(header, sect, slide, trampee_addr, tramp);
       }
     }
-    byte++;
   }
 }
 
+
+// This function takes a pointer to a loaded *in memory* mach_header_64
+// and returns it's image index. This will NOT work for mach objects read
+// from a file.
+
+int
+find_dyld_image_index(const struct mach_header_64 *hdr) {
+  int i;
+
+  for (i = 0; i < _dyld_image_count(); i++) {
+    const struct mach_header_64 *tmphdr = (const struct mach_header_64*) _dyld_get_image_header(i);
+    if (hdr == tmphdr)
+      return i;
+  }
+  errx(EX_SOFTWARE, "Could not find image index");
+}
+
+
+// This function returns a buffer containing the file that is presumed
+// to be either the Ruby executable or libruby. (Wherever rb_newobj is found.)
+//
+// The passed pointer index is set to the image index for the associated
+// in-memory mach image.
+//
+// !!! The pointer returned by this function must be freed !!!
+
 void *
-bin_allocate_page()
-{
-  void *ret = NULL;
-  size_t i = 0;
+get_ruby_file_and_header_index(int *index) {
+  void *ptr = NULL;
+  void *buf = NULL;
+  Dl_info info;
+  struct stat filestat;
 
-  for (i = pagesize; i < INT_MAX - pagesize; i += pagesize) {
-    ret = mmap((void*)(NULL + i), pagesize, PROT_WRITE|PROT_READ|PROT_EXEC,
-               MAP_ANON|MAP_PRIVATE, -1, 0);
+  // We can use this is a reasonably sure method of finding the file
+  // that the Ruby junk resides in.
+  ptr = dlsym(RTLD_DEFAULT, "rb_newobj");
 
-    if (tramp_table != MAP_FAILED) {
-      memset(tramp_table, 0x90, pagesize);
-      return ret;
+  if (!ptr)
+    errx(EX_SOFTWARE, "Could not find rb_newobj in this process. WTF???");
+
+  if (!dladdr(ptr, &info) || !info.dli_fname)
+    errx(EX_SOFTWARE, "Could not find the Mach object associated with rb_newobj.");
+
+  FILE *file = fopen(info.dli_fname, "r");
+  if (!file)
+    errx(EX_OSFILE, "Failed to open Ruby file %s", info.dli_fname);
+
+  stat(info.dli_fname, &filestat);
+  buf = malloc(filestat.st_size);
+
+  if (fread(buf, filestat.st_size, 1, file) != 1)
+    errx(EX_OSFILE, "Failed to fread() Ruby file %s", info.dli_fname);
+
+  fclose(file);
+
+  *index = find_dyld_image_index((const struct mach_header_64*) info.dli_fbase);
+  return buf;
+}
+
+
+// This function compares two nlist_64 structures by their n_value field (address)
+// used by qsort in build_sorted_nlist_table
+
+int
+nlist_cmp(const void *obj1, const void *obj2) {
+  const struct nlist_64 *nlist1 = *(const struct nlist_64**) obj1;
+  const struct nlist_64 *nlist2 = *(const struct nlist_64**) obj2;
+
+  if (nlist1->n_value == nlist2->n_value)
+    return 0;
+  else if (nlist1->n_value < nlist2->n_value)
+    return -1;
+  else
+    return 1;
+}
+
+
+// This function returns an array of pointers to nlist_64 entries in the symbol table
+// of the file pointed to by the passed mach header, sorted by address, and sets the
+// passed uint32_t pointers nsyms and stroff to those fields found in the symtab_command structure.
+//
+// !!! The pointer returned by this function must be freed !!!
+
+const struct nlist_64 **
+build_sorted_nlist_table(const struct mach_header_64 *hdr, uint32_t *nsyms, uint32_t *stroff) {
+  const struct nlist_64 **base;
+  uint32_t i, j;
+
+  const char *lc = (const char*) hdr + sizeof(struct mach_header_64);
+
+  for (i = 0; i < hdr->ncmds; i++) {
+    if (((const struct load_command*)lc)->cmd == LC_SYMTAB) {
+      const struct symtab_command *sc = (const struct symtab_command*) lc;
+      const struct nlist_64 *symbol_table = (const struct nlist_64*)((const char*)hdr + sc->symoff);
+
+      base = malloc(sc->nsyms * sizeof(struct nlist_64*));
+
+      for (j = 0; j < sc->nsyms; j++)
+        base[j] = symbol_table + j;
+
+      qsort(base, sc->nsyms, sizeof(struct nlist_64*), &nlist_cmp);
+
+      *nsyms = sc->nsyms;
+      *stroff = sc->stroff;
+      return base;
     }
+
+    lc += ((const struct load_command*)lc)->cmdsize;
   }
-  return NULL;
+  errx(EX_SOFTWARE, "Unable to find LC_SYMTAB");
+}
+
+void *
+bin_find_symbol(char *symbol, size_t *size) {
+  // Correctly prefix the symbol with a '_' (whats a prettier way to do this?)
+  size_t len = strlen(symbol);
+  char real_symbol[len + 2];
+  memcpy(real_symbol, "_", 1);
+  memcpy((real_symbol + 1), symbol, len);
+  memcpy((real_symbol + len + 1), "\0", 1);
+
+  void *ptr = NULL;
+  void *file = NULL;
+
+  uint32_t i, j, k;
+  uint32_t stroff, nsyms = 0;
+  int index = 0;
+
+  file = get_ruby_file_and_header_index(&index);
+
+  const struct mach_header_64 *hdr = (const struct mach_header_64*) file;
+  if (hdr->magic != MH_MAGIC_64)
+    errx(EX_SOFTWARE, "Magic for Ruby Mach-O file doesn't match");
+
+  const struct nlist_64 **nlist_table = build_sorted_nlist_table(hdr, &nsyms, &stroff);
+  const char *string_table = (const char*)hdr + stroff;
+
+  for (i=0; i < nsyms; i++) {
+    const struct nlist_64 *nlist_entry = nlist_table[i];
+    const char *string = string_table + nlist_entry->n_un.n_strx;
+
+    if (strcmp(real_symbol, string) == 0) {
+      const uint64_t addr = nlist_entry->n_value;
+      ptr = (void*)(addr + _dyld_get_image_vmaddr_slide(index));
+
+      if (size) {
+        const struct nlist_64 *next_entry = NULL;
+
+        j = 1;
+        while (next_entry == NULL) {
+          const struct nlist_64 *tmp_entry = nlist_table[i + j];
+          if (nlist_entry->n_value != tmp_entry->n_value)
+            next_entry = tmp_entry;
+          j++;
+        }
+
+        *size = (next_entry->n_value - addr);
+      }
+      break;
+    }
+  }
+
+  free(nlist_table);
+  free(file);
+  return ptr;
 }
 
 void
-bin_update_image(int entry, void *trampee_addr)
+bin_update_image(int entry, char *trampee, struct tramp_st2_entry *tramp)
 {
-  int i, j, k;
+  int i;
   int header_count = _dyld_image_count();
+  void *trampee_addr = bin_find_symbol(trampee, NULL);
 
   // Go through all the mach objects that are loaded into this process
   for (i=0; i < header_count; i++) {
     const struct mach_header *current_hdr = _dyld_get_image_header(i);
+    if ((void*)current_hdr == &_mh_bundle_header)
+      continue;
 
-    // Modify any callsites residing inside the text segment
-    set_text_segment(current_hdr, "__text");
-    text_segment += _dyld_get_image_vmaddr_slide(i);
-    update_callqs(entry, trampee_addr);
-
-    int lc_count = current_hdr->ncmds;
-
-    // this as a char* because we need to step it forward by an arbitrary number of bytes
-    const char *lc = ((const char*) current_hdr) + sizeof(struct mach_header_64);
-
-    // Check all the load commands in the object to see if they are segment commands
-    for (j = 0; j < lc_count; j++) {
-      if (((struct load_command*)lc)->cmd == LC_SEGMENT_64) {
-        const struct segment_command_64 *seg = (const struct segment_command_64 *) lc;
-        const struct section_64 * sect = (const struct section_64*)(lc + sizeof(struct segment_command_64));
-        int section_count = (seg->cmdsize - sizeof(struct segment_command_64)) / sizeof(struct section_64);
-
-        // Search the segment for a section containing dyld stub functions
-        for (k=0; k < section_count; k++) {
-          if (strncmp(sect->sectname, "__symbol_stub", 13) == 0) {
-            set_text_segment((struct mach_header*)current_hdr, sect->sectname);
-            text_segment += _dyld_get_image_vmaddr_slide(i);
-            update_dyld_stubs(entry, trampee_addr);
-          }
-          sect++;
-        }
-      }
-      lc += ((struct load_command*)lc)->cmdsize;
-    }
+    update_bin_for_mach_header(current_hdr, _dyld_get_image_vmaddr_slide(i), trampee_addr, tramp);
   }
 }
 
-void  *
-bin_find_symbol(char *sym,  size_t *size) {
-  void *ptr = NULL;
-  _dyld_lookup_and_bind((const char*)sym, &ptr, NULL);
-  return ptr;
+void *
+bin_allocate_page()
+{
+  void *ret = NULL;
+  size_t i = 0;
+
+  for (i = pagesize; i < INT_MAX - pagesize; i += pagesize) {
+    ret = mmap((void*)(NULL + i), pagesize, PROT_WRITE|PROT_READ|PROT_EXEC,
+               MAP_ANON|MAP_PRIVATE, -1, 0);
+
+    if (ret != MAP_FAILED) {
+      memset(ret, 0x90, pagesize);
+      return ret;
+    }
+  }
+  return NULL;
 }
 
 int

data/ext/memprof.c

@@ -14,6 +14,7 @@
 #include <sysexits.h>
 #include <sys/mman.h>
 #include <err.h>
+#include <assert.h>
 
 #include <st.h>
 #include <intern.h>
@@ -83,10 +84,17 @@ newobj_tramp()
   return ret;
 }
 
+static void (*rb_add_freelist)(VALUE);
+
 static void
 freelist_tramp(unsigned long rval)
 {
   struct obj_track *tracker = NULL;
+
+  if (rb_add_freelist) {
+    rb_add_freelist(rval);
+  }
+
   if (track_objs && objs) {
     st_delete(objs, (st_data_t *) &rval, (st_data_t *) &tracker);
     if (tracker) {
@@ -390,9 +398,11 @@ obj_dump(VALUE obj, yajl_gen gen)
   yajl_gen_value(gen, obj);
 
   struct obj_track *tracker = NULL;
-  if (st_lookup(objs, (st_data_t)obj, (st_data_t *)&tracker)) {
-    yajl_gen_cstr(gen, "source");
-    yajl_gen_format(gen, "%s:%d", tracker->source, tracker->line);
+  if (st_lookup(objs, (st_data_t)obj, (st_data_t *)&tracker) && BUILTIN_TYPE(obj) != T_NODE) {
+    yajl_gen_cstr(gen, "file");
+    yajl_gen_cstr(gen, tracker->source);
+    yajl_gen_cstr(gen, "line");
+    yajl_gen_integer(gen, tracker->line);
   }
 
   yajl_gen_cstr(gen, "type");
@@ -716,16 +726,26 @@ memprof_dump(int argc, VALUE *argv, VALUE self)
 static VALUE
 memprof_dump_all(int argc, VALUE *argv, VALUE self)
 {
-  int sizeof_RVALUE = bin_type_size("RVALUE");
   char *heaps = *(char**)bin_find_symbol("heaps",0);
   int heaps_used = *(int*)bin_find_symbol("heaps_used",0);
-  int sizeof_heaps_slot = bin_type_size("heaps_slot");
-  int offset_limit = bin_type_member_offset("heaps_slot", "limit");
-  int offset_slot = bin_type_member_offset("heaps_slot", "slot");
+
+#ifndef sizeof__RVALUE
+  int sizeof__RVALUE = bin_type_size("RVALUE");
+#endif
+#ifndef sizeof__heaps_slot
+  int sizeof__heaps_slot = bin_type_size("heaps_slot");
+#endif
+#ifndef offset__heaps_slot__limit
+  int offset__heaps_slot__limit = bin_type_member_offset("heaps_slot", "limit");
+#endif
+#ifndef offset__heaps_slot__slot
+  int offset__heaps_slot__slot = bin_type_member_offset("heaps_slot", "slot");
+#endif
+
   char *p, *pend;
   int i, limit;
 
-  if (sizeof_RVALUE < 0 || sizeof_heaps_slot < 0)
+  if (sizeof__RVALUE < 0 || sizeof__heaps_slot < 0)
     rb_raise(eUnsupported, "could not find internal heap");
 
   VALUE str;
@@ -747,9 +767,9 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
   //yajl_gen_array_open(gen);
 
   for (i=0; i < heaps_used; i++) {
-    p = *(char**)(heaps + (i * sizeof_heaps_slot) + offset_slot);
-    limit = *(int*)(heaps + (i * sizeof_heaps_slot) + offset_limit);
-    pend = p + (sizeof_RVALUE * limit);
+    p = *(char**)(heaps + (i * sizeof__heaps_slot) + offset__heaps_slot__slot);
+    limit = *(int*)(heaps + (i * sizeof__heaps_slot) + offset__heaps_slot__limit);
+    pend = p + (sizeof__RVALUE * limit);
 
     while (p < pend) {
       if (RBASIC(p)->flags) {
@@ -761,7 +781,7 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
         while(fputc('\n', out ? out : stdout) == EOF);
       }
 
-      p += sizeof_RVALUE;
+      p += sizeof__RVALUE;
     }
   }
 
@@ -813,16 +833,19 @@ hook_freelist(int entry)
   void *freelist_inliners[FREELIST_INLINES];
   void *freelist = NULL;
   unsigned char *byte = NULL;
+  int tramps_completed = 0;
 
   freelist_inliners[0] = bin_find_symbol("gc_sweep", &sizes[0]);
   /* sometimes gc_sweep gets inlined in garbage_collect */
-  if (!freelist_inliners[0]) {
+  /* on REE, it gets inlined into garbage_collect_0 */
+  if (!freelist_inliners[0])
+    freelist_inliners[0] = bin_find_symbol("garbage_collect_0", &sizes[0]);
+  if (!freelist_inliners[0])
     freelist_inliners[0] = bin_find_symbol("garbage_collect", &sizes[0]);
-    if (!freelist_inliners[0]) {
-      /* couldn't find garbage_collect either. */
-      fprintf(stderr, "Couldn't find gc_sweep or garbage_collect!\n");
-      return;
-    }
+  if (!freelist_inliners[0]) {
+    /* couldn't find anything containing gc_sweep. */
+    fprintf(stderr, "Couldn't find gc_sweep or garbage_collect!\n");
+    return;
   }
 
   freelist_inliners[1] = bin_find_symbol("finalize_list", &sizes[1]);
@@ -853,6 +876,15 @@ hook_freelist(int entry)
       /* insert occurred, so increment internal counters for the tramp table */
       entry++;
       inline_tramp_size++;
+
+      /* add_freelist() only gets inlined *ONCE* into any of the 3 functions that we're scanning, */
+      /* so move on to the next 'inliner' when after we tramp the first instruction we find. */
+      /* REE's gc_sweep has 2 calls, but this gets optimized into a single inlining and a jmp to it */
+      /* older patchlevels of 1.8.7 don't have an add_freelist(), but the instruction should be the same */
+      tramps_completed++;
+      i++;
+      byte = freelist_inliners[i];
+      continue;
     }
 
     /* if we've looked at all the bytes in this function... */
@@ -863,6 +895,8 @@ hook_freelist(int entry)
     }
     byte++;
   }
+
+  assert(tramps_completed == 3);
 }
 
 static void
@@ -881,6 +915,10 @@ insert_tramp(char *trampee, void *tramp)
       return;
     }
   } else {
+    if (strcmp("add_freelist", trampee) == 0) {
+      rb_add_freelist = trampee_addr;
+    }
+
     tramp_table[tramp_size].addr = tramp;
     bin_update_image(entry, trampee, &tramp_table[tramp_size]);
     tramp_size++;
@@ -904,13 +942,10 @@ Init_memprof()
   objs = st_init_numtable();
   bin_init();
   create_tramp_table();
+  rb_add_freelist = NULL;
 
-#if defined(HAVE_MACH)
-  insert_tramp("_rb_newobj", newobj_tramp);
-#elif defined(HAVE_ELF)
   insert_tramp("rb_newobj", newobj_tramp);
   insert_tramp("add_freelist", freelist_tramp);
-#endif
 
   rb_classname = bin_find_symbol("classname", 0);
 

data/lib/memprof/middleware.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../../memprof', __FILE__)
+module Memprof
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      ret = nil
+      Memprof.track{
+        ret = @app.call(env)
+        puts
+        puts '-' * 80
+        puts '-' * 80
+      }
+      ret
+    end
+  end
+end

data/lib/memprof/usr2.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../../memprof', __FILE__)
+Memprof.start
+trap('USR2'){
+  pid = Process.pid
+  fork{
+    Memprof.dump_all("/tmp/memprof-#{pid}-#{Time.now.to_i}.json")
+    exit!
+  }
+}

data/memprof.gemspec

@@ -1,32 +1,13 @@
 spec = Gem::Specification.new do |s|
   s.name = 'memprof'
-  s.version = '0.2.1'
-  s.date = '2010-02-20'
+  s.version = '0.2.5'
+  s.date = '2010-02-27'
   s.summary = 'Ruby Memory Profiler'
   s.description = "Ruby memory profiler similar to bleak_house, but without patches to the Ruby VM"
-  s.email = "ice799@gmail.com"
   s.homepage = "http://github.com/ice799/memprof"
   s.has_rdoc = false
   s.authors = ["Joe Damato", "Aman Gupta", "Jake Douglas"]
+  s.email = ["joe@memprof.com", "aman@memprof.com", "jake@memprof.com"]
   s.extensions = "ext/extconf.rb"
-  s.files = %w[
-    .gitignore
-    README
-    ext/arch.h
-    ext/bin_api.h
-    ext/elf.c
-    ext/extconf.rb
-    ext/i386.c
-    ext/i386.h
-    ext/mach.c
-    ext/memprof.c
-    ext/src/libdwarf-20091118.tar.gz
-    ext/src/libelf-0.8.13.tar.gz
-    ext/src/yajl-1.0.9.tar.gz
-    ext/x86_64.c
-    ext/x86_64.h
-    ext/x86_gen.h
-    memprof.gemspec
-    spec/memprof_spec.rb
-  ]
+  s.files = `git ls-files`.split
 end

data/spec/memprof_spec.rb

@@ -61,7 +61,8 @@ describe Memprof do
     1.23+1
     Memprof.dump(filename)
 
-    filedata.should =~ /"source": "#{__FILE__}:#{__LINE__-3}"/
+    filedata.should =~ /"file": "#{__FILE__}"/
+    filedata.should =~ /"line": #{__LINE__-4}/
     filedata.should =~ /"type": "float"/
     filedata.should =~ /"data": 2\.23/
   end
@@ -75,11 +76,27 @@ describe Memprof do
     Memprof.stop
     Memprof.dump_all(filename)
 
-    File.open(filename, 'r').each_line do |line|
-      if line =~ /"data": "dump out the entire heap"/
-        break :found
-      end
-    end.should == :found
+    obj = File.open(filename, 'r').each_line.find do |line|
+      line =~ /"dump out the entire heap"/
+    end
+
+    obj.should =~ /"length":24/
+    obj.should =~ /"type":"string"/
+    obj.should =~ /"_id":"0x(\w+?)"/
+  end
+
+  should 'dump out the entire heap with tracking info' do
+    Memprof.start
+    @str = "some random" + " string"
+    Memprof.dump_all(filename)
+
+    obj = File.open(filename, 'r').each_line.find do |line|
+      line =~ /"some random string"/
+    end
+
+    obj.should =~ /"type":"string"/
+    obj.should =~ /"file":".+?memprof_spec.rb"/
+    obj.should =~ /"line":#{__LINE__-9}/
   end
 end
 

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: memprof
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 5
+  version: 0.2.5
 platform: ruby
 authors: 
 - Joe Damato
@@ -11,12 +16,15 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-20 00:00:00 -08:00
+date: 2010-02-27 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
 description: Ruby memory profiler similar to bleak_house, but without patches to the Ruby VM
-email: ice799@gmail.com
+email: 
+- joe@memprof.com
+- aman@memprof.com
+- jake@memprof.com
 executables: []
 
 extensions: 
@@ -26,6 +34,7 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - README
+- Rakefile
 - ext/arch.h
 - ext/bin_api.h
 - ext/elf.c
@@ -40,6 +49,8 @@ files:
 - ext/x86_64.c
 - ext/x86_64.h
 - ext/x86_gen.h
+- lib/memprof/middleware.rb
+- lib/memprof/usr2.rb
 - memprof.gemspec
 - spec/memprof_spec.rb
 has_rdoc: true
@@ -55,18 +66,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Ruby Memory Profiler