1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
#!/usr/bin/env python2
# -*- 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
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:]))
|
