Home | History | Annotate | Download | only in metrics 
      1 # Copyright 2014 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 import collections
      5 
      6 from telemetry.web_perf.metrics import timeline_based_metric
      7 from telemetry.value import scalar
      8 
      9 
     10 class LoadTimesTimelineMetric(timeline_based_metric.TimelineBasedMetric):
     11   def __init__(self):
     12     super(LoadTimesTimelineMetric, self).__init__()
     13     self.report_main_thread_only = True
     14 
     15   def AddResults(self, model, renderer_thread, interaction_records, results):
     16     assert model
     17     assert len(interaction_records) == 1, (
     18       'LoadTimesTimelineMetric cannot compute metrics for more than 1 time '
     19       'range.')
     20     interaction_record = interaction_records[0]
     21     if self.report_main_thread_only:
     22       thread_filter = 'CrRendererMain'
     23     else:
     24       thread_filter = None
     25 
     26     events_by_name = collections.defaultdict(list)
     27     renderer_process = renderer_thread.parent
     28 
     29     for thread in renderer_process.threads.itervalues():
     30 
     31       if thread_filter and not thread.name in thread_filter:
     32         continue
     33 
     34       thread_name = thread.name.replace('/','_')
     35       for e in thread.IterAllSlicesInRange(interaction_record.start,
     36                                            interaction_record.end):
     37         events_by_name[e.name].append(e)
     38 
     39       for event_name, event_group in events_by_name.iteritems():
     40         times = [event.self_time for event in event_group]
     41         total = sum(times)
     42         biggest_jank = max(times)
     43 
     44         # Results objects cannot contain the '.' character, so remove that here.
     45         sanitized_event_name = event_name.replace('.', '_')
     46 
     47         full_name = thread_name + '|' + sanitized_event_name
     48         results.AddValue(scalar.ScalarValue(
     49             results.current_page, full_name, 'ms', total))
     50         results.AddValue(scalar.ScalarValue(
     51             results.current_page, full_name + '_max', 'ms', biggest_jank))
     52         results.AddValue(scalar.ScalarValue(
     53             results.current_page, full_name + '_avg', 'ms', total / len(times)))
     54 
     55     for counter_name, counter in renderer_process.counters.iteritems():
     56       total = sum(counter.totals)
     57 
     58       # Results objects cannot contain the '.' character, so remove that here.
     59       sanitized_counter_name = counter_name.replace('.', '_')
     60 
     61       results.AddValue(scalar.ScalarValue(
     62           results.current_page, sanitized_counter_name, 'count', total))
     63       results.AddValue(scalar.ScalarValue(
     64           results.current_page, sanitized_counter_name + '_avg', 'count',
     65           total / float(len(counter.totals))))
     66 
     67 # We want to generate a consistant picture of our thread usage, despite
     68 # having several process configurations (in-proc-gpu/single-proc).
     69 # Since we can't isolate renderer threads in single-process mode, we
     70 # always sum renderer-process threads' times. We also sum all io-threads
     71 # for simplicity.
     72 TimelineThreadCategories =  {
     73   "Chrome_InProcGpuThread": "GPU",
     74   "CrGpuMain"             : "GPU",
     75   "AsyncTransferThread"   : "GPU_transfer",
     76   "CrBrowserMain"         : "browser",
     77   "Browser Compositor"    : "browser",
     78   "CrRendererMain"        : "renderer_main",
     79   "Compositor"            : "renderer_compositor",
     80   "IOThread"              : "IO",
     81   "CompositorRasterWorker": "raster",
     82   "DummyThreadName1"      : "other",
     83   "DummyThreadName2"      : "total_fast_path",
     84   "DummyThreadName3"      : "total_all"
     85 }
     86 
     87 _MatchBySubString = ["IOThread", "CompositorRasterWorker"]
     88 
     89 AllThreads = TimelineThreadCategories.values()
     90 NoThreads = []
     91 FastPathThreads = ["GPU", "renderer_compositor", "browser", "IO"]
     92 
     93 ReportMainThreadOnly = ["renderer_main"]
     94 ReportFastPathResults = AllThreads
     95 ReportFastPathDetails = NoThreads
     96 ReportSilkResults = ["renderer_main", "total_all"]
     97 ReportSilkDetails = ["renderer_main"]
     98 
     99 # TODO(epenner): Thread names above are likely fairly stable but trace names
    100 # could change. We should formalize these traces to keep this robust.
    101 OverheadTraceCategory = "trace_event_overhead"
    102 OverheadTraceName = "overhead"
    103 FrameTraceName = "::SwapBuffers"
    104 FrameTraceThreadName = "renderer_compositor"
    105 
    106 
    107 def ClockOverheadForEvent(event):
    108   if (event.category == OverheadTraceCategory and
    109       event.name == OverheadTraceName):
    110     return event.duration
    111   else:
    112     return 0
    113 
    114 def CpuOverheadForEvent(event):
    115   if (event.category == OverheadTraceCategory and
    116       event.thread_duration):
    117     return event.thread_duration
    118   else:
    119     return 0
    120 
    121 def ThreadCategoryName(thread_name):
    122   thread_category = "other"
    123   for substring, category in TimelineThreadCategories.iteritems():
    124     if substring in _MatchBySubString and substring in thread_name:
    125       thread_category = category
    126   if thread_name in TimelineThreadCategories:
    127     thread_category = TimelineThreadCategories[thread_name]
    128   return thread_category
    129 
    130 def ThreadTimeResultName(thread_category):
    131   return "thread_" + thread_category + "_clock_time_per_frame"
    132 
    133 def ThreadCpuTimeResultName(thread_category):
    134   return "thread_" + thread_category + "_cpu_time_per_frame"
    135 
    136 def ThreadDetailResultName(thread_category, detail):
    137   detail_sanitized = detail.replace('.','_')
    138   return "thread_" + thread_category + "|" + detail_sanitized
    139 
    140 
    141 class ResultsForThread(object):
    142   def __init__(self, model, record_ranges, name):
    143     self.model = model
    144     self.toplevel_slices = []
    145     self.all_slices = []
    146     self.name = name
    147     self.record_ranges = record_ranges
    148 
    149   @property
    150   def clock_time(self):
    151     clock_duration = sum([x.duration for x in self.toplevel_slices])
    152     clock_overhead = sum([ClockOverheadForEvent(x) for x in self.all_slices])
    153     return clock_duration - clock_overhead
    154 
    155   @property
    156   def cpu_time(self):
    157     cpu_duration = 0
    158     cpu_overhead = sum([CpuOverheadForEvent(x) for x in self.all_slices])
    159     for x in self.toplevel_slices:
    160       # Only report thread-duration if we have it for all events.
    161       #
    162       # A thread_duration of 0 is valid, so this only returns 0 if it is None.
    163       if x.thread_duration == None:
    164         if not x.duration:
    165           continue
    166         else:
    167           return 0
    168       else:
    169         cpu_duration += x.thread_duration
    170     return cpu_duration - cpu_overhead
    171 
    172   def SlicesInActions(self, slices):
    173     slices_in_actions = []
    174     for event in slices:
    175       for record_range in self.record_ranges:
    176         if record_range.ContainsInterval(event.start, event.end):
    177           slices_in_actions.append(event)
    178           break
    179     return slices_in_actions
    180 
    181   def AppendThreadSlices(self, thread):
    182     self.all_slices.extend(self.SlicesInActions(thread.all_slices))
    183     self.toplevel_slices.extend(self.SlicesInActions(thread.toplevel_slices))
    184 
    185   def AddResults(self, num_frames, results):
    186     cpu_per_frame = (float(self.cpu_time) / num_frames) if num_frames else 0
    187     results.AddValue(scalar.ScalarValue(
    188         results.current_page, ThreadCpuTimeResultName(self.name),
    189         'ms', cpu_per_frame))
    190 
    191   def AddDetailedResults(self, num_frames, results):
    192     slices_by_category = collections.defaultdict(list)
    193     for s in self.all_slices:
    194       slices_by_category[s.category].append(s)
    195     all_self_times = []
    196     for category, slices_in_category in slices_by_category.iteritems():
    197       self_time = sum([x.self_time for x in slices_in_category])
    198       all_self_times.append(self_time)
    199       self_time_result = (float(self_time) / num_frames) if num_frames else 0
    200       results.AddValue(scalar.ScalarValue(
    201           results.current_page, ThreadDetailResultName(self.name, category),
    202           'ms', self_time_result))
    203     all_measured_time = sum(all_self_times)
    204     all_action_time = \
    205         sum([record_range.bounds for record_range in self.record_ranges])
    206     idle_time = max(0, all_action_time - all_measured_time)
    207     idle_time_result = (float(idle_time) / num_frames) if num_frames else 0
    208     results.AddValue(scalar.ScalarValue(
    209         results.current_page, ThreadDetailResultName(self.name, "idle"),
    210         'ms', idle_time_result))
    211 
    212 
    213 class ThreadTimesTimelineMetric(timeline_based_metric.TimelineBasedMetric):
    214   def __init__(self):
    215     super(ThreadTimesTimelineMetric, self).__init__()
    216     # Minimal traces, for minimum noise in CPU-time measurements.
    217     self.results_to_report = AllThreads
    218     self.details_to_report = NoThreads
    219 
    220   def CountSlices(self, slices, substring):
    221     count = 0
    222     for event in slices:
    223       if substring in event.name:
    224         count += 1
    225     return count
    226 
    227   def AddResults(self, model, _, interaction_records, results):
    228     # Set up each thread category for consistant results.
    229     thread_category_results = {}
    230     for name in TimelineThreadCategories.values():
    231       thread_category_results[name] = ResultsForThread(
    232         model, [r.GetBounds() for r in interaction_records], name)
    233 
    234     # Group the slices by their thread category.
    235     for thread in model.GetAllThreads():
    236       thread_category = ThreadCategoryName(thread.name)
    237       thread_category_results[thread_category].AppendThreadSlices(thread)
    238 
    239     # Group all threads.
    240     for thread in model.GetAllThreads():
    241       thread_category_results['total_all'].AppendThreadSlices(thread)
    242 
    243     # Also group fast-path threads.
    244     for thread in model.GetAllThreads():
    245       if ThreadCategoryName(thread.name) in FastPathThreads:
    246         thread_category_results['total_fast_path'].AppendThreadSlices(thread)
    247 
    248     # Calculate the number of frames.
    249     frame_slices = thread_category_results[FrameTraceThreadName].all_slices
    250     num_frames = self.CountSlices(frame_slices, FrameTraceName)
    251 
    252     # Report the desired results and details.
    253     for thread_results in thread_category_results.values():
    254       if thread_results.name in self.results_to_report:
    255         thread_results.AddResults(num_frames, results)
    256       # TOOD(nduca): When generic results objects are done, this special case
    257       # can be replaced with a generic UI feature.
    258       if thread_results.name in self.details_to_report:
    259         thread_results.AddDetailedResults(num_frames, results)
    260