| #!/usr/bin/env vpython3 |
| # Copyright 2017 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Tests for process_profiles.py.""" |
| |
| import collections |
| import unittest |
| |
| import process_profiles |
| |
| from test_utils import (ProfileFile, |
| SimpleTestSymbol, |
| TestSymbolOffsetProcessor, |
| TestProfileManager) |
| |
| class ProcessProfilesTestCase(unittest.TestCase): |
| START_SYMBOL = 'linker_script_start_of_text' |
| |
| def setUp(self): |
| self.symbol_0 = SimpleTestSymbol(self.START_SYMBOL, 0, 0) |
| self.symbol_1 = SimpleTestSymbol('1', 6, 16) |
| self.symbol_2 = SimpleTestSymbol('2', 32, 8) |
| self.symbol_3 = SimpleTestSymbol('3', 40, 12) |
| self.offset_to_symbol_info = ( |
| [None] * 3 + [self.symbol_1] * 8 + [None] * 5 + [self.symbol_2] * 4 + |
| [self.symbol_3] * 6) |
| self.symbol_infos = [self.symbol_0, self.symbol_1, |
| self.symbol_2, self.symbol_3] |
| self._file_counter = 0 |
| |
| def MakeAnnotatedOffset(self, offset, counts): |
| ao = process_profiles.ProfileManager.AnnotatedOffset(offset) |
| ao._count = counts |
| return ao |
| |
| def testGetOffsetToSymbolInfo(self): |
| processor = TestSymbolOffsetProcessor(self.symbol_infos) |
| self.assertListEqual(self.offset_to_symbol_info, |
| processor.GetDumpOffsetToSymbolInfo()) |
| |
| def testOverlappingSymbols(self): |
| symbol_1 = SimpleTestSymbol(self.START_SYMBOL, 6, 8) |
| symbol_2 = SimpleTestSymbol('2', 10, 10) |
| processor = TestSymbolOffsetProcessor([symbol_1, symbol_2]) |
| self.assertListEqual([symbol_1] * 4 + [symbol_2] * 3, |
| processor.GetDumpOffsetToSymbolInfo()) |
| |
| def testSymbolsBeforeStart(self): |
| self.symbol_infos = [SimpleTestSymbol(s.name, s.offset + 8, s.size) |
| for s in self.symbol_infos] |
| self.symbol_infos.append(SimpleTestSymbol('early', 0, 4)) |
| processor = TestSymbolOffsetProcessor(self.symbol_infos) |
| self.assertRaises(AssertionError, processor.GetDumpOffsetToSymbolInfo) |
| |
| def testGetReachedOffsetsFromDump(self): |
| processor = TestSymbolOffsetProcessor(self.symbol_infos) |
| # 2 hits for symbol_1, 0 for symbol_2, 1 for symbol_3 |
| dump = [8, 12, 48] |
| reached = processor.GetReachedOffsetsFromDump(dump) |
| self.assertListEqual([self.symbol_1.offset, self.symbol_3.offset], reached) |
| # Ordering matters, no repetitions |
| dump = [48, 12, 8, 12, 8, 16] |
| reached = processor.GetReachedOffsetsFromDump(dump) |
| self.assertListEqual([self.symbol_3.offset, self.symbol_1.offset], reached) |
| |
| def testSymbolNameToPrimary(self): |
| symbol_infos = [SimpleTestSymbol('1', 8, 16), |
| SimpleTestSymbol('AnAlias', 8, 16), |
| SimpleTestSymbol('Another', 40, 16)] |
| processor = TestSymbolOffsetProcessor(symbol_infos) |
| self.assertDictEqual({8: symbol_infos[0], |
| 40: symbol_infos[2]}, processor.OffsetToPrimaryMap()) |
| |
| def testGetOrderedSymbols(self): |
| processor = TestSymbolOffsetProcessor(self.symbol_infos) |
| self.assertListEqual(['1', '3', self.START_SYMBOL], |
| processor.GetOrderedSymbols([7, 41, 5, 0])) |
| |
| def testOffsetToSymbolsMap(self): |
| symbol_infos = [SimpleTestSymbol('1', 8, 16), |
| SimpleTestSymbol('AnAlias', 8, 16), |
| SimpleTestSymbol('Another', 40, 16)] |
| processor = TestSymbolOffsetProcessor(symbol_infos) |
| self.assertDictEqual({8: [symbol_infos[0], symbol_infos[1]], |
| 40: [symbol_infos[2]]}, |
| processor.OffsetToSymbolsMap()) |
| |
| def testPrimarySizeMismatch(self): |
| symbol_infos = [SimpleTestSymbol('1', 8, 16), |
| SimpleTestSymbol('AnAlias', 8, 32)] |
| processor = TestSymbolOffsetProcessor(symbol_infos) |
| self.assertRaises(AssertionError, processor.OffsetToPrimaryMap) |
| symbol_infos = [SimpleTestSymbol('1', 8, 0), |
| SimpleTestSymbol('2', 8, 32), |
| SimpleTestSymbol('3', 8, 32), |
| SimpleTestSymbol('4', 8, 0),] |
| processor = TestSymbolOffsetProcessor(symbol_infos) |
| self.assertDictEqual({8: symbol_infos[1]}, processor.OffsetToPrimaryMap()) |
| |
| def testMatchSymbols(self): |
| symbols = [SimpleTestSymbol('W', 30, 10), |
| SimpleTestSymbol('Y', 60, 5), |
| SimpleTestSymbol('X', 100, 10)] |
| processor = TestSymbolOffsetProcessor(symbols) |
| self.assertListEqual(sorted(symbols[1:3]), |
| processor.MatchSymbolNames(['Y', 'X'])) |
| |
| def testSymbolsSize(self): |
| symbols = [SimpleTestSymbol('W', 10, 1), |
| SimpleTestSymbol('X', 20, 2), |
| SimpleTestSymbol('Y', 30, 4), |
| SimpleTestSymbol('Z', 40, 8)] |
| processor = TestSymbolOffsetProcessor(symbols) |
| self.assertEqual(13, processor.SymbolsSize(['W', 'Y', 'Z'])) |
| |
| def testMedian(self): |
| self.assertEquals(None, process_profiles._Median([])) |
| self.assertEquals(5, process_profiles._Median([5])) |
| self.assertEquals(5, process_profiles._Median([1, 5, 20])) |
| self.assertEquals(5, process_profiles._Median([4, 6])) |
| self.assertEquals(5, process_profiles._Median([1, 4, 6, 100])) |
| self.assertEquals(5, process_profiles._Median([1, 4, 5, 6, 100])) |
| |
| def testRunGroups(self): |
| files = [ProfileFile(40, 0), ProfileFile(100, 0), |
| ProfileFile(200, 1), ProfileFile(35, 1), |
| ProfileFile(42, 0), ProfileFile(95, 0)] |
| mgr = process_profiles.ProfileManager(files) |
| mgr._ComputeRunGroups() |
| self.assertEquals(3, len(mgr._run_groups)) |
| self.assertEquals(3, len(mgr._run_groups[0].Filenames())) |
| self.assertEquals(2, len(mgr._run_groups[1].Filenames())) |
| self.assertEquals(1, len(mgr._run_groups[2].Filenames())) |
| self.assertTrue(files[0] in mgr._run_groups[0].Filenames()) |
| self.assertTrue(files[3] in mgr._run_groups[0].Filenames()) |
| self.assertTrue(files[4] in mgr._run_groups[0].Filenames()) |
| self.assertTrue(files[1] in mgr._run_groups[1].Filenames()) |
| self.assertTrue(files[5] in mgr._run_groups[1].Filenames()) |
| self.assertTrue(files[2] in mgr._run_groups[2].Filenames()) |
| |
| def testRunGroupSanity(self): |
| files = [] |
| # Generate 20 sets of files in groups separated by 60s. |
| for ts_base in range(0, 20): |
| ts = ts_base * 60 |
| files.extend([ProfileFile(ts, 0, 'browser'), |
| ProfileFile(ts + 1, 0, 'renderer'), |
| ProfileFile(ts + 2, 1, 'browser'), |
| ProfileFile(ts + 3, 0, 'gpu'), |
| ProfileFile(ts + 2, 1, 'renderer'), |
| ProfileFile(ts + 5, 1, 'gpu')]) |
| # The following call should not assert. |
| process_profiles.ProfileManager(files)._ComputeRunGroups() |
| |
| files.extend([ |
| ProfileFile(20 * 60, 0, 'browser'), |
| ProfileFile(20 * 60 + 2, 1, 'renderer'), |
| ProfileFile(21 * 60, 0, 'browser') |
| ] + [ProfileFile(22 * 60, 0, 'renderer') for _ in range(0, 10)]) |
| |
| self.assertRaises(AssertionError, |
| process_profiles.ProfileManager(files)._ComputeRunGroups) |
| |
| def testReadOffsets(self): |
| mgr = TestProfileManager({ |
| ProfileFile(30, 0): [1, 3, 5, 7], |
| ProfileFile(40, 1): [8, 10], |
| ProfileFile(50, 0): [13, 15]}) |
| self.assertListEqual([1, 3, 5, 7, 8, 10, 13, 15], |
| mgr.GetMergedOffsets()) |
| self.assertListEqual([8, 10], mgr.GetMergedOffsets(1)) |
| self.assertListEqual([], mgr.GetMergedOffsets(2)) |
| |
| def testRunGroupOffsets(self): |
| mgr = TestProfileManager({ |
| ProfileFile(30, 0): [1, 2, 3, 4], |
| ProfileFile(150, 0): [9, 11, 13], |
| ProfileFile(40, 1): [5, 6, 7]}) |
| offsets_list = mgr.GetRunGroupOffsets() |
| self.assertEquals(2, len(offsets_list)) |
| self.assertListEqual([1, 2, 3, 4, 5, 6, 7], offsets_list[0]) |
| self.assertListEqual([9, 11, 13], offsets_list[1]) |
| offsets_list = mgr.GetRunGroupOffsets(0) |
| self.assertEquals(2, len(offsets_list)) |
| self.assertListEqual([1, 2, 3, 4], offsets_list[0]) |
| self.assertListEqual([9, 11, 13], offsets_list[1]) |
| offsets_list = mgr.GetRunGroupOffsets(1) |
| self.assertEquals(2, len(offsets_list)) |
| self.assertListEqual([5, 6, 7], offsets_list[0]) |
| self.assertListEqual([], offsets_list[1]) |
| |
| def testSorted(self): |
| # The fact that the ProfileManager sorts by filename is implicit in the |
| # other tests. It is tested explicitly here. |
| mgr = TestProfileManager({ |
| ProfileFile(40, 0): [1, 2, 3, 4], |
| ProfileFile(150, 0): [9, 11, 13], |
| ProfileFile(30, 1): [5, 6, 7]}) |
| offsets_list = mgr.GetRunGroupOffsets() |
| self.assertEquals(2, len(offsets_list)) |
| self.assertListEqual([5, 6, 7, 1, 2, 3, 4], offsets_list[0]) |
| |
| def testPhases(self): |
| mgr = TestProfileManager({ |
| ProfileFile(40, 0): [], |
| ProfileFile(150, 0): [], |
| ProfileFile(30, 1): [], |
| ProfileFile(30, 2): [], |
| ProfileFile(30, 0): []}) |
| self.assertEquals(set([0,1,2]), mgr.GetPhases()) |
| |
| def testGetAnnotatedOffsets(self): |
| mgr = TestProfileManager({ |
| ProfileFile(40, 0, ''): [1, 2, 3], |
| ProfileFile(50, 1, ''): [3, 4, 5], |
| ProfileFile(51, 0, 'renderer'): [2, 3, 6], |
| ProfileFile(51, 1, 'gpu-process'): [6, 7], |
| ProfileFile(70, 0, ''): [2, 8, 9], |
| ProfileFile(70, 1, ''): [9]}) |
| offsets = list(mgr.GetAnnotatedOffsets()) |
| self.assertListEqual([ |
| self.MakeAnnotatedOffset(1, {(0, 'browser'): 1}), |
| self.MakeAnnotatedOffset(2, {(0, 'browser'): 2, |
| (0, 'renderer'): 1}), |
| self.MakeAnnotatedOffset(3, {(0, 'browser'): 1, |
| (1, 'browser'): 1, |
| (0, 'renderer'): 1}), |
| self.MakeAnnotatedOffset(4, {(1, 'browser'): 1}), |
| self.MakeAnnotatedOffset(5, {(1, 'browser'): 1}), |
| self.MakeAnnotatedOffset(6, {(0, 'renderer'): 1, |
| (1, 'gpu-process'): 1}), |
| self.MakeAnnotatedOffset(7, {(1, 'gpu-process'): 1}), |
| self.MakeAnnotatedOffset(8, {(0, 'browser'): 1}), |
| self.MakeAnnotatedOffset(9, {(0, 'browser'): 1, |
| (1, 'browser'): 1})], |
| offsets) |
| self.assertListEqual(['browser', 'renderer'], |
| sorted(offsets[1].Processes())) |
| self.assertListEqual(['browser'], list(offsets[0].Processes())) |
| self.assertListEqual([0], list(offsets[1].Phases())) |
| self.assertListEqual([0, 1], sorted(offsets[2].Phases())) |
| self.assertListEqual([0, 1], sorted(mgr.GetPhases())) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
