| # 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 random |
| import unittest |
| |
| from metrics import smoothness |
| from metrics import statistics |
| from metrics import rendering_stats |
| from telemetry.core.backends.chrome.tracing_backend import RawTraceResultImpl |
| from telemetry.core.backends.chrome.trace_result import TraceResult |
| from telemetry.page import page |
| from telemetry.page.page_measurement_results import PageMeasurementResults |
| |
| SYNTHETIC_GESTURE_MARKER = 'SyntheticGestureController::running' |
| |
| |
| class MockTimer(object): |
| """A mock timer class which can generate random durations. |
| |
| An instance of this class is used as a global timer to generate random |
| durations for stats and consistent timestamps for all mock trace events. |
| """ |
| def __init__(self): |
| self.microseconds = 0 |
| |
| def Advance(self, low=0, high=100000): |
| duration = random.randint(low, high) |
| self.microseconds += duration |
| return duration |
| |
| |
| class MockFrame(object): |
| """Mocks rendering, texture and latency stats for a single frame.""" |
| def __init__(self, mock_timer): |
| """ Initialize the stats to random values """ |
| self.start = mock_timer.microseconds |
| self.main_stats = {} |
| self.impl_stats = {} |
| self.texture_stats = {} |
| self.latency_stats = {} |
| self.main_stats['frame_count'] = 0 |
| self.main_stats['paint_time'] = mock_timer.Advance() |
| self.main_stats['painted_pixel_count'] = random.randint(0, 2000000) |
| self.main_stats['record_time'] = mock_timer.Advance() |
| self.main_stats['recorded_pixel_count'] = random.randint(0, 2000000) |
| self.impl_stats['frame_count'] = 1 |
| self.impl_stats['rasterize_time'] = mock_timer.Advance() |
| self.impl_stats['rasterized_pixel_count'] = random.randint(0, 2000000) |
| self.end = mock_timer.microseconds |
| self.duration = self.end - self.start |
| |
| def AppendTraceEventForMainThreadStats(self, trace_events): |
| """Appends a trace event with the main thread stats. |
| |
| The trace event is a dict with the following keys: |
| 'name', |
| 'tts' (thread timestamp), |
| 'pid' (process id), |
| 'ts' (timestamp), |
| 'cat' (category), |
| 'tid' (thread id), |
| 'ph' (phase), |
| 'args' (a dict with the key 'data'). |
| This is related to src/base/debug/trace_event.h. |
| """ |
| event = {'name': 'MainThreadRenderingStats::IssueTraceEvent', |
| 'tts': self.end, |
| 'pid': 20978, |
| 'ts': self.end, |
| 'cat': 'benchmark', |
| 's': 't', |
| 'tid': 11, |
| 'ph': 'i', |
| 'args': {'data': self.main_stats}} |
| trace_events.append(event) |
| |
| def AppendTraceEventForImplThreadStats(self, trace_events): |
| """Appends a trace event with the impl thread stat.""" |
| event = {'name': 'ImplThreadRenderingStats::IssueTraceEvent', |
| 'tts': self.end, |
| 'pid': 20978, |
| 'ts': self.end, |
| 'cat': 'benchmark', |
| 's': 't', |
| 'tid': 11, |
| 'ph': 'i', |
| 'args': {'data': self.impl_stats}} |
| trace_events.append(event) |
| |
| |
| class SmoothnessMetricUnitTest(unittest.TestCase): |
| def testCalcResultsTraceEvents(self): |
| # Make the test repeatable by seeding the random number generator |
| # (which is used by the mock timer) with a constant number. |
| random.seed(1234567) |
| mock_timer = MockTimer() |
| trace_events = [] |
| total_time_seconds = 0.0 |
| num_frames_sent = 0.0 |
| first_frame = True |
| previous_frame_time = None |
| # This list represents time differences between frames in milliseconds. |
| expected_frame_times = [] |
| |
| # Append start trace events for the timeline marker and gesture marker, |
| # with some amount of time in between them. |
| trace_events.append({'name': rendering_stats.RENDER_PROCESS_MARKER, |
| 'tts': mock_timer.microseconds, |
| 'args': {}, |
| 'pid': 20978, |
| 'ts': mock_timer.microseconds, |
| 'cat': 'webkit', |
| 'tid': 11, |
| 'ph': 'S', # Phase: start. |
| 'id': '0x12345'}) |
| mock_timer.Advance() |
| trace_events.append({'name': SYNTHETIC_GESTURE_MARKER, |
| 'tts': mock_timer.microseconds, |
| 'args': {}, |
| 'pid': 20978, |
| 'ts': mock_timer.microseconds, |
| 'cat': 'webkit', |
| 'tid': 11, |
| 'ph': 'S', |
| 'id': '0xabcde'}) |
| |
| # Generate 100 random mock frames and append their trace events. |
| for _ in xrange(0, 100): |
| mock_frame = MockFrame(mock_timer) |
| mock_frame.AppendTraceEventForMainThreadStats(trace_events) |
| mock_frame.AppendTraceEventForImplThreadStats(trace_events) |
| # Exclude the first frame, because it may have started before the |
| # benchmark run. |
| if not first_frame: |
| total_time_seconds += mock_frame.duration / 1e6 |
| num_frames_sent += mock_frame.main_stats['frame_count'] |
| num_frames_sent += mock_frame.impl_stats['frame_count'] |
| first_frame = False |
| current_frame_time = mock_timer.microseconds / 1000.0 |
| if previous_frame_time: |
| difference = current_frame_time - previous_frame_time |
| difference = round(difference, 2) |
| expected_frame_times.append(difference) |
| previous_frame_time = current_frame_time |
| |
| # Append finish trace events for the timeline and gesture markers, in the |
| # reverse order from how they were added, with some time in between. |
| trace_events.append({'name': SYNTHETIC_GESTURE_MARKER, |
| 'tts': mock_timer.microseconds, |
| 'args': {}, |
| 'pid': 20978, |
| 'ts': mock_timer.microseconds, |
| 'cat': 'webkit', |
| 'tid': 11, |
| 'ph': 'F', # Phase: finish. |
| 'id': '0xabcde'}) |
| mock_timer.Advance() |
| trace_events.append({'name': rendering_stats.RENDER_PROCESS_MARKER, |
| 'tts': mock_timer.microseconds, |
| 'args': {}, |
| 'pid': 20978, |
| 'ts': mock_timer.microseconds, |
| 'cat': 'webkit', |
| 'tid': 11, |
| 'ph': 'F', |
| 'id': '0x12345'}) |
| |
| # Create a timeline object from the trace. |
| trace_impl = RawTraceResultImpl(trace_events) |
| trace_result = TraceResult(trace_impl) |
| timeline = trace_result.AsTimelineModel() |
| |
| # Find the timeline marker and gesture marker in the timeline, |
| # and create a RenderingStats object. |
| render_process_marker = timeline.FindTimelineMarkers( |
| rendering_stats.RENDER_PROCESS_MARKER) |
| timeline_markers = timeline.FindTimelineMarkers( |
| SYNTHETIC_GESTURE_MARKER) |
| stats = rendering_stats.RenderingStats( |
| render_process_marker, timeline_markers) |
| |
| # Make a results object and add results to it from the smoothness metric. |
| results = PageMeasurementResults() |
| results.WillMeasurePage(page.Page('http://foo.com/', None)) |
| smoothness_metric = smoothness.SmoothnessMetric(stats) |
| smoothness_metric.AddResults(None, results) |
| results.DidMeasurePage() |
| |
| self.assertEquals( |
| expected_frame_times, |
| results.page_results[0]['frame_times'].value) |
| self.assertAlmostEquals( |
| 1000.0 * (total_time_seconds / num_frames_sent), |
| results.page_results[0]['mean_frame_time'].value, |
| places=2) |
| |
| # We don't verify the correctness of the discrepancy computation itself, |
| # because we have a separate unit test for that purpose. |
| self.assertAlmostEquals( |
| statistics.FrameDiscrepancy(stats.frame_timestamps, True), |
| results.page_results[0]['jank'].value, |
| places=4) |
| |
| # We do not verify the correctness of Percentile here; Percentile should |
| # have its own test. |
| # The 17 here represents a threshold of 17 ms; this should match the value |
| # in the smoothness metric. |
| self.assertEquals( |
| statistics.Percentile(expected_frame_times, 95.0) < 17.0, |
| results.page_results[0]['mostly_smooth'].value) |
