memprof 0.3.2 → 0.3.3

data/ext/util.c

@@ -1,10 +1,13 @@
+#include <stdlib.h>
+#include <time.h>
+#include <util.h>
+
+#include <sys/time.h>
+
 /* This is the CRC function used by GNU. Stripped executables may contain a
  * section .gnu_debuglink which holds the name of an elf object with debug
  * information and a checksum.
- */
-#include <stdlib.h>
-#include <util.h>
-/*   !!!! DO NOT MODIFY THIS FUNCTION !!!!
+ *   !!!! DO NOT MODIFY THIS FUNCTION !!!!
  *   TODO create specs for this!
  */
 unsigned long
@@ -71,3 +74,18 @@ gnu_debuglink_crc32(unsigned long crc, unsigned char *buf, size_t len)
     crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
   return ~crc & 0xffffffff;
 }
+
+double
+timeofday()
+{
+  struct timeval tv;
+#ifdef CLOCK_MONOTONIC
+  struct timespec tp;
+
+  if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0) {
+    return (double)tp.tv_sec + (double)tp.tv_nsec * 1e-9;
+  }
+#endif
+  gettimeofday(&tv, NULL);
+  return (double)tv.tv_sec + (double)tv.tv_usec * 1e-6;
+}

data/ext/util.h

@@ -73,4 +73,9 @@ struct memprof_config {
 unsigned long
 gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len);
 
+/* Use this function for time tracking. It will (interally) try to use an
+ * appropriately granual timing function.
+ */
+double
+timeofday();
 #endif

data/ext/x86_gen.c

@@ -27,14 +27,14 @@ arch_insert_st1_tramp(void *start, void *trampee, void *tramp)
   assert(tramp != NULL);
 
   int32_t fn_addr = 0;
+  int32_t offset = 0;
   struct st1_base *check = start;
 
   if (check->call == 0xe8) {
     fn_addr = check->displacement;
     if ((trampee - (void *)(check + 1)) == fn_addr) {
-      WRITE_INSTRUCTIONS(&check->displacement,
-                         sizeof(*check),
-                         (check->displacement = (tramp - (void *)(check + 1))));
+      offset = tramp - (void *)(check + 1);
+      copy_instructions(&check->displacement, &offset, sizeof(offset));
       return 0;
     }
   }

data/ext/x86_gen.h

@@ -75,17 +75,4 @@ copy_instructions(void *dest, void *src, size_t count)
    */
   return;
 }
-
-/*
- * WRITE_INSTRUCTIONS - page align start, recalculate len to take into account
- * alignment, set the read/write permissions and execute the code stmt.
- */
-#define WRITE_INSTRUCTIONS(start, len, stmt) do { \
-  void *aligned_addr = page_align((void *)start); \
-  int count = ((void *)start) - aligned_addr + len; \
-  mprotect(aligned_addr, count, PROT_READ | PROT_WRITE | PROT_EXEC); \
-  stmt; \
-  mprotect(aligned_addr, count, PROT_READ | PROT_EXEC); \
-} while (0)
-
 #endif

data/lib/memprof/tracer.rb

@@ -0,0 +1,34 @@
+begin
+  require File.expand_path('../../memprof', __FILE__)
+rescue LoadError
+  require File.expand_path('../../../ext/memprof', __FILE__)
+end
+
+module Memprof
+  # Middleware for tracing requests
+  #
+  #  require 'memprof/tracer'
+  #  config.middleware.use(Memprof::Tracer)
+  class Tracer
+    def initialize(app)
+      @app=app
+    end
+    def call(env)
+      Memprof.trace_filename ||= "/tmp/memprof_tracer-#{Process.pid}.json"
+      Memprof.trace_request(env){ @app.call(env) }
+    end
+  end
+
+  # Legacy filter for tracing requests on Rails 2.2
+  #
+  #  require 'memprof/tracer'
+  #  around_filter(Memprof::Filter)
+  module Filter
+    def self.filter(controller)
+      env = controller.request.env
+      info = controller.request.path_parameters
+      Memprof.trace_filename ||= "/tmp/memprof_tracer-#{Process.pid}.json"
+      Memprof.trace_request(env.merge('action_controller.request.path_parameters' => info)){ yield }
+    end
+  end
+end

data/memprof.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'memprof'
-  s.version = '0.3.2'
+  s.version = '0.3.3'
   s.date = '2010-04-13'
   s.summary = 'Ruby Memory Profiler'
   s.description = "Ruby memory profiler similar to bleak_house, but without patches to the Ruby VM"

data/spec/memprof_spec.rb

@@ -61,10 +61,10 @@ describe Memprof do
     1.23+1
     Memprof.dump(filename)
 
-    filedata.should =~ /"file": "#{__FILE__}"/
-    filedata.should =~ /"line": #{__LINE__-4}/
-    filedata.should =~ /"type": "float"/
-    filedata.should =~ /"data": 2\.23/
+    filedata.should =~ /"file":"#{__FILE__}"/
+    filedata.should =~ /"line":#{__LINE__-4}/
+    filedata.should =~ /"type":"float"/
+    filedata.should =~ /"data":2\.23/
   end
 
   should 'raise error when calling ::stats or ::dump without ::start' do
@@ -72,6 +72,14 @@ describe Memprof do
     lambda{ Memprof.dump }.should.raise(RuntimeError).message.should =~ /Memprof.start/
   end
 
+  should 'dump objects created for block' do
+    Memprof.dump(filename) do
+      2.45+1
+    end
+
+    filedata.should =~ /"data":3\.45/
+  end
+
   should 'dump out the entire heap' do
     Memprof.stop
     Memprof.dump_all(filename)

data/spec/tracing_spec.rb

@@ -0,0 +1,135 @@
+require File.dirname(__FILE__) + "/../ext/memprof"
+
+require 'rubygems'
+require 'bacon'
+Bacon.summary_on_exit
+
+require 'tempfile'
+
+# XXX must require upfront before tracers are installed
+require 'socket'
+require 'open-uri'
+begin; require 'mysql';     rescue LoadError; end
+begin; require 'memcached'; rescue LoadError; end
+
+describe 'Memprof tracers' do
+  @tempfile = Tempfile.new('tracing_spec')
+
+  def filename
+    @tempfile.path
+  end
+
+  def filedata
+    File.read(filename)
+  end
+
+  should 'trace i/o for block' do
+    Memprof.trace(filename) do
+      open("http://google.com").read
+    end
+
+    filedata.should =~ /"read":\{"calls":\d+/
+    filedata.should =~ /"write":\{"calls":\d+/
+    filedata.should =~ /"connect":\{"calls":\d+/
+  end
+
+  should 'trace select for block' do
+    Memprof.trace(filename) do
+      select(nil, nil, nil, 0.15)
+    end
+
+    filedata.should =~ /"select":\{"calls":1,"time":0\.1[567]/
+    time = filedata[/"select":\{"calls":\d+,"time":([\d.]+)/, 1].to_f
+    time.should.be.close(0.15, 0.1)
+  end
+
+  should 'trace objects created for block' do
+    Memprof.trace(filename) do
+      10.times{1.1+1.2}
+    end
+
+    filedata.should =~ /"float":10/
+  end
+
+  should 'trace gc runs for block' do
+    Memprof.trace(filename) do
+      10.times{GC.start}
+    end
+
+    filedata.should =~ /"gc":\{"calls":10,"time":[\d.]+/
+  end
+
+  should 'trace memory allocation for block' do
+    Memprof.trace(filename) do
+      10.times{ "abc" << "def" }
+    end
+
+    filedata.should =~ /"malloc":\{"calls":10/
+    filedata.should =~ /"realloc":\{"calls":10/
+  end
+
+  if defined? Mysql
+    begin
+      conn = Mysql.connect('localhost', 'root')
+
+      should 'trace mysql calls for block' do
+        Memprof.trace(filename) do
+          5.times{ conn.query("select sleep(0.05)") }
+        end
+
+        filedata.should =~ /"mysql":\{"queries":5,"time":([\d.]+)/
+        time = filedata[/"mysql":\{"queries":5,"time":([\d.]+)/, 1].to_f
+        time.should.be.close(0.25, 0.1)
+      end
+    rescue Mysql::Error => e
+      raise unless e.message =~ /connect/
+    end
+  end
+
+  if defined? Memcached
+    begin
+      conn = Memcached.new("localhost:11211", :show_backtraces => true)
+      conn.stats
+
+      should 'trace memcached calls for block' do
+        Memprof.trace(filename) do
+          conn.delete("memprof") rescue nil
+          conn.get("memprof") rescue nil
+          conn.set("memprof", "is cool")
+          conn.get("memprof")
+        end
+
+        filedata.should =~ /"memcache":\{"get":\{"calls":2,"responses":\{"success":1,"notfound":1/
+        filedata.should =~ /"set":\{"calls":1,"responses":\{"success":1/
+      end
+    rescue Memcached::SomeErrorsWereReported
+    end
+  end
+end
+
+describe 'Memprof request tracing' do
+  @tempfile = Tempfile.new('tracing_spec')
+
+  def filename
+    @tempfile.path
+  end
+
+  def filedata
+    File.read(filename)
+  end
+
+  should 'trace request env' do
+    env = {"REQUEST_PATH" => "value"}
+
+    Memprof.trace_filename = filename
+    Memprof.trace_filename.should == filename
+
+    Memprof.trace_request(env) do
+    end
+
+    Memprof.trace_filename = nil
+    Memprof.trace_filename.should.be.nil
+
+    filedata.should =~ /"REQUEST_PATH":"value"/
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 2
-  version: 0.3.2
+  - 3
+  version: 0.3.3
 platform: ruby
 authors: 
 - Joe Damato
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-13 00:00:00 -04:00
+date: 2010-04-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -68,14 +68,22 @@ files:
 - ext/extconf.rb
 - ext/i386.c
 - ext/i386.h
+- ext/json.c
+- ext/json.h
 - ext/mach.c
 - ext/memprof.c
+- ext/mmap.h
 - ext/src/libdwarf-20091118.tar.gz
 - ext/src/libelf-0.8.13.tar.gz
 - ext/src/yajl-1.0.9.tar.gz
 - ext/tracer.c
 - ext/tracer.h
-- ext/tracers/malloc.c
+- ext/tracers/fd.c
+- ext/tracers/gc.c
+- ext/tracers/memcache.c
+- ext/tracers/memory.c
+- ext/tracers/mysql.c
+- ext/tracers/objects.c
 - ext/tramp.c
 - ext/tramp.h
 - ext/util.c
@@ -86,9 +94,11 @@ files:
 - ext/x86_gen.h
 - lib/memprof/middleware.rb
 - lib/memprof/signal.rb
+- lib/memprof/tracer.rb
 - memprof.gemspec
 - spec/memprof_spec.rb
 - spec/memprof_uploader_spec.rb
+- spec/tracing_spec.rb
 has_rdoc: true
 homepage: http://github.com/ice799/memprof
 licenses: []

data/ext/tracers/malloc.c

@@ -1,163 +0,0 @@
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "arch.h"
-#include "bin_api.h"
-#include "tracer.h"
-#include "util.h"
-
-struct memprof_malloc_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_malloc_stats memprof_malloc_stats;
-static void *(*orig_malloc)(size_t), *(*orig_realloc)(void *, size_t),
-            *(*orig_calloc)(size_t, size_t), (*orig_free)(void *);
-static size_t (*malloc_usable_size)(void *ptr);
-
-static void *
-malloc_tramp(size_t size)
-{
-  void *ret = NULL;
-  memprof_malloc_stats.malloc_bytes_requested += size;
-  memprof_malloc_stats.malloc_calls++;
-  ret = orig_malloc(size);
-  memprof_malloc_stats.malloc_bytes_actual += malloc_usable_size(ret);
-  return ret;
-}
-
-static void *
-calloc_tramp(size_t nmemb, size_t size)
-{
-  void *ret = NULL;
-  memprof_malloc_stats.calloc_bytes_requested += (nmemb * size);
-  memprof_malloc_stats.calloc_calls++;
-  ret = (*orig_calloc)(nmemb, size);
-  memprof_malloc_stats.calloc_bytes_actual += malloc_usable_size(ret);
-  return ret;
-}
-
-static void *
-realloc_tramp(void *ptr, size_t size)
-{
-  /* TODO need to check malloc_usable_size of before/after i guess? */
-  void *ret = NULL;
-  memprof_malloc_stats.realloc_bytes_requested += size;
-  memprof_malloc_stats.realloc_calls++;
-  ret = orig_realloc(ptr, size);
-  memprof_malloc_stats.realloc_bytes_actual += malloc_usable_size(ptr);
-  return ret;
-}
-
-static void
-free_tramp(void *ptr)
-{
-  memprof_malloc_stats.free_bytes_actual += malloc_usable_size(ptr);
-  memprof_malloc_stats.free_calls++;
-  orig_free(ptr);
-}
-
-static void
-malloc_trace_stop()
-{
-  struct tramp_st2_entry tmp;
-
-  tmp.addr = orig_malloc;
-  bin_update_image("malloc", &tmp, NULL);
-
-  tmp.addr = orig_realloc;
-  bin_update_image("realloc", &tmp, NULL);
-
-  if (orig_calloc) {
-    tmp.addr = orig_calloc;
-    bin_update_image("calloc", &tmp, NULL);
-  }
-
-  tmp.addr = orig_free;
-  bin_update_image("free", &tmp, NULL);
-}
-
-static void
-malloc_trace_reset()
-{
-  memset(&memprof_malloc_stats, 0, sizeof(memprof_malloc_stats));
-}
-
-static void
-malloc_trace_dump()
-{
-  fprintf(stderr, "================ Requested ====================\n");
-  fprintf(stderr, "Malloced: %zd, Realloced: %zd, Calloced: %zd\n",
-      memprof_malloc_stats.malloc_bytes_requested, memprof_malloc_stats.realloc_bytes_requested,
-      memprof_malloc_stats.calloc_bytes_requested);
-  fprintf(stderr, "================ Actual ====================\n");
-  fprintf(stderr, "Malloced: %zd, Realloced: %zd, Calloced: %zd, Freed: %zd\n",
-      memprof_malloc_stats.malloc_bytes_actual, memprof_malloc_stats.realloc_bytes_actual,
-      memprof_malloc_stats.calloc_bytes_actual, memprof_malloc_stats.free_bytes_actual);
-  fprintf(stderr, "================ Call count ====================\n");
-  fprintf(stderr, "Calls to malloc: %zd, realloc: %zd, calloc: %zd, free: %zd\n",
-      memprof_malloc_stats.malloc_calls,
-      memprof_malloc_stats.realloc_calls,
-      memprof_malloc_stats.calloc_calls,
-      memprof_malloc_stats.free_calls);
-}
-
-static void
-malloc_trace_start()
-{
-  struct tramp_st2_entry tmp;
-
-  if (!malloc_usable_size) {
-    if ((malloc_usable_size =
-          bin_find_symbol("MallocExtension_GetAllocatedSize", NULL, 1)) == NULL) {
-      malloc_usable_size = bin_find_symbol("malloc_usable_size", NULL, 1);
-      dbg_printf("tcmalloc was not found...\n");
-    }
-    assert(malloc_usable_size != NULL);
-    dbg_printf("malloc_usable_size: %p\n", malloc_usable_size);
-  }
-
-  tmp.addr = malloc_tramp;
-  bin_update_image("malloc", &tmp, (void **)(&orig_malloc));
-  assert(orig_malloc != NULL);
-  dbg_printf("orig_malloc: %p\n", orig_malloc);
-
-  tmp.addr = realloc_tramp;
-  bin_update_image("realloc", &tmp,(void **)(&orig_realloc));
-  dbg_printf("orig_realloc: %p\n", orig_realloc);
-
-  tmp.addr = calloc_tramp;
-  bin_update_image("calloc", &tmp, (void **)(&orig_calloc));
-  dbg_printf("orig_calloc: %p\n", orig_calloc);
-
-  tmp.addr = free_tramp;
-  bin_update_image("free", &tmp, (void **)(&orig_free));
-  assert(orig_free != NULL);
-  dbg_printf("orig_free: %p\n", orig_free);
-}
-
-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 = strdup("malloc_tracer");
-
-  trace_insert(&tracer);
-}