memprof 0.3.7 → 0.3.8

data/ext/memprof.c

@@ -7,6 +7,7 @@
 #include <assert.h>
 #include <err.h>
 #include <fcntl.h>
+#include <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -485,8 +486,9 @@ memprof_trace_request(VALUE self, VALUE env)
   if (!rb_block_given_p())
     rb_raise(rb_eArgError, "block required");
 
-  double secs;
-  struct timeval now;
+  uint64_t start_time;
+  uint64_t end_time;
+  char str_time[32];
 
   json_gen gen;
   if (tracing_json_gen)
@@ -497,8 +499,9 @@ memprof_trace_request(VALUE self, VALUE env)
   json_gen_map_open(gen);
 
   json_gen_cstr(gen, "start");
-  gettimeofday(&now, NULL);
-  json_gen_integer(gen, (now.tv_sec * 1000) + (now.tv_usec / 1000));
+  start_time = timeofday_ms();
+  sprintf(str_time, "%" PRIu64, start_time);
+  json_gen_number(gen, str_time, strlen(str_time));
 
   json_gen_cstr(gen, "tracers");
   json_gen_map_open(gen);
@@ -507,32 +510,32 @@ memprof_trace_request(VALUE self, VALUE env)
   trace_invoke_all(TRACE_RESET);
   trace_invoke_all(TRACE_START);
 
-  secs = timeofday();
+  start_time = timeofday_ms();
   VALUE ret = rb_yield(Qnil);
-  secs = timeofday() - secs;
+  end_time = timeofday_ms();
 
   trace_invoke_all(TRACE_DUMP);
   trace_invoke_all(TRACE_STOP);
 
   json_gen_map_close(gen);
 
-  if (RTEST(env) && BUILTIN_TYPE(env) == T_HASH) {
+  if (RTEST(env) && TYPE(env) == T_HASH) {
     VALUE val, str;
     val = rb_hash_aref(env, rb_str_new2("action_controller.request.path_parameters"));
     if (!RTEST(val))
       val = rb_hash_aref(env, rb_str_new2("action_dispatch.request.parameters"));
 
-    if (RTEST(val) && BUILTIN_TYPE(val) == T_HASH) {
+    if (RTEST(val) && TYPE(val) == T_HASH) {
       json_gen_cstr(gen, "rails");
       json_gen_map_open(gen);
       str = rb_hash_aref(val, rb_str_new2("controller"));
-      if (RTEST(str) && BUILTIN_TYPE(str) == T_STRING) {
+      if (RTEST(str) && TYPE(str) == T_STRING) {
         json_gen_cstr(gen, "controller");
         json_gen_cstr(gen, RSTRING_PTR(str));
       }
 
       str = rb_hash_aref(val, rb_str_new2("action"));
-      if (RTEST(str) && BUILTIN_TYPE(str) == T_STRING) {
+      if (RTEST(str) && TYPE(str) == T_STRING) {
         json_gen_cstr(gen, "action");
         json_gen_cstr(gen, RSTRING_PTR(str));
       }
@@ -547,7 +550,7 @@ memprof_trace_request(VALUE self, VALUE env)
     #define DUMP_HASH_ENTRY(key) do {                    \
       str = rb_hash_aref(env, rb_str_new2(key));         \
       if (RTEST(str) &&                                  \
-          BUILTIN_TYPE(str) == T_STRING &&               \
+          TYPE(str) == T_STRING &&                       \
           RSTRING_PTR(str)) {                            \
         json_gen_cstr(gen, key);                         \
         json_gen_cstr(gen, RSTRING_PTR(str));            \
@@ -562,18 +565,18 @@ memprof_trace_request(VALUE self, VALUE env)
     DUMP_HASH_ENTRY("QUERY_STRING");
 
     json_gen_map_close(gen);
+  }
 
-    if (RTEST(ret) && BUILTIN_TYPE(ret) == T_ARRAY) {
-      json_gen_cstr(gen, "response");
-      json_gen_map_open(gen);
-      json_gen_cstr(gen, "code");
-      json_gen_value(gen, RARRAY_PTR(ret)[0]);
-      json_gen_map_close(gen);
-    }
+  if (RTEST(ret) && TYPE(ret) == T_ARRAY) {
+    json_gen_cstr(gen, "response");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "code");
+    json_gen_value(gen, RARRAY_PTR(ret)[0]);
+    json_gen_map_close(gen);
   }
 
   json_gen_cstr(gen, "time");
-  json_gen_double(gen, secs);
+  json_gen_integer(gen, end_time-start_time);
 
   json_gen_map_close(gen);
   json_gen_reset(gen);

data/ext/tracers/fd.c

@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <errno.h>
+#include <poll.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -17,20 +18,23 @@
 
 struct memprof_fd_stats {
   size_t read_calls;
-  double read_time;
+  uint32_t read_time;
   size_t read_requested_bytes;
   size_t read_actual_bytes;
 
   size_t write_calls;
-  double write_time;
+  uint32_t write_time;
   size_t write_requested_bytes;
   size_t write_actual_bytes;
 
   size_t connect_calls;
-  double connect_time;
+  uint32_t connect_time;
 
   size_t select_calls;
-  double select_time;
+  uint32_t select_time;
+
+  size_t poll_calls;
+  uint32_t poll_time;
 };
 
 static struct tracer tracer;
@@ -38,16 +42,16 @@ static struct memprof_fd_stats stats;
 
 static ssize_t
 read_tramp(int fildes, void *buf, size_t nbyte) {
-  double secs = 0;
+  uint32_t millis = 0;
   int err;
   ssize_t ret;
 
-  secs = timeofday();
+  millis = timeofday_ms();
   ret = read(fildes, buf, nbyte);
   err = errno;
-  secs = timeofday() - secs;
+  millis = timeofday_ms() - millis;
 
-  stats.read_time += secs;
+  stats.read_time += millis;
   stats.read_calls++;
   stats.read_requested_bytes += nbyte;
   if (ret > 0)
@@ -59,16 +63,16 @@ read_tramp(int fildes, void *buf, size_t nbyte) {
 
 static ssize_t
 write_tramp(int fildes, const void *buf, size_t nbyte) {
-  double secs = 0;
+  uint32_t millis = 0;
   int err;
   ssize_t ret;
 
-  secs = timeofday();
+  millis = timeofday_ms();
   ret = write(fildes, buf, nbyte);
   err = errno;
-  secs = timeofday() - secs;
+  millis = timeofday_ms() - millis;
 
-  stats.write_time += secs;
+  stats.write_time += millis;
   stats.write_calls++;
   stats.write_requested_bytes += nbyte;
   if (ret > 0)
@@ -80,15 +84,15 @@ write_tramp(int fildes, const void *buf, size_t nbyte) {
 
 static int
 connect_tramp(int socket, const struct sockaddr *address, socklen_t address_len) {
-  double secs = 0;
+  uint32_t millis = 0;
   int err, ret;
 
-  secs = timeofday();
+  millis = timeofday_ms();
   ret = connect(socket, address, address_len);
   err = errno;
-  secs = timeofday() - secs;
+  millis = timeofday_ms() - millis;
 
-  stats.connect_time += secs;
+  stats.connect_time += millis;
   stats.connect_calls++;
 
   errno = err;
@@ -98,21 +102,39 @@ connect_tramp(int socket, const struct sockaddr *address, socklen_t address_len)
 static int
 select_tramp(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout)
 {
-  double secs = 0;
+  uint32_t millis = 0;
   int ret, err;
 
-  secs = timeofday();
+  millis = timeofday_ms();
   ret = select(nfds, readfds, writefds, errorfds, timeout);
   err = errno;
-  secs = timeofday() - secs;
+  millis = timeofday_ms() - millis;
 
-  stats.select_time += secs;
+  stats.select_time += millis;
   stats.select_calls++;
 
   errno = err;
   return ret;
 }
 
+static int
+poll_tramp(struct pollfd fds[], nfds_t nfds, int timeout)
+{
+  uint32_t millis = 0;
+  int ret, err;
+
+  millis = timeofday_ms();
+  ret = poll(fds, nfds, timeout);
+  err = errno;
+  millis = timeofday_ms() - millis;
+
+  stats.poll_time += millis;
+  stats.poll_calls++;
+
+  errno = err;
+  return ret;
+}
+
 static void
 fd_trace_start() {
   static int inserted = 0;
@@ -124,11 +146,13 @@ fd_trace_start() {
 
   insert_tramp("read", read_tramp);
   insert_tramp("write", write_tramp);
-  insert_tramp("connect", connect_tramp);
+  insert_tramp("poll", poll_tramp);
+
   #ifdef HAVE_MACH
   insert_tramp("select$DARWIN_EXTSN", select_tramp);
   #else
   insert_tramp("select", select_tramp);
+  insert_tramp("connect", connect_tramp);
   #endif
 }
 
@@ -149,7 +173,7 @@ fd_trace_dump(json_gen 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_integer(gen, stats.read_time);
     json_gen_cstr(gen, "requested");
     json_gen_integer(gen, stats.read_requested_bytes);
     json_gen_cstr(gen, "actual");
@@ -163,7 +187,7 @@ fd_trace_dump(json_gen 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_integer(gen, stats.write_time);
     json_gen_cstr(gen, "requested");
     json_gen_integer(gen, stats.write_requested_bytes);
     json_gen_cstr(gen, "actual");
@@ -177,7 +201,7 @@ fd_trace_dump(json_gen 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_integer(gen, stats.connect_time);
     json_gen_map_close(gen);
   }
 
@@ -187,7 +211,17 @@ fd_trace_dump(json_gen 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_integer(gen, stats.select_time);
+    json_gen_map_close(gen);
+  }
+
+  if (stats.poll_calls > 0) {
+    json_gen_cstr(gen, "poll");
+    json_gen_map_open(gen);
+    json_gen_cstr(gen, "calls");
+    json_gen_integer(gen, stats.poll_calls);
+    json_gen_cstr(gen, "time");
+    json_gen_integer(gen, stats.poll_time);
     json_gen_map_close(gen);
   }
 }

data/ext/tracers/gc.c

@@ -13,7 +13,7 @@
 
 struct memprof_gc_stats {
   size_t gc_calls;
-  double gc_time;
+  uint32_t gc_time;
 };
 
 static struct tracer tracer;
@@ -23,13 +23,13 @@ static void (*orig_garbage_collect)();
 static void
 gc_tramp()
 {
-  double secs = 0;
+  uint32_t millis = 0;
 
-  secs = timeofday();
+  millis = timeofday_ms();
   orig_garbage_collect();
-  secs = timeofday() - secs;
+  millis = timeofday_ms() - millis;
 
-  stats.gc_time += secs;
+  stats.gc_time += millis;
   stats.gc_calls++;
 }
 
@@ -64,7 +64,7 @@ gc_trace_dump(json_gen gen) {
   json_gen_integer(gen, stats.gc_calls);
 
   json_gen_cstr(gen, "time");
-  json_gen_double(gen, stats.gc_time);
+  json_gen_integer(gen, stats.gc_time);
 }
 
 void install_gc_tracer()

data/ext/tracers/mysql.c

@@ -9,30 +9,55 @@
 #include "bin_api.h"
 #include "json.h"
 #include "tracer.h"
+#include "tracers/sql.h"
 #include "tramp.h"
 #include "util.h"
 
 struct memprof_mysql_stats {
   size_t query_calls;
-  double query_time;
+  uint32_t query_time;
+
+  size_t query_calls_by_type[sql_UNKNOWN];
+  uint32_t query_time_by_type[sql_UNKNOWN];
 };
 
 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 (*orig_send_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;
+  enum memprof_sql_type type;
+  uint32_t millis = 0;
   int ret;
 
-  secs = timeofday();
+  millis = timeofday_ms();
   ret = orig_real_query(mysql, stmt_str, length);
-  secs = timeofday() - secs;
+  millis = timeofday_ms() - millis;
+
+  stats.query_time += millis;
+  stats.query_calls++;
+
+  type = memprof_sql_query_type(stmt_str, length);
+  stats.query_time_by_type[type] += millis;
+  stats.query_calls_by_type[type]++;
+
+  return ret;
+}
+
+static int
+send_query_tramp(void *mysql, const char *stmt_str, unsigned long length) {
+  enum memprof_sql_type type;
+  int ret;
 
-  stats.query_time += secs;
+  ret = orig_send_query(mysql, stmt_str, length);
   stats.query_calls++;
 
+  type = memprof_sql_query_type(stmt_str, length);
+  stats.query_calls_by_type[type]++;
+
   return ret;
 }
 
@@ -48,6 +73,10 @@ mysql_trace_start() {
   orig_real_query = bin_find_symbol("mysql_real_query", NULL, 1);
   if (orig_real_query)
     insert_tramp("mysql_real_query", real_query_tramp);
+
+  orig_send_query = bin_find_symbol("mysql_send_query", NULL, 1);
+  if (orig_send_query)
+    insert_tramp("mysql_send_query", send_query_tramp);
 }
 
 static void
@@ -61,12 +90,30 @@ mysql_trace_reset() {
 
 static void
 mysql_trace_dump(json_gen gen) {
+  enum memprof_sql_type i;
+
   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);
+    json_gen_integer(gen, stats.query_time);
+
+    json_gen_cstr(gen, "types");
+    json_gen_map_open(gen);
+    for (i=0; i<=sql_UNKNOWN; i++) {
+      json_gen_cstr(gen, memprof_sql_type_str(i));
+      json_gen_map_open(gen);
+
+      json_gen_cstr(gen, "queries");
+      json_gen_integer(gen, stats.query_calls_by_type[i]);
+
+      json_gen_cstr(gen, "time");
+      json_gen_integer(gen, stats.query_time_by_type[i]);
+
+      json_gen_map_close(gen);
+    }
+    json_gen_map_close(gen);
   }
 }
 

data/ext/tracers/postgres.c

@@ -9,11 +9,13 @@
 #include "bin_api.h"
 #include "json.h"
 #include "tracer.h"
+#include "tracers/sql.h"
 #include "tramp.h"
 #include "util.h"
 
 struct memprof_postgres_stats {
   size_t query_calls;
+  size_t query_calls_by_type[sql_UNKNOWN+1];
 };
 
 static struct tracer tracer;
@@ -22,11 +24,15 @@ static void * (*orig_PQexec)(void *postgres, const char *stmt);
 
 static void *
 PQexec_tramp(void *postgres, const char *stmt) {
+  enum memprof_sql_type type;
   void *ret;
 
   ret = orig_PQexec(postgres, stmt);
   stats.query_calls++;
 
+  type = memprof_sql_query_type(stmt, strlen(stmt));
+  stats.query_calls_by_type[type]++;
+
   return ret;
 }
 
@@ -55,9 +61,22 @@ postgres_trace_reset() {
 
 static void
 postgres_trace_dump(json_gen gen) {
+  enum memprof_sql_type i;
+
   if (stats.query_calls > 0) {
     json_gen_cstr(gen, "queries");
     json_gen_integer(gen, stats.query_calls);
+
+    json_gen_cstr(gen, "types");
+    json_gen_map_open(gen);
+    for (i=0; i<=sql_UNKNOWN; i++) {
+      json_gen_cstr(gen, memprof_sql_type_str(i));
+      json_gen_map_open(gen);
+      json_gen_cstr(gen, "queries");
+      json_gen_integer(gen, stats.query_calls_by_type[i]);
+      json_gen_map_close(gen);
+    }
+    json_gen_map_close(gen);
   }
 }
 

data/ext/tracers/resources.c

@@ -15,14 +15,14 @@ struct memprof_resources_stats {
   long inblock;
   long oublock;
 
-  double utime;
-  double stime;
+  int64_t utime;
+  int64_t stime;
 };
 
 static struct tracer tracer;
 static struct memprof_resources_stats stats;
 
-#define TVAL_TO_DBL(tv) ((double)tv.tv_sec + (double)tv.tv_usec * 1e-6)
+#define TVAL_TO_INT64(tv) ((int64_t)tv.tv_sec*1e3 + (int64_t)tv.tv_usec*1e-3)
 
 static void
 resources_trace_start() {
@@ -34,8 +34,8 @@ resources_trace_start() {
   stats.inblock = -usage.ru_inblock;
   stats.oublock = -usage.ru_oublock;
 
-  stats.stime = -TVAL_TO_DBL(usage.ru_stime);
-  stats.utime = -TVAL_TO_DBL(usage.ru_utime);
+  stats.stime = -TVAL_TO_INT64(usage.ru_stime);
+  stats.utime = -TVAL_TO_INT64(usage.ru_utime);
 }
 
 static void
@@ -49,8 +49,8 @@ resources_trace_dump(json_gen gen) {
     stats.inblock += usage.ru_inblock;
     stats.oublock += usage.ru_oublock;
 
-    stats.stime += TVAL_TO_DBL(usage.ru_stime);
-    stats.utime += TVAL_TO_DBL(usage.ru_utime);
+    stats.stime += TVAL_TO_INT64(usage.ru_stime);
+    stats.utime += TVAL_TO_INT64(usage.ru_utime);
   }
 
   json_gen_cstr(gen, "signals");
@@ -63,10 +63,10 @@ resources_trace_dump(json_gen gen) {
   json_gen_integer(gen, stats.oublock);
 
   json_gen_cstr(gen, "stime");
-  json_gen_double(gen, stats.stime);
+  json_gen_integer(gen, stats.stime);
 
   json_gen_cstr(gen, "utime");
-  json_gen_double(gen, stats.utime);
+  json_gen_integer(gen, stats.utime);
 }
 
 static void
@@ -83,7 +83,7 @@ void install_resources_tracer()
   tracer.stop = resources_trace_stop;
   tracer.reset = resources_trace_reset;
   tracer.dump = resources_trace_dump;
-  tracer.id = "resource";
+  tracer.id = "resources";
 
   trace_insert(&tracer);
 }

data/ext/tracers/sql.c

@@ -0,0 +1,56 @@
+#include <tracers/sql.h>
+
+enum memprof_sql_type
+memprof_sql_query_type(const char *stmt, unsigned long length)
+{
+  int i;
+
+  for (i=0; i<length && i<10; i++) {
+    switch (stmt[i]) {
+      case ' ':
+      case '\n':
+      case '\r':
+        continue;
+        break;
+
+      case 'S':
+      case 's':
+        return sql_SELECT;
+
+      case 'I':
+      case 'i':
+        return sql_INSERT;
+
+      case 'U':
+      case 'u':
+        return sql_UPDATE;
+
+      case 'D':
+      case 'd':
+        return sql_DELETE;
+
+      default:
+        return sql_UNKNOWN;
+    }
+  }
+
+  return sql_UNKNOWN;
+}
+
+const char *
+memprof_sql_type_str(enum memprof_sql_type type)
+{
+  switch (type) {
+    case sql_SELECT:
+      return "select";
+    case sql_UPDATE:
+      return "update";
+    case sql_INSERT:
+      return "insert";
+    case sql_DELETE:
+      return "delete";
+    default:
+    case sql_UNKNOWN:
+      return "unknown";
+  }
+}

data/ext/tracers/sql.h

@@ -0,0 +1,18 @@
+#if !defined(_sql_h_)
+#define _sql_h_
+
+enum memprof_sql_type {
+  sql_SELECT,
+  sql_UPDATE,
+  sql_INSERT,
+  sql_DELETE,
+  sql_UNKNOWN // last
+};
+
+enum memprof_sql_type
+memprof_sql_query_type(const char *stmt, unsigned long length);
+
+const char *
+memprof_sql_type_str(enum memprof_sql_type);
+
+#endif

data/ext/util.c

@@ -89,3 +89,11 @@ timeofday()
   gettimeofday(&tv, NULL);
   return (double)tv.tv_sec + (double)tv.tv_usec * 1e-6;
 }
+
+uint64_t
+timeofday_ms()
+{
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return (uint64_t)tv.tv_sec*1e3 + (uint64_t)tv.tv_usec*1e-3;
+}

data/ext/util.h

@@ -1,6 +1,8 @@
 #if !defined(__util_h__)
 #define __util_h__
 
+#include <stdint.h>
+
 #if defined(_MEMPROF_DEBUG)
 #include <stdio.h>
 #define dbg_printf(...) do {\
@@ -73,9 +75,13 @@ struct memprof_config {
 unsigned long
 gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len);
 
+/* Copy of timeofday() implementation inside ruby 1.8, used w/ thread state */
+double
+timeofday();
+
 /* Use this function for time tracking. It will (interally) try to use an
  * appropriately granual timing function.
  */
-double
-timeofday();
+uint64_t
+timeofday_ms();
 #endif

data/memprof.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'memprof'
-  s.version = '0.3.7'
+  s.version = '0.3.8'
   s.summary = 'Ruby Memory Profiler'
   s.description = "Ruby memory profiler similar to bleak_house, but without patches to the Ruby VM"
   s.homepage = "http://github.com/ice799/memprof"

data/spec/tracing_spec.rb

@@ -38,9 +38,9 @@ describe 'Memprof tracers' do
       select(nil, nil, nil, 0.15)
     end
 
-    filedata.should =~ /"select":\{"calls":1,"time":0\.1[567]/
+    filedata.should =~ /"select":\{"calls":1,"time":1[567]\d/
     time = filedata[/"select":\{"calls":\d+,"time":([\d.]+)/, 1].to_f
-    time.should.be.close(0.15, 0.1)
+    time.should.be.close(150, 10)
   end
 
   should 'trace objects created for block' do
@@ -79,7 +79,7 @@ describe 'Memprof tracers' do
 
         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)
+        time.should.be.close(250, 25)
       end
     rescue Mysql::Error => e
       raise unless e.message =~ /connect/

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: memprof
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 3
   prerelease: 
   segments: 
   - 0
   - 3
-  - 7
-  version: 0.3.7
+  - 8
+  version: 0.3.8
 platform: ruby
 authors: 
 - Joe Damato
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-28 00:00:00 -08:00
+date: 2011-01-31 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -91,6 +91,8 @@ files:
 - ext/tracers/objects.c
 - ext/tracers/postgres.c
 - ext/tracers/resources.c
+- ext/tracers/sql.c
+- ext/tracers/sql.h
 - ext/tramp.c
 - ext/tramp.h
 - ext/util.c