def ValidateAndMeasurePage(self, page, tab, results): timeline_data = tab.browser.platform.tracing_controller.StopTracing() timeline_model = TimelineModel(timeline_data) threads = timeline_model.GetAllThreads() for thread in threads: if thread.name == _CR_RENDERER_MAIN: _AddTracingResults(thread, results)
def ValidateAndMeasurePage(self, page, tab, results): del page # unused trace_data = tab.browser.platform.tracing_controller.StopTracing()[0] timeline_model = TimelineModel(trace_data) renderer_process = timeline_model.GetFirstRendererProcess(tab.id) self._AddV8MetricsToResults(renderer_process, results)
def Stop(self, tab, results): # End the smooth marker for all actions. self._interaction.End() # Stop tracing. timeline_data = tab.browser.platform.tracing_controller.Stop() results.AddValue(trace.TraceValue( results.current_page, timeline_data)) self._model = TimelineModel(timeline_data) self._renderer_process = self._model.GetRendererProcessFromTabId(tab.id) renderer_thread = self.model.GetRendererThreadFromTabId(tab.id) run_smooth_actions_record = None self._smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) if r.label == RUN_SMOOTH_ACTIONS: assert run_smooth_actions_record is None, ( 'TimelineController cannot issue more than 1 %s record' % RUN_SMOOTH_ACTIONS) run_smooth_actions_record = r else: self._smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self.model, r)) # If there is no other smooth records, we make measurements on time range # marked by timeline_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(self._smooth_records) == 0 and run_smooth_actions_record: self._smooth_records = [run_smooth_actions_record]
def DidRunActions(self, page, tab): trace_data = tab.browser.platform.tracing_controller.Stop() timeline_model = TimelineModel(trace_data) self._renderer_process = timeline_model.GetRendererProcessFromTabId( tab.id) self._browser_process = timeline_model.browser_process
def ValidateAndMeasurePage(self, page, tab, results): trace_data = tab.browser.platform.tracing_controller.StopTracing() timeline_model = TimelineModel(trace_data) self._renderer_process = timeline_model.GetRendererProcessFromTabId( tab.id) self._browser_process = timeline_model.browser_process self._AddResults(results)
def Stop(self, tab): # End the smooth marker for all smooth actions. self._interaction.End() # Stop tracing for smoothness metric. if tab.browser.platform.IsRawDisplayFrameRateSupported(): tab.browser.platform.StopRawDisplayFrameRateMeasurement() self._tracing_timeline_data = tab.browser.StopTracing() self._timeline_model = TimelineModel( timeline_data=self._tracing_timeline_data)
def Stop(self, tab, results): # End the smooth marker for all actions. if self._enable_auto_issuing_record: self._interaction.End() # Stop tracing. timeline_data = tab.browser.platform.tracing_controller.StopTracing() # TODO(charliea): This is part of a three-sided Chromium/Telemetry patch # where we're changing the return type of StopTracing from a TraceValue to a # (TraceValue, nonfatal_exception_list) tuple. Once the tuple return value # lands in Chromium, the non-tuple logic should be deleted. if isinstance(timeline_data, tuple): timeline_data = timeline_data[0] # TODO(#763375): Rely on results.telemetry_info.trace_local_path/etc. kwargs = {} if hasattr(results.telemetry_info, 'trace_local_path'): kwargs['file_path'] = results.telemetry_info.trace_local_path kwargs['remote_path'] = results.telemetry_info.trace_remote_path kwargs['upload_bucket'] = results.telemetry_info.upload_bucket kwargs['cloud_url'] = results.telemetry_info.trace_remote_url results.AddValue( trace.TraceValue(results.current_page, timeline_data, **kwargs)) self._model = TimelineModel(timeline_data) self._renderer_process = self._model.GetRendererProcessFromTabId( tab.id) renderer_thread = self.model.GetRendererThreadFromTabId(tab.id) run_smooth_actions_record = None self._smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) if r.label == RUN_SMOOTH_ACTIONS: assert run_smooth_actions_record is None, ( 'TimelineController cannot issue more than 1 %s record' % RUN_SMOOTH_ACTIONS) run_smooth_actions_record = r else: self._smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self.model, r)) # If there is no other smooth records, we make measurements on time range # marked by timeline_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(self._smooth_records) == 0 and run_smooth_actions_record: self._smooth_records = [run_smooth_actions_record] if len(self._smooth_records) == 0: raise legacy_page_test.Failure( 'No interaction record was created.')
def _get_memory_usage(self): """Helper function to get the memory usage. It returns a tuple of six elements: (browser_usage, renderer_usage, gpu_usage, kernel_usage, total_usage, graphics_usage) All are expected in the unit of KB. browser_usage: the RSS of the browser process renderer_usage: the total RSS of all renderer processes gpu_usage: the total RSS of all gpu processes kernel_usage: the memory used in kernel total_usage: the sum of the above memory usages. The graphics_usage is not included because the composition of the graphics memory is much more complicated (could be from video card, user space, or kenerl space). It doesn't make so much sense to sum it up with others. graphics_usage: the memory usage reported by the graphics driver """ config = tracing_config.TracingConfig() config.chrome_trace_config.category_filter.AddExcludedCategory("*") config.chrome_trace_config.category_filter.AddDisabledByDefault( "disabled-by-default-memory-infra") config.chrome_trace_config.SetMemoryDumpConfig( chrome_trace_config.MemoryDumpConfig()) config.enable_chrome_trace = True self.browser.platform.tracing_controller.StartTracing(config) # Force to collect garbage before measuring memory for t in self.browser.tabs: t.CollectGarbage() self.browser.DumpMemory() trace_data = self.browser.platform.tracing_controller.StopTracing()[0] model = TimelineModel(trace_data) memory_dump = model.IterGlobalMemoryDumps().next() process_memory = collections.defaultdict(int) for process_memory_dump in memory_dump.IterProcessMemoryDumps(): process_name = process_memory_dump.process_name process_memory[process_name] += sum( process_memory_dump.GetMemoryUsage().values()) result = (process_memory[KEY_BROWSER] / 1024, process_memory[KEY_RENDERER] / 1024, process_memory[KEY_GPU] / 1024, _get_kernel_memory_usage()) # total = browser + renderer + gpu + kernal result += (sum(result), _get_graphics_memory_usage()) return result
def ValidateAndMeasurePage(self, page, tab, results): del page # unused trace_data = tab.browser.platform.tracing_controller.StopTracing() # TODO(charliea): This is part of a three-sided Chromium/Telemetry patch # where we're changing the return type of StopTracing from a TraceValue to a # (TraceValue, nonfatal_exception_list) tuple. Once the tuple return value # lands in Chromium, the non-tuple logic should be deleted. if isinstance(trace_data, tuple): trace_data = trace_data[0] timeline_model = TimelineModel(trace_data) renderer_process = timeline_model.GetRendererProcessFromTabId(tab.id) self._AddV8MetricsToResults(renderer_process, results)
class _OilpanGCTimesBase(page_test.PageTest): def __init__(self, action_name=''): super(_OilpanGCTimesBase, self).__init__(action_name) self._timeline_model = None def WillNavigateToPage(self, page, tab): # FIXME: Remove webkit.console when blink.console lands in chromium and # the ref builds are updated. crbug.com/386847 categories = ['webkit.console', 'blink.console', 'blink_gc'] category_filter = tracing_category_filter.TracingCategoryFilter() for c in categories: category_filter.AddIncludedCategory(c) options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.browser.platform.tracing_controller.Start(options, category_filter, timeout=1000) def DidRunActions(self, page, tab): timeline_data = tab.browser.platform.tracing_controller.Stop() self._timeline_model = TimelineModel(timeline_data) def ValidateAndMeasurePage(self, page, tab, results): threads = self._timeline_model.GetAllThreads() for thread in threads: if thread.name == _CR_RENDERER_MAIN: _AddTracingResults(thread.all_slices, results) def CleanUpAfterPage(self, page, tab): if tab.browser.platform.tracing_controller.is_tracing_running: tab.browser.platform.tracing_controller.Stop()
def testBrowserProcess(self): ri = tracing_timeline_data.TracingTimelineData( map(json.loads, [ '{"name": "process_name",' '"args": {"name": "Browser"},' '"pid": 5, "ph": "M"}', '{"name": "thread_name",' '"args": {"name": "CrBrowserMain"},' '"pid": 5, "tid": 32578, "ph": "M"}' ])) model = TimelineModel(ri) self.assertEquals(model.browser_process.pid, 5)
class SmoothnessController(object): def __init__(self): self._timeline_model = None self._trace_data = None self._interaction = None self._surface_flinger_trace_data = None def Start(self, page, tab): # FIXME: Remove webkit.console when blink.console lands in chromium and # the ref builds are updated. crbug.com/386847 custom_categories = ['webkit.console', 'blink.console', 'benchmark'] custom_categories += page.GetSyntheticDelayCategories() category_filter = tracing_category_filter.TracingCategoryFilter() for c in custom_categories: category_filter.AddIncludedCategory(c) options = tracing_options.TracingOptions() options.enable_chrome_trace = True options.enable_platform_display_trace = True tab.browser.platform.tracing_controller.Start(options, category_filter, 60) def Stop(self, tab): self._trace_data = tab.browser.platform.tracing_controller.Stop() self._timeline_model = TimelineModel(self._trace_data) def AddResults(self, tab, results): # Add results of smoothness metric. This computes the smoothness metric for # the time ranges of gestures, if there is at least one, else the the time # ranges from the first action to the last action. results.AddValue( trace.TraceValue(results.current_page, self._trace_data)) renderer_thread = self._timeline_model.GetRendererThreadFromTabId( tab.id) smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self._timeline_model, r)) # If there is no other smooth records, we make measurements on time range # marked smoothness_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(smooth_records) == 0: raise page_test.Failure('Page failed to issue any markers.') # Check to make sure all smooth records have same label and repeatable if # there are more than one. need_repeatable_flag = len(smooth_records) > 1 record_label = smooth_records[0].label for r in smooth_records: if r.label != record_label: raise page_test.Failure( 'SmoothController does not support multiple interactions with ' 'different label. Interactions: %s' % repr(smooth_records)) if need_repeatable_flag and not r.repeatable: raise page_test.Failure( 'If there are more than one interaction record, each interaction ' 'must has repeatable flag. Interactions: %s' % repr(smooth_records)) # Create an interaction_record for this legacy measurement. Since we don't # wrap the results that are sent to smoothness metric, the label will # not be used. smoothness_metric = smoothness.SmoothnessMetric() smoothness_metric.AddResults(self._timeline_model, renderer_thread, smooth_records, results) def CleanUp(self, tab): if tab.browser.platform.tracing_controller.is_tracing_running: tab.browser.platform.tracing_controller.Stop()
class TimelineController(object): def __init__(self): super(TimelineController, self).__init__() self.trace_categories = None self._model = None self._renderer_process = None self._smooth_records = [] self._interaction = None def SetUp(self, page, tab): """Starts gathering timeline data. """ # Resets these member variables incase this object is reused. self._model = None self._renderer_process = None if not tab.browser.platform.tracing_controller.IsChromeTracingSupported(): raise Exception('Not supported') category_filter = tracing_category_filter.TracingCategoryFilter( filter_string=self.trace_categories) for delay in page.GetSyntheticDelayCategories(): category_filter.AddSyntheticDelay(delay) options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.browser.platform.tracing_controller.Start(options, category_filter) def Start(self, tab): # Start the smooth marker for all actions. runner = action_runner.ActionRunner(tab) self._interaction = runner.CreateInteraction( RUN_SMOOTH_ACTIONS) self._interaction.Begin() def Stop(self, tab, results): # End the smooth marker for all actions. self._interaction.End() # Stop tracing. timeline_data = tab.browser.platform.tracing_controller.Stop() results.AddValue(trace.TraceValue( results.current_page, timeline_data)) self._model = TimelineModel(timeline_data) self._renderer_process = self._model.GetRendererProcessFromTabId(tab.id) renderer_thread = self.model.GetRendererThreadFromTabId(tab.id) run_smooth_actions_record = None self._smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) if r.label == RUN_SMOOTH_ACTIONS: assert run_smooth_actions_record is None, ( 'TimelineController cannot issue more than 1 %s record' % RUN_SMOOTH_ACTIONS) run_smooth_actions_record = r else: self._smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self.model, r)) # If there is no other smooth records, we make measurements on time range # marked by timeline_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(self._smooth_records) == 0 and run_smooth_actions_record: self._smooth_records = [run_smooth_actions_record] def CleanUp(self, tab): if tab.browser.platform.tracing_controller.is_tracing_running: tab.browser.platform.tracing_controller.Stop() @property def model(self): return self._model @property def renderer_process(self): return self._renderer_process @property def smooth_records(self): return self._smooth_records
class TimelineController(object): def __init__(self, enable_auto_issuing_record=True): super(TimelineController, self).__init__() self.trace_categories = None self._model = None self._renderer_process = None self._smooth_records = [] self._interaction = None self._enable_auto_issuing_record = enable_auto_issuing_record def SetUp(self, page, tab): """Starts gathering timeline data. """ del page # unused # Resets these member variables incase this object is reused. self._model = None self._renderer_process = None if not tab.browser.platform.tracing_controller.IsChromeTracingSupported( ): raise Exception('Not supported') config = tracing_config.TracingConfig() config.chrome_trace_config.category_filter.AddFilterString( self.trace_categories) config.enable_chrome_trace = True tab.browser.platform.tracing_controller.StartTracing(config) def Start(self, tab): # Start the smooth marker for all actions. if self._enable_auto_issuing_record: self._interaction = tab.action_runner.CreateInteraction( RUN_SMOOTH_ACTIONS) self._interaction.Begin() def Stop(self, tab, results): # End the smooth marker for all actions. if self._enable_auto_issuing_record: self._interaction.End() # Stop tracing. timeline_data = tab.browser.platform.tracing_controller.StopTracing() # TODO(#763375): Rely on results.telemetry_info.trace_local_path/etc. kwargs = {} if hasattr(results.telemetry_info, 'trace_local_path'): kwargs['file_path'] = results.telemetry_info.trace_local_path kwargs['remote_path'] = results.telemetry_info.trace_remote_path kwargs['upload_bucket'] = results.telemetry_info.upload_bucket kwargs['cloud_url'] = results.telemetry_info.trace_remote_url results.AddValue( trace.TraceValue(results.current_page, timeline_data, **kwargs)) self._model = TimelineModel(timeline_data) self._renderer_process = self._model.GetRendererProcessFromTabId( tab.id) renderer_thread = self.model.GetRendererThreadFromTabId(tab.id) run_smooth_actions_record = None self._smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) if r.label == RUN_SMOOTH_ACTIONS: assert run_smooth_actions_record is None, ( 'TimelineController cannot issue more than 1 %s record' % RUN_SMOOTH_ACTIONS) run_smooth_actions_record = r else: self._smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self.model, r)) # If there is no other smooth records, we make measurements on time range # marked by timeline_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(self._smooth_records) == 0 and run_smooth_actions_record: self._smooth_records = [run_smooth_actions_record] if len(self._smooth_records) == 0: raise legacy_page_test.Failure( 'No interaction record was created.') def CleanUp(self, platform): if platform.tracing_controller.is_tracing_running: platform.tracing_controller.StopTracing() @property def model(self): return self._model @property def renderer_process(self): return self._renderer_process @property def smooth_records(self): return self._smooth_records
class SmoothnessController(object): def __init__(self): self._timeline_model = None self._tracing_timeline_data = None self._interaction = None def SetUp(self, page, tab): # FIXME: Remove webkit.console when blink.console lands in chromium and # the ref builds are updated. crbug.com/386847 custom_categories = ['webkit.console', 'blink.console', 'benchmark'] custom_categories += page.GetSyntheticDelayCategories() category_filter = tracing_category_filter.TracingCategoryFilter() for c in custom_categories: category_filter.AddIncludedCategory(c) options = tracing_options.TracingOptions() options.enable_chrome_trace = True tab.browser.platform.tracing_controller.Start(options, category_filter, 60) if tab.browser.platform.IsRawDisplayFrameRateSupported(): tab.browser.platform.StartRawDisplayFrameRateMeasurement() def Start(self, tab): # Start the smooth marker for all smooth actions. runner = action_runner.ActionRunner(tab) self._interaction = runner.BeginInteraction(RUN_SMOOTH_ACTIONS, is_smooth=True) def Stop(self, tab): # End the smooth marker for all smooth actions. self._interaction.End() # Stop tracing for smoothness metric. if tab.browser.platform.IsRawDisplayFrameRateSupported(): tab.browser.platform.StopRawDisplayFrameRateMeasurement() self._tracing_timeline_data = tab.browser.platform.tracing_controller.Stop( ) self._timeline_model = TimelineModel( timeline_data=self._tracing_timeline_data) def AddResults(self, tab, results): # Add results of smoothness metric. This computes the smoothness metric for # the time ranges of gestures, if there is at least one, else the the time # ranges from the first action to the last action. renderer_thread = self._timeline_model.GetRendererThreadFromTabId( tab.id) run_smooth_actions_record = None smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) if r.label == RUN_SMOOTH_ACTIONS: assert run_smooth_actions_record is None, ( 'SmoothnessController cannot issue more than 1 %s record' % RUN_SMOOTH_ACTIONS) run_smooth_actions_record = r elif r.is_smooth: smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self._timeline_model, r)) # If there is no other smooth records, we make measurements on time range # marked smoothness_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(smooth_records) == 0: if run_smooth_actions_record is None: sys.stderr.write('Raw tracing data:\n') sys.stderr.write(repr(self._tracing_timeline_data.EventData())) sys.stderr.write('\n') raise Exception( 'SmoothnessController failed to issue markers for the ' 'whole interaction.') else: smooth_records = [run_smooth_actions_record] # Create an interaction_record for this legacy measurement. Since we don't # wrap the results that are sent to smoothness metric, the label will # not be used. smoothness_metric = smoothness.SmoothnessMetric() smoothness_metric.AddResults(self._timeline_model, renderer_thread, smooth_records, results) if tab.browser.platform.IsRawDisplayFrameRateSupported(): for r in tab.browser.platform.GetRawDisplayFrameRateMeasurements(): if r.value is None: raise MissingDisplayFrameRateError(r.name) if isinstance(r.value, list): results.AddValue( list_of_scalar_values.ListOfScalarValues( results.current_page, r.name, r.unit, r.value, description=DESCRIPTIONS.get(r.name))) else: results.AddValue( scalar.ScalarValue(results.current_page, r.name, r.unit, r.value, description=DESCRIPTIONS.get( r.name))) def CleanUp(self, tab): if tab.browser.platform.IsRawDisplayFrameRateSupported(): tab.browser.platform.StopRawDisplayFrameRateMeasurement() if tab.browser.platform.tracing_controller.is_tracing_running: tab.browser.platform.tracing_controller.Stop()
class TimelineController(object): def __init__(self): super(TimelineController, self).__init__() self.trace_categories = tracing_backend.DEFAULT_TRACE_CATEGORIES self._model = None self._renderer_process = None self._smooth_records = [] self._interaction = None def Start(self, page, tab): """Starts gathering timeline data. """ # Resets these member variables incase this object is reused. self._model = None self._renderer_process = None if not tab.browser.supports_tracing: raise Exception('Not supported') if self.trace_categories: categories = [self.trace_categories] + \ page.GetSyntheticDelayCategories() else: categories = page.GetSyntheticDelayCategories() tab.browser.StartTracing(','.join(categories)) # Start the smooth marker for all actions. runner = action_runner.ActionRunner(tab) self._interaction = runner.BeginInteraction(RUN_SMOOTH_ACTIONS, is_smooth=True) def Stop(self, tab): # End the smooth marker for all actions. self._interaction.End() # Stop tracing. timeline_data = tab.browser.StopTracing() self._model = TimelineModel(timeline_data) self._renderer_process = self._model.GetRendererProcessFromTabId( tab.id) renderer_thread = self.model.GetRendererThreadFromTabId(tab.id) run_smooth_actions_record = None self._smooth_records = [] for event in renderer_thread.async_slices: if not tir_module.IsTimelineInteractionRecord(event.name): continue r = tir_module.TimelineInteractionRecord.FromAsyncEvent(event) if r.logical_name == RUN_SMOOTH_ACTIONS: assert run_smooth_actions_record is None, ( 'TimelineController cannot issue more than 1 %s record' % RUN_SMOOTH_ACTIONS) run_smooth_actions_record = r elif r.is_smooth: self._smooth_records.append( smooth_gesture_util.GetAdjustedInteractionIfContainGesture( self.model, r)) # If there is no other smooth records, we make measurements on time range # marked by timeline_controller itself. # TODO(nednguyen): when crbug.com/239179 is marked fixed, makes sure that # page sets are responsible for issueing the markers themselves. if len(self._smooth_records) == 0 and run_smooth_actions_record: self._smooth_records = [run_smooth_actions_record] def CleanUp(self, tab): if tab.browser.is_tracing_running: tab.browser.StopTracing() @property def model(self): return self._model @property def renderer_process(self): return self._renderer_process @property def smooth_records(self): return self._smooth_records
def Stop(self, tab): # End the smooth marker for all smooth actions. self._interaction.End() self._trace_data = tab.browser.platform.tracing_controller.Stop() self._timeline_model = TimelineModel(self._trace_data)
def Stop(self, tab): self._trace_data = tab.browser.platform.tracing_controller.Stop() self._timeline_model = TimelineModel(self._trace_data)
def DidRunActions(self, page, tab): timeline_data = tab.browser.platform.tracing_controller.Stop() self._timeline_model = TimelineModel(timeline_data)