Always use global indexes for nodes and edges in the heap snapshot representation

Source/devtools/front_end/HeapSnapshot.js

 /*
  * Copyright (C) 2011 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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
  * @param {!WebInspector.HeapSnapshot} snapshot
- * @param {!Uint32Array} edges
  * @param {number=} edgeIndex
  */
-WebInspector.HeapSnapshotEdge = function(snapshot, edges, edgeIndex)
+WebInspector.HeapSnapshotEdge = function(snapshot, edgeIndex)
 {
     this._snapshot = snapshot;
-    this._edges = edges;
+    this._edges = snapshot._containmentEdges;
     this.edgeIndex = edgeIndex || 0;
 }
 
 /**
  * @constructor
  * @param {string} name
  * @param {!WebInspector.HeapSnapshotNode.Serialized} node
  * @param {number} nodeIndex
  * @param {string} type
  * @param {number} distance
  */
 WebInspector.HeapSnapshotEdge.Serialized = function(name, node, nodeIndex, type, distance) {
     this.name = name;
     this.node = node;
     this.nodeIndex = nodeIndex;
     this.type = type;
     this.distance = distance;
 };
 
 WebInspector.HeapSnapshotEdge.prototype = {
     /**
      * @return {!WebInspector.HeapSnapshotEdge}
      */
     clone: function()
     {
-        return new WebInspector.HeapSnapshotEdge(this._snapshot, this._edges, this.edgeIndex);
+        return new WebInspector.HeapSnapshotEdge(this._snapshot, this.edgeIndex);
     },
 
     /**
      * @return {boolean}
      */
     hasStringName: function()
     {
         throw new Error("Not implemented");
     },
 
@@ skipping 81 matching lines @@
     item: function() { },
 
     next: function() { }
 };
 
 
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIterator}
- * @param {!WebInspector.HeapSnapshotEdge} edge
+ * @param {!WebInspector.HeapSnapshotNode} node
  */
-WebInspector.HeapSnapshotEdgeIterator = function(edge)
+WebInspector.HeapSnapshotEdgeIterator = function(node)
 {
-    this.edge = edge;
+    this._sourceNode = node;
+    this.edge = node._snapshot.createEdge(node._edgeIndexesStart());
 }
 
 WebInspector.HeapSnapshotEdgeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
-        return this.edge.edgeIndex < this.edge._edges.length;
+        return this.edge.edgeIndex < this._sourceNode._edgeIndexesEnd();
     },
 
     /**
      * @return {number}
      */
     index: function()
     {
         return this.edge.edgeIndex;
     },
 
@@ skipping 14 matching lines @@
     },
 
     next: function()
     {
         this.edge.edgeIndex += this.edge._snapshot._edgeFieldsCount;
     }
 };
 
 /**
  * @constructor
+ * @param {!WebInspector.HeapSnapshot} snapshot
+ * @param {number} retainerIndex
  */
-WebInspector.HeapSnapshotRetainerEdge = function(snapshot, retainedNodeIndex, retainerIndex)
+WebInspector.HeapSnapshotRetainerEdge = function(snapshot, retainerIndex)
 {
     this._snapshot = snapshot;
-    this._retainedNodeIndex = retainedNodeIndex;
-
-    var retainedNodeOrdinal = retainedNodeIndex / snapshot._nodeFieldCount;
-    this._firstRetainer = snapshot._firstRetainerIndex[retainedNodeOrdinal];
-    this._retainersCount = snapshot._firstRetainerIndex[retainedNodeOrdinal + 1] - this._firstRetainer;
-
     this.setRetainerIndex(retainerIndex);
 }
 
 /**
  * @constructor
  * @param {string} name
  * @param {!WebInspector.HeapSnapshotNode.Serialized} node
  * @param {number} nodeIndex
  * @param {string} type
  * @param {number} distance
  */
 WebInspector.HeapSnapshotRetainerEdge.Serialized = function(name, node, nodeIndex, type, distance) {
     this.name = name;
     this.node = node;
     this.nodeIndex = nodeIndex;
     this.type = type;
     this.distance = distance;
 }
 
 WebInspector.HeapSnapshotRetainerEdge.prototype = {
     /**
      * @return {!WebInspector.HeapSnapshotRetainerEdge}
      */
     clone: function()
     {
-        return new WebInspector.HeapSnapshotRetainerEdge(this._snapshot, this._retainedNodeIndex, this.retainerIndex());
+        return new WebInspector.HeapSnapshotRetainerEdge(this._snapshot, this.retainerIndex());
     },
 
     /**
      * @return {boolean}
      */
     hasStringName: function()
     {
         return this._edge().hasStringName();
     },
 
@@ skipping 11 matching lines @@
     node: function()
     {
         return this._node();
     },
 
     /**
      * @return {number}
      */
     nodeIndex: function()
     {
-        return this._nodeIndex;
+        return this._retainingNodeIndex;
     },
 
     /**
      * @return {number}
      */
     retainerIndex: function()
     {
         return this._retainerIndex;
     },
 
     /**
-     * @param {number} newIndex
+     * @param {number} retainerIndex
      */
-    setRetainerIndex: function(newIndex)
+    setRetainerIndex: function(retainerIndex)
     {
-        if (newIndex !== this._retainerIndex) {
-            this._retainerIndex = newIndex;
-            this.edgeIndex = newIndex;
-        }
+        if (retainerIndex === this._retainerIndex)
+            return;
+        this._retainerIndex = retainerIndex;
+        this._globalEdgeIndex = this._snapshot._retainingEdges[retainerIndex];
+        this._retainingNodeIndex = this._snapshot._retainingNodes[retainerIndex];
+        this._edgeInstance = null;
+        this._nodeInstance = null;
     },
 
     /**
      * @param {number} edgeIndex
      */
     set edgeIndex(edgeIndex)
     {
-        var retainerIndex = this._firstRetainer + edgeIndex;
-        this._globalEdgeIndex = this._snapshot._retainingEdges[retainerIndex];
-        this._nodeIndex = this._snapshot._retainingNodes[retainerIndex];
-        delete this._edgeInstance;
-        delete this._nodeInstance;
+        this.setRetainerIndex(edgeIndex);
     },
 
     _node: function()
     {
         if (!this._nodeInstance)
-            this._nodeInstance = this._snapshot.createNode(this._nodeIndex);
+            this._nodeInstance = this._snapshot.createNode(this._retainingNodeIndex);
         return this._nodeInstance;
     },
 
     _edge: function()
     {
-        if (!this._edgeInstance) {
-            var edgeIndex = this._globalEdgeIndex - this._node()._edgeIndexesStart();
-            this._edgeInstance = this._snapshot.createEdge(this._node().rawEdges(), edgeIndex);
-        }
+        if (!this._edgeInstance)
+            this._edgeInstance = this._snapshot.createEdge(this._globalEdgeIndex);
         return this._edgeInstance;
     },
 
     /**
      * @return {string}
      */
     toString: function()
     {
         return this._edge().toString();
     },
@@ skipping 12 matching lines @@
      */
     type: function()
     {
         return this._edge().type();
     }
 }
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIterator}
- * @param {!WebInspector.HeapSnapshotRetainerEdge} retainer
+ * @param {!WebInspector.HeapSnapshotNode} retainedNode
  */
-WebInspector.HeapSnapshotRetainerEdgeIterator = function(retainer)
+WebInspector.HeapSnapshotRetainerEdgeIterator = function(retainedNode)
 {
-    this.retainer = retainer;
+    var snapshot = retainedNode._snapshot;
+    var retainedNodeOrdinal = retainedNode.nodeIndex / snapshot._nodeFieldCount;

[alph, 2014/03/21 08:30:39]

_ordinal() ?

[yurys, 2014/03/21 08:33:20]

Done.

+    var retainerIndex = snapshot._firstRetainerIndex[retainedNodeOrdinal];
+    this._retainersEnd = snapshot._firstRetainerIndex[retainedNodeOrdinal + 1];
+    this.retainer = snapshot.createRetainingEdge(retainerIndex);
 }
 
 WebInspector.HeapSnapshotRetainerEdgeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
-        return this.retainer.retainerIndex() < this.retainer._retainersCount;
+        return this.retainer.retainerIndex() < this._retainersEnd;
     },
 
     /**
      * @return {number}
      */
     index: function()
     {
         return this.retainer.retainerIndex();
     },
 
@@ skipping 82 matching lines @@
     {
         var nodeFieldCount = this._snapshot._nodeFieldCount;
         return this._snapshot._dominatorsTree[this.nodeIndex / this._snapshot._nodeFieldCount] * nodeFieldCount;
     },
 
     /**
      * @return {!WebInspector.HeapSnapshotEdgeIterator}
      */
     edges: function()
     {
-        return new WebInspector.HeapSnapshotEdgeIterator(this._snapshot.createEdge(this.rawEdges(), 0));
+        return new WebInspector.HeapSnapshotEdgeIterator(this);
     },
 
     /**
      * @return {number}
      */
     edgesCount: function()
     {
         return (this._edgeIndexesEnd() - this._edgeIndexesStart()) / this._snapshot._edgeFieldsCount;
     },
 
@@ skipping 12 matching lines @@
 
     /**
      * @return {string}
      */
     name: function()
     {
         return this._snapshot._strings[this._name()];
     },
 
     /**
-     * @return {!Uint32Array}
-     */
-    rawEdges: function()
-    {
-        return this._snapshot._containmentEdges.subarray(this._edgeIndexesStart(), this._edgeIndexesEnd());
-    },
-
-    /**
      * @return {number}
      */
     retainedSize: function()
     {
         return this._snapshot._retainedSizes[this._ordinal()];
     },
 
     /**
      * @return {!WebInspector.HeapSnapshotRetainerEdgeIterator}
      */
     retainers: function()
     {
-        return new WebInspector.HeapSnapshotRetainerEdgeIterator(this._snapshot.createRetainingEdge(this.nodeIndex, 0));
+        return new WebInspector.HeapSnapshotRetainerEdgeIterator(this);
     },
 
     /**
      * @return {number}
      */
     retainersCount: function()
     {
         var snapshot = this._snapshot;
         var ordinal = this._ordinal();
         return snapshot._firstRetainerIndex[ordinal + 1] - snapshot._firstRetainerIndex[ordinal];
@@ skipping 491 matching lines @@
     },
 
     /**
      * @param {number=} nodeIndex
      */
     createNode: function(nodeIndex)
     {
         throw new Error("Not implemented");
     },
 
-    createEdge: function(edges, edgeIndex)
+    /**
+     * @param {number} edgeIndex
+     * @return {!WebInspector.JSHeapSnapshotEdge}
+     */
+    createEdge: function(edgeIndex)
     {
         throw new Error("Not implemented");
     },
 
-    createRetainingEdge: function(retainedNodeIndex, retainerIndex)
+    /**
+     * @param {number} retainerIndex
+     * @return {!WebInspector.JSHeapSnapshotRetainerEdge}
+     */
+    createRetainingEdge: function(retainerIndex)
     {
         throw new Error("Not implemented");
     },
 
     dispose: function()
     {
         delete this._nodes;
         delete this._strings;
         delete this._retainingEdges;
         delete this._retainingNodes;
@@ skipping 1224 matching lines @@
      * @param {number} windowRight
      */
     sort: function(comparator, leftBound, rightBound, windowLeft, windowRight)
     {
         this._iterationOrder.sortRange(this._buildCompareFunction(comparator), leftBound, rightBound, windowLeft, windowRight);
     },
 
     __proto__: WebInspector.HeapSnapshotItemProvider.prototype
 }