cc: Add compositor name for easier GPU debugging.

tools/perf/metrics/timeline.py

 # Copyright 2013 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
 
 from metrics import Metric
 
 TRACING_MODE = 'tracing-mode'
 TIMELINE_MODE = 'timeline-mode'
 
@@ skipping 79 matching lines @@
       total = sum(counter.totals)
       results.Add(counter_name, 'count', total)
       results.Add(counter_name + '_avg', 'count', total / len(counter.totals))
 
 
 # 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.
+MatchBySubString = ["IOThread", "CompositorRasterWorker"]
 TimelineThreadCategories =  {
-  # These are matched exactly
   "Chrome_InProcGpuThread": "GPU",
   "CrGPUMain"             : "GPU",
   "AsyncTransferThread"   : "GPU_transfer",
   "CrBrowserMain"         : "browser_main",
   "Browser Compositor"    : "browser_compositor",
   "CrRendererMain"        : "renderer_main",
   "Compositor"            : "renderer_compositor",
-  # These are matched by substring
   "IOThread"              : "IO",
   "CompositorRasterWorker": "raster"
 }
 
 def ThreadTimePercentageName(category):
   return "thread_" + category + "_clock_time_percentage"
 
 def ThreadCPUTimePercentageName(category):
   return "thread_" + category + "_cpu_time_percentage"
 
 class ThreadTimesTimelineMetric(TimelineMetric):
   def __init__(self):
     super(ThreadTimesTimelineMetric, self).__init__(TRACING_MODE)
 
   def AddResults(self, tab, results):
     # Default each category to zero for consistant results.
     category_clock_times = collections.defaultdict(float)
     category_cpu_times = collections.defaultdict(float)
 
     for category in TimelineThreadCategories.values():
       category_clock_times[category] = 0
       category_cpu_times[category] = 0
 
     # Add up thread time for all threads we care about.
     for thread in self._model.GetAllThreads():
       # First determine if we care about this thread.
       # Check substrings first, followed by exact matches
       thread_category = None
       for substring, category in TimelineThreadCategories.iteritems():
-        if substring in thread.name:
+        if substring in thread.name and substring in MatchBySubString:
           thread_category = category
       if thread.name in TimelineThreadCategories:
         thread_category = TimelineThreadCategories[thread.name]
       if thread_category == None:
         thread_category = "other"
 
       # Sum top-level durations and thread-durations
       have_thread_durations = True
       for event in thread.toplevel_slices:
         if not event.duration:
@@ skipping 17 matching lines @@
     for category, category_time in category_clock_times.iteritems():
       report_name = ThreadTimePercentageName(category)
       time_as_percentage = (category_time / self._model.bounds.bounds) * 100
       results.Add(report_name, '%', time_as_percentage)
 
     # Do the same for CPU (scheduled) time.
     for category, category_time in category_cpu_times.iteritems():
       report_name = ThreadCPUTimePercentageName(category)
       time_as_percentage = (category_time / self._model.bounds.bounds) * 100
       results.Add(report_name, '%', time_as_percentage)