| <!DOCTYPE html> |
| <!-- |
| Copyright 2016 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. |
| --> |
| |
| <link rel="import" href="/tracing/base/range.html"> |
| <link rel="import" href="/tracing/base/unit.html"> |
| <link rel="import" href="/tracing/metrics/metric_registry.html"> |
| <link rel="import" href="/tracing/metrics/v8/utils.html"> |
| <link rel="import" href="/tracing/value/histogram.html"> |
| |
| <script> |
| 'use strict'; |
| |
| tr.exportTo('tr.metrics.v8', function() { |
| // The time window size for mutator utilization computation. |
| // It is equal to the duration of one frame corresponding to 60 FPS rendering. |
| var TARGET_FPS = 60; |
| var MS_PER_SECOND = 1000; |
| var WINDOW_SIZE_MS = MS_PER_SECOND / TARGET_FPS; |
| |
| function gcMetric(values, model) { |
| addDurationOfTopEvents(values, model); |
| addTotalDurationOfTopEvents(values, model); |
| addDurationOfSubEvents(values, model); |
| addIdleTimesOfTopEvents(values, model); |
| addTotalIdleTimesOfTopEvents(values, model); |
| addPercentageInV8ExecuteOfTopEvents(values, model); |
| addTotalPercentageInV8Execute(values, model); |
| addV8ExecuteMutatorUtilization(values, model); |
| } |
| |
| tr.metrics.MetricRegistry.register(gcMetric); |
| |
| var timeDurationInMs_smallerIsBetter = |
| tr.b.Unit.byName.timeDurationInMs_smallerIsBetter; |
| var percentage_biggerIsBetter = |
| tr.b.Unit.byName.normalizedPercentage_biggerIsBetter; |
| var percentage_smallerIsBetter = |
| tr.b.Unit.byName.normalizedPercentage_smallerIsBetter; |
| |
| // 0.1 steps from 0 to 20 since it is the most common range. |
| // Exponentially increasing steps from 20 to 200. |
| var CUSTOM_BOUNDARIES = tr.v.HistogramBinBoundaries.createLinear(0, 20, 200) |
| .addExponentialBins(200, 100); |
| |
| function createNumericForTopEventTime(name) { |
| var n = new tr.v.Histogram(name, |
| timeDurationInMs_smallerIsBetter, CUSTOM_BOUNDARIES); |
| n.customizeSummaryOptions({ |
| avg: true, |
| count: true, |
| max: true, |
| min: false, |
| std: true, |
| sum: true, |
| percentile: [0.90]}); |
| return n; |
| } |
| |
| function createNumericForSubEventTime(name) { |
| var n = new tr.v.Histogram(name, |
| timeDurationInMs_smallerIsBetter, CUSTOM_BOUNDARIES); |
| n.customizeSummaryOptions({ |
| avg: true, |
| count: false, |
| max: true, |
| min: false, |
| std: false, |
| sum: false, |
| percentile: [0.90] |
| }); |
| return n; |
| } |
| |
| function createNumericForIdleTime(name) { |
| var n = new tr.v.Histogram(name, |
| timeDurationInMs_smallerIsBetter, CUSTOM_BOUNDARIES); |
| n.customizeSummaryOptions({ |
| avg: true, |
| count: false, |
| max: true, |
| min: false, |
| std: false, |
| sum: true, |
| percentile: [] |
| }); |
| return n; |
| } |
| |
| function createPercentage(name, numerator, denominator, unit) { |
| var hist = new tr.v.Histogram(name, unit); |
| if (denominator === 0) |
| hist.addSample(0); |
| else |
| hist.addSample(numerator / denominator); |
| hist.customizeSummaryOptions({ |
| avg: true, |
| count: false, |
| max: false, |
| min: false, |
| std: false, |
| sum: false, |
| percentile: [] |
| }); |
| return hist; |
| } |
| |
| function isNotForcedTopGarbageCollectionEvent(event) { |
| // We exclude garbage collection events forced by benchmark runner, |
| // because they cannot happen in real world. |
| return tr.metrics.v8.utils.isTopGarbageCollectionEvent(event) && |
| !tr.metrics.v8.utils.isForcedGarbageCollectionEvent(event); |
| } |
| |
| function isNotForcedSubGarbageCollectionEvent(event) { |
| // We exclude garbage collection events forced by benchmark runner, |
| // because they cannot happen in real world. |
| return tr.metrics.v8.utils.isSubGarbageCollectionEvent(event) && |
| !tr.metrics.v8.utils.isForcedGarbageCollectionEvent(event); |
| } |
| |
| /** |
| * Example output: |
| * - v8-gc-full-mark-compactor. |
| */ |
| function addDurationOfTopEvents(values, model) { |
| tr.metrics.v8.utils.groupAndProcessEvents(model, |
| isNotForcedTopGarbageCollectionEvent, |
| tr.metrics.v8.utils.topGarbageCollectionEventName, |
| function(name, events) { |
| var cpuDuration = createNumericForTopEventTime(name); |
| events.forEach(function(event) { |
| cpuDuration.addSample(event.cpuDuration); |
| }); |
| values.addHistogram(cpuDuration); |
| } |
| ); |
| } |
| |
| /** |
| * Example output: |
| * - v8-gc-total |
| */ |
| function addTotalDurationOfTopEvents(values, model) { |
| tr.metrics.v8.utils.groupAndProcessEvents(model, |
| isNotForcedTopGarbageCollectionEvent, |
| event => 'v8-gc-total', |
| function(name, events) { |
| var cpuDuration = createNumericForTopEventTime(name); |
| events.forEach(function(event) { |
| cpuDuration.addSample(event.cpuDuration); |
| }); |
| values.addHistogram(cpuDuration); |
| } |
| ); |
| } |
| |
| /** |
| * Example output: |
| * - v8-gc-full-mark-compactor-evacuate. |
| */ |
| function addDurationOfSubEvents(values, model) { |
| tr.metrics.v8.utils.groupAndProcessEvents(model, |
| isNotForcedSubGarbageCollectionEvent, |
| tr.metrics.v8.utils.subGarbageCollectionEventName, |
| function(name, events) { |
| var cpuDuration = createNumericForSubEventTime(name); |
| events.forEach(function(event) { |
| cpuDuration.addSample(event.cpuDuration); |
| }); |
| values.addHistogram(cpuDuration); |
| } |
| ); |
| } |
| |
| /** |
| * Example output: |
| * - v8-gc-full-mark-compactor_idle_deadline_overrun, |
| * - v8-gc-full-mark-compactor_outside_idle, |
| * - v8-gc-full-mark-compactor_percentage_idle. |
| */ |
| function addIdleTimesOfTopEvents(values, model) { |
| tr.metrics.v8.utils.groupAndProcessEvents(model, |
| isNotForcedTopGarbageCollectionEvent, |
| tr.metrics.v8.utils.topGarbageCollectionEventName, |
| function(name, events) { |
| addIdleTimes(values, model, name, events); |
| } |
| ); |
| } |
| |
| /** |
| * Example output: |
| * - v8-gc-total_idle_deadline_overrun, |
| * - v8-gc-total_outside_idle, |
| * - v8-gc-total_percentage_idle. |
| */ |
| function addTotalIdleTimesOfTopEvents(values, model) { |
| tr.metrics.v8.utils.groupAndProcessEvents(model, |
| isNotForcedTopGarbageCollectionEvent, |
| event => 'v8-gc-total', |
| function(name, events) { |
| addIdleTimes(values, model, name, events); |
| } |
| ); |
| } |
| |
| function addIdleTimes(values, model, name, events) { |
| var cpuDuration = createNumericForIdleTime(); |
| var insideIdle = createNumericForIdleTime(); |
| var outsideIdle = createNumericForIdleTime(name + '_outside_idle'); |
| var idleDeadlineOverrun = createNumericForIdleTime( |
| name + '_idle_deadline_overrun'); |
| events.forEach(function(event) { |
| var idleTask = tr.metrics.v8.utils.findParent( |
| event, tr.metrics.v8.utils.isIdleTask); |
| var inside = 0; |
| var overrun = 0; |
| if (idleTask) { |
| var allottedTime = idleTask['args']['allotted_time_ms']; |
| if (event.duration > allottedTime) { |
| overrun = event.duration - allottedTime; |
| // Don't count time over the deadline as being inside idle time. |
| // Since the deadline should be relative to wall clock we |
| // compare allotted_time_ms with wall duration instead of thread |
| // duration, and then assume the thread duration was inside idle |
| // for the same percentage of time. |
| inside = event.cpuDuration * allottedTime / event.duration; |
| } else { |
| inside = event.cpuDuration; |
| } |
| } |
| cpuDuration.addSample(event.cpuDuration); |
| insideIdle.addSample(inside); |
| outsideIdle.addSample(event.cpuDuration - inside); |
| idleDeadlineOverrun.addSample(overrun); |
| }); |
| values.addHistogram(idleDeadlineOverrun); |
| values.addHistogram(outsideIdle); |
| var percentage = createPercentage(name + '_percentage_idle', insideIdle.sum, |
| cpuDuration.sum, |
| percentage_biggerIsBetter); |
| values.addHistogram(percentage); |
| } |
| |
| |
| /** |
| * Example output: |
| * - v8-gc-full-mark-compactor_percentage_in_v8_execute. |
| */ |
| function addPercentageInV8ExecuteOfTopEvents(values, model) { |
| tr.metrics.v8.utils.groupAndProcessEvents(model, |
| isNotForcedTopGarbageCollectionEvent, |
| tr.metrics.v8.utils.topGarbageCollectionEventName, |
| function(name, events) { |
| addPercentageInV8Execute(values, model, name, events); |
| } |
| ); |
| } |
| |
| /** |
| * Example output: |
| * - v8-gc-total_percentage_in_v8_execute. |
| */ |
| function addTotalPercentageInV8Execute(values, model) { |
| tr.metrics.v8.utils.groupAndProcessEvents(model, |
| isNotForcedTopGarbageCollectionEvent, |
| event => 'v8-gc-total', |
| function(name, events) { |
| addPercentageInV8Execute(values, model, name, events); |
| } |
| ); |
| } |
| |
| function addPercentageInV8Execute(values, model, name, events) { |
| var cpuDurationInV8Execute = 0; |
| var cpuDurationTotal = 0; |
| events.forEach(function(event) { |
| var v8Execute = tr.metrics.v8.utils.findParent( |
| event, tr.metrics.v8.utils.isV8ExecuteEvent); |
| if (v8Execute) { |
| cpuDurationInV8Execute += event.cpuDuration; |
| } |
| cpuDurationTotal += event.cpuDuration; |
| }); |
| var percentage = createPercentage( |
| name + '_percentage_in_v8_execute', cpuDurationInV8Execute, |
| cpuDurationTotal, percentage_smallerIsBetter); |
| values.addHistogram(percentage); |
| } |
| |
| function addV8ExecuteMutatorUtilization(values, model) { |
| tr.metrics.v8.utils.groupAndProcessEvents(model, |
| tr.metrics.v8.utils.isTopV8ExecuteEvent, |
| event => 'v8-execute', |
| function(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. |
| for (var topEvent of events) { |
| for (var e of topEvent.enumerateAllDescendents()) { |
| if (isNotForcedTopGarbageCollectionEvent(e)) { |
| pauses.push({ start: e.start - topEvent.start + time, |
| end: e.end - topEvent.start + time }); |
| } |
| } |
| 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, WINDOW_SIZE_MS, pauses); |
| [0.90, 0.95, 0.99].forEach(function(percent) { |
| var hist = new tr.v.Histogram( |
| 'v8-execute-mutator-utilization_pct_0' + percent * 100, |
| percentage_biggerIsBetter); |
| hist.addSample(mutatorUtilization.percentile(1.0 - percent)); |
| values.addHistogram(hist); |
| }); |
| var hist = new tr.v.Histogram( |
| 'v8-execute-mutator-utilization_min', percentage_biggerIsBetter); |
| hist.addSample(mutatorUtilization.min); |
| values.addHistogram(hist); |
| } |
| ); |
| } |
| |
| return { |
| gcMetric: gcMetric, |
| WINDOW_SIZE_MS: WINDOW_SIZE_MS // For testing purposes only. |
| }; |
| }); |
| </script> |
