Changeset 119498 in webkit


Ignore:
Timestamp:
Jun 5, 2012 10:08:19 AM (12 years ago)
Author:
loislo@chromium.org
Message:

Web Inspector: serialize edge counts instead of indexes in heap snapshot
​https://bugs.webkit.org/show_bug.cgi?id=88324

The serialized node structure currently holds an index
of its first containment edge in the edges array.
The index can be quite big (up to 7 digits for large snapshots).
The patch changes the serialization format to pass
node containment edge count instead. For most nodes the count
is just a single digit number.
This reduces serialized snapshot size and therefore its transfer time.

Patch by Alexei Filippov <​alexeif@chromium.org> on 2012-06-05
Reviewed by Yury Semikhatsky.

PerformanceTests:

  • inspector/heap-snapshot-performance-test.js:

Source/WebCore:

  • inspector/front-end/HeapSnapshot.js:

(WebInspector.HeapSnapshotNode.prototype._edgeIndexesStart):
(WebInspector.HeapSnapshotNode.prototype._edgeIndexesEnd):
(WebInspector.HeapSnapshotNode.prototype._ordinal):
(WebInspector.HeapSnapshotNodeIterator):
(WebInspector.HeapSnapshot.prototype._init):
(WebInspector.HeapSnapshot.prototype._buildEdgeIndexes):
(WebInspector.HeapSnapshot.prototype._buildRetainers):
(WebInspector.HeapSnapshot.prototype._bfs):
(WebInspector.HeapSnapshot.prototype._buildAggregates):
(WebInspector.HeapSnapshot.prototype._buildPostOrderIndex):
(WebInspector.HeapSnapshot.prototype._buildDominatorTree):
(WebInspector.HeapSnapshot.prototype._markPageOwnedNodes):
(WebInspector.HeapSnapshot.prototype._markQueriableHeapObjects):

LayoutTests:

  • inspector/profiler/heap-snapshot-expected.txt:
  • inspector/profiler/heap-snapshot-test.js:

(initialize_HeapSnapshotTest.InspectorTest.createHeapSnapshotMockObject):
(initialize_HeapSnapshotTest.InspectorTest.createHeapSnapshotMockRaw):
(initialize_HeapSnapshotTest.InspectorTest.createHeapSnapshotMockWithDOM):
(initialize_HeapSnapshotTest.):

  • inspector/profiler/heap-snapshot.html:
Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r119492 r119498  
     12012-06-05  Alexei Filippov  <alexeif@chromium.org>
     2
     3        Web Inspector: serialize edge counts instead of indexes in heap snapshot
     4        https://bugs.webkit.org/show_bug.cgi?id=88324
     5
     6        The serialized node structure currently holds an index
     7        of its first containment edge in the edges array.
     8        The index can be quite big (up to 7 digits for large snapshots).
     9        The patch changes the serialization format to pass
     10        node containment edge count instead. For most nodes the count
     11        is just a single digit number.
     12        This reduces serialized snapshot size and therefore its transfer time.
     13
     14        Reviewed by Yury Semikhatsky.
     15
     16        * inspector/profiler/heap-snapshot-expected.txt:
     17        * inspector/profiler/heap-snapshot-test.js:
     18        (initialize_HeapSnapshotTest.InspectorTest.createHeapSnapshotMockObject):
     19        (initialize_HeapSnapshotTest.InspectorTest.createHeapSnapshotMockRaw):
     20        (initialize_HeapSnapshotTest.InspectorTest.createHeapSnapshotMockWithDOM):
     21        (initialize_HeapSnapshotTest.):
     22        * inspector/profiler/heap-snapshot.html:
     23
    1242012-06-05  Arpita Bahuguna  <arpitabahuguna@gmail.com>
    225

  • trunk/LayoutTests/inspector/profiler/heap-snapshot-expected.txt

    r117953 r119498  
    1313
    1414Running: heapSnapshotSimpleTest
     15
     16Running: heapSnapshotContainmentEdgeIndexesTest
    1517
    1618Running: heapSnapshotPostOrderIndexTest

  • trunk/LayoutTests/inspector/profiler/heap-snapshot-test.js

    r118793 r119498  
    77        _nodeTypeOffset: 0,
    88        _nodeNameOffset: 1,
    9         _edgesCountOffset: 2,
    10         _firstEdgeIndexOffset: 2,
    11         _firstEdgeOffset: 3,
     9        _nodeEdgeCountOffset: 2,
    1210        _nodeFieldCount: 3,
    1311        _edgeFieldsCount: 3,
    … …  
    3129        //
    3230        _nodes: [
    33             0, 0, 0,    //  0: root
    34             1, 1, 6,    //  3: A
    35             1, 2, 12,   //  6: B
    36             1, 3, 18,   //  9: C
    37             1, 4, 21,   // 12: D
    38             1, 5, 21,   // 15: E
    39             0, 0, 21],  // 18: (extra node)
     31            0, 0, 2,    //  0: root
     32            1, 1, 2,    //  3: A
     33            1, 2, 2,    //  6: B
     34            1, 3, 1,    //  9: C
     35            1, 4, 0,    // 12: D
     36            1, 5, 0],   // 15: E
    4037        _containmentEdges: [
    4138            2,  6, 3,   //  0: shortcut 'a' to node 'A'
    … …  
    4643            1, 10, 12,  // 15: property 'bd' to node 'D'
    4744            1, 11, 15], // 18: property 'ce' to node 'E'
    48         _strings: ["", "A", "B", "C", "D", "E", "a", "b", "ac", "bc", "bd", "ce"]
     45        _strings: ["", "A", "B", "C", "D", "E", "a", "b", "ac", "bc", "bd", "ce"],
     46        _firstEdgeIndexes: [0, 6, 12, 18, 21, 21, 21]
    4947    };
    5048};
    … …  
    6765        snapshot: {
    6866            meta: {
    69                 node_fields: ["type", "name", "id", "self_size", "retained_size", "dominator", "edges_index"],
     67                node_fields: ["type", "name", "id", "self_size", "retained_size", "dominator", "edge_count"],
    7068                node_types: [["hidden", "object"], "", "", "", "", "", ""],
    7169                edge_fields: ["type", "name_or_index", "to_node"],
    … …  
    7573            edge_count: 7},
    7674        nodes: [
    77             0, 0, 1, 0, 20,  0,  0, // root (0)
    78             1, 1, 2, 2,  2,  0,  6, // A (7)
    79             1, 2, 3, 3,  8,  0, 12, // B (14)
    80             1, 3, 4, 4, 10,  0, 18, // C (21)
    81             1, 4, 5, 5,  5, 14, 21, // D (28)
    82             1, 5, 6, 6,  6, 21, 21],// E (35)
     75            0, 0, 1, 0, 20,  0, 2, // root (0)
     76            1, 1, 2, 2,  2,  0, 2, // A (7)
     77            1, 2, 3, 3,  8,  0, 2, // B (14)
     78            1, 3, 4, 4, 10,  0, 1, // C (21)
     79            1, 4, 5, 5,  5, 14, 0, // D (28)
     80            1, 5, 6, 6,  6, 21, 0], // E (35)
    8381        edges: [
    8482            // root node edges
    … …  
    117115        snapshot: {
    118116            meta: {
    119                 node_fields: ["type", "name", "id", "edges_index"],
     117                node_fields: ["type", "name", "id", "edge_count"],
    120118                node_types: [["hidden", "object"], "", "", ""],
    121119                edge_fields: ["type", "name_or_index", "to_node"],
    … …  
    138136            //    |----->F--->G       M
    139137            //
    140             /* (root) */    0,  0,  1,  0,
    141             /* Window */    1, 11,  2, 12,
    142             /* Window */    1, 11,  3, 18,
    143             /* E */         1,  5,  4, 27,
    144             /* F */         1,  6,  5, 27,
    145             /* A */         1,  1,  6, 30,
    146             /* B */         1,  2,  7, 30,
    147             /* D */         1,  4,  8, 33,
    148             /* H */         1,  8,  9, 39,
    149             /* G */         1,  7, 10, 39,
    150             /* C */         1,  3, 11, 39,
    151             /* N */         1, 10, 12, 39,
    152             /* M */         1,  9, 13, 39
     138            /* (root) */    0,  0,  1, 4,
     139            /* Window */    1, 11,  2, 2,
     140            /* Window */    1, 11,  3, 3,
     141            /* E */         1,  5,  4, 0,
     142            /* F */         1,  6,  5, 1,
     143            /* A */         1,  1,  6, 0,
     144            /* B */         1,  2,  7, 1,
     145            /* D */         1,  4,  8, 2,
     146            /* H */         1,  8,  9, 0,
     147            /* G */         1,  7, 10, 0,
     148            /* C */         1,  3, 11, 0,
     149            /* N */         1, 10, 12, 0,
     150            /* M */         1,  9, 13, 0
    153151            ],
    154152        edges: [
    … …  
    461459        rawSnapshot.nodes.push(this._id || this._ordinal * 2 + 1);
    462460        rawSnapshot.nodes.push(this._selfSize);
    463         rawSnapshot.nodes.push(0);                        // retained_size
    464         rawSnapshot.nodes.push(0);                        // dominator
    465         rawSnapshot.nodes.push(rawSnapshot.edges.length); // edges_index
     461        rawSnapshot.nodes.push(0);                               // retained_size
     462        rawSnapshot.nodes.push(0);                               // dominator
     463        rawSnapshot.nodes.push(Object.keys(this._edges).length); // edge_count
    466464
    467465        for (var i in this._edges)
    … …  
    529527            "snapshot": {
    530528                "meta": {
    531                     "node_fields": ["type","name","id","self_size","retained_size","dominator","edges_index"],
     529                    "node_fields": ["type","name","id","self_size","retained_size","dominator","edge_count"],
    532530                    "node_types": [
    533531                        this._nodeTypesArray,

  • trunk/LayoutTests/inspector/profiler/heap-snapshot.html

    r118182 r119498  
    9393            InspectorTest.assertEquals(6, snapshot.nodeCount, "node count");
    9494            InspectorTest.assertEquals(20, snapshot.totalSize, "total size");
     95            next();
     96        },
     97
     98        function heapSnapshotContainmentEdgeIndexesTest(next)
     99        {
     100            var snapshot = new WebInspector.HeapSnapshot(InspectorTest.createHeapSnapshotMock());
     101            var actual = snapshot._firstEdgeIndexes;
     102            var expected = [0, 6, 12, 18, 21, 21, 21];
     103            InspectorTest.assertEquals(expected.length, actual.length, "Edge indexes size");
     104            for (var i = 0; i < expected.length; ++i)
     105                InspectorTest.assertEquals(expected[i], actual[i], "Edge indexes");
    95106            next();
    96107        },

  • trunk/PerformanceTests/ChangeLog

    r119389 r119498  
     12012-06-05  Alexei Filippov  <alexeif@chromium.org>
     2
     3        Web Inspector: serialize edge counts instead of indexes in heap snapshot
     4        https://bugs.webkit.org/show_bug.cgi?id=88324
     5
     6        The serialized node structure currently holds an index
     7        of its first containment edge in the edges array.
     8        The index can be quite big (up to 7 digits for large snapshots).
     9        The patch changes the serialization format to pass
     10        node containment edge count instead. For most nodes the count
     11        is just a single digit number.
     12        This reduces serialized snapshot size and therefore its transfer time.
     13
     14        Reviewed by Yury Semikhatsky.
     15
     16        * inspector/heap-snapshot-performance-test.js:
     17
    1182012-06-04  Alexei Filippov  <alexeif@chromium.org>
    219

  • trunk/PerformanceTests/inspector/heap-snapshot-performance-test.js

    r119389 r119498  
    11function test()
    22{
     3    InspectorTest.measureFunction(WebInspector.HeapSnapshot.prototype, "_buildEdgeIndexes");
    34    InspectorTest.measureFunction(WebInspector.HeapSnapshot.prototype, "_buildRetainers");
    45    InspectorTest.measureFunction(WebInspector.HeapSnapshot.prototype, "_buildDominatedNodes");

  • trunk/Source/WebCore/ChangeLog

    r119492 r119498  
     12012-06-05  Alexei Filippov  <alexeif@chromium.org>
     2
     3        Web Inspector: serialize edge counts instead of indexes in heap snapshot
     4        https://bugs.webkit.org/show_bug.cgi?id=88324
     5
     6        The serialized node structure currently holds an index
     7        of its first containment edge in the edges array.
     8        The index can be quite big (up to 7 digits for large snapshots).
     9        The patch changes the serialization format to pass
     10        node containment edge count instead. For most nodes the count
     11        is just a single digit number.
     12        This reduces serialized snapshot size and therefore its transfer time.
     13
     14        Reviewed by Yury Semikhatsky.
     15
     16        * inspector/front-end/HeapSnapshot.js:
     17        (WebInspector.HeapSnapshotNode.prototype._edgeIndexesStart):
     18        (WebInspector.HeapSnapshotNode.prototype._edgeIndexesEnd):
     19        (WebInspector.HeapSnapshotNode.prototype._ordinal):
     20        (WebInspector.HeapSnapshotNodeIterator):
     21        (WebInspector.HeapSnapshot.prototype._init):
     22        (WebInspector.HeapSnapshot.prototype._buildEdgeIndexes):
     23        (WebInspector.HeapSnapshot.prototype._buildRetainers):
     24        (WebInspector.HeapSnapshot.prototype._bfs):
     25        (WebInspector.HeapSnapshot.prototype._buildAggregates):
     26        (WebInspector.HeapSnapshot.prototype._buildPostOrderIndex):
     27        (WebInspector.HeapSnapshot.prototype._buildDominatorTree):
     28        (WebInspector.HeapSnapshot.prototype._markPageOwnedNodes):
     29        (WebInspector.HeapSnapshot.prototype._markQueriableHeapObjects):
     30
    1312012-06-05  Arpita Bahuguna  <arpitabahuguna@gmail.com>
    232

  • trunk/Source/WebCore/inspector/front-end/HeapSnapshot.js

    r119389 r119498  
    536536    _edgeIndexesStart: function()
    537537    {
    538         var snapshot = this._snapshot;
    539         return snapshot._nodes[this.nodeIndex + snapshot._firstEdgeIndexOffset];
     538        return this._snapshot._firstEdgeIndexes[this._ordinal()];
    540539    },
    541540
    542541    _edgeIndexesEnd: function()
    543542    {
    544         var snapshot = this._snapshot;
    545         return snapshot._nodes[this._nextNodeIndex() + snapshot._firstEdgeIndexOffset]
     543        return this._snapshot._firstEdgeIndexes[this._ordinal() + 1];
     544    },
     545
     546    _ordinal: function()
     547    {
     548        return this.nodeIndex / this._snapshot._nodeFieldCount;
    546549    },
    547550
    … …  
    564567{
    565568    this.node = node;
    566     this._nodesLength = node._snapshot._realNodesLength;
     569    this._nodesLength = node._snapshot._nodes.length;
    567570}
    568571
    … …  
    656659        this._nodeIdOffset = meta.node_fields.indexOf("id");
    657660        this._nodeSelfSizeOffset = meta.node_fields.indexOf("self_size");
    658         this._firstEdgeIndexOffset = meta.node_fields.indexOf("edges_index");
     661        this._nodeEdgeCountOffset = meta.node_fields.indexOf("edge_count");
    659662        this._nodeFieldCount = meta.node_fields.length;
    660663
    … …  
    689692        };
    690693
    691         this._realNodesLength = this._nodes.length;
    692         this.nodeCount = this._realNodesLength / this._nodeFieldCount;
     694        this.nodeCount = this._nodes.length / this._nodeFieldCount;
    693695        this._edgeCount = this._containmentEdges.length / this._edgeFieldsCount;
    694696
    695         // Add an extra node and make its first edge field point to the end of edges array.
    696         var nodes = this._nodes;
    697         this._nodes = new Uint32Array(this._realNodesLength + this._nodeFieldCount);
    698         this._nodes.set(nodes);
    699         this._nodes[this._realNodesLength + this._firstEdgeIndexOffset] = this._containmentEdges.length;
    700 
     697        this._buildEdgeIndexes();
    701698        this._markInvisibleEdges();
    702699        this._buildRetainers();
    … …  
    710707    },
    711708
     709    _buildEdgeIndexes: function()
     710    {
     711        // Support for old serialization.
     712        if (this._nodeEdgeCountOffset === -1) {
     713            var nodes = this._nodes;
     714            var nodeCount = this.nodeCount;
     715            var firstEdgeIndexes = this._firstEdgeIndexes = new Uint32Array(nodeCount + 1);
     716            var nodeFieldCount = this._nodeFieldCount;
     717            var nodeEdgesIndexOffset = this._metaNode.node_fields.indexOf("edges_index");
     718            firstEdgeIndexes[nodeCount] = this._containmentEdges.length;
     719            for (var nodeOrdinal = 0; nodeOrdinal < nodeCount; ++nodeOrdinal) {
     720                firstEdgeIndexes[nodeOrdinal] = nodes[nodeOrdinal * nodeFieldCount + nodeEdgesIndexOffset];
     721            }
     722            return;
     723        }
     724
     725        var nodes = this._nodes;
     726        var nodeCount = this.nodeCount;
     727        var firstEdgeIndexes = this._firstEdgeIndexes = new Uint32Array(nodeCount + 1);
     728        var nodeFieldCount = this._nodeFieldCount;
     729        var edgeFieldsCount = this._edgeFieldsCount;
     730        var nodeEdgeCountOffset = this._nodeEdgeCountOffset;
     731        firstEdgeIndexes[nodeCount] = this._containmentEdges.length;
     732        for (var nodeOrdinal = 0, edgeIndex = 0; nodeOrdinal < nodeCount; ++nodeOrdinal) {
     733            firstEdgeIndexes[nodeOrdinal] = edgeIndex;
     734            edgeIndex += nodes[nodeOrdinal * nodeFieldCount + nodeEdgeCountOffset] * edgeFieldsCount;
     735        }
     736    },
     737
    712738    _buildRetainers: function()
    713739    {
    … …  
    723749        var edgeToNodeOffset = this._edgeToNodeOffset;
    724750        var nodes = this._nodes;
    725         var firstEdgeIndexOffset = this._firstEdgeIndexOffset;
     751        var firstEdgeIndexes = this._firstEdgeIndexes;
     752        var nodeCount = this.nodeCount;
    726753
    727754        for (var toNodeFieldIndex = edgeToNodeOffset, l = containmentEdges.length; toNodeFieldIndex < l; toNodeFieldIndex += edgeFieldsCount) {
    … …  
    731758            ++firstRetainerIndex[toNodeIndex / nodeFieldCount];
    732759        }
    733         for (var i = 0, firstUnusedRetainerSlot = 0, l = this.nodeCount; i < l; i++) {
     760        for (var i = 0, firstUnusedRetainerSlot = 0; i < nodeCount; i++) {
    734761            var retainersCount = firstRetainerIndex[i];
    735762            firstRetainerIndex[i] = firstUnusedRetainerSlot;
    … …  
    737764            firstUnusedRetainerSlot += retainersCount;
    738765        }
    739         firstRetainerIndex[this.nodeCount] = retainingNodes.length;
    740 
    741         var srcNodeIndex = 0;
    742         var nextNodeFirstEdgeIndex = nodes[firstEdgeIndexOffset];
    743         var nodesLength = this._realNodesLength;
    744         while (srcNodeIndex < nodesLength) {
     766        firstRetainerIndex[nodeCount] = retainingNodes.length;
     767
     768        var nextNodeFirstEdgeIndex = firstEdgeIndexes[0];
     769        for (var srcNodeOrdinal = 0; srcNodeOrdinal < nodeCount; ++srcNodeOrdinal) {
    745770            var firstEdgeIndex = nextNodeFirstEdgeIndex;
    746             var nextNodeIndex = srcNodeIndex + nodeFieldCount;
    747             nextNodeFirstEdgeIndex = nodes[nextNodeIndex + firstEdgeIndexOffset];
     771            nextNodeFirstEdgeIndex = firstEdgeIndexes[srcNodeOrdinal + 1];
     772            var srcNodeIndex = srcNodeOrdinal * nodeFieldCount;
    748773            for (var edgeIndex = firstEdgeIndex; edgeIndex < nextNodeFirstEdgeIndex; edgeIndex += edgeFieldsCount) {
    749774                var toNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
    … …  
    755780                retainingEdges[nextUnusedRetainerSlotIndex] = edgeIndex;
    756781            }
    757             srcNodeIndex = nextNodeIndex;
    758782        }
    759783    },
    … …  
    912936        // Peload fields into local variables for better performance.
    913937        var edgeFieldsCount = this._edgeFieldsCount;
     938        var nodeFieldCount = this._nodeFieldCount;
    914939        var containmentEdges = this._containmentEdges;
    915         var nodeFieldCount = this._nodeFieldCount;
    916         var firstEdgeIndexOffset = this._firstEdgeIndexOffset;
     940        var firstEdgeIndexes = this._firstEdgeIndexes;
    917941        var edgeToNodeOffset = this._edgeToNodeOffset;
    918942        var nodes = this._nodes;
    … …  
    925949            var nodeOrdinal = nodeIndex / nodeFieldCount;
    926950            var distance = distances[nodeOrdinal] + 1;
    927             var firstEdgeIndex = nodes[nodeIndex + firstEdgeIndexOffset];
    928             var edgesEnd = nodes[nodeIndex + firstEdgeIndexOffset + nodeFieldCount];
     951            var firstEdgeIndex = firstEdgeIndexes[nodeOrdinal];
     952            var edgesEnd = firstEdgeIndexes[nodeOrdinal + 1];
    929953            for (var edgeToNodeIndex = firstEdgeIndex + edgeToNodeOffset; edgeToNodeIndex < edgesEnd; edgeToNodeIndex += edgeFieldsCount) {
    930954                var childNodeIndex = containmentEdges[edgeToNodeIndex];
    … …  
    947971        var nodes = this._nodes;
    948972        var flags = this._flags;
    949         var nodesLength = this._realNodesLength;
     973        var nodesLength = nodes.length;
    950974        var nodeNativeType = this._nodeNativeType;
    951975        var nodeFieldCount = this._nodeFieldCount;
    … …  
    10671091        var nodes = this._nodes;
    10681092        var nodeCount = this.nodeCount;
    1069         var rootNodeIndex = this._rootNodeIndex;
     1093        var rootNodeOrdinal = this._rootNodeIndex / nodeFieldCount;
    10701094
    10711095        var edgeFieldsCount = this._edgeFieldsCount;
     1096        var edgeTypeOffset = this._edgeTypeOffset;
    10721097        var edgeToNodeOffset = this._edgeToNodeOffset;
    1073         var edgeTypeOffset = this._edgeTypeOffset;
    10741098        var edgeShortcutType = this._edgeShortcutType;
    1075         var firstEdgeIndexOffset = this._firstEdgeIndexOffset;
     1099        var firstEdgeIndexes = this._firstEdgeIndexes;
    10761100        var containmentEdges = this._containmentEdges;
    10771101        var containmentEdgesLength = this._containmentEdges.length;
    … …  
    10891113        var black = 2;
    10901114
    1091         nodesToVisit[nodesToVisitLength++] = this._rootNodeIndex;
    1092         painted[this._rootNodeIndex / nodeFieldCount] = grey;
     1115        nodesToVisit[nodesToVisitLength++] = rootNodeOrdinal;
     1116        painted[rootNodeOrdinal] = grey;
    10931117
    10941118        while (nodesToVisitLength) {
    1095             var nodeIndex = nodesToVisit[nodesToVisitLength - 1];
    1096             var nodeOrdinal = nodeIndex / nodeFieldCount;
     1119            var nodeOrdinal = nodesToVisit[nodesToVisitLength - 1];
    10971120            if (painted[nodeOrdinal] === grey) {
    10981121                painted[nodeOrdinal] = black;
    10991122                var nodeFlag = flags[nodeOrdinal] & flag;
    1100                 var beginEdgeIndex = nodes[nodeIndex + firstEdgeIndexOffset];
    1101                 var endEdgeIndex = nodes[nodeIndex + firstEdgeIndexOffset + nodeFieldCount];
     1123                var beginEdgeIndex = firstEdgeIndexes[nodeOrdinal];
     1124                var endEdgeIndex = firstEdgeIndexes[nodeOrdinal + 1];
    11021125                for (var edgeIndex = beginEdgeIndex; edgeIndex < endEdgeIndex; edgeIndex += edgeFieldsCount) {
    1103                     if (nodeIndex !== rootNodeIndex && containmentEdges[edgeIndex + edgeTypeOffset] === edgeShortcutType)
     1126                    if (nodeOrdinal !== rootNodeOrdinal && containmentEdges[edgeIndex + edgeTypeOffset] === edgeShortcutType)
    11041127                        continue;
    11051128                    var childNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
    … …  
    11081131                    // We are skipping the edges from non-page-owned nodes to page-owned nodes.
    11091132                    // Otherwise the dominators for the objects that also were retained by debugger would be affected.
    1110                     if (nodeIndex !== rootNodeIndex && childNodeFlag && !nodeFlag)
     1133                    if (nodeOrdinal !== rootNodeOrdinal && childNodeFlag && !nodeFlag)
    11111134                        continue;
    11121135                    if (!painted[childNodeOrdinal]) {
    11131136                        painted[childNodeOrdinal] = grey;
    1114                         nodesToVisit[nodesToVisitLength++] = childNodeIndex;
     1137                        nodesToVisit[nodesToVisitLength++] = childNodeOrdinal;
    11151138                    }
    11161139                }
    … …  
    11431166        var retainingEdges = this._retainingEdges;
    11441167        var edgeFieldsCount = this._edgeFieldsCount;
     1168        var edgeTypeOffset = this._edgeTypeOffset;
    11451169        var edgeToNodeOffset = this._edgeToNodeOffset;
    1146         var edgeTypeOffset = this._edgeTypeOffset;
    11471170        var edgeShortcutType = this._edgeShortcutType;
    1148         var firstEdgeIndexOffset = this._firstEdgeIndexOffset;
     1171        var firstEdgeIndexes = this._firstEdgeIndexes;
    11491172        var containmentEdges = this._containmentEdges;
    11501173        var containmentEdgesLength = this._containmentEdges.length;
    … …  
    11671190
    11681191        { // Mark the root direct children as affected.
    1169             var nodeIndex = this._rootNodeIndex;
    1170             var beginEdgeToNodeFieldIndex = nodes[nodeIndex + firstEdgeIndexOffset] + edgeToNodeOffset;
    1171             var endEdgeToNodeFieldIndex = nodes[nodeIndex + nodeFieldCount + firstEdgeIndexOffset];
     1192            var nodeOrdinal = this._rootNodeIndex / nodeFieldCount;
     1193            var beginEdgeToNodeFieldIndex = firstEdgeIndexes[nodeOrdinal] + edgeToNodeOffset;
     1194            var endEdgeToNodeFieldIndex = firstEdgeIndexes[nodeOrdinal + 1];
    11721195            for (var toNodeFieldIndex = beginEdgeToNodeFieldIndex;
    11731196                 toNodeFieldIndex < endEdgeToNodeFieldIndex;
    … …  
    12281251                    changed = true;
    12291252                    nodeOrdinal = postOrderIndex2NodeOrdinal[postOrderIndex];
    1230                     nodeIndex = nodeOrdinal * nodeFieldCount;
    1231                     beginEdgeToNodeFieldIndex = nodes[nodeIndex + firstEdgeIndexOffset] + edgeToNodeOffset;
    1232                     endEdgeToNodeFieldIndex = nodes[nodeIndex + firstEdgeIndexOffset + nodeFieldCount];
     1253                    beginEdgeToNodeFieldIndex = firstEdgeIndexes[nodeOrdinal] + edgeToNodeOffset;
     1254                    endEdgeToNodeFieldIndex = firstEdgeIndexes[nodeOrdinal + 1];
    12331255                    for (var toNodeFieldIndex = beginEdgeToNodeFieldIndex;
    12341256                         toNodeFieldIndex < endEdgeToNodeFieldIndex;
    … …  
    13681390        var edgeFieldsCount = this._edgeFieldsCount;
    13691391        var edgeWeakType = this._edgeWeakType;
    1370         var firstEdgeIndexOffset = this._firstEdgeIndexOffset;
     1392        var firstEdgeIndexes = this._firstEdgeIndexes;
    13711393        var containmentEdges = this._containmentEdges;
    13721394        var containmentEdgesLength = containmentEdges.length;
    … …  
    13841406        var nodesToVisitLength = 0;
    13851407
    1386         for (var edgeIndex = nodes[this._rootNodeIndex + firstEdgeIndexOffset], endEdgeIndex = nodes[this._rootNodeIndex + nodeFieldCount + firstEdgeIndexOffset];
     1408        var rootNodeOrdinal = this._rootNodeIndex / nodeFieldCount;
     1409        for (var edgeIndex = firstEdgeIndexes[rootNodeOrdinal], endEdgeIndex = firstEdgeIndexes[rootNodeOrdinal + 1];
    13871410             edgeIndex < endEdgeIndex;
    13881411             edgeIndex += edgeFieldsCount) {
    13891412            if (containmentEdges[edgeIndex + edgeTypeOffset] === edgeShortcutType) {
    1390                 var nodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
    1391                 nodesToVisit[nodesToVisitLength++] = nodeIndex;
    1392                 flags[nodeIndex / nodeFieldCount] |= visitedMarker;
     1413                var nodeOrdinal = containmentEdges[edgeIndex + edgeToNodeOffset] / nodeFieldCount;
     1414                nodesToVisit[nodesToVisitLength++] = nodeOrdinal;
     1415                flags[nodeOrdinal] |= visitedMarker;
    13931416            }
    13941417        }
    13951418
    13961419        while (nodesToVisitLength) {
    1397             var nodeIndex = nodesToVisit[--nodesToVisitLength];
    1398             var nodeOrdinal = nodeIndex / nodeFieldCount;
     1420            var nodeOrdinal = nodesToVisit[--nodesToVisitLength];
    13991421            flags[nodeOrdinal] |= flag;
    14001422            flags[nodeOrdinal] &= visitedMarkerMask;
    1401             var beginEdgeIndex = nodes[nodeIndex + firstEdgeIndexOffset];
    1402             var endEdgeIndex = nodeOrdinal < nodesCount - 1
    1403                 ? nodes[nodeIndex + firstEdgeIndexOffset + nodeFieldCount]
    1404                 : containmentEdgesLength;
     1423            var beginEdgeIndex = firstEdgeIndexes[nodeOrdinal];
     1424            var endEdgeIndex = firstEdgeIndexes[nodeOrdinal + 1];
    14051425            for (var edgeIndex = beginEdgeIndex; edgeIndex < endEdgeIndex; edgeIndex += edgeFieldsCount) {
    14061426                var childNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
    … …  
    14111431                if (type === edgeWeakType)
    14121432                    continue;
    1413                 nodesToVisit[nodesToVisitLength++] = childNodeIndex;
     1433                nodesToVisit[nodesToVisitLength++] = childNodeOrdinal;
    14141434                flags[childNodeOrdinal] |= visitedMarker;
    14151435            }
    … …  
    14331453        var nodeCount = this.nodeCount;
    14341454        var nodeFieldCount = this._nodeFieldCount;
    1435         var firstEdgeIndexOffset = this._firstEdgeIndexOffset;
     1455        var firstEdgeIndexes = this._firstEdgeIndexes;
    14361456
    14371457        var flags = this._flags;
    … …  
    14401460        for (var iter = this.rootNode().edges(); iter.hasNext(); iter.next()) {
    14411461            if (iter.edge.node().isWindow())
    1442                 list.push(iter.edge.node().nodeIndex);
     1462                list.push(iter.edge.node().nodeIndex / nodeFieldCount);
    14431463        }
    14441464
    14451465        while (list.length) {
    1446             var nodeIndex = list.pop();
    1447             var nodeOrdinal = nodeIndex / nodeFieldCount;
     1466            var nodeOrdinal = list.pop();
    14481467            if (flags[nodeOrdinal] & flag)
    14491468                continue;
    14501469            flags[nodeOrdinal] |= flag;
    1451             var beginEdgeIndex = nodes[nodeIndex + firstEdgeIndexOffset];
    1452             var endEdgeIndex = nodes[nodeIndex + firstEdgeIndexOffset + nodeFieldCount];
     1470            var beginEdgeIndex = firstEdgeIndexes[nodeOrdinal];
     1471            var endEdgeIndex = firstEdgeIndexes[nodeOrdinal + 1];
    14531472            for (var edgeIndex = beginEdgeIndex; edgeIndex < endEdgeIndex; edgeIndex += edgeFieldsCount) {
    14541473                var childNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
    1455                 if (flags[childNodeIndex / nodeFieldCount] & flag)
     1474                var childNodeOrdinal = childNodeIndex / nodeFieldCount;
     1475                if (flags[childNodeOrdinal] & flag)
    14561476                    continue;
    14571477                var type = containmentEdges[edgeIndex + edgeTypeOffset];
    14581478                if (type === hiddenEdgeType || type === invisibleEdgeType || type === internalEdgeType)
    14591479                    continue;
    1460                 list.push(childNodeIndex);
     1480                list.push(childNodeOrdinal);
    14611481            }
    14621482        }
Note: See TracChangeset for help on using the changeset viewer.