| #!/usr/bin/env python3 |
| # -*- coding: utf-8 -*- |
| # Copyright 2015 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Wrapper to generate heat maps for chrome.""" |
| |
| from __future__ import print_function |
| |
| import argparse |
| import os |
| import shutil |
| import sys |
| import tempfile |
| |
| from cros_utils import command_executer |
| from heatmaps import heatmap_generator |
| |
| |
| def IsARepoRoot(directory): |
| """Returns True if directory is the root of a repo checkout.""" |
| return os.path.exists( |
| os.path.join(os.path.realpath(os.path.expanduser(directory)), '.repo')) |
| |
| |
| class HeatMapProducer(object): |
| """Class to produce heat map.""" |
| |
| def __init__(self, |
| chromeos_root, |
| perf_data, |
| hugepage, |
| binary, |
| title, |
| logger=None): |
| self.chromeos_root = os.path.realpath(os.path.expanduser(chromeos_root)) |
| self.perf_data = os.path.realpath(os.path.expanduser(perf_data)) |
| self.hugepage = hugepage |
| self.dir = os.path.dirname(os.path.realpath(__file__)) |
| self.binary = binary |
| self.ce = command_executer.GetCommandExecuter() |
| self.temp_dir = '' |
| self.temp_perf_inchroot = '' |
| self.temp_dir_created = False |
| self.perf_report = '' |
| self.title = title |
| self.logger = logger |
| |
| def _EnsureFileInChroot(self): |
| chroot_prefix = os.path.join(self.chromeos_root, 'chroot') |
| if self.perf_data.startswith(chroot_prefix): |
| # If the path to perf_data starts with the same chromeos_root, assume |
| # it's in the chromeos_root so no need for temporary directory and copy. |
| self.temp_dir = self.perf_data.replace('perf.data', '') |
| self.temp_perf_inchroot = self.temp_dir.replace(chroot_prefix, '') |
| |
| else: |
| # Otherwise, create a temporary directory and copy perf.data into chroot. |
| self.temp_dir = tempfile.mkdtemp( |
| prefix=os.path.join(self.chromeos_root, 'src/')) |
| temp_perf = os.path.join(self.temp_dir, 'perf.data') |
| shutil.copy2(self.perf_data, temp_perf) |
| self.temp_perf_inchroot = os.path.join('~/trunk/src', |
| os.path.basename(self.temp_dir)) |
| self.temp_dir_created = True |
| |
| def _GeneratePerfReport(self): |
| cmd = ('cd %s && perf report -D -i perf.data > perf_report.txt' % |
| self.temp_perf_inchroot) |
| retval = self.ce.ChrootRunCommand(self.chromeos_root, cmd) |
| if retval: |
| raise RuntimeError('Failed to generate perf report') |
| self.perf_report = os.path.join(self.temp_dir, 'perf_report.txt') |
| |
| def _GetHeatMap(self, top_n_pages): |
| generator = heatmap_generator.HeatmapGenerator( |
| perf_report=self.perf_report, |
| page_size=4096, |
| hugepage=self.hugepage, |
| title=self.title) |
| generator.draw() |
| # Analyze top N hottest symbols with the binary, if provided |
| if self.binary: |
| generator.analyze(self.binary, top_n_pages) |
| |
| def _RemoveFiles(self): |
| files = [ |
| 'out.txt', 'inst-histo.txt', 'inst-histo-hp.txt', 'inst-histo-sp.txt' |
| ] |
| for f in files: |
| if os.path.exists(f): |
| os.remove(f) |
| |
| def Run(self, top_n_pages): |
| try: |
| self._EnsureFileInChroot() |
| self._GeneratePerfReport() |
| self._GetHeatMap(top_n_pages) |
| finally: |
| self._RemoveFiles() |
| msg = ('heat map and time histogram genereated in the current ' |
| 'directory with name heat_map.png and timeline.png ' |
| 'accordingly.') |
| if self.binary: |
| msg += ('\nThe hottest %d pages inside and outside hugepage ' |
| 'is symbolized and saved to addr2symbol.txt' % top_n_pages) |
| if self.logger: |
| self.logger.LogOutput(msg) |
| else: |
| print(msg) |
| |
| |
| def main(argv): |
| """Parse the options. |
| |
| Args: |
| argv: The options with which this script was invoked. |
| |
| Returns: |
| 0 unless an exception is raised. |
| """ |
| parser = argparse.ArgumentParser() |
| |
| parser.add_argument( |
| '--chromeos_root', |
| dest='chromeos_root', |
| required=True, |
| help='ChromeOS root to use for generate heatmaps.') |
| parser.add_argument( |
| '--perf_data', |
| dest='perf_data', |
| required=True, |
| help='The raw perf data. Must be collected with -e instructions while ' |
| 'disabling ASLR.') |
| parser.add_argument( |
| '--binary', |
| dest='binary', |
| help='The path to the Chrome binary. Only useful if want to print ' |
| 'symbols on hottest pages', |
| default=None) |
| parser.add_argument( |
| '--top_n', |
| dest='top_n', |
| type=int, |
| default=10, |
| help='Print out top N hottest pages within/outside huge page range. ' |
| 'Must be used with --hugepage and --binary. (Default: %(default)s)') |
| parser.add_argument( |
| '--title', dest='title', help='Title of the heatmap', default='') |
| parser.add_argument( |
| '--hugepage', |
| dest='hugepage', |
| help='A range of addresses (start,end) where huge page starts and ends' |
| ' in text section, separated by a comma.' |
| ' Used to differentiate regions in heatmap.' |
| ' Example: --hugepage=0,4096' |
| ' If not specified, no effect on the heatmap.', |
| default=None) |
| |
| options = parser.parse_args(argv) |
| |
| if not IsARepoRoot(options.chromeos_root): |
| parser.error('%s does not contain .repo dir.' % options.chromeos_root) |
| |
| if not os.path.isfile(options.perf_data): |
| parser.error('Cannot find perf_data: %s.' % options.perf_data) |
| |
| hugepage_range = None |
| if options.hugepage: |
| hugepage_range = options.hugepage.split(',') |
| if len(hugepage_range) != 2 or \ |
| int(hugepage_range[0]) > int(hugepage_range[1]): |
| parser.error('Wrong format of hugepage range: %s' % options.hugepage) |
| hugepage_range = [int(x) for x in hugepage_range] |
| |
| heatmap_producer = HeatMapProducer(options.chromeos_root, options.perf_data, |
| hugepage_range, options.binary, |
| options.title) |
| |
| heatmap_producer.Run(options.top_n) |
| |
| |
| if __name__ == '__main__': |
| sys.exit(main(sys.argv[1:])) |
