src/tools/perf/metrics/timeline_unittest.py

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import unittest
   6
   7 from metrics import test_page_measurement_results
   8 from metrics import timeline
   9 from telemetry.core.timeline import bounds
  10 from telemetry.core.timeline import model as model_module
  11
  12
  13 class LoadTimesTimelineMetric(unittest.TestCase):
  14   def GetResults(self, metric):
  15     results = test_page_measurement_results.TestPageMeasurementResults(self)
  16     tab = None
  17     metric.AddResults(tab, results)
  18     return results
  19
  20   def testSanitizing(self):
  21     model = model_module.TimelineModel()
  22     renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
  23     renderer_main.name = 'CrRendererMain'
  24
  25     # [      X       ]
  26     #      [  Y  ]
  27     renderer_main.BeginSlice('cat1', 'x.y', 10, 0)
  28     renderer_main.EndSlice(20, 20)
  29     model.FinalizeImport()
  30
  31     metric = timeline.LoadTimesTimelineMetric(model, renderer_main.parent)
  32     results = self.GetResults(metric)
  33     results.AssertHasPageSpecificScalarValue(
  34       'CrRendererMain|x_y', 'ms', 10)
  35     results.AssertHasPageSpecificScalarValue(
  36       'CrRendererMain|x_y_max', 'ms', 10)
  37     results.AssertHasPageSpecificScalarValue(
  38       'CrRendererMain|x_y_avg', 'ms', 10)
  39
  40   def testCounterSanitizing(self):
  41     model = model_module.TimelineModel()
  42     renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
  43     renderer_main.name = 'CrRendererMain'
  44
  45     x_counter = renderer_main.parent.GetOrCreateCounter('cat', 'x.y')
  46     x_counter.samples += [1, 2]
  47     x_counter.series_names += ['a']
  48     x_counter.timestamps += [0, 1]
  49     model.FinalizeImport()
  50
  51     metric = timeline.LoadTimesTimelineMetric(model, renderer_main.parent)
  52     results = self.GetResults(metric)
  53     results.AssertHasPageSpecificScalarValue(
  54       'cat_x_y', 'count', 3)
  55     results.AssertHasPageSpecificScalarValue(
  56       'cat_x_y_avg', 'count', 1.5)
  57
  58
  59 class ThreadTimesTimelineMetricUnittest(unittest.TestCase):
  60   def GetResults(self, metric):
  61     results = test_page_measurement_results.TestPageMeasurementResults(self)
  62     tab = None
  63     metric.AddResults(tab, results)
  64     return results
  65
  66   def GetActionRange(self, start, end):
  67     action_range = bounds.Bounds()
  68     action_range.AddValue(start)
  69     action_range.AddValue(end)
  70     return action_range
  71
  72   def testResults(self):
  73     model = model_module.TimelineModel()
  74     renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
  75     renderer_main.name = 'CrRendererMain'
  76
  77     metric = timeline.ThreadTimesTimelineMetric(model, renderer_main.parent,
  78                                                 [self.GetActionRange(1, 2)])
  79     metric.details_to_report = timeline.ReportMainThreadOnly
  80     results = self.GetResults(metric)
  81
  82     # Test that all result thread categories exist
  83     for name in timeline.TimelineThreadCategories.values():
  84       results.GetPageSpecificValueNamed(timeline.ThreadCpuTimeResultName(name))
  85
  86   def testBasic(self):
  87     model = model_module.TimelineModel()
  88     renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
  89     renderer_main.name = 'CrRendererMain'
  90
  91     # Create two frame swaps (Results times should be divided by two)
  92     cc_main = model.GetOrCreateProcess(1).GetOrCreateThread(3)
  93     cc_main.name = 'Compositor'
  94     cc_main.BeginSlice('cc_cat', timeline.FrameTraceName, 10, 10)
  95     cc_main.EndSlice(11, 11)
  96     cc_main.BeginSlice('cc_cat', timeline.FrameTraceName, 12, 12)
  97     cc_main.EndSlice(13, 13)
  98
  99     # [      X       ]   [ Z ]
 100     #      [  Y  ]
 101     renderer_main.BeginSlice('cat1', 'X', 10, 0)
 102     renderer_main.BeginSlice('cat2', 'Y', 15, 5)
 103     renderer_main.EndSlice(16, 5.5)
 104     renderer_main.EndSlice(30, 19.5)
 105     renderer_main.BeginSlice('cat1', 'Z', 31, 20)
 106     renderer_main.BeginSlice('cat1', 'Z', 33, 21)
 107     model.FinalizeImport()
 108
 109     # Exclude 'Z' using an action-range.
 110     metric = timeline.ThreadTimesTimelineMetric(
 111       model, renderer_main.parent, action_ranges=[self.GetActionRange(10, 30)])
 112     metric.details_to_report = timeline.ReportMainThreadOnly
 113     results = self.GetResults(metric)
 114
 115     # Test a couple specific results.
 116     assert_results = {
 117       timeline.ThreadCpuTimeResultName('renderer_main') : 9.75,
 118       timeline.ThreadDetailResultName('renderer_main','cat1') : 9.5,
 119       timeline.ThreadDetailResultName('renderer_main','cat2') : 0.5,
 120       timeline.ThreadDetailResultName('renderer_main','idle') : 0
 121     }
 122     for name, value in assert_results.iteritems():
 123       results.AssertHasPageSpecificScalarValue(name, 'ms', value)
 124
 125   def testOverheadIsRemoved(self):
 126     model = model_module.TimelineModel()
 127     renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
 128     renderer_main.name = 'CrRendererMain'
 129
 130     # Create one frame swap.
 131     cc_main = model.GetOrCreateProcess(1).GetOrCreateThread(3)
 132     cc_main.name = 'Compositor'
 133     cc_main.BeginSlice('cc_cat', timeline.FrameTraceName, 10, 10)
 134     cc_main.EndSlice(11, 11)
 135
 136     # [      X       ]
 137     #    [Overhead]
 138     overhead_category = timeline.OverheadTraceCategory
 139     overhead_name = timeline.OverheadTraceName
 140     renderer_main.BeginSlice('cat1', 'X', 10, 0)
 141     renderer_main.BeginSlice(overhead_category, overhead_name, 15, 5)
 142     renderer_main.EndSlice(16, 6)
 143     renderer_main.EndSlice(30, 10)
 144     model.FinalizeImport()
 145
 146     # Include everything in an action-range.
 147     metric = timeline.ThreadTimesTimelineMetric(
 148       model, renderer_main.parent, action_ranges=[self.GetActionRange(10, 30)])
 149     metric.details_to_report = timeline.ReportMainThreadOnly
 150     results = self.GetResults(metric)
 151
 152     # Test a couple specific results.
 153     assert_results = {
 154       timeline.ThreadCpuTimeResultName('renderer_main') : 9.0,
 155     }
 156     for name, value in assert_results.iteritems():
 157       results.AssertHasPageSpecificScalarValue(name, 'ms', value)