DevTools: Add banks to JS sampling code map.

Source/devtools/front_end/timeline/TimelineJSProfile.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 WebInspector.TimelineJSProfileProcessor = { };
 
 /**
  * @param {!ProfilerAgent.CPUProfile} jsProfile
  * @param {!WebInspector.TracingModel.Thread} thread
@@ skipping 186 matching lines @@
 
     WebInspector.TimelineModel.forEachEvent(events, onStartEvent, onEndEvent, onInstantEvent);
     return jsFrameEvents;
 }
 
 /**
  * @constructor
  */
 WebInspector.TimelineJSProfileProcessor.CodeMap = function()
 {
-    /** @type {!Array<!WebInspector.TimelineJSProfileProcessor.CodeMap.Entry>} */
-    this._entries = [];
+    /** @type {!Map<string, !WebInspector.TimelineJSProfileProcessor.CodeMap.Bank>} */
+    this._banks = new Map();
 }
 
 /**
  * @constructor
  * @param {number} address
  * @param {number} size
  * @param {!ConsoleAgent.CallFrame} callFrame
  */
 WebInspector.TimelineJSProfileProcessor.CodeMap.Entry = function(address, size, callFrame)
 {
@@ skipping 13 matching lines @@
 }
 
 WebInspector.TimelineJSProfileProcessor.CodeMap.prototype = {
     /**
      * @param {string} addressHex
      * @param {number} size
      * @param {!ConsoleAgent.CallFrame} callFrame
      */
     addEntry: function(addressHex, size, callFrame)
     {
-        var address = this._addressStringToNumber(addressHex);
-        this._addEntry(new WebInspector.TimelineJSProfileProcessor.CodeMap.Entry(address, size, callFrame));
+        var entry = new WebInspector.TimelineJSProfileProcessor.CodeMap.Entry(this._getAddress(addressHex), size, callFrame);
+        this._addEntry(addressHex, entry);
     },
 
     /**
      * @param {string} oldAddressHex
      * @param {string} newAddressHex
      * @param {number} size
      */
     moveEntry: function(oldAddressHex, newAddressHex, size)
     {
-        var oldAddress = this._addressStringToNumber(oldAddressHex);
-        var newAddress = this._addressStringToNumber(newAddressHex);
-        var index = this._entries.lowerBound(oldAddress, WebInspector.TimelineJSProfileProcessor.CodeMap.comparator);
-        var entry = this._entries[index];
-        if (!entry || entry.address !== oldAddress)
+        var entry = this._getBank(oldAddressHex).removeEntry(this._getAddress(oldAddressHex));
+        if (!entry) {
+            console.error("Entry at address " + oldAddressHex + " not found");
             return;
-        this._entries.splice(index, 1);
-        entry.address = newAddress;
+        }
+        entry.address = this._getAddress(newAddressHex);
         entry.size = size;
-        this._addEntry(entry);
+        this._addEntry(newAddressHex, entry);
     },
 
     /**
      * @param {string} addressHex
      * @return {?ConsoleAgent.CallFrame}
      */
     lookupEntry: function(addressHex)
     {
-        var address = this._addressStringToNumber(addressHex);
+        return this._getBank(addressHex).lookupEntry(this._getAddress(addressHex));
+    },
+
+    /**
+     * @param {string} addressHex
+     * @param {!WebInspector.TimelineJSProfileProcessor.CodeMap.Entry} entry
+     */
+    _addEntry: function(addressHex, entry)
+    {
+        // FIXME: deal with entries that span across [multiple] banks.
+        this._getBank(addressHex).addEntry(entry);
+    },
+
+    /**
+     * @param {string} addressHex
+     * @return {!WebInspector.TimelineJSProfileProcessor.CodeMap.Bank}
+     */
+    _getBank: function(addressHex)
+    {
+        addressHex = addressHex.slice(2);  // cut 0x prefix.
+        // 13 hex digits == 52 bits, double mantissa fits 53 bits.
+        var /** @const */ bankSizeHexDigits = 13;

[yurys, 2015/06/22 16:33:00]

Please extract these constants so that they are not duplicated.

[alph, 2015/06/23 16:06:28]

I'd like to keep them as constants for the sake of performance.

+        var /** @const */ maxHexDigits = 16;
+        var bankName = addressHex.slice(-maxHexDigits, -bankSizeHexDigits);
+        var bank = this._banks.get(bankName);
+        if (!bank) {
+            bank = new WebInspector.TimelineJSProfileProcessor.CodeMap.Bank();
+            this._banks.set(bankName, bank);
+        }
+        return bank;
+    },
+
+    /**
+     * @param {string} addressHex
+     * @return {number}
+     */
+    _getAddress: function(addressHex)
+    {
+        // 13 hex digits == 52 bits, double mantissa fits 53 bits.
+        var /** @const */ bankSizeHexDigits = 13;
+        addressHex = addressHex.slice(2);  // cut 0x prefix.
+        return parseInt(addressHex.slice(-bankSizeHexDigits), 16);
+    }
+}
+
+/**
+ * @constructor
+ */
+WebInspector.TimelineJSProfileProcessor.CodeMap.Bank = function()
+{
+    /** @type {!Array<!WebInspector.TimelineJSProfileProcessor.CodeMap.Entry>} */
+    this._entries = [];
+}
+
+WebInspector.TimelineJSProfileProcessor.CodeMap.Bank.prototype = {
+    /**
+     * @param {number} address
+     * @return {?WebInspector.TimelineJSProfileProcessor.CodeMap.Entry}
+     */
+    removeEntry: function(address)
+    {
+        var index = this._entries.lowerBound(address, WebInspector.TimelineJSProfileProcessor.CodeMap.comparator);
+        var entry = this._entries[index];
+        if (!entry || entry.address !== address)
+            return null;
+        this._entries.splice(index, 1);
+        return entry;
+    },
+
+    /**
+     * @param {number} address
+     * @return {?ConsoleAgent.CallFrame}
+     */
+    lookupEntry: function(address)
+    {
         var index = this._entries.upperBound(address, WebInspector.TimelineJSProfileProcessor.CodeMap.comparator) - 1;
         var entry = this._entries[index];
         return entry && address < entry.address + entry.size ? entry.callFrame : null;
     },
 
     /**
-     * @param {string} addressHex
-     * @return {number}
-     */
-    _addressStringToNumber: function(addressHex)
-    {
-        // TODO(alph): The addressHex may represent addresses from 0 to 2^64-1,
-        // whereas address is a double type that has exact representation for
-        // integers up to 2^53. So it might lose up to 11 bits at the end.
-        // Do something about it, e.g. introduce banks, or just find and subtract a base.
-        return parseInt(addressHex, 16);
-    },
-
-    /**
      * @param {!WebInspector.TimelineJSProfileProcessor.CodeMap.Entry} newEntry
      */
-    _addEntry: function(newEntry)
+    addEntry: function(newEntry)
     {
         var endAddress = newEntry.address + newEntry.size;
         var lastIndex = this._entries.lowerBound(endAddress, WebInspector.TimelineJSProfileProcessor.CodeMap.comparator);
         var index;
         for (index = lastIndex - 1; index >= 0; --index) {
             var entry = this._entries[index];
             var entryEndAddress = entry.address + entry.size;
             if (entryEndAddress <= newEntry.address)
                 break;
         }
@@ skipping 81 matching lines @@
                 WebInspector.TracingModel.Phase.Instant, e.startTime, e.thread);
             sampleEvent.ordinal = e.ordinal;
             sampleEvent.args = {"data": {"stackTrace": stack }};
             samples.push(sampleEvent);
             break;
         }
     }
 
     return samples;
 }