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++;
+    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 1708 matching lines @@
           groupKey.push(entry);
         }
 
         return JSON.stringify(groupKey);
       };
     },
   };
 
   return MainView;
 })();