Example #1
0
    def AddResults(self, _, renderer_thread, interaction_records, results):
        self.VerifyNonOverlappedRecords(interaction_records)
        try:
            jank_stats = mainthread_jank_stats.MainthreadJankStats(
                renderer_thread, interaction_records)
        # TODO(nednguyen): maybe fall back to use wall-time for computing the
        # metrics.
        except tir_module.NoThreadTimeDataException as e:
            #TODO(nednguyen): Report the warning with page_results system.
            logging.warning(
                'Main thread jank metrics cannot be computed for records %s since '
                'trace does not contain thread time data. %s',
                repr(interaction_records), repr(e))
            return

        results.AddValue(
            scalar.ScalarValue(
                results.current_page,
                'responsive-total_big_jank_thread_time',
                'ms',
                jank_stats.total_big_jank_thread_time,
                tir_label=interaction_records[0].label,
                improvement_direction=improvement_direction.DOWN))
        results.AddValue(
            scalar.ScalarValue(
                results.current_page,
                'responsive-biggest_jank_thread_time',
                'ms',
                jank_stats.biggest_jank_thread_time,
                tir_label=interaction_records[0].label,
                improvement_direction=improvement_direction.DOWN))
Example #2
0
    def testMainthreadJankStats(self):
        # [ MessageLoop::RunTask]  [MessageLoop::RunTask]  [MessagLoop::RunTask]
        # 10                   100 120                 400 450                750
        #     [  record_1  ]       [  record_2  ]   [            record_3        ]
        #     40          70      120          200  220                         900

        model = model_module.TimelineModel()
        renderer_main = model.GetOrCreateProcess(1).GetOrCreateThread(2)
        renderer_main.name = 'CrRendererMain'

        #   [     MessageLoop::RunTask  ]
        #   10ms                       100ms
        renderer_main.BeginSlice('toplevel', 'MessageLoop::RunTask', 12, 10)
        renderer_main.EndSlice(120, 100)

        #   [     MessageLoop::RunTask  ]
        #   120ms                      200ms
        renderer_main.BeginSlice('toplevel', 'MessageLoop::RunTask', 115, 120)
        renderer_main.EndSlice(410, 400)

        #   [     MessageLoop::RunTask  ]
        #  220ms                       900ms
        renderer_main.BeginSlice('toplevel', 'MessageLoop::RunTask', 477, 450)
        renderer_main.EndSlice(772, 750)

        model.FinalizeImport(shift_world_to_zero=False)

        test_records = [
            self.CreateTestRecord('record_1', 10, 80, 40, 70, renderer_main),
            self.CreateTestRecord('record_2', 100, 210, 120, 200,
                                  renderer_main),
            self.CreateTestRecord('record_3', 215, 920, 220, 900,
                                  renderer_main)
        ]

        stats = mainthread_jank_stats.MainthreadJankStats(
            renderer_main, test_records)
        # Main thread janks covered by records' ranges are:
        # Record 1: (40ms -> 70ms)
        # Record 2: (120ms -> 200ms)
        # Record 3: (220ms -> 400ms), (450ms -> 750ms)
        self.assertEquals(560, stats.total_big_jank_thread_time)
        self.assertEquals(300, stats.biggest_jank_thread_time)