Added ProfileView object for performing sorting, searching and filtering operations on a profile.

tools/profile.js

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 38 matching lines @@
  * Should be overriden by subclasses.
  *
  * @param {string} name Function name.
  */
 devtools.profiler.Profile.prototype.skipThisFunction = function(name) {
   return false;
 };
 
 
 /**
+ * Enum for profiler operations that involve looking up existing
+ * code entries.
+ *
+ * @enum {number}
+ */
+devtools.profiler.Profile.Operation = {
+  MOVE: 0,
+  DELETE: 1,
+  TICK: 2
+};
+
+
+/**
  * Called whenever the specified operation has failed finding a function
  * containing the specified address. Should be overriden by subclasses.
- * Operation is one of the following: 'move', 'delete', 'tick'.
+ * See the devtools.profiler.Profile.Operation enum for the list of
+ * possible operations.
  *
- * @param {string} operation Operation name.
+ * @param {number} operation Operation.
  * @param {number} addr Address of the unknown code.
+ * @param {number} opt_stackPos If an unknown address is encountered
+ *     during stack strace processing, specifies a position of the frame
+ *     containing the address.
  */
 devtools.profiler.Profile.prototype.handleUnknownCode = function(
-    operation, addr) {
+    operation, addr, opt_stackPos) {
 };
 
 
 /**
  * Registers static (library) code entry.
  *
  * @param {string} name Code entry name.
  * @param {number} startAddr Starting address.
  * @param {number} endAddr Ending address.
  */
 devtools.profiler.Profile.prototype.addStaticCode = function(
     name, startAddr, endAddr) {
-  this.codeMap_.addStaticCode(startAddr,
-      new devtools.profiler.CodeMap.CodeEntry(endAddr - startAddr, name));
+  var entry = new devtools.profiler.CodeMap.CodeEntry(
+      endAddr - startAddr, name);
+  this.codeMap_.addStaticCode(startAddr, entry);
+  return entry;
 };
 
 
 /**
  * Registers dynamic (JIT-compiled) code entry.
  *
  * @param {string} type Code entry type.
  * @param {string} name Code entry name.
  * @param {number} start Starting address.
  * @param {number} size Code entry size.
  */
 devtools.profiler.Profile.prototype.addCode = function(
     type, name, start, size) {
-  this.codeMap_.addCode(start,
-      new devtools.profiler.Profile.DynamicCodeEntry(size, type, name));
+  var entry = new devtools.profiler.Profile.DynamicCodeEntry(size, type, name);
+  this.codeMap_.addCode(start, entry);
+  return entry;
 };
 
 
 /**
  * Reports about moving of a dynamic code entry.
  *
  * @param {number} from Current code entry address.
  * @param {number} to New code entry address.
  */
 devtools.profiler.Profile.prototype.moveCode = function(from, to) {
   try {
     this.codeMap_.moveCode(from, to);
   } catch (e) {
-    this.handleUnknownCode('move', from);
+    this.handleUnknownCode(devtools.profiler.Profile.Operation.MOVE, from);
   }
 };
 
 
 /**
  * Reports about deletion of a dynamic code entry.
  *
  * @param {number} start Starting address.
  */
 devtools.profiler.Profile.prototype.deleteCode = function(start) {
   try {
     this.codeMap_.deleteCode(start);
   } catch (e) {
-    this.handleUnknownCode('delete', start);
+    this.handleUnknownCode(devtools.profiler.Profile.Operation.DELETE, start);
   }
 };
 
 
 /**
  * Records a tick event. Stack must contain a sequence of
  * addresses starting with the program counter value.
  *
  * @param {Array<number>} stack Stack sample.
  */
@@ skipping 14 matching lines @@
 devtools.profiler.Profile.prototype.resolveAndFilterFuncs_ = function(stack) {
   var result = [];
   for (var i = 0; i < stack.length; ++i) {
     var entry = this.codeMap_.findEntry(stack[i]);
     if (entry) {
       var name = entry.getName();
       if (!this.skipThisFunction(name)) {
         result.push(name);
       }
     } else {
-      this.handleUnknownCode('tick', stack[i]);
+      this.handleUnknownCode(
+          devtools.profiler.Profile.Operation.TICK, stack[i], i);
     }
   }
   return result;
 };
 
 
 /**
  * Returns the root of the top down call graph.
  */
 devtools.profiler.Profile.prototype.getTopDownTreeRoot = function() {
   this.topDownTree_.computeTotalWeights();
-  return this.topDownTree_.root_;
+  return this.topDownTree_.getRoot();
 };
 
 
 /**
  * Returns the root of the bottom up call graph.
  */
 devtools.profiler.Profile.prototype.getBottomUpTreeRoot = function() {
   this.bottomUpTree_.computeTotalWeights();
-  return this.bottomUpTree_.root_;
+  return this.bottomUpTree_.getRoot();
 };
 
 
 /**
  * Traverses the top down call graph in preorder.
  *
  * @param {function(devtools.profiler.CallTree.Node)} f Visitor function.
  */
 devtools.profiler.Profile.prototype.traverseTopDownTree = function(f) {
   this.topDownTree_.traverse(f);
 };
 
 
 /**
  * Traverses the bottom up call graph in preorder.
  *
  * @param {function(devtools.profiler.CallTree.Node)} f Visitor function.
  */
 devtools.profiler.Profile.prototype.traverseBottomUpTree = function(f) {
   this.bottomUpTree_.traverse(f);
 };
 
 
 /**
+ * Calculates a top down profile starting from the specified node.
+ *
+ * @param {devtools.profiler.CallTree.Node} opt_root Starting node.
+ */
+devtools.profiler.Profile.prototype.getTopDownProfile = function(opt_root) {
+  if (!opt_root) {
+    this.topDownTree_.computeTotalWeights();
+    return this.topDownTree_;
+  } else {
+    throw Error('not implemented');
+  }
+};
+
+
+/**
+ * Calculates a bottom up profile starting from the specified node.
+ *
+ * @param {devtools.profiler.CallTree.Node} opt_root Starting node.
+ */
+devtools.profiler.Profile.prototype.getBottomUpProfile = function(opt_root) {
+  if (!opt_root) {
+    this.bottomUpTree_.computeTotalWeights();
+    return this.bottomUpTree_;
+  } else {
+    throw Error('not implemented');
+  }
+};
+
+
+/**
  * Calculates a flat profile of callees starting from the specified node.
  *
  * @param {devtools.profiler.CallTree.Node} opt_root Starting node.
  */
 devtools.profiler.Profile.prototype.getFlatProfile = function(opt_root) {
-  var counters = new devtools.profiler.CallTree.Node('');
+  var counters = new devtools.profiler.CallTree();
   var precs = {};
   this.topDownTree_.computeTotalWeights();
   this.topDownTree_.traverseInDepth(
     function onEnter(node) {
       if (!(node.label in precs)) {
         precs[node.label] = 0;
       }
       var rec = counters.findOrAddChild(node.label);
       rec.selfWeight += node.selfWeight;
       if (precs[node.label] == 0) {
         rec.totalWeight += node.totalWeight;
       }
       precs[node.label]++;
     },
     function onExit(node) {
       precs[node.label]--;
     },
     opt_root);
-  return counters.exportChildren();
+  return counters;
 };
 
 
 /**
  * Creates a dynamic code entry.
  *
  * @param {number} size Code size.
  * @param {string} type Code type.
  * @param {string} name Function name.
  * @constructor
@@ skipping 29 matching lines @@
 };
 
 
 /**
  * @private
  */
 devtools.profiler.CallTree.prototype.totalsComputed_ = false;
 
 
 /**
+ * Returns the tree root.
+ */
+devtools.profiler.CallTree.prototype.getRoot = function() {
+  return this.root_;
+};
+
+
+/**
  * Adds the specified call path, constructing nodes as necessary.
  *
  * @param {Array<string>} path Call path.
  */
 devtools.profiler.CallTree.prototype.addPath = function(path) {
   if (path.length == 0) {
     return;
   }
   var curr = this.root_;
   for (var i = 0; i < path.length; ++i) {
     curr = curr.findOrAddChild(path[i]);
   }
   curr.selfWeight++;
   this.totalsComputed_ = false;
 };
 
 
 /**
+ * Finds an immediate child of the specified parent with the specified
+ * label, creates a child node if necessary. If a parent node isn't
+ * specified, uses tree root.
+ *
+ * @param {string} label Child node label.
+ */
+devtools.profiler.CallTree.prototype.findOrAddChild = function(
+    label, opt_parent) {
+  var parent = opt_parent || this.root_;
+  return parent.findOrAddChild(label);
+};
+
+
+/**
  * Computes total weights in the call graph.
  */
 devtools.profiler.CallTree.prototype.computeTotalWeights = function() {
   if (this.totalsComputed_) {
     return;
   }
   this.root_.computeTotalWeight();
   this.totalsComputed_ = true;
 };
 
 
 /**
- * Traverses the call graph in preorder.
+ * Traverses the call graph in preorder. This function can be used for
+ * building optionally modified tree clones. This is the boilerplate code
+ * for this scenario:
  *
- * @param {function(devtools.profiler.CallTree.Node)} f Visitor function.
+ * callTree.traverse(function(node, parentClone) {
+ *   var nodeClone = cloneNode(node);
+ *   if (parentClone)
+ *     parentClone.addChild(nodeClone);
+ *   return nodeClone;
+ * });
+ *
+ * @param {function(devtools.profiler.CallTree.Node, *)} f Visitor function.
+ *    The second parameter is the result of calling 'f' on the parent node.
  * @param {devtools.profiler.CallTree.Node} opt_start Starting node.
  */
 devtools.profiler.CallTree.prototype.traverse = function(f, opt_start) {
-  var nodesToVisit = [opt_start || this.root_];
-  while (nodesToVisit.length > 0) {
-    var node = nodesToVisit.shift();
-    f(node);
-    nodesToVisit = nodesToVisit.concat(node.exportChildren());
+  var pairsToProcess = [{node: opt_start || this.root_, param: null}];
+  while (pairsToProcess.length > 0) {
+    var pair = pairsToProcess.shift();
+    var node = pair.node;
+    var newParam = f(node, pair.param);
+    node.forEachChild(
+      function (child) { pairsToProcess.push({node: child, param: newParam}); }
+    );
   }
 };
 
 
 /**
  * Performs an indepth call graph traversal.
  *
  * @param {function(devtools.profiler.CallTree.Node)} enter A function called
  *     prior to visiting node's children.
  * @param {function(devtools.profiler.CallTree.Node)} exit A function called
@@ skipping 129 matching lines @@
     labels, opt_f) {
   for (var pos = 0, curr = this; pos < labels.length && curr != null; pos++) {
     var child = curr.findChild(labels[pos]);
     if (opt_f) {
       opt_f(child, pos);
     }
     curr = child;
   }
   return curr;
 };