rubinius-profiler 2.0.2 → 2.1

data/lib/rubinius/profiler/version.rb

@@ -1,5 +1,5 @@
 module Rubinius
   module Profiler
-    VERSION = "2.0.2"
+    VERSION = "2.1"
   end
 end

data/rubinius-profiler.gemspec

@@ -13,7 +13,6 @@ Gem::Specification.new do |spec|
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.extensions    = ["ext/rubinius/profiler/extconf.rb"]
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 

metadata

@@ -1,22 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: rubinius-profiler
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: '2.1'
 platform: ruby
 authors:
 - Brian Shirai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-15 00:00:00.000000000 Z
+date: 2016-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+  name: bundler
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -25,12 +25,12 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+  name: rake
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,8 +42,7 @@ description: Rubinius profiler.
 email:
 - brixen@gmail.com
 executables: []
-extensions:
-- ext/rubinius/profiler/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -51,8 +50,6 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- ext/rubinius/profiler/extconf.rb
-- ext/rubinius/profiler/profiler.cpp
 - lib/rubinius/profiler.rb
 - lib/rubinius/profiler/profiler.rb
 - lib/rubinius/profiler/version.rb
@@ -77,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.2
 signing_key: 
 specification_version: 4
 summary: Rubinius profiler.

data/ext/rubinius/profiler/extconf.rb

@@ -1,3 +0,0 @@
-require 'mkmf'
-
-create_makefile 'rubinius/profiler/ext/profiler'

data/ext/rubinius/profiler/profiler.cpp

@@ -1,1059 +0,0 @@
-#include <rbxti.hpp>
-#include <rbxti/atomic.hpp>
-#include <rbx_config.h>
-
-#include <stdint.h>
-#include <stdio.h>
-
-#include <list>
-#include <stack>
-#include <map>
-#ifdef RBX_HAVE_TR1
-#include <tr1/unordered_map>
-#define std_unordered_map std::tr1::unordered_map
-#else
-#include <unordered_map>
-#define std_unordered_map std::unordered_map
-#endif
-
-#include <time.h>
-
-#include <sstream>
-#include <iostream>
-#include <vector>
-#include <algorithm>
-
-typedef uint64_t method_id;
-
-#if defined(RBX_HAVE_TR1) && !defined(RBX_HAVE_TR1_HASH)
-namespace std {
-  namespace tr1 {
-    template <>
-      struct hash<method_id> {
-        size_t operator()(const method_id id) const {
-          return id;
-        }
-      };
-  }
-}
-#endif
-
-using namespace rbxti;
-
-namespace profiler {
-
-  enum Kind {
-    kNormal,
-    kSingleton,
-    kBlock,
-    kYoungGC,
-    kMatureGC,
-    kNormalJIT,
-    kSingletonJIT,
-    kBlockJIT,
-    kFinalizers,
-    kScript,
-    kRoot
-  };
-
-  class VM;
-  class Profiler;
-  class Method;
-  class Node;
-  typedef std_unordered_map<Method*, rinteger> KeyMap;
-  typedef std_unordered_map<method_id, Method*> MethodMap;
-
-  /* An accumulating increment timer. Keeps track of the maximum and minimum
-   * intervals recorded. Calculates a cumulative moving average according to
-   * the formula:
-   *
-   *               x(i+1) + i*CA(i)
-   *    CA(i+1) = -----------------
-   *                   i + 1
-   *
-   *  where:
-   *
-   *    CA(n) is the nth cumulative average
-   *    x(n) is the nth measured value of x
-   *    i is the number of measurements
-   */
-  class Timer {
-  protected:
-
-    uint64_t total_;
-    uint64_t timings_;
-    uint64_t max_;
-    uint64_t min_;
-    uint64_t last_;
-    uint64_t start_;
-    double   moving_average_;
-    bool     started_;
-
-  public:
-
-    Timer()
-      : total_(0)
-      , timings_(0)
-      , max_(0)
-      , min_(0)
-      , last_(0)
-      , start_(0)
-      , moving_average_(0.0)
-      , started_(false)
-    { }
-
-    bool started() {
-      return started_;
-    }
-
-    uint64_t total() {
-      return total_;
-    }
-
-    uint64_t timings() {
-      return timings_;
-    }
-
-    uint64_t max() {
-      return max_;
-    }
-
-    uint64_t min() {
-      return min_;
-    }
-
-    double moving_average() {
-      return moving_average_;
-    }
-
-    void start(Env* env) {
-      if(started_) return;
-
-      started_ = true;
-      start_ = env->time_current_ns();
-    }
-
-    void stop(Env* env, uint64_t cur) {
-      if(!started_) return;
-
-      started_ = false;
-
-      last_ = cur - start_;
-      total_ += last_;
-
-      if(min_ == 0 || min_ > last_) min_ = last_;
-      if(max_ == 0 || max_ < last_) max_ = last_;
-
-      moving_average_ = (last_ + timings_ * moving_average_) / (timings_ + 1);
-      ++timings_;
-    }
-  };
-
-  class StackTimer : public Timer {
-    size_t   entered_;
-    uint64_t count_;
-
-  public:
-    StackTimer()
-      : entered_(0)
-      , count_(0)
-    { }
-
-    uint64_t count() {
-      return count_;
-    }
-
-    void start(Env* env) {
-      ++entered_;
-      Timer::start(env);
-    }
-
-    void stop(Env* env, uint64_t cur) {
-      if(!started_) return;
-
-      ++count_;
-      if(--entered_ == 0) Timer::stop(env, cur);
-    }
-  };
-
-  class Node {
-    int id_;
-    int called_;
-    uint64_t total_;
-    Method*  method_;
-
-    Node* sibling_;
-    Node* first_sub_node_;
-
-  public:
-    Node(Method* method, int id)
-      : id_(id)
-      , called_(0)
-      , total_(0)
-      , method_(method)
-      , sibling_(0)
-      , first_sub_node_(0)
-    { }
-
-    int id() {
-      return id_;
-    }
-
-    Method* method() {
-      return method_;
-    }
-
-    uint64_t total() {
-      return total_;
-    }
-
-    int called() {
-      return called_;
-    }
-
-    Node* sub_nodes() {
-      return first_sub_node_;
-    }
-
-    int count_sub_nodes() {
-      int count = 0;
-      Node* node = first_sub_node_;
-      while(node) {
-        ++count;
-        node = node->sibling();
-      }
-
-      return count;
-    }
-
-    Node* sibling() {
-      return sibling_;
-    }
-
-    void set_sibling(Node* node) {
-      sibling_ = node;
-    }
-
-    void accumulate(uint64_t time) {
-      total_ += time;
-      called_++;
-    }
-
-    Node* find_sub_node(Profiler* profiler, Method* method);
-  };
-
-  class Method {
-  private:
-    method_id id_;
-    rsymbol   name_;
-    rsymbol   container_;
-    Kind      kind_;
-    rsymbol   file_;
-    int       line_;
-    uint64_t  total_;
-
-  public:
-    StackTimer  timer;
-
-  public:
-    Method(method_id id, rsymbol name, rsymbol container, Kind kind=kNormal)
-      : id_(id)
-      , name_(name)
-      , container_(container)
-      , kind_(kind)
-      , file_(0)
-      , line_(0)
-      , total_(0)
-    { }
-
-    method_id id() {
-      return id_;
-    }
-
-    rsymbol container() {
-      return container_;
-    }
-
-    rsymbol name() {
-      return name_;
-    }
-
-    Kind kind() {
-      return kind_;
-    }
-
-    rstring to_s(Env* env);
-
-    rsymbol file() {
-      return file_;
-    }
-
-    int line() {
-      return line_;
-    }
-
-    void set_position(rsymbol file, int line) {
-      file_ = file;
-      line_ = line;
-    }
-
-    uint64_t total() {
-      return total_;
-    }
-
-    void accumulate(uint64_t time) {
-      total_ += time;
-    }
-  };
-
-  class Profiler;
-
-  /** Created when a method is being called. Contains a timer that tracks
-   * how much time is spent in the method. When the MethodEntry instance
-   * goes out of scope, the destructor records the elapsed time and updates
-   * the Method and Node objects.
-   */
-  class MethodEntry {
-    Method*       method_;
-    Node*         node_;
-    MethodEntry*  previous_me_;
-    Timer         timer_;
-
-  public:
-
-    MethodEntry(Method* method, Node* node=0)
-      : method_(method)
-      , node_(node)
-      , previous_me_(0)
-    {}
-
-    void start(Profiler* profiler, Env* env);
-    void stop(Profiler* profiler, Env* env);
-    void stop_all(Profiler* profiler, Env* env, uint64_t end_time);
-  };
-
-  class Profiler {
-    MethodMap methods_;
-    Node*     root_;
-    MethodEntry* current_me_;
-    int       nodes_;
-    uint32_t  threshold_;
-    uint64_t  start_time_;
-    uint64_t  end_time_;
-    int       id_;
-    bool      attached_;
-
-    rbxti::SpinLock  lock_;
-
-  public:
-    Profiler(Env* env);
-
-    ~Profiler();
-
-    void lock() {
-      lock_.lock();
-    }
-
-    void unlock() {
-      lock_.unlock();
-    }
-
-    MethodEntry* current_me() {
-      return current_me_;
-    }
-
-    void set_current_me(MethodEntry* me) {
-      current_me_ = me;
-    }
-
-    int next_node_id() {
-      return nodes_++;
-    }
-
-    uint64_t start_time() {
-      return start_time_;
-    }
-
-    uint64_t end_time() {
-      return end_time_;
-    }
-
-    uint64_t runtime() {
-      return end_time_ - start_time_;
-    }
-
-    void finish(Env* env, uint64_t end_time) {
-      if(end_time_ == 0) {
-        end_time_ = end_time;
-
-        current_me_->stop_all(this, env, end_time);
-      }
-    }
-
-    void detach(Env* env, uint64_t end_time) {
-      finish(env, end_time);
-      attached_ = false;
-    }
-
-    bool attached_p() {
-      return attached_;
-    }
-
-    int id() {
-      return id_;
-    }
-
-    method_id create_id(Env* env, rcompiled_code ccode,
-                        rsymbol container, rsymbol name, Kind kind);
-    Method* find_method(Env* env, rcompiled_code ccode,
-                        rsymbol container, rsymbol name, Kind kind);
-
-
-    Method* enter_method(Env* env, robject recv, rsymbol name, rmodule mod,
-                         rcompiled_code ccode);
-    Method* enter_block(Env* env, rsymbol name, rmodule module,
-                        rcompiled_code ccode);
-    Method* get_method(Env* env, rcompiled_code ccode, rsymbol name,
-                       rsymbol container, Kind kind);
-
-    void results(Env* env, rtable profile, rtable nodes, rtable methods,
-                         KeyMap& keys, uint64_t runtime);
-  };
-
-  rstring Method::to_s(Env* env) {
-    std::stringstream ss;
-    char data[1024];
-
-    if(kind() == kScript) {
-      ss << "script:";
-      if(file_) {
-        env->symbol_cstr(file_, data, 1024);
-        ss << data;
-      } else {
-        ss << "--unknown-file--";
-        ss << ":" << line_;
-      }
-
-      return env->string_new(ss.str().c_str());
-    }
-
-    if(!env->is_nil(container())) {
-      env->symbol_cstr(container_, data, 1024);
-      ss << data;
-    } else {
-      ss << "<anonymous>";
-    }
-
-    env->symbol_cstr(name(), data, 1024);
-
-    switch(kind()) {
-    case kNormal:
-      ss << "#" << data;
-      break;
-    case kNormalJIT:
-      ss << "#" << data << " <jit>";
-      break;
-    case kSingleton:
-    case kYoungGC:
-    case kMatureGC:
-    case kFinalizers:
-      ss << "." << data;
-      break;
-    case kSingletonJIT:
-      ss << "." << data << " <jit>";
-      break;
-    case kBlock:
-      ss << "::" << data << "<" << line_ << "> {}";
-      break;
-    case kBlockJIT:
-      ss << "::" << data << " {" << line_ << "} <jit>";
-      break;
-    case kRoot:
-      break;
-    case kScript:
-      // handled above, just here to make gcc happy.
-      abort();
-    }
-
-    return env->string_new(ss.str().c_str());
-  }
-
-  Node* Node::find_sub_node(Profiler* profiler, Method* method) {
-    Node* sub = first_sub_node_;
-
-    while(sub) {
-      if(sub->method() == method) return sub;
-      sub = sub->sibling();
-    }
-
-    Node* node = new Node(method, profiler->next_node_id());
-    node->set_sibling(first_sub_node_);
-    first_sub_node_ = node;
-
-    return node;
-  }
-
-  void MethodEntry::start(Profiler* profiler, Env* env) {
-    previous_me_ = profiler->current_me();
-
-    node_ = previous_me_->node_->find_sub_node(profiler, method_);
-
-    profiler->set_current_me(this);
-
-    method_->timer.start(env);
-    timer_.start(env);
-  }
-
-  void MethodEntry::stop(Profiler* profiler, Env* env) {
-    uint64_t cur = env->time_current_ns();
-
-    method_->timer.stop(env, cur);
-    timer_.stop(env, cur);
-
-    method_->accumulate(timer_.total());
-    node_->accumulate(timer_.total());
-
-    if(previous_me_) {
-      profiler->set_current_me(previous_me_);
-    }
-  }
-
-  void MethodEntry::stop_all(Profiler* profiler, Env* env, uint64_t end_time) {
-    method_->timer.stop(env, end_time);
-    timer_.stop(env, end_time);
-
-    method_->accumulate(timer_.total());
-    node_->accumulate(timer_.total());
-
-    if(previous_me_) previous_me_->stop_all(profiler, env, end_time);
-  }
-
-  Profiler::Profiler(Env* env)
-    : root_(0)
-    , current_me_(0)
-    , nodes_(0)
-    , threshold_((uint32_t)env->config_get_int("profiler.threshold"))
-    , start_time_(env->time_current_ns())
-    , end_time_(0)
-    , id_(env->current_thread_id())
-    , attached_(true)
-  {
-    Method* root_me = new Method(0, 0, 0, kRoot);
-    root_ = new Node(root_me, next_node_id());
-    current_me_ = new MethodEntry(root_me, root_);
-  }
-
-  Method* Profiler::enter_block(Env* env, rsymbol name, rmodule module,
-                                rcompiled_code ccode)
-  {
-    return get_method(env, ccode, name, env->module_name(module), kBlock);
-  }
-
-  Method* Profiler::enter_method(Env* env, robject recv, rsymbol name, rmodule mod,
-                                 rcompiled_code ccode)
-  {
-    if(env->module_is_metaclass(mod)) {
-      robject attached = env->metaclass_attached_instance(mod);
-
-      rmodule as_module = env->cast_to_rmodule(attached);
-      if(as_module) {
-        return get_method(env, ccode, name, env->module_name(as_module), kSingleton);
-      } else {
-        rstring str = env->to_s(mod);
-        return get_method(env, ccode, name, env->string_to_symbol(str), kSingleton);
-      }
-    } else {
-      return get_method(env, ccode, name, env->module_name(mod), kNormal);
-    }
-  }
-
-  Method* Profiler::get_method(Env* env, rcompiled_code ccode, rsymbol name,
-                               rsymbol container, Kind kind)
-  {
-    Method* method = find_method(env, ccode, container, name, kind);
-
-    if(!method->file() && ccode && !env->is_nil(ccode)) {
-      method->set_position(env->method_file(ccode), env->method_line(ccode));
-    }
-
-    return method;
-  }
-
-  method_id Profiler::create_id(Env* env, rcompiled_code ccode, rsymbol name,
-                                rsymbol container, Kind kind)
-  {
-    // If we have a CompiledCode, use it's method id.
-    if(ccode && !env->is_nil(ccode)) {
-      r_mint i = env->method_id(ccode);
-      if(i) return i;
-    }
-
-    // | -- 32 bits of container -- | -- 29 bits of name -- | -- 2 bits of kind -- | 0
-
-    uint32_t c = env->symbol_id(container) & 0xffffffff;
-    uint32_t n = env->symbol_id(name)      & 0x1fffffff;
-    uint32_t k = kind               & 0x3;
-
-    return (((uint64_t)c) << 32) |
-           (n << 3) |
-           k << 1;
-  }
-
-  Method* Profiler::find_method(Env* env, rcompiled_code ccode, rsymbol container,
-                                rsymbol name, Kind kind)
-  {
-    method_id id = create_id(env, ccode, container, name, kind);
-
-    Method* method;
-
-    MethodMap::iterator iter = methods_.find(id);
-
-    if(iter == methods_.end()) {
-      method = new Method(id, name, container, kind);
-      methods_[method->id()] = method;
-    } else {
-      method = iter->second;
-    }
-
-    return method;
-  }
-
-  typedef std::vector<Node*> WorkList;
-
-  static rinteger make_key(Env* env, Method* meth, KeyMap& keys) {
-    KeyMap::iterator iter = keys.find(meth);
-
-    if(iter == keys.end()) {
-      rinteger key = env->integer_new(keys.size());
-      keys[meth] = key;
-      return key;
-    }
-
-    return iter->second;
-  }
-
-  static rinteger add_method(Env* env, rtable methods, Method* meth,
-                            KeyMap& keys)
-  {
-    rinteger key = make_key(env, meth, keys);
-
-    // We already have the method, skip this.
-    bool fetched = false;
-    env->table_fetch(methods, key, &fetched);
-    if(fetched) return env->cast_to_rinteger(key);
-
-    rsymbol cumulative_sym = env->symbol("cumulative");
-    rsymbol total_sym = env->symbol("total");
-    rsymbol called_sym = env->symbol("called");
-
-    rtable method = env->table_new();
-    env->table_store(methods, key, method);
-
-    env->table_store(method, env->symbol("name"), meth->to_s(env));
-    env->table_store(method, cumulative_sym, env->integer_new(meth->timer.total()));
-    env->table_store(method, total_sym, env->integer_new(meth->total()));
-    env->table_store(method, called_sym, env->integer_new(meth->timer.count()));
-
-    if(meth->file()) {
-      if(env->is_nil(meth->file())) {
-        env->table_store(method, env->symbol("file"), env->string_new("unknown file"));
-      } else {
-        env->table_store(method, env->symbol("file"),
-                         env->symbol_to_string(meth->file()));
-      }
-
-      env->table_store(method, env->symbol("line"), env->integer_new(meth->line()));
-    }
-
-    return key;
-  }
-
-  static void add_node(Env* env, rtable nodes, rtable methods, Node* node,
-                       WorkList& work, KeyMap& keys, uint32_t threshold)
-  {
-    // We haven't exited this method yet, so its stats won't be accurate
-    if(node->method()->timer.started()) return;
-
-    rinteger key = env->integer_new(node->id());
-
-    rarray tbl = env->array_new(5);
-
-    env->table_store(nodes, key, tbl);
-
-    robject meth_key = add_method(env, methods, node->method(), keys);
-
-    env->array_set(tbl, 0, meth_key);
-    env->array_set(tbl, 1, env->integer_new(node->total()));
-    env->array_set(tbl, 2, env->integer_new(node->called()));
-
-    int count = node->count_sub_nodes();
-    env->array_set(tbl, 3, env->integer_new(count));
-
-    rarray ary = env->array_new(count);
-
-    int idx = 0;
-
-    Node* sub = node->sub_nodes();
-
-    while(sub) {
-      if(sub->total() >= threshold) {
-        env->array_set(ary, idx++, env->integer_new(sub->id()));
-        work.push_back(sub);
-      }
-
-      sub = sub->sibling();
-    }
-
-    env->array_set(tbl, 4, ary);
-  }
-
-  void Profiler::results(Env* env, rtable profile, rtable nodes, rtable methods,
-                         KeyMap& keys, uint64_t runtime)
-  {
-
-    WorkList work;
-
-    // If we haven't even gone for a total of longer than 10x the threshold,
-    // just disable the threshold.
-    if(runtime < 10 * threshold_) threshold_ = 0;
-
-    env->table_store(profile, env->symbol("total_nodes"), env->integer_new(nodes_));
-
-    rarray roots = env->array_new(root_->count_sub_nodes());
-    env->table_store(profile, env->symbol("roots"), roots);
-
-    int idx = 0;
-    Node* sub = root_->sub_nodes();
-
-    while(sub) {
-      if(sub->total() >= threshold_) {
-        env->array_set(roots, idx++, env->integer_new(sub->id()));
-        work.push_back(sub);
-      }
-
-      sub = sub->sibling();
-    }
-
-    while(work.size() > 0) {
-      Node* node = work.back();
-      work.pop_back();
-
-      add_node(env, nodes, methods, node, work, keys, threshold_);
-    }
-  }
-
-  Profiler::~Profiler() {
-    for(MethodMap::iterator i = methods_.begin();
-        i != methods_.end();
-        i++) {
-      delete i->second;
-    }
-
-    WorkList work;
-
-    work.push_back(root_);
-
-    while(work.size() > 0) {
-      Node* node = work.back();
-      work.pop_back();
-
-      Node* sub = node->sub_nodes();
-
-      while(sub) {
-        work.push_back(sub);
-        sub = sub->sibling();
-      }
-
-      delete node;
-    }
-  }
-
-  struct GlobalState {
-    Profiler* main_profiler;
-    std::list<Profiler*> profilers;
-
-    GlobalState()
-      : main_profiler(0)
-    {}
-
-    void add(Profiler* prof) {
-      profilers.push_back(prof);
-    }
-  };
-
-  static int cProfileToolID = -1;
-
-  namespace {
-    void tool_enable(Env* env) {
-      // Ignore if we are already enabled
-      if(env->global_tool_data()) return;
-
-      GlobalState* st = new GlobalState;
-      env->set_global_tool_data(st);
-
-      Profiler* profiler = new Profiler(env);
-      st->main_profiler = profiler;
-
-      env->thread_tool_set_data(cProfileToolID, profiler);
-      st->add(profiler);
-
-      env->enable_thread_tooling();
-    }
-
-    void* tool_enter_method(Env* env, robject recv, rsymbol name, rmodule mod,
-                            rcompiled_code ccode)
-    {
-      Profiler* profiler = (Profiler*)env->thread_tool_data(cProfileToolID);
-      if(!profiler) return 0;
-
-      profiler->lock();
-
-      Method* method = profiler->enter_method(env, recv, name, mod, ccode);
-      MethodEntry* me = new MethodEntry(method);
-      me->start(profiler, env);
-
-      profiler->unlock();
-
-      return me;
-    }
-
-    void tool_leave_entry(Env* env, void* tag) {
-      MethodEntry* me = (MethodEntry*)tag;
-
-      Profiler* profiler = (Profiler*)env->thread_tool_data(cProfileToolID);
-      if(!profiler) return;
-
-      profiler->lock();
-
-      me->stop(profiler, env);
-
-      profiler->unlock();
-
-      delete me;
-    }
-
-    void* tool_enter_block(Env* env, rsymbol name, rmodule module, rcompiled_code ccode) {
-      Profiler* profiler = (Profiler*)env->thread_tool_data(cProfileToolID);
-      if(!profiler) return 0;
-
-      profiler->lock();
-
-      Method* method = profiler->enter_block(env, name, module, ccode);
-      MethodEntry* me = new MethodEntry(method);
-      me->start(profiler, env);
-
-      profiler->unlock();
-
-      return me;
-    }
-
-    void* tool_enter_gc(Env* env, int level) {
-      Profiler* profiler = (Profiler*)env->thread_tool_data(cProfileToolID);
-      if(!profiler) return 0;
-
-      rsymbol container = env->symbol("GC");
-      rsymbol name;
-
-      Kind kind;
-
-      switch(level) {
-      case GCYoung:
-        kind = kYoungGC;
-        name = env->symbol("collect_young");
-        break;
-      case GCMature:
-        kind = kMatureGC;
-        name = env->symbol("collect_mature");
-        break;
-      case GCFinalizer:
-        kind = kFinalizers;
-        name = env->symbol("run_finalizers");
-        break;
-      default:
-        kind = kFinalizers;
-        name = env->symbol("unknown");
-        break;
-      }
-
-      profiler->lock();
-
-      Method* method = profiler->get_method(env, NULL, name, container, kind);
-      MethodEntry* me = new MethodEntry(method);
-      me->start(profiler, env);
-
-      profiler->unlock();
-
-      return me;
-    }
-
-    void* tool_enter_script(Env* env, rcompiled_code ccode) {
-      Profiler* profiler = (Profiler*)env->thread_tool_data(cProfileToolID);
-      if(!profiler) return 0;
-
-      profiler->lock();
-
-      Kind kind = kScript;
-      rsymbol container = env->symbol("unknown");
-      rsymbol name = container;
-
-      Method* method = profiler->get_method(env, ccode, name, container, kind);
-      MethodEntry* me = new MethodEntry(method);
-      me->start(profiler, env);
-
-      profiler->unlock();
-
-      return me;
-    }
-
-    void tool_shutdown(Env* env) {
-      GlobalState* st = (GlobalState*)env->global_tool_data();
-      if(!st) return;
-
-      env->set_global_tool_data(0);
-
-      for(std::list<Profiler*>::iterator i = st->profilers.begin();
-          i != st->profilers.end();
-          ++i) {
-
-        Profiler* prof = *i;
-        if(!prof->attached_p()) delete prof;
-      }
-
-      delete st;
-    }
-
-    void tool_start_thread(Env* env) {
-      GlobalState* st = (GlobalState*)env->global_tool_data();
-
-      // No GlobalState means that the tool isn't currently enabled.
-      if(!st) return;
-
-      Profiler* profiler = new Profiler(env);
-      profiler->lock();
-
-      st->add(profiler);
-
-      env->thread_tool_set_data(cProfileToolID, profiler);
-
-      env->enable_thread_tooling();
-
-      profiler->unlock();
-    }
-
-    void tool_stop_thread(Env* env) {
-      Profiler* profiler = (Profiler*)env->thread_tool_data(cProfileToolID);
-      if(!profiler) return;
-
-      profiler->lock();
-
-      env->thread_tool_set_data(cProfileToolID, 0);
-      profiler->detach(env, env->time_current_ns());
-
-      env->disable_thread_tooling();
-
-      profiler->unlock();
-    }
-
-    void tool_at_gc(Env* env) {
-      Profiler* profiler = (Profiler*)env->thread_tool_data(cProfileToolID);
-      if(!profiler) return;
-
-      profiler->lock();
-
-      // The main thread finished profiling, so we've already stopped
-      // doing our work, so we can safely bail.
-      if(profiler->end_time() > 0) {
-        env->thread_tool_set_data(cProfileToolID, 0);
-        delete profiler;
-        return;
-      }
-
-      profiler->unlock();
-    }
-
-    robject tool_results(Env* env) {
-      uint64_t fin = env->time_current_ns();
-
-      GlobalState* st = (GlobalState*)env->global_tool_data();
-
-      // If we are already shutting down, ignore this
-      if(!st) return env->nil();
-
-      Profiler* profiler = (Profiler*)env->thread_tool_data(cProfileToolID);
-
-      // Ignore results requests that don't come from the thread that
-      // started profiling.
-      if(st->main_profiler != profiler) return env->nil();
-
-      profiler->detach(env, fin);
-
-      env->thread_tool_set_data(cProfileToolID, 0);
-
-      rtable profile = env->table_new();
-
-      for(std::list<Profiler*>::iterator i = st->profilers.begin();
-          i != st->profilers.end();
-          ++i) {
-
-        Profiler* prof = *i;
-
-        prof->lock();
-
-        prof->finish(env, fin);
-
-        rtable thread = env->table_new();
-
-        env->table_store(profile, env->integer_new(prof->id()), thread);
-
-        rtable methods = env->table_new();
-        rtable nodes = env->table_new();
-
-        env->table_store(thread, env->symbol("methods"), methods);
-        env->table_store(thread, env->symbol("nodes"),   nodes);
-
-        uint64_t runtime = prof->runtime();
-        env->table_store(thread, env->symbol("runtime"), env->integer_new(runtime));
-
-        KeyMap keys;
-        prof->results(env, thread, nodes, methods, keys, runtime);
-
-        prof->unlock();
-      }
-
-      tool_shutdown(env);
-
-      env->disable_thread_tooling();
-      return profile;
-    }
-
-  }
-
-  extern "C" int Tool_Init(Env* env) {
-    env->config_set("tool.require", "tooling/profiler/profiler.rb");
-
-    cProfileToolID = env->thread_tool_new_id();
-
-    env->set_tool_results(tool_results);
-    env->set_tool_enable(tool_enable);
-
-    env->set_tool_enter_method(tool_enter_method);
-    env->set_tool_leave_method(tool_leave_entry);
-
-    env->set_tool_enter_block(tool_enter_block);
-    env->set_tool_leave_block(tool_leave_entry);
-
-    env->set_tool_enter_gc(tool_enter_gc);
-    env->set_tool_leave_gc(tool_leave_entry);
-
-    env->set_tool_enter_script(tool_enter_script);
-    env->set_tool_leave_script(tool_leave_entry);
-
-    env->set_tool_shutdown(tool_shutdown);
-
-    env->set_tool_thread_start(tool_start_thread);
-    env->set_tool_thread_stop(tool_stop_thread);
-
-    return 1;
-  }
-
-}