First commit

Author: Qard

.gitignore

@@ -0,0 +1,7 @@
+build
+lib-cov
+node_modules
+.lock-wscript
+*.swp
+*.swo
+.DS_Store

binding.gyp

@@ -0,0 +1,13 @@
+{
+  'targets': [
+    {
+      'target_name': 'profiler',
+      'sources': [
+        'cpu_profiler.cc',
+        'profile.cc',
+        'profile_node.cc',
+        'profiler.cc',
+      ],
+    }
+  ]
+}

builderror.log

@@ -0,0 +1,66 @@
+#include "cpu_profiler.h"
+#include "profile.h"
+
+namespace nodex {
+  CpuProfiler::CpuProfiler () {}
+  CpuProfiler::~CpuProfiler () {}
+
+  void CpuProfiler::Initialize (Handle<Object> target) {
+    HandleScope scope;
+
+    NODE_SET_METHOD(target, "getProfilesCount", CpuProfiler::GetProfilesCount);
+    NODE_SET_METHOD(target, "getProfile", CpuProfiler::GetProfile);
+    NODE_SET_METHOD(target, "findProfile", CpuProfiler::FindProfile);
+    NODE_SET_METHOD(target, "startProfiling", CpuProfiler::StartProfiling);
+    NODE_SET_METHOD(target, "stopProfiling", CpuProfiler::StopProfiling);
+    NODE_SET_METHOD(target, "deleteAllProfiles", CpuProfiler::DeleteAllProfiles);
+  }
+
+  Handle<Value> CpuProfiler::GetProfilesCount (const Arguments& args) {
+    HandleScope scope;
+    return scope.Close(Integer::New(v8::CpuProfiler::GetProfilesCount()));
+  }
+
+  Handle<Value> CpuProfiler::GetProfile (const Arguments& args) {
+    HandleScope scope;
+    if (args.Length() < 1) {
+      return ThrowException(Exception::Error(String::New("No index specified")));
+    } else if ( ! args[0]->IsInt32()) {
+      return ThrowException(Exception::TypeError(String::New("Argument must be an integer")));
+    }
+    int32_t index = args[0]->Int32Value();
+    const CpuProfile* profile = v8::CpuProfiler::GetProfile(index);
+    return scope.Close(Profile::New(profile));
+  }
+
+  Handle<Value> CpuProfiler::FindProfile (const Arguments& args) {
+    HandleScope scope;
+    if (args.Length() < 1) {
+      return ThrowException(Exception::Error(String::New("No index specified")));
+    } else if ( ! args[0]->IsInt32()) {
+      return ThrowException(Exception::TypeError(String::New("Argument must be an integer")));
+    }
+    uint32_t uid = args[0]->Uint32Value();
+    const CpuProfile* profile = v8::CpuProfiler::FindProfile(uid);
+    return scope.Close(Profile::New(profile));
+  }
+
+  Handle<Value> CpuProfiler::StartProfiling (const Arguments& args) {
+    HandleScope scope;
+    Local<String> title = args.Length() > 0 ? args[0]->ToString() : String::New("");
+    v8::CpuProfiler::StartProfiling(title);
+    return Undefined();
+  }
+
+  Handle<Value> CpuProfiler::StopProfiling (const Arguments& args) {
+    HandleScope scope;
+    Local<String> title = args.Length() > 0 ? args[0]->ToString() : String::New("");
+    const CpuProfile* profile = v8::CpuProfiler::StopProfiling(title);
+    return scope.Close(Profile::New(profile));
+  }
+
+  Handle<Value> CpuProfiler::DeleteAllProfiles (const Arguments& args) {
+    v8::CpuProfiler::DeleteAllProfiles();
+    return Undefined();
+  }
+} //namespace nodex

cpu_profiler.cc

@@ -0,0 +1,28 @@
+#ifndef NODE_CPU_PROFILER_
+#define NODE_CPU_PROFILER_
+
+#include <v8-profiler.h>
+#include <node.h>
+
+using namespace v8;
+using namespace node;
+
+namespace nodex {
+  class CpuProfiler {
+    public:
+      static void Initialize(Handle<Object> target);
+
+      CpuProfiler();
+      virtual ~CpuProfiler();
+
+    protected:
+      static Handle<Value> GetProfilesCount(const Arguments& args);
+      static Handle<Value> GetProfile(const Arguments& args);
+      static Handle<Value> FindProfile(const Arguments& args);
+      static Handle<Value> StartProfiling(const Arguments& args);
+      static Handle<Value> StopProfiling(const Arguments& args);
+      static Handle<Value> DeleteAllProfiles(const Arguments& args);
+  };
+} //namespace nodex
+
+#endif  // NODE_CPU_PROFILER_H

cpu_profiler.h

@@ -0,0 +1,2 @@
+var base = process.env.STRONG_PROFILER_COV ? 'lib-cov' : 'lib';
+module.exports = require('./' + base + '/strong-profiler');

index.js

@@ -0,0 +1,115 @@
+// Precompile the profiler module for 4 platforms: Windows, Solaris/SunOS, Linux, OSX
+// both 32 and 64 bit architectures
+//
+// lib_ver (example: 'v0.10.12') indicates the version (.12)
+// that the library was compiled under.
+//
+// we first try a locally compiled version; failing that we'll look for a
+// precompiled version
+
+var version_map = {
+  'v0.10.*': 'v0.10.12'
+};
+var platform = process.platform;
+var key, lib_ver;
+
+if (platform === 'solaris') platform = 'sunos';
+
+for (key in version_map) {
+  if (RegExp(key).test(process.version)) {
+    lib_ver = version_map[key];
+  }
+}
+
+// if lib_ver stays undefined require will fail and we'll catch it
+// same behaviour when there's a new version of node and we haven't 
+// compiled for it yet
+var modpath = '../compiled/' + platform + '/' + process.arch + '/' + lib_ver
+  + '/profiler';
+var buildpath = '../build/Release/profiler';
+var binding
+
+// try local build dir in case node-gyp was successful
+try { binding = require(buildpath); }
+catch (err) {
+  // Try pre-built modules
+  try { binding = require(modpath); }
+  catch (err) {
+    // stub out the API functions in case we were unable to load the native
+    // module, which will prevent it from blowing up
+    binding = {
+      takeSnapshot: function(){},
+      startProfiling: function(){},
+      stopProfiling: function(){}
+    }
+    console.log('unable to load native module "profiler.node" from ' +
+      buildpath + ' or ' + modpath);
+  }
+}
+
+function CpuProfile() {}
+
+function inspectorObjectFor(node) {
+  var i, count, child,
+      result = {
+        functionName: node.functionName,
+        url: node.scriptName,
+        lineNumber: node.lineNumber,
+        totalTime: node.totalTime,
+        selfTime: node.selfTime,
+        numberOfCalls: 0,
+        visible: true,
+        callUID: node.callUid,
+        children: []
+      };
+  for(i = 0, count = node.childrenCount; i < count; i++) {
+    child = node.getChild(i);
+    result.children.push(inspectorObjectFor(child));
+  }
+  return result;
+}
+
+CpuProfile.prototype.getTopDownRoot = function() {
+  return inspectorObjectFor(this.topRoot);
+};
+
+CpuProfile.prototype.getBottomUpRoot = function() {
+  return inspectorObjectFor(this.bottomRoot);
+};
+
+var cpuCache = [];
+
+exports.startProfiling = function(name) {
+  if (!name || !name.length) {
+    name = 'org.nodejs.profiles.cpu.user-initiated.' + (cpuCache.length + 1);
+  }
+
+  binding.startProfiling(name);
+};
+
+exports.stopProfiling = function(name) {
+  name = name ? name : '';
+  var profile = binding.stopProfiling(name);
+  profile.__proto__ = CpuProfile.prototype;
+  cpuCache.push(profile);
+  return profile;
+};
+
+exports.getProfile = function(index) {
+  return cpuCache[index];
+};
+
+exports.findProfile = function(uid) {
+  return cpuCache.filter(function(s) {return s.uid === uid;})[0];
+};
+
+exports.profileCount = function() {
+  return cpuCache.length;
+};
+
+exports.deleteAllProfiles = function() {
+  cpuCache = [];
+  binding.deleteAllProfiles();
+};
+
+process.profiler = exports;

lib/strong-profiler.js

@@ -0,0 +1,18 @@
+{
+  "name": "strong-cpu-profiler",
+  "version": "0.1.0",
+  "description": "Node bindings for the v8 cpu profiler",
+  "homepage": "http://github.com/strongloop/strong-cpu-profiler",
+  "author": "Stephen Belanger <[email protected]>",
+  "keywords": [ "profiler", "inspector", "cpu" ],
+  "engines": { "node": ">=0.8" },
+  "devDependencies": {
+    "should": "*",
+    "mocha": "*"
+  },
+  "scripts": {
+    "install" : "(node-gyp rebuild 2> builderror.log) || (exit 0)",
+    "test": "mocha -r should -G -R spec",
+    "coverage": "rm -rf lib-cov && jscoverage lib lib-cov && STRONG_PROFILER_COV=1 mocha -r should -G -R html-cov > lib-cov/index.html && open lib-cov/index.html"
+  }
+}

package.json

@@ -0,0 +1,76 @@
+#include "profile.h"
+#include "profile_node.h"
+
+using namespace v8;
+
+namespace nodex {
+  Persistent<ObjectTemplate> Profile::profile_template_;
+
+  void Profile::Initialize () {
+    profile_template_ = Persistent<ObjectTemplate>::New(ObjectTemplate::New());
+    profile_template_->SetInternalFieldCount(1);
+    profile_template_->SetAccessor(String::New("title"), Profile::GetTitle);
+    profile_template_->SetAccessor(String::New("uid"), Profile::GetUid);
+    profile_template_->SetAccessor(String::New("topRoot"), Profile::GetTopRoot);
+    profile_template_->SetAccessor(String::New("bottomRoot"), Profile::GetBottomRoot);
+    profile_template_->Set(String::New("delete"), FunctionTemplate::New(Profile::Delete));
+  }
+
+  Handle<Value> Profile::GetUid (Local<String> property, const AccessorInfo& info) {
+    HandleScope scope;
+    Local<Object> self = info.Holder();
+    void* ptr = self->GetPointerFromInternalField(0);
+    uint32_t uid = static_cast<CpuProfile*>(ptr)->GetUid();
+    return scope.Close(Integer::NewFromUnsigned(uid));
+  }
+
+
+  Handle<Value> Profile::GetTitle (Local<String> property, const AccessorInfo& info) {
+    HandleScope scope;
+    Local<Object> self = info.Holder();
+    void* ptr = self->GetPointerFromInternalField(0);
+    Handle<String> title = static_cast<CpuProfile*>(ptr)->GetTitle();
+    return scope.Close(title);
+  }
+
+  Handle<Value> Profile::GetTopRoot (Local<String> property, const AccessorInfo& info) {
+    HandleScope scope;
+    Local<Object> self = info.Holder();
+    void* ptr = self->GetPointerFromInternalField(0);
+    const CpuProfileNode* node = static_cast<CpuProfile*>(ptr)->GetTopDownRoot();
+    return scope.Close(ProfileNode::New(node));
+  }
+
+
+  Handle<Value> Profile::GetBottomRoot (Local<String> property, const AccessorInfo& info) {
+    HandleScope scope;
+    Local<Object> self = info.Holder();
+    void* ptr = self->GetPointerFromInternalField(0);
+    const CpuProfileNode* node = static_cast<CpuProfile*>(ptr)->GetBottomUpRoot();
+    return scope.Close(ProfileNode::New(node));
+  }
+
+  Handle<Value> Profile::Delete (const Arguments& args) {
+  	HandleScope scope;
+    Handle<Object> self = args.This();
+  	void* ptr = self->GetPointerFromInternalField(0);
+    static_cast<CpuProfile*>(ptr)->Delete();
+  	return Undefined();
+  }
+
+  Handle<Value> Profile::New (const CpuProfile* profile) {
+    HandleScope scope;
+    
+    if (profile_template_.IsEmpty()) {
+      Profile::Initialize();
+    }
+    
+    if ( ! profile) {
+      return Undefined();
+    } else {
+      Local<Object> obj = profile_template_->NewInstance();
+      obj->SetPointerInInternalField(0, const_cast<CpuProfile*>(profile));
+      return scope.Close(obj);
+    }
+  }
+}

profile.cc

@@ -0,0 +1,25 @@
+#ifndef NODE_PROFILE_
+#define NODE_PROFILE_
+
+#include <v8-profiler.h>
+
+using namespace v8;
+
+namespace nodex {
+
+class Profile {
+ public:
+  static Handle<Value> New(const CpuProfile* profile);
+ 
+ private:
+  static Handle<Value> GetUid(Local<String> property, const AccessorInfo& info);
+  static Handle<Value> GetTitle(Local<String> property, const AccessorInfo& info);
+  static Handle<Value> GetTopRoot(Local<String> property, const AccessorInfo& info);
+  static Handle<Value> GetBottomRoot(Local<String> property, const AccessorInfo& info);
+  static Handle<Value> Delete(const Arguments& args);
+  static void Initialize();
+  static Persistent<ObjectTemplate> profile_template_;
+};
+
+} //namespace nodex
+#endif  // NODE_PROFILE_