Enhancing profiling data processing code with functionality needed for the Dev Tools Profiler.

test/mjsunit/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 106 matching lines @@
         this.enter('T: F3');
           this.enter('T: F3');
             this.enter('T: F3');
             this.leave();
             this.enter('T: F2');
             this.stay();
             this.leave();
           this.leave();
         this.leave();
       this.leave();
+      this.enter('lib2-f1');
+        this.enter('lib1-f1');
+        this.leave();
+      this.leave();
     this.stay();
   this.leave();
 };
 
 
 function Inherits(childCtor, parentCtor) {
   function tempCtor() {};
   tempCtor.prototype = parentCtor.prototype;
   childCtor.superClass_ = parentCtor.prototype;
   childCtor.prototype = new tempCtor();
   childCtor.prototype.constructor = childCtor;
 };
 
 
 (function testCallTreeBuilding() {
   function Driver() {
     ProfileTestDriver.call(this);
     this.namesTopDown = [];
     this.namesBottomUp = [];
   };
   Inherits(Driver, ProfileTestDriver);
 
   Driver.prototype.enter = function(func) {
     this.namesTopDown.push(func);
     this.namesBottomUp.unshift(func);
-    assertNoPathExists(this.profile.getTopDownTreeRoot(), this.namesTopDown,
+    assertNoPathExists(this.profile.getTopDownProfile().getRoot(), this.namesTopDown,
         'pre enter/topDown');
-    assertNoPathExists(this.profile.getBottomUpTreeRoot(), this.namesBottomUp,
+    assertNoPathExists(this.profile.getBottomUpProfile().getRoot(), this.namesBottomUp,
         'pre enter/bottomUp');
     Driver.superClass_.enter.call(this, func);
-    assertPathExists(this.profile.getTopDownTreeRoot(), this.namesTopDown,
+    assertPathExists(this.profile.getTopDownProfile().getRoot(), this.namesTopDown,
         'post enter/topDown');
-    assertPathExists(this.profile.getBottomUpTreeRoot(), this.namesBottomUp,
+    assertPathExists(this.profile.getBottomUpProfile().getRoot(), this.namesBottomUp,
         'post enter/bottomUp');
   };
 
   Driver.prototype.stay = function() {
     var preTopDownNodes = countNodes(this.profile, this.profile.traverseTopDownTree);
     var preBottomUpNodes = countNodes(this.profile, this.profile.traverseBottomUpTree);
     Driver.superClass_.stay.call(this);
     var postTopDownNodes = countNodes(this.profile, this.profile.traverseTopDownTree);
     var postBottomUpNodes = countNodes(this.profile, this.profile.traverseBottomUpTree);
     // Must be no changes in tree layout.
@@ skipping 19 matching lines @@
   assertEquals(selfTicks, node.selfWeight, 'self of ' + stack);
   assertEquals(totalTicks, node.totalWeight, 'total of ' + stack);
 };
 
 
 (function testTopDownRootProfileTicks() {
   var testDriver = new ProfileTestDriver();
   testDriver.execute();
 
   var pathWeights = [
-    [['lib1-f1'], 1, 14],
-    [['lib1-f1', 'lib1-f2'], 2, 13],
+    [['lib1-f1'], 1, 16],
+    [['lib1-f1', 'lib1-f2'], 2, 15],
     [['lib1-f1', 'lib1-f2', 'T: F1'], 2, 11],
     [['lib1-f1', 'lib1-f2', 'T: F1', 'T: F2'], 1, 1],
     [['lib1-f1', 'lib1-f2', 'T: F1', 'lib2-f1'], 2, 3],
     [['lib1-f1', 'lib1-f2', 'T: F1', 'lib2-f1', 'lib2-f1'], 1, 1],
     [['lib1-f1', 'lib1-f2', 'T: F1', 'T: F3'], 1, 5],
     [['lib1-f1', 'lib1-f2', 'T: F1', 'T: F3', 'T: F3'], 1, 4],
     [['lib1-f1', 'lib1-f2', 'T: F1', 'T: F3', 'T: F3', 'T: F3'], 1, 1],
-    [['lib1-f1', 'lib1-f2', 'T: F1', 'T: F3', 'T: F3', 'T: F2'], 2, 2]
+    [['lib1-f1', 'lib1-f2', 'T: F1', 'T: F3', 'T: F3', 'T: F2'], 2, 2],
+    [['lib1-f1', 'lib1-f2', 'lib2-f1'], 1, 2],
+    [['lib1-f1', 'lib1-f2', 'lib2-f1', 'lib1-f1'], 1, 1]
   ];
 
-  var root = testDriver.profile.getTopDownTreeRoot();
+  var root = testDriver.profile.getTopDownProfile().getRoot();
   for (var i = 0; i < pathWeights.length; ++i) {
     var data = pathWeights[i];
     assertNodeWeights(root, data[0], data[1], data[2]);
   }
 })();
 
 
 (function testRootFlatProfileTicks() {
   function Driver() {
     ProfileTestDriver.call(this);
     this.namesTopDown = [''];
     this.counters = {};
+    this.root = null;
   };
   Inherits(Driver, ProfileTestDriver);
 
   Driver.prototype.increment = function(func, self, total) {
     if (!(func in this.counters)) {
       this.counters[func] = { self: 0, total: 0 };
     }
     this.counters[func].self += self;
     this.counters[func].total += total;
   };
@@ skipping 21 matching lines @@
     Driver.superClass_.stay.call(this);
     this.increment(this.namesTopDown[this.namesTopDown.length - 1], 1, 0);
     this.incrementTotals();
   };
 
   Driver.prototype.leave = function() {
     Driver.superClass_.leave.call(this);
     this.namesTopDown.pop();
   };
 
+  Driver.prototype.extractRoot = function() {
+    assertTrue('' in this.counters);
+    this.root = this.counters[''];
+    delete this.counters[''];
+  };
+
   var testDriver = new Driver();
   testDriver.execute();
+  testDriver.extractRoot();
 
   var counted = 0;
   for (var c in testDriver.counters) {
     counted++;
   }
 
-  var flatProfile =
-      testDriver.profile.getFlatProfile().getRoot().exportChildren();
+  var flatProfileRoot = testDriver.profile.getFlatProfile().getRoot();
+  assertEquals(testDriver.root.self, flatProfileRoot.selfWeight);
+  assertEquals(testDriver.root.total, flatProfileRoot.totalWeight);
+
+  var flatProfile = flatProfileRoot.exportChildren();
   assertEquals(counted, flatProfile.length, 'counted vs. flatProfile');
   for (var i = 0; i < flatProfile.length; ++i) {
     var rec = flatProfile[i];
     assertTrue(rec.label in testDriver.counters, 'uncounted: ' + rec.label);
     var reference = testDriver.counters[rec.label];
     assertEquals(reference.self, rec.selfWeight, 'self of ' + rec.label);
     assertEquals(reference.total, rec.totalWeight, 'total of ' + rec.label);
   }
 
 })();
+
+
+(function testFunctionCalleesProfileTicks() {
+  var testDriver = new ProfileTestDriver();
+  testDriver.execute();
+
+  var pathWeights = [
+    [['lib2-f1'], 3, 5],
+    [['lib2-f1', 'lib2-f1'], 1, 1],
+    [['lib2-f1', 'lib1-f1'], 1, 1]
+  ];
+
+  var profile = testDriver.profile.getTopDownProfile('lib2-f1');
+  var root = profile.getRoot();
+  for (var i = 0; i < pathWeights.length; ++i) {
+    var data = pathWeights[i];
+    assertNodeWeights(root, data[0], data[1], data[2]);
+  }
+})();
+
+
+(function testFunctionFlatProfileTicks() {
+  var testDriver = new ProfileTestDriver();
+  testDriver.execute();
+
+  var flatWeights = {
+    'lib2-f1': [1, 1],
+    'lib1-f1': [1, 1]
+  };
+
+  var flatProfileRoot =
+     testDriver.profile.getFlatProfile('lib2-f1').findOrAddChild('lib2-f1');
+  assertEquals(3, flatProfileRoot.selfWeight);
+  assertEquals(5, flatProfileRoot.totalWeight);
+
+  var flatProfile = flatProfileRoot.exportChildren();
+  assertEquals(2, flatProfile.length, 'counted vs. flatProfile');
+  for (var i = 0; i < flatProfile.length; ++i) {
+    var rec = flatProfile[i];
+    assertTrue(rec.label in flatWeights, 'uncounted: ' + rec.label);
+    var reference = flatWeights[rec.label];
+    assertEquals(reference[0], rec.selfWeight, 'self of ' + rec.label);
+    assertEquals(reference[1], rec.totalWeight, 'total of ' + rec.label);
+  }
+
+})();
+