rblineprof 0.2.0

data/README.md

@@ -0,0 +1,34 @@
+# rblineprof
+
+```
+% ruby -C ext extconf.rb
+% make -C ext
+% ruby test.rb 
+       | $:.unshift 'ext'
+       | require 'rblineprof'
+       | 
+       | profile = lineprof(/./) do
+     1 |    1000.times do
+       | 
+   410 |      1*2*3
+   441 |      4*5*6
+  1243 |      7*8*9*10*11*12*13*14*15
+   380 |      2**32
+  1115 |      2**128
+       | 
+       |   end
+       | end
+       | 
+       | File.readlines(__FILE__).each_with_index do |line, num|
+       |   if (sample = profile[__FILE__][num+1]) > 0
+       |     printf "% 6d |  %s", sample, line
+       |   else
+       |     printf "       | %s", line
+       |   end
+       | end
+```
+
+## Other profilers
+
+* [PLine](https://github.com/soba1104/PLine) line-profiler for ruby 1.9
+* pure-ruby [LineProfiler](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/18997?help-en) for ruby 1.6

data/ext/.gitignore

@@ -0,0 +1,3 @@
+Makefile
+*.bundle
+*.o

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'rblineprof'

data/ext/rblineprof.c

@@ -0,0 +1,228 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include <ruby.h>
+#include <node.h>
+#include <intern.h>
+#include <st.h>
+#include <re.h>
+
+static VALUE gc_hook;
+
+typedef struct {
+  char *filename;
+  uint64_t *lines;
+  long nlines;
+
+  uint64_t last_time;
+  long last_line;
+} sourcefile_t;
+
+static struct {
+  bool enabled;
+
+  // single file mode, store filename and line data directly
+  char *source_filename;
+  sourcefile_t file;
+
+  // regex mode, store file data in hash table
+  VALUE source_regex;
+  st_table *files;
+  sourcefile_t *last_file;
+}
+rblineprof = {
+  .enabled = false,
+  .source_filename = NULL,
+  .source_regex = Qfalse,
+  .files = NULL,
+  .last_file = NULL
+};
+
+static uint64_t
+timeofday_usec()
+{
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return (uint64_t)tv.tv_sec*1e6 +
+         (uint64_t)tv.tv_usec;
+}
+
+static void
+profiler_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
+{
+  sourcefile_t *sourcefile = NULL;
+
+  char *file = node->nd_file;
+  long line  = nd_line(node);
+
+  if (!file) return;
+  if (line <= 0) return;
+
+  if (rblineprof.source_filename) { // single file mode
+    if (rblineprof.source_filename == file) {
+      sourcefile = &rblineprof.file;
+      sourcefile->filename = file;
+    } else {
+      return;
+    }
+
+  } else { // regex mode
+    st_lookup(rblineprof.files, (st_data_t)file, (st_data_t *)&sourcefile);
+
+    if ((VALUE)sourcefile == Qnil) // known negative match, skip
+      return;
+
+    if (!sourcefile) { // unknown file, check against regex
+      if (rb_reg_search(rblineprof.source_regex, rb_str_new2(file), 0, 0) >= 0) {
+        sourcefile = ALLOC_N(sourcefile_t, 1);
+        MEMZERO(sourcefile, sourcefile_t, 1);
+        sourcefile->filename = strdup(file);
+        st_insert(rblineprof.files, (st_data_t)sourcefile->filename, (st_data_t)sourcefile);
+      } else { // no match, insert Qnil to prevent regex next time
+        st_insert(rblineprof.files, (st_data_t)strdup(file), (st_data_t)Qnil);
+        return;
+      }
+    }
+  }
+
+  if (sourcefile) {
+    uint64_t now = timeofday_usec();
+
+    if (sourcefile->last_time) {
+      /* allocate space for per-line data the first time */
+      if (sourcefile->lines == NULL) {
+        sourcefile->nlines = sourcefile->last_line + 100;
+        sourcefile->lines = ALLOC_N(uint64_t, sourcefile->nlines);
+        MEMZERO(sourcefile->lines, uint64_t, sourcefile->nlines);
+      }
+
+      /* grow the per-line array if necessary */
+      if (sourcefile->last_line >= sourcefile->nlines) {
+        long prev_nlines = sourcefile->nlines;
+        sourcefile->nlines = sourcefile->last_line + 100;
+
+        REALLOC_N(sourcefile->lines, uint64_t, sourcefile->nlines);
+        MEMZERO(sourcefile->lines + prev_nlines, uint64_t, sourcefile->nlines - prev_nlines);
+      }
+
+      /* record the sample */
+      sourcefile->lines[sourcefile->last_line] += (now - sourcefile->last_time);
+    }
+
+    sourcefile->last_time = now;
+    sourcefile->last_line = line;
+
+    if (rblineprof.last_file && rblineprof.last_file != sourcefile)
+      rblineprof.last_file->last_time = 0;
+
+    rblineprof.last_file = sourcefile;
+  }
+}
+
+static int
+cleanup_files(st_data_t key, st_data_t record, st_data_t arg)
+{
+  xfree((char *)key);
+
+  sourcefile_t *sourcefile = (sourcefile_t*)record;
+  if (!sourcefile || (VALUE)sourcefile == Qnil) return ST_DELETE;
+
+  if (sourcefile->lines)
+    xfree(sourcefile->lines);
+  xfree(sourcefile);
+
+  return ST_DELETE;
+}
+
+static int
+summarize_files(st_data_t key, st_data_t record, st_data_t arg)
+{
+  sourcefile_t *sourcefile = (sourcefile_t*)record;
+  if (!sourcefile || (VALUE)sourcefile == Qnil) return ST_CONTINUE;
+
+  VALUE ret = (VALUE)arg;
+  VALUE ary = rb_ary_new();
+  long i;
+
+  for (i=0; i<sourcefile->nlines; i++)
+    rb_ary_store(ary, i, ULL2NUM(sourcefile->lines[i]));
+
+  rb_hash_aset(ret, rb_str_new2(sourcefile->filename), ary);
+
+  return ST_CONTINUE;
+}
+
+static VALUE
+lineprof_ensure(VALUE self)
+{
+  rb_remove_event_hook(profiler_hook);
+  rblineprof.enabled = false;
+}
+
+VALUE
+lineprof(VALUE self, VALUE filename)
+{
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "block required");
+
+  if (rblineprof.enabled)
+    rb_raise(rb_eArgError, "profiler is already enabled");
+
+  VALUE filename_class = rb_obj_class(filename);
+
+  if (filename_class == rb_cString) {
+    rblineprof.source_filename = rb_source_filename(StringValuePtr(filename));
+  } else if (filename_class == rb_cRegexp) {
+    rblineprof.source_regex = filename;
+    rblineprof.source_filename = NULL;
+  } else {
+    rb_raise(rb_eArgError, "argument must be String or Regexp");
+  }
+
+  // cleanup
+  rblineprof.last_file = NULL;
+  st_foreach(rblineprof.files, cleanup_files, 0);
+  if (rblineprof.file.lines) {
+    xfree(rblineprof.file.lines);
+    rblineprof.file.lines = NULL;
+    rblineprof.file.nlines = 0;
+  }
+
+  rblineprof.enabled = true;
+  rb_add_event_hook(profiler_hook, RUBY_EVENT_LINE);
+  rb_ensure(rb_yield, Qnil, lineprof_ensure, self);
+
+  VALUE ret = rb_hash_new();
+  VALUE ary = Qnil;
+
+  if (rblineprof.source_filename) {
+    long i;
+    ary = rb_ary_new();
+    for (i=0; i<rblineprof.file.nlines; i++)
+      rb_ary_store(ary, i, ULL2NUM(rblineprof.file.lines[i]));
+    rb_hash_aset(ret, rb_str_new2(rblineprof.source_filename), ary);
+  } else {
+    st_foreach(rblineprof.files, summarize_files, ret);
+  }
+
+  return ret;
+}
+
+static void
+rblineprof_gc_mark()
+{
+  if (rblineprof.enabled)
+    rb_gc_mark_maybe(rblineprof.source_regex);
+}
+
+void
+Init_rblineprof()
+{
+  gc_hook = Data_Wrap_Struct(rb_cObject, rblineprof_gc_mark, NULL, NULL);
+  rb_global_variable(&gc_hook);
+
+  rblineprof.files = st_init_strtable();
+  rb_define_global_function("lineprof", lineprof, 1);
+}

data/rblineprof.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'rblineprof'
+  s.version = '0.2.0'
+  s.homepage = 'http://github.com/tmm1/rblineprof'
+
+  s.authors = 'Aman Gupta'
+  s.email   = 'aman@tmm1.net'
+
+  s.files = `git ls-files`.split("\n")
+  s.extensions = 'ext/extconf.rb'
+
+  s.summary = 'line-profiler for ruby 1.8'
+  s.description = 'rblineprof shows you lines of code that are slow.'
+end

data/test.rb

@@ -0,0 +1,22 @@
+$:.unshift 'ext'
+require 'rblineprof'
+
+profile = lineprof(/./) do
+  1000.times do
+
+    1*2*3
+    4*5*6
+    7*8*9*10*11*12*13*14*15
+    2**32
+    2**128
+
+  end
+end
+
+File.readlines(__FILE__).each_with_index do |line, num|
+  if (sample = profile[__FILE__][num+1]) > 0
+    printf "% 6d |  %s", sample, line
+  else
+    printf "       | %s", line
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: rblineprof
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Aman Gupta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-09-18 00:00:00 Z
+dependencies: []
+
+description: rblineprof shows you lines of code that are slow.
+email: aman@tmm1.net
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- README.md
+- ext/.gitignore
+- ext/extconf.rb
+- ext/rblineprof.c
+- rblineprof.gemspec
+- test.rb
+homepage: http://github.com/tmm1/rblineprof
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: line-profiler for ruby 1.8
+test_files: []
+