Rough prototype of deferred TBM results processing.

telemetry/telemetry/web_perf/timeline_based_measurement.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 logging
 from collections import defaultdict
+import threading
 
 from tracing.metrics import metric_runner
 
 from telemetry.timeline import chrome_trace_category_filter
 from telemetry.timeline import model as model_module
 from telemetry.timeline import tracing_config
 from telemetry.value import trace
 from telemetry.value import common_value_helpers
 from telemetry.web_perf.metrics import timeline_based_metric
 from telemetry.web_perf.metrics import blob_timeline
@@ skipping 49 matching lines @@
     self._results = None
 
   def SetResults(self, results):
     self._results = results
 
   def SetTirLabel(self, tir_label):
     self._tir_label = tir_label
 
   @property
   def current_page(self):
-    return self._results.current_page
+    return self._results.story
 
   def AddValue(self, value):
     raise NotImplementedError
 
 
 class _TBMResultWrapper(ResultsWrapperInterface):
   def AddValue(self, value):
     assert self._tir_label
     if value.tir_label:
       assert value.tir_label == self._tir_label
@@ skipping 190 matching lines @@
     if self._tbm_options.config.enable_chrome_trace:
       # Always enable 'blink.console' category for:
       # 1) Backward compat of chrome clock sync (crbug.com/646925)
       # 2) Allows users to add trace event through javascript.
       # Note that blink.console is extremely low-overhead, so this doesn't
       # affect the tracing overhead budget much.
       chrome_config = self._tbm_options.config.chrome_trace_config
       chrome_config.category_filter.AddIncludedCategory('blink.console')
     platform.tracing_controller.StartTracing(self._tbm_options.config)
 
-  def Measure(self, platform, results):
-    """Collect all possible metrics and added them to results."""
-    platform.tracing_controller.telemetry_info = results.telemetry_info
-    trace_result = platform.tracing_controller.StopTracing()
-    trace_value = trace.TraceValue(results.current_page, trace_result)
-    results.AddValue(trace_value)
+  def MeasureWorker(self, page_run, trace_result):
+    logging.warn('Running MeasureWorker for %s' % page_run.story.display_name)
+
+    trace_value = trace.TraceValue(page_run.story, trace_result)
+    page_run.AddValue(trace_value)
 
     try:
       if self._tbm_options.GetTimelineBasedMetrics():
         assert not self._tbm_options.GetLegacyTimelineBasedMetrics(), (
             'Specifying both TBMv1 and TBMv2 metrics is not allowed.')
-        self._ComputeTimelineBasedMetrics(results, trace_value)
+        logging.warn('running _ComputeTimelineBasedMetrics')
+        self._ComputeTimelineBasedMetrics(page_run, trace_value)
       else:
         # Run all TBMv1 metrics if no other metric is specified
         # (legacy behavior)
+        logging.warn('running legacy metrics')
         if not self._tbm_options.GetLegacyTimelineBasedMetrics():
           logging.warn('Please specify the TBMv1 metrics you are interested in '
                        'explicitly. This implicit functionality will be removed'
                        ' on July 17, 2016.')
           self._tbm_options.SetLegacyTimelineBasedMetrics(
               _GetAllLegacyTimelineBasedMetrics())
-        self._ComputeLegacyTimelineBasedMetrics(results, trace_result)
+        self._ComputeLegacyTimelineBasedMetrics(page_run, trace_result)
     finally:
       trace_result.CleanUpAllTraces()
 
+
+  def Measure(self, platform, results):
+    """Collect all possible metrics and added them to results."""
+    platform.tracing_controller.telemetry_info = results.telemetry_info
+    trace_result = platform.tracing_controller.StopTracing()
+
+    page_run = results.current_page_run
+    thread = threading.Thread(target=TimelineBasedMeasurement.MeasureWorker,
+                              args=(self, page_run, trace_result,))
+    page_run.AddResultThread(thread)
+    thread.start()
+
   def DidRunStory(self, platform):
     """Clean up after running the story."""
     if platform.tracing_controller.is_tracing_running:
       platform.tracing_controller.StopTracing()
 
   def _ComputeTimelineBasedMetrics(self, results, trace_value):
     metrics = self._tbm_options.GetTimelineBasedMetrics()
     extra_import_options = {
       'trackDetailedModelStats': True
     }
@@ skipping 27 matching lines @@
 
     for renderer_thread, interaction_records in (
         threads_to_records_map.iteritems()):
       meta_metrics = _TimelineBasedMetrics(
           model, renderer_thread, interaction_records, self._results_wrapper,
           all_metrics)
       meta_metrics.AddResults(results)
 
     for metric in all_metrics:
       metric.AddWholeTraceResults(model, results)