Add mutator utilization metric.

tracing/tracing/metrics/v8/gc_metric.html

Index: tracing/tracing/metrics/v8/gc_metric.html
diff --git a/tracing/tracing/metrics/v8/gc_metric.html b/tracing/tracing/metrics/v8/gc_metric.html
index 3243402f13b6da68883493752a8a9e43055aae57..3eed4e6c98a20e7f241ee8c6414ef0d2a6dc4b4a 100644
--- a/tracing/tracing/metrics/v8/gc_metric.html
+++ b/tracing/tracing/metrics/v8/gc_metric.html
@@ -21,6 +21,7 @@ tr.exportTo('tr.metrics.v8', function() {
     addDurationOfSubEvents(valueList, model);
     addIdleTimesOfTopEvents(valueList, model);
     addTotalIdleTimesOfTopEvents(valueList, model);
+    addMutatorUtilization(valueList, model);
   }
 
   gcMetric.prototype = {
@@ -191,6 +192,47 @@ tr.exportTo('tr.metrics.v8', function() {
         stageTitle + '-' + name + '_percentage_idle', percentage));
   }
 
+  function addMutatorUtilization(valueList, model) {
+    groupAndProcessEvents(model,
+      tr.metrics.v8.utils.isTopV8ExecuteEvent,
+      event => 'v8.execute',
+      function(stageTitle, name, events) {
+        events.sort((a, b) => a.start - b.start);
+        var time = 0;
+        var pauses = [];
+        // Glue together the v8.execute events and adjust the GC pause
+        // times accordingly.
+        events.forEach(function(topEvent) {
+          topEvent.descendentSlices.forEach(function(e) {

[eakuefner, 2016/04/20 17:25:54]

One thing overall about this metric that this CL caused me to notice is that you
shouldn't have to use your custom utils to do this type of iteration.

You should look into replacing the util functions with
model.findTopmostSlicesNamed, or if you need more general predicates than that,
model.findTopmostSlices, and refactoring groupAndProcessEvents to take this into
account. I think using these helpers throughout will increase the clarity
substantially, and we use them in the execution metric to avoid the
double-counting problem.

Take a look at the docstring to see how it works:
https://github.com/catapult-project/catapult/blob/master/tracing/tracing/mode...

and at the docstring for the related Slice.findTopmostSlicesRelativeToThisSlice:
https://github.com/catapult-project/catapult/blob/master/tracing/tracing/mode...

[ulan, 2016/04/20 18:47:04]

Partially done. Replaced descendentSlices with
findTopmostSlicesRelativeToThisSlice

The model.findTopmostSlicesNamed it didn't work out: model.findTopmostSlices
doesn't know about user expectations, but we  are interested in events per user
expectation. 

Also note that we rely on the order of events (line 200) to shift the GC pauses
in time. This is cannot be handled in a single event callback of
findTopmostSlices.

+            if (tr.metrics.v8.utils.isTopGarbageCollectionEvent(e)) {
+              var start = e.start - topEvent.start + time;
+              var end = e.end - topEvent.start + time;
+              pauses.push({start: start, end: end});
+            }
+          });
+          time += topEvent.duration;
+        });
+        // Now we have one big v8.execute interval from 0 to |time| and
+        // a list of GC pauses.
+        var mutatorUtilization =
+            tr.metrics.v8.utils.mutatorUtilization(0, time, 16, pauses);
+        [0.95, 0.99].forEach(function(percent) {
+          var value = new tr.v.ScalarNumeric(percentage_biggerIsBetter,
+              mutatorUtilization.percentile(1.0 - percent) * 100);
+          valueList.addValue(
+            new tr.v.NumericValue(model.canonicalUrl,
+              stageTitle + '-mutator_utilization_pct' + percent * 100,
+              value));
+        });
+        var value = new tr.v.ScalarNumeric(percentage_biggerIsBetter,
+            mutatorUtilization.min());
+        valueList.addValue(
+          new tr.v.NumericValue(model.canonicalUrl,
+            stageTitle + '-mutator_utilization_min', value));
+      }
+    );
+  }
+
   /**
   * Filters events using the |filterCallback|, then groups events by the user
   * expectation stage title and the name computed using the |nameCallback|,