Add heap allocator usage to task profiler.

chrome/browser/resources/profiler/profiler.js

 // Copyright (c) 2012 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.
 
 var g_browserBridge;
 var g_mainView;
 
 // TODO(eroman): The handling of "max" across snapshots is not correct.
 // For starters the browser needs to be aware to generate new maximums.
 // Secondly, we need to take into account the "max" of intermediary snapshots,
@@ skipping 109 matching lines @@
   var BEGIN_KEY = 1;  // Start at 1 rather than 0 to simplify sorting code.
   var END_KEY = BEGIN_KEY;
 
   var KEY_COUNT = END_KEY++;
   var KEY_RUN_TIME = END_KEY++;
   var KEY_AVG_RUN_TIME = END_KEY++;
   var KEY_MAX_RUN_TIME = END_KEY++;
   var KEY_QUEUE_TIME = END_KEY++;
   var KEY_AVG_QUEUE_TIME = END_KEY++;
   var KEY_MAX_QUEUE_TIME = END_KEY++;
+  if (loadTimeData.getBoolean('enableMemoryTaskProfiler')) {
+    var KEY_AVG_ALLOC_OPS = END_KEY++;

[eroman, 2016/12/02 17:13:37]

I suggest giving these a common prefix, like "KEY_MEMORY_" to more easily
recognize these (given that they are conditionally defined).

[Sigurður Ásgeirsson, 2016/12/02 18:58:09]

Ah, good idea!

+    var KEY_AVG_FREE_OPS = END_KEY++;
+    var KEY_AVG_NET_BYTES = END_KEY++;
+    var KEY_MAX_ALLOCATED_BYTES = END_KEY++;
+    var KEY_ALLOC_OPS = END_KEY++;
+    var KEY_FREE_OPS = END_KEY++;
+    var KEY_ALLOCATED_BYTES = END_KEY++;
+    var KEY_FREED_BYTES = END_KEY++;
+    var KEY_ALLOC_OVERHEAD_BYTES = END_KEY++;
+  }
   var KEY_BIRTH_THREAD = END_KEY++;
   var KEY_DEATH_THREAD = END_KEY++;
   var KEY_PROCESS_TYPE = END_KEY++;
   var KEY_PROCESS_ID = END_KEY++;
   var KEY_FUNCTION_NAME = END_KEY++;
   var KEY_SOURCE_LOCATION = END_KEY++;
   var KEY_FILE_NAME = END_KEY++;
   var KEY_LINE_NUMBER = END_KEY++;
 
   var NUM_KEYS = END_KEY - BEGIN_KEY;
@@ skipping 96 matching lines @@
         return {
           create: function(key) {
             return new Aggregator(numeratorKey, divisorKey);
           },
         };
       }
     };
   })();
 
   /**
+   * This aggregator computes an average by summing the difference of two
+   * numeric fields, summing a count, and then dividing the totals.
+   */
+  var AvgDiffAggregator = (function() {
+    function Aggregator(numeratorPosKey, numeratorNegKey, divisorKey) {
+      this.numeratorPosKey_ = numeratorPosKey;
+      this.numeratorNegKey_ = numeratorNegKey;
+      this.divisorKey_ = divisorKey;
+
+      this.numeratorSum_ = 0;
+      this.divisorSum_ = 0;
+    }
+
+    Aggregator.prototype = {
+      consume: function(e) {
+        this.numeratorSum_ +=
+            e[this.numeratorPosKey_] - e[this.numeratorNegKey_];
+        this.divisorSum_ += e[this.divisorKey_];
+      },
+
+      getValue: function() {
+        return this.numeratorSum_ / this.divisorSum_;
+      },
+
+      getValueAsText: function() {
+        return formatNumberAsText(this.getValue());
+      },
+    };
+
+    return {
+      create: function(numeratorPosKey, numeratorNegKey, divisorKey) {
+        return {
+          create: function(key) {
+            return new Aggregator(numeratorPosKey, numeratorNegKey, divisorKey);
+          },
+        };
+      }
+    };
+  })();
+
+  /**
    * This aggregator finds the maximum for a numeric field.
    */
   var MaxAggregator = (function() {
     function Aggregator(key) {
       this.key_ = key;
       this.max_ = -Infinity;
     }
 
     Aggregator.prototype = {
       consume: function(e) {
@@ skipping 155 matching lines @@
   KEY_PROPERTIES[KEY_RUN_TIME] = {
     name: 'Total run time',
     cellAlignment: 'right',
     sortDescending: true,
     textPrinter: formatNumberAsText,
     inputJsonKey: 'death_data.run_ms',
     aggregator: SumAggregator,
     diff: diffFuncForCount,
   };
 
+  if (loadTimeData.getBoolean('enableMemoryTaskProfiler')) {
+    KEY_PROPERTIES[KEY_AVG_ALLOC_OPS] = {
+      name: 'Avg Allocations',
+      cellAlignment: 'right',
+      sortDescending: true,
+      textPrinter: formatNumberAsText,
+      aggregator: AvgAggregator.create(KEY_ALLOC_OPS, KEY_COUNT),
+    };
+
+    KEY_PROPERTIES[KEY_AVG_FREE_OPS] = {
+      name: 'Avg Frees',
+      cellAlignment: 'right',
+      sortDescending: true,
+      textPrinter: formatNumberAsText,
+      aggregator: AvgAggregator.create(KEY_FREE_OPS, KEY_COUNT),
+    };
+
+    KEY_PROPERTIES[KEY_AVG_NET_BYTES] = {
+      name: 'Avg Net Bytes',
+      cellAlignment: 'right',
+      sortDescending: true,
+      textPrinter: formatNumberAsText,
+      aggregator: AvgDiffAggregator.create(KEY_ALLOCATED_BYTES,
+                                           KEY_FREED_BYTES, KEY_COUNT),
+    };
+
+    KEY_PROPERTIES[KEY_ALLOC_OPS] = {
+      name: 'Allocation count',
+      cellAlignment: 'right',
+      sortDescending: true,
+      textPrinter: formatNumberAsText,
+      inputJsonKey: 'death_data.alloc_ops',
+      aggregator: SumAggregator,
+      diff: diffFuncForCount,
+    };
+
+    KEY_PROPERTIES[KEY_FREE_OPS] = {
+      name: 'Free Count',
+      cellAlignment: 'right',
+      sortDescending: true,
+      textPrinter: formatNumberAsText,
+      inputJsonKey: 'death_data.free_ops',
+      aggregator: SumAggregator,
+      diff: diffFuncForCount,
+    };
+
+    KEY_PROPERTIES[KEY_ALLOCATED_BYTES] = {
+      name: 'Allocated bytes',
+      cellAlignment: 'right',
+      sortDescending: true,
+      textPrinter: formatNumberAsText,
+      inputJsonKey: 'death_data.allocated_bytes',
+      aggregator: SumAggregator,
+      diff: diffFuncForCount,
+    };
+
+    KEY_PROPERTIES[KEY_FREED_BYTES] = {
+      name: 'Freed bytes',
+      cellAlignment: 'right',
+      sortDescending: true,
+      textPrinter: formatNumberAsText,
+      inputJsonKey: 'death_data.freed_bytes',
+      aggregator: SumAggregator,
+      diff: diffFuncForCount,
+    };
+
+    KEY_PROPERTIES[KEY_ALLOC_OVERHEAD_BYTES] = {
+      name: 'Overhead bytes',
+      cellAlignment: 'right',
+      sortDescending: true,
+      textPrinter: formatNumberAsText,
+      inputJsonKey: 'death_data.alloc_overhead_bytes',
+      aggregator: SumAggregator,
+      diff: diffFuncForCount,
+    };
+
+    KEY_PROPERTIES[KEY_MAX_ALLOCATED_BYTES] = {
+      name: 'Max allocated (outstanding) bytes',
+      cellAlignment: 'right',
+      sortDescending: true,
+      textPrinter: formatNumberAsText,
+      inputJsonKey: 'death_data.max_allocated_bytes',
+      aggregator: MaxAggregator,
+      diff: diffFuncForMax,
+    };
+  }
+
   KEY_PROPERTIES[KEY_AVG_RUN_TIME] = {
     name: 'Avg run time',
     cellAlignment: 'right',
     sortDescending: true,
     textPrinter: formatNumberAsText,
     aggregator: AvgAggregator.create(KEY_RUN_TIME, KEY_COUNT),
   };
 
   KEY_PROPERTIES[KEY_MAX_RUN_TIME] = {
     name: 'Max run time',
@@ skipping 44 matching lines @@
   /**
    * List of keys for those properties which we want to initially omit
    * from the table. (They can be re-enabled by clicking [Edit columns]).
    */
   var INITIALLY_HIDDEN_KEYS = [
     KEY_FILE_NAME,
     KEY_LINE_NUMBER,
     KEY_QUEUE_TIME,
   ];
 
+  if (loadTimeData.getBoolean('enableMemoryTaskProfiler')) {
+    INITIALLY_HIDDEN_KEYS = INITIALLY_HIDDEN_KEYS.concat([
+      KEY_ALLOC_OPS,
+      KEY_FREE_OPS,
+      KEY_ALLOCATED_BYTES,
+      KEY_FREED_BYTES,
+      KEY_ALLOC_OVERHEAD_BYTES,
+    ]);
+  }
+
   /**
    * The ordered list of grouping choices to expose in the "Group by"
    * dropdowns. We don't include the numeric properties, since they
    * leads to awkward bucketing.
    */
   var GROUPING_DROPDOWN_CHOICES = [
     KEY_PROCESS_TYPE,
     KEY_PROCESS_ID,
     KEY_BIRTH_THREAD,
     KEY_DEATH_THREAD,
@@ skipping 323 matching lines @@
    * Adds new derived properties to row. Mutates the provided dictionary |e|.
    */
   function augmentDataRow(e) {
     computeDataRowAverages(e);
     e[KEY_SOURCE_LOCATION] = e[KEY_FILE_NAME] + ' [' + e[KEY_LINE_NUMBER] + ']';
   }
 
   function computeDataRowAverages(e) {
     e[KEY_AVG_QUEUE_TIME] = e[KEY_QUEUE_TIME] / e[KEY_COUNT];
     e[KEY_AVG_RUN_TIME] = e[KEY_RUN_TIME] / e[KEY_COUNT];
+
+    if (loadTimeData.getBoolean('enableMemoryTaskProfiler')) {
+      e[KEY_AVG_ALLOC_OPS] = e[KEY_ALLOC_OPS] / e[KEY_COUNT];
+      e[KEY_AVG_FREE_OPS] = e[KEY_FREE_OPS] / e[KEY_COUNT];
+      e[KEY_AVG_NET_BYTES] =
+          (e[KEY_ALLOCATED_BYTES] - e[KEY_FREED_BYTES]) / e[KEY_COUNT];
+    }
   }
 
   /**
    * Creates and initializes an aggregator object for each key in |columns|.
    * Returns an array whose keys are values from |columns|, and whose
    * values are Aggregator instances.
    */
   function initializeAggregates(columns) {
     var aggregates = [];
 
@@ skipping 123 matching lines @@
    * time), it is found by subtracting.
    *
    * Rows in data1 and data2 are expected to use the same scheme for the keys.
    * In other words, data1[k] is considered the analagous row to data2[k].
    */
   function subtractSnapshots(data1, data2, columnsToExclude) {
     // These columns are computed from the other columns. We won't bother
     // diffing/aggregating these, but rather will derive them again from the
     // final row.
     var COMPUTED_AGGREGATE_KEYS = [KEY_AVG_QUEUE_TIME, KEY_AVG_RUN_TIME];
+    if (loadTimeData.getBoolean('enableMemoryTaskProfiler')) {
+       COMPUTED_AGGREGATE_KEYS = COMPUTED_AGGREGATE_KEYS.concat([
+          KEY_AVG_ALLOC_OPS, KEY_AVG_FREE_OPS, KEY_AVG_NET_BYTES]);
+    }
 
     // These are the keys which determine row equality. Since we are not doing
     // any merging yet at this point, it is simply the list of all identity
     // columns.
     var identityKeys = IDENTITY_KEYS.slice(0);
     deleteValuesFromArray(identityKeys, columnsToExclude);
 
     // The columns to compute via aggregation is everything else.
     var aggregateKeys = ALL_KEYS.slice(0);
     deleteValuesFromArray(aggregateKeys, IDENTITY_KEYS);
@@ skipping 928 matching lines @@
         checkbox.checked = true;
         checkbox.__time = getTimeMillis();
         this.updateSnapshotCheckboxStyling_();
       }
     },
 
     updateSnapshotCheckboxStyling_: function() {
       for (var i = 0; i < this.snapshots_.length; ++i) {
         var checkbox = this.getSnapshotCheckbox_(i);
         checkbox.parentNode.parentNode.className =
-            checkbox.checked ? 'selected_snapshot' : '';
+            checkbox.checked ? 'selected-snapshot' : '';
       }
     },
 
     onSnapshotCheckboxChanged_: function(event) {
       // Keep track of when we clicked this box (for when we need to uncheck
       // older boxes).
       event.target.__time = getTimeMillis();
 
       // Find all the checked boxes. Either 1 or 2 can be checked. If a third
       // was just checked, then uncheck one of the earlier ones so we only have
@@ skipping 273 matching lines @@
           groupKey.push(entry);
         }
 
         return JSON.stringify(groupKey);
       };
     },
   };
 
   return MainView;
 })();