Use top-down and bottom-up profile notions in allocation profiler

Source/devtools/front_end/AllocationProfile.js

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 25 matching lines @@
     this._strings = profile.strings;
     this._liveObjectStats = liveObjectStats;
 
     this._nextNodeId = 1;
     this._functionInfos = []
     this._idToNode = {};
     this._collapsedTopNodeIdToFunctionInfo = {};
 
     this._traceTops = null;
 
-    this._buildAllocationFunctionInfos(profile);
-    this._traceTree = this._buildInvertedAllocationTree(profile, liveObjectStats);
+    this._buildFunctionAllocationInfos(profile);
+    this._traceTree = this._buildAllocationTree(profile, liveObjectStats);
 }
 
 WebInspector.AllocationProfile.prototype = {
-    _buildAllocationFunctionInfos: function(profile)
+    _buildFunctionAllocationInfos: function(profile)
     {
         var strings = this._strings;
 
         var functionInfoFields = profile.snapshot.meta.trace_function_info_fields;
         var functionIdOffset = functionInfoFields.indexOf("function_id");
         var functionNameOffset = functionInfoFields.indexOf("name");
         var scriptNameOffset = functionInfoFields.indexOf("script_name");
         var scriptIdOffset = functionInfoFields.indexOf("script_id");
         var lineOffset = functionInfoFields.indexOf("line");
         var columnOffset = functionInfoFields.indexOf("column");
         var functionInfoFieldCount = functionInfoFields.length;
 
         var rawInfos = profile.trace_function_infos;
         var infoLength = rawInfos.length;
         var functionInfos = this._functionInfos = new Array(infoLength / functionInfoFieldCount);
         var index = 0;
         for (var i = 0; i < infoLength; i += functionInfoFieldCount) {
             functionInfos[index++] = new WebInspector.FunctionAllocationInfo(
                 strings[rawInfos[i + functionNameOffset]],
                 strings[rawInfos[i + scriptNameOffset]],
                 rawInfos[i + scriptIdOffset],
                 rawInfos[i + lineOffset],
                 rawInfos[i + columnOffset]);
         }
     },
 
-    _buildInvertedAllocationTree: function(profile, liveObjectStats)
+    _buildAllocationTree: function(profile, liveObjectStats)
     {
         var traceTreeRaw = profile.trace_tree;
         var functionInfos = this._functionInfos;
 
         var traceNodeFields = profile.snapshot.meta.trace_node_fields;
         var nodeIdOffset = traceNodeFields.indexOf("id");
         var functionInfoIndexOffset = traceNodeFields.indexOf("function_info_index");
         var allocationCountOffset = traceNodeFields.indexOf("count");
         var allocationSizeOffset = traceNodeFields.indexOf("size");
         var childrenOffset = traceNodeFields.indexOf("children");
         var nodeFieldCount = traceNodeFields.length;
 
         function traverseNode(rawNodeArray, nodeOffset, parent)
         {
             var functionInfo = functionInfos[rawNodeArray[nodeOffset + functionInfoIndexOffset]];
             var id = rawNodeArray[nodeOffset + nodeIdOffset];
             var stats = liveObjectStats[id];
             var liveCount = stats ? stats.count : 0;
             var liveSize = stats ? stats.size : 0;
-            var result = new WebInspector.AllocationTraceNode(
+            var result = new WebInspector.TopDownAllocationNode(
                 id,
                 functionInfo,
                 rawNodeArray[nodeOffset + allocationCountOffset],
                 rawNodeArray[nodeOffset + allocationSizeOffset],
                 liveCount,
                 liveSize,
                 parent);
             functionInfo.addTraceTopNode(result);
 
             var rawChildren = rawNodeArray[nodeOffset + childrenOffset];
@@ skipping 38 matching lines @@
 
     /**
      * @param {string} nodeId
      * @return {!WebInspector.HeapSnapshotCommon.AllocationNodeCallers}
      */
     serializeCallers: function(nodeId)
     {
         var node = this._idToNode[nodeId];
         if (!node) {
             var functionInfo = this._collapsedTopNodeIdToFunctionInfo[nodeId];
-            node = functionInfo.tracesWithThisTop();
+            node = functionInfo.bottomUpRoot();
             delete this._collapsedTopNodeIdToFunctionInfo[nodeId];
             this._idToNode[nodeId] = node;
         }
 
         var nodesWithSingleCaller = [];
         while (node.callers().length === 1) {
             node = node.callers()[0];
             nodesWithSingleCaller.push(this._serializeCaller(node));
         }
 
@@ skipping 42 matching lines @@
             liveCount,
             liveSize,
             hasChildren
         );
     }
 }
 
 
 /**
  * @constructor
+ * @param {number} id
+ * @param {!WebInspector.FunctionAllocationInfo} functionInfo
+ * @param {number} count
+ * @param {number} size
+ * @param {number} liveCount
+ * @param {number} liveSize
+ * @param {?WebInspector.TopDownAllocationNode} parent
  */
-WebInspector.AllocationTraceNode = function(id, functionInfo, count, size, liveCount, liveSize, parent)
+WebInspector.TopDownAllocationNode = function(id, functionInfo, count, size, liveCount, liveSize, parent)
 {
     this.id = id;
     this.functionInfo = functionInfo;
     this.allocationCount = count;
     this.allocationSize = size;
     this.liveCount = liveCount;
     this.liveSize = liveSize;
     this.parent = parent;
     this.children = [];
 }
 
 
 /**
  * @constructor
  * @param {!WebInspector.FunctionAllocationInfo} functionInfo
  */
-WebInspector.AllocationBackTraceNode = function(functionInfo)
+WebInspector.BottomUpAllocationNode = function(functionInfo)
 {
     this.functionInfo = functionInfo;
     this.allocationCount = 0;
     this.allocationSize = 0;
     this.liveCount = 0;
     this.liveSize = 0;
     this._callers = [];
 }
 
 
-WebInspector.AllocationBackTraceNode.prototype = {
+WebInspector.BottomUpAllocationNode.prototype = {
     /**
-     * @param {!WebInspector.AllocationTraceNode} traceNode
-     * @return {!WebInspector.AllocationTraceNode}
+     * @param {!WebInspector.TopDownAllocationNode} traceNode
+     * @return {!WebInspector.TopDownAllocationNode}
      */
     addCaller: function(traceNode)
     {
         var functionInfo = traceNode.functionInfo;
         var result;
         for (var i = 0; i < this._callers.length; i++) {
             var caller = this._callers[i];
             if (caller.functionInfo === functionInfo) {
                 result = caller;
                 break;
             }
         }
         if (!result) {
-            result = new WebInspector.AllocationBackTraceNode(functionInfo);
+            result = new WebInspector.BottomUpAllocationNode(functionInfo);
             this._callers.push(result);
         }
         return result;
     },
 
     /**
-     * @return {!Array.<!WebInspector.AllocationBackTraceNode>}
+     * @return {!Array.<!WebInspector.BottomUpAllocationNode>}
      */
     callers: function()
     {
         return this._callers;
     },
 
     /**
      * @return {boolean}
      */
     hasCallers: function()
     {
         return this._callers.length > 0;
     }
 }
 
 
 /**
  * @constructor
+ * @param {string} functionName
+ * @param {string} scriptName
+ * @param {number} scriptId
+ * @param {number} line
+ * @param {number} column
  */
 WebInspector.FunctionAllocationInfo = function(functionName, scriptName, scriptId, line, column)
 {
     this.functionName = functionName;
     this.scriptName = scriptName;
     this.scriptId = scriptId;
     this.line = line;
     this.column = column;
     this.totalCount = 0;
     this.totalSize = 0;
     this.totalLiveCount = 0;
     this.totalLiveSize = 0;
     this._traceTops = [];
 }
 
 WebInspector.FunctionAllocationInfo.prototype = {
+    /**
+     * @param {!WebInspector.TopDownAllocationNode} node
+     */
     addTraceTopNode: function(node)
     {
         if (node.allocationCount === 0)
             return;
         this._traceTops.push(node);
         this.totalCount += node.allocationCount;
         this.totalSize += node.allocationSize;
         this.totalLiveCount += node.liveCount;
         this.totalLiveSize += node.liveSize;
     },
 
     /**
-     * @return {?WebInspector.AllocationBackTraceNode}
+     * @return {?WebInspector.BottomUpAllocationNode}
      */
-    tracesWithThisTop: function()
+    bottomUpRoot: function()
     {
         if (!this._traceTops.length)
             return null;
-        if (!this._backTraceTree)
+        if (!this._bottomUpTree)
             this._buildAllocationTraceTree();
-        return this._backTraceTree;
+        return this._bottomUpTree;
     },
 
     _buildAllocationTraceTree: function()
     {
-        this._backTraceTree = new WebInspector.AllocationBackTraceNode(this._traceTops[0].functionInfo);
+        this._bottomUpTree = new WebInspector.BottomUpAllocationNode(this);
 
         for (var i = 0; i < this._traceTops.length; i++) {
             var node = this._traceTops[i];
-            var backTraceNode = this._backTraceTree;
+            var bottomUpNode = this._bottomUpTree;
             var count = node.allocationCount;
             var size = node.allocationSize;
             var liveCount = node.liveCount;
             var liveSize = node.liveSize;
             while (true) {
-                backTraceNode.allocationCount += count;
-                backTraceNode.allocationSize += size;
-                backTraceNode.liveCount += liveCount;
-                backTraceNode.liveSize += liveSize;
+                bottomUpNode.allocationCount += count;
+                bottomUpNode.allocationSize += size;
+                bottomUpNode.liveCount += liveCount;
+                bottomUpNode.liveSize += liveSize;
                 node = node.parent;
                 if (node === null) {
                     break;
                 }
-                backTraceNode = backTraceNode.addCaller(node);
+                bottomUpNode = bottomUpNode.addCaller(node);
             }
         }
     }
 }