Telemetry: Remove 'overhead' time from thread times measurement.

tools/perf/metrics/timeline.py

 # Copyright 2014 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.
 import collections
 import itertools
 
 from metrics import Metric
 from telemetry.core.timeline import bounds
 from telemetry.page import page_measurement
 
@@ skipping 122 matching lines @@
 
 # We want to generate a consistant picture of our thread usage, despite
 # having several process configurations (in-proc-gpu/single-proc).
 # Since we can't isolate renderer threads in single-process mode, we
 # always sum renderer-process threads' times. We also sum all io-threads
 # for simplicity.
 TimelineThreadCategories =  {
   "Chrome_InProcGpuThread": "GPU",
   "CrGpuMain"             : "GPU",
   "AsyncTransferThread"   : "GPU_transfer",
-  "CrBrowserMain"         : "browser_main",
-  "Browser Compositor"    : "browser_compositor",
+  "CrBrowserMain"         : "browser",
+  "Browser Compositor"    : "browser",
   "CrRendererMain"        : "renderer_main",
   "Compositor"            : "renderer_compositor",
   "IOThread"              : "IO",
   "CompositorRasterWorker": "raster",
   "DummyThreadName1"      : "other",
   "DummyThreadName2"      : "total_fast_path",
   "DummyThreadName3"      : "total_all"
 }
 
 MatchBySubString = ["IOThread", "CompositorRasterWorker"]
 
 AllThreads = TimelineThreadCategories.values()
 NoThreads = []
-FastPathThreads = ["GPU",
-                   "browser_main",
-                   "browser_compositor",
-                   "renderer_compositor",
-                   "IO"]
-MainThread = ["renderer_main"]
+
+FastPathThreads = ["GPU", "renderer_compositor", "browser", "IO"]
 FastPathResults = AllThreads
 FastPathDetails = NoThreads
 SilkResults = ["renderer_main", "total_all"]
-SilkDetails = MainThread
+SilkDetails = ["renderer_main"]
 
 # TODO(epenner): Thread names above are likely fairly stable but trace names
-# could change. We should formalize this trace to keep this robust.
-CompositorFrameTraceName = "::SwapBuffers"
+# could change. We should formalize these traces to keep this robust.
+OverheadTraceCategory = "trace_event_overhead"

[nduca, 2014/02/05 00:34:11]

global vars sould be prefixed with _ when not intended for use outside the
module

+OverheadTraceName = "overhead"
+FrameTraceName = "::SwapBuffers"
+FrameTraceThread = "renderer_compositor"
+
+def ClockOverhead(event):

[nduca, 2014/02/05 00:34:11]

GetClockOverheadFromEvent

+  if (event.category == OverheadTraceCategory and
+      event.name == OverheadTraceName):
+    return event.duration
+  else:
+    return 0
+
+def CpuOverhead(event):

[nduca, 2014/02/05 00:34:11]

GetCpuOverheadFromEvent or someting like that

+  if (event.category == OverheadTraceCategory and
+      event.name == OverheadTraceName and
+      event.thread_duration):
+    return event.thread_duration
+  else:
+    return 0
 
 def ThreadCategoryName(thread_name):
   thread_category = "other"
   for substring, category in TimelineThreadCategories.iteritems():
     if substring in MatchBySubString and substring in thread_name:
       thread_category = category
   if thread_name in TimelineThreadCategories:
     thread_category = TimelineThreadCategories[thread_name]
   return thread_category
 
 def ThreadTimeResultName(thread_category):
   return "thread_" + thread_category + "_clock_time_per_frame"
 
 def ThreadCpuTimeResultName(thread_category):
   return "thread_" + thread_category + "_cpu_time_per_frame"
 
 def ThreadDetailResultName(thread_category, detail):
   return "thread_" + thread_category + "|" + detail
 
 class ResultsForThread(object):
   def __init__(self, model, action_ranges, name):
     self.model = model
     self.toplevel_slices = []
     self.all_slices = []
     self.name = name
     self.action_ranges = action_ranges
 
   @property
   def clock_time(self):
-    return sum([x.duration for x in self.toplevel_slices])
+    clock_duration = sum([x.duration for x in self.toplevel_slices])
+    clock_overhead = sum([ClockOverhead(x) for x in self.all_slices])
+    return clock_duration - clock_overhead
 
   @property
   def cpu_time(self):
-    res = 0
+    cpu_duration = 0
+    cpu_overhead = sum([CpuOverhead(x) for x in self.all_slices])
     for x in self.toplevel_slices:
       # Only report thread-duration if we have it for all events.
       #
       # A thread_duration of 0 is valid, so this only returns 0 if it is None.
       if x.thread_duration == None:
         if not x.duration:
           continue
         else:
           return 0
       else:
-        res += x.thread_duration
-    return res
+        cpu_duration += x.thread_duration
+    return cpu_duration - cpu_overhead
 
   def ActionSlices(self, slices):
     slices_in_actions = []
     for event in slices:
       for action_range in self.action_ranges:
         if action_range.Contains(bounds.Bounds.CreateFromEvent(event)):
           slices_in_actions.append(event)
           break
     return slices_in_actions
 
@@ skipping 58 matching lines @@
 
     # Group all threads.
     for thread in self._model.GetAllThreads():
       thread_category_results['total_all'].AppendThreadSlices(thread)
 
     # Also group fast-path threads.
     for thread in self._model.GetAllThreads():
       if ThreadCategoryName(thread.name) in FastPathThreads:
         thread_category_results['total_fast_path'].AppendThreadSlices(thread)
 
-    # Calculate the number of frames from the CC thread.
-    cc_slices = thread_category_results['renderer_compositor'].all_slices
-    num_frames = self.CountSlices(cc_slices, CompositorFrameTraceName)
+    # Calculate the number of frames.
+    frame_slices = thread_category_results[FrameTraceThread].all_slices
+    num_frames = self.CountSlices(frame_slices, FrameTraceName)
 
     # Report the desired results and details.
     for thread_results in thread_category_results.values():
       if thread_results.name in self.results_to_report:
         thread_results.AddResults(num_frames, results)
       # TOOD(nduca): When generic results objects are done, this special case
       # can be replaced with a generic UI feature.
       if thread_results.name in self.details_to_report:
         thread_results.AddDetailedResults(num_frames, results)