sadmen
/
openpilot_comma
mirror of https://github.com/commaai/openpilot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
openpilot is an open source driver assistance system. openpilot performs the functions of Automated Lane Centering and Adaptive Cruise Control for over 200 supported car makes and models.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1028 Commits
123 Branches
82 Tags
5.0 GiB
 
 
 
 
 
 
Tag: Branch: Tree: f3dcf861c7
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f3dcf861c7'
${ noResults }
openpilot_comma/external/simpleperf/utils.py

677 lines
24 KiB
Raw Blame History

#!/usr/bin/env python3
#
# Copyright (C) 2016 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""utils.py: export utility functions.
"""
from __future__ import print_function
import logging
import os
import os.path
import re
import shutil
import subprocess
import sys
import time
def get_script_dir():
return os.path.dirname(os.path.realpath(__file__))
def is_windows():
return sys.platform == 'win32' or sys.platform == 'cygwin'
def is_darwin():
return sys.platform == 'darwin'
def get_platform():
if is_windows():
return 'windows'
if is_darwin():
return 'darwin'
return 'linux'
def is_python3():
return sys.version_info >= (3, 0)
def log_debug(msg):
logging.debug(msg)
def log_info(msg):
logging.info(msg)
def log_warning(msg):
logging.warning(msg)
def log_fatal(msg):
raise Exception(msg)
def log_exit(msg):
sys.exit(msg)
def disable_debug_log():
logging.getLogger().setLevel(logging.WARN)
def str_to_bytes(str):
if not is_python3():
return str
# In python 3, str are wide strings whereas the C api expects 8 bit strings,
# hence we have to convert. For now using utf-8 as the encoding.
return str.encode('utf-8')
def bytes_to_str(bytes):
if not is_python3():
return bytes
return bytes.decode('utf-8')
def get_target_binary_path(arch, binary_name):
if arch == 'aarch64':
arch = 'arm64'
arch_dir = os.path.join(get_script_dir(), "bin", "android", arch)
if not os.path.isdir(arch_dir):
log_fatal("can't find arch directory: %s" % arch_dir)
binary_path = os.path.join(arch_dir, binary_name)
if not os.path.isfile(binary_path):
log_fatal("can't find binary: %s" % binary_path)
return binary_path
def get_host_binary_path(binary_name):
dir = os.path.join(get_script_dir(), 'bin')
if is_windows():
if binary_name.endswith('.so'):
binary_name = binary_name[0:-3] + '.dll'
elif '.' not in binary_name:
binary_name += '.exe'
dir = os.path.join(dir, 'windows')
elif sys.platform == 'darwin': # OSX
if binary_name.endswith('.so'):
binary_name = binary_name[0:-3] + '.dylib'
dir = os.path.join(dir, 'darwin')
else:
dir = os.path.join(dir, 'linux')
dir = os.path.join(dir, 'x86_64' if sys.maxsize > 2 ** 32 else 'x86')
binary_path = os.path.join(dir, binary_name)
if not os.path.isfile(binary_path):
log_fatal("can't find binary: %s" % binary_path)
return binary_path
def is_executable_available(executable, option='--help'):
""" Run an executable to see if it exists. """
try:
subproc = subprocess.Popen([executable, option], stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
subproc.communicate()
return subproc.returncode == 0
except:
return False
DEFAULT_NDK_PATH = {
'darwin': 'Library/Android/sdk/ndk-bundle',
'linux': 'Android/Sdk/ndk-bundle',
'windows': 'AppData/Local/Android/sdk/ndk-bundle',
}
EXPECTED_TOOLS = {
'adb': {
'is_binutils': False,
'test_option': 'version',
'path_in_ndk': '../platform-tools/adb',
},
'readelf': {
'is_binutils': True,
'accept_tool_without_arch': True,
},
'addr2line': {
'is_binutils': True,
'accept_tool_without_arch': True
},
'objdump': {
'is_binutils': True,
},
}
def _get_binutils_path_in_ndk(toolname, arch, platform):
if not arch:
arch = 'arm64'
if arch == 'arm64':
name = 'aarch64-linux-android-' + toolname
path = 'toolchains/aarch64-linux-android-4.9/prebuilt/%s-x86_64/bin/%s' % (platform, name)
elif arch == 'arm':
name = 'arm-linux-androideabi-' + toolname
path = 'toolchains/arm-linux-androideabi-4.9/prebuilt/%s-x86_64/bin/%s' % (platform, name)
elif arch == 'x86_64':
name = 'x86_64-linux-android-' + toolname
path = 'toolchains/x86_64-4.9/prebuilt/%s-x86_64/bin/%s' % (platform, name)
elif arch == 'x86':
name = 'i686-linux-android-' + toolname
path = 'toolchains/x86-4.9/prebuilt/%s-x86_64/bin/%s' % (platform, name)
else:
log_fatal('unexpected arch %s' % arch)
return (name, path)
def find_tool_path(toolname, ndk_path=None, arch=None):
if toolname not in EXPECTED_TOOLS:
return None
tool_info = EXPECTED_TOOLS[toolname]
is_binutils = tool_info['is_binutils']
test_option = tool_info.get('test_option', '--help')
platform = get_platform()
if is_binutils:
toolname_with_arch, path_in_ndk = _get_binutils_path_in_ndk(toolname, arch, platform)
else:
toolname_with_arch = toolname
path_in_ndk = tool_info['path_in_ndk']
path_in_ndk = path_in_ndk.replace('/', os.sep)
# 1. Find tool in the given ndk path.
if ndk_path:
path = os.path.join(ndk_path, path_in_ndk)
if is_executable_available(path, test_option):
return path
# 2. Find tool in the ndk directory containing simpleperf scripts.
path = os.path.join('..', path_in_ndk)
if is_executable_available(path, test_option):
return path
# 3. Find tool in the default ndk installation path.
home = os.environ.get('HOMEPATH') if is_windows() else os.environ.get('HOME')
if home:
default_ndk_path = os.path.join(home, DEFAULT_NDK_PATH[platform].replace('/', os.sep))
path = os.path.join(default_ndk_path, path_in_ndk)
if is_executable_available(path, test_option):
return path
# 4. Find tool in $PATH.
if is_executable_available(toolname_with_arch, test_option):
return toolname_with_arch
# 5. Find tool without arch in $PATH.
if is_binutils and tool_info.get('accept_tool_without_arch'):
if is_executable_available(toolname, test_option):
return toolname
return None
class AdbHelper(object):
def __init__(self, enable_switch_to_root=True):
adb_path = find_tool_path('adb')
if not adb_path:
log_exit("Can't find adb in PATH environment.")
self.adb_path = adb_path
self.enable_switch_to_root = enable_switch_to_root
def run(self, adb_args):
return self.run_and_return_output(adb_args)[0]
def run_and_return_output(self, adb_args, stdout_file=None, log_output=True):
adb_args = [self.adb_path] + adb_args
log_debug('run adb cmd: %s' % adb_args)
if stdout_file:
with open(stdout_file, 'wb') as stdout_fh:
returncode = subprocess.call(adb_args, stdout=stdout_fh)
stdoutdata = ''
else:
subproc = subprocess.Popen(adb_args, stdout=subprocess.PIPE)
(stdoutdata, _) = subproc.communicate()
returncode = subproc.returncode
result = (returncode == 0)
if stdoutdata and adb_args[1] != 'push' and adb_args[1] != 'pull':
stdoutdata = bytes_to_str(stdoutdata)
if log_output:
log_debug(stdoutdata)
log_debug('run adb cmd: %s [result %s]' % (adb_args, result))
return (result, stdoutdata)
def check_run(self, adb_args):
self.check_run_and_return_output(adb_args)
def check_run_and_return_output(self, adb_args, stdout_file=None, log_output=True):
result, stdoutdata = self.run_and_return_output(adb_args, stdout_file, log_output)
if not result:
log_exit('run "adb %s" failed' % adb_args)
return stdoutdata
def _unroot(self):
result, stdoutdata = self.run_and_return_output(['shell', 'whoami'])
if not result:
return
if 'root' not in stdoutdata:
return
log_info('unroot adb')
self.run(['unroot'])
self.run(['wait-for-device'])
time.sleep(1)
def switch_to_root(self):
if not self.enable_switch_to_root:
self._unroot()
return False
result, stdoutdata = self.run_and_return_output(['shell', 'whoami'])
if not result:
return False
if 'root' in stdoutdata:
return True
build_type = self.get_property('ro.build.type')
if build_type == 'user':
return False
self.run(['root'])
time.sleep(1)
self.run(['wait-for-device'])
result, stdoutdata = self.run_and_return_output(['shell', 'whoami'])
return result and 'root' in stdoutdata
def get_property(self, name):
result, stdoutdata = self.run_and_return_output(['shell', 'getprop', name])
return stdoutdata if result else None
def set_property(self, name, value):
return self.run(['shell', 'setprop', name, value])
def get_device_arch(self):
output = self.check_run_and_return_output(['shell', 'uname', '-m'])
if 'aarch64' in output:
return 'arm64'
if 'arm' in output:
return 'arm'
if 'x86_64' in output:
return 'x86_64'
if '86' in output:
return 'x86'
log_fatal('unsupported architecture: %s' % output.strip())
def get_android_version(self):
build_version = self.get_property('ro.build.version.release')
android_version = 0
if build_version:
if not build_version[0].isdigit():
c = build_version[0].upper()
if c.isupper() and c >= 'L':
android_version = ord(c) - ord('L') + 5
else:
strs = build_version.split('.')
if strs:
android_version = int(strs[0])
return android_version
def flatten_arg_list(arg_list):
res = []
if arg_list:
for items in arg_list:
res += items
return res
def remove(dir_or_file):
if os.path.isfile(dir_or_file):
os.remove(dir_or_file)
elif os.path.isdir(dir_or_file):
shutil.rmtree(dir_or_file, ignore_errors=True)
def open_report_in_browser(report_path):
if is_darwin():
# On darwin 10.12.6, webbrowser can't open browser, so try `open` cmd first.
try:
subprocess.check_call(['open', report_path])
return
except:
pass
import webbrowser
try:
# Try to open the report with Chrome
browser_key = ''
for key, _ in webbrowser._browsers.items():
if 'chrome' in key:
browser_key = key
browser = webbrowser.get(browser_key)
browser.open(report_path, new=0, autoraise=True)
except:
# webbrowser.get() doesn't work well on darwin/windows.
webbrowser.open_new_tab(report_path)
def find_real_dso_path(dso_path_in_record_file, binary_cache_path):
""" Given the path of a shared library in perf.data, find its real path in the file system. """
if dso_path_in_record_file[0] != '/' or dso_path_in_record_file == '//anon':
return None
if binary_cache_path:
tmp_path = os.path.join(binary_cache_path, dso_path_in_record_file[1:])
if os.path.isfile(tmp_path):
return tmp_path
if os.path.isfile(dso_path_in_record_file):
return dso_path_in_record_file
return None
class Addr2Nearestline(object):
""" Use addr2line to convert (dso_path, func_addr, addr) to (source_file, line) pairs.
For instructions generated by C++ compilers without a matching statement in source code
(like stack corruption check, switch optimization, etc.), addr2line can't generate
line information. However, we want to assign the instruction to the nearest line before
the instruction (just like objdump -dl). So we use below strategy:
Instead of finding the exact line of the instruction in an address, we find the nearest
line to the instruction in an address. If an address doesn't have a line info, we find
the line info of address - 1. If still no line info, then use address - 2, address - 3,
etc.
The implementation steps are as below:
1. Collect all (dso_path, func_addr, addr) requests before converting. This saves the
times to call addr2line.
2. Convert addrs to (source_file, line) pairs for each dso_path as below:
2.1 Check if the dso_path has .debug_line. If not, omit its conversion.
2.2 Get arch of the dso_path, and decide the addr_step for it. addr_step is the step we
change addr each time. For example, since instructions of arm64 are all 4 bytes long,
addr_step for arm64 can be 4.
2.3 Use addr2line to find line info for each addr in the dso_path.
2.4 For each addr without line info, use addr2line to find line info for
range(addr - addr_step, addr - addr_step * 4 - 1, -addr_step).
2.5 For each addr without line info, use addr2line to find line info for
range(addr - addr_step * 5, addr - addr_step * 128 - 1, -addr_step).
(128 is a guess number. A nested switch statement in
system/core/demangle/Demangler.cpp has >300 bytes without line info in arm64.)
"""
class Dso(object):
""" Info of a dynamic shared library.
addrs: a map from address to Addr object in this dso.
"""
def __init__(self):
self.addrs = {}
class Addr(object):
""" Info of an addr request.
func_addr: start_addr of the function containing addr.
source_lines: a list of [file_id, line_number] for addr.
source_lines[:-1] are all for inlined functions.
"""
def __init__(self, func_addr):
self.func_addr = func_addr
self.source_lines = None
def __init__(self, ndk_path, binary_cache_path):
self.addr2line_path = find_tool_path('addr2line', ndk_path)
if not self.addr2line_path:
log_exit("Can't find addr2line. Please set ndk path with --ndk-path option.")
self.readelf = ReadElf(ndk_path)
self.dso_map = {} # map from dso_path to Dso.
self.binary_cache_path = binary_cache_path
# Saving file names for each addr takes a lot of memory. So we store file ids in Addr,
# and provide data structures connecting file id and file name here.
self.file_name_to_id = {}
self.file_id_to_name = []
def add_addr(self, dso_path, func_addr, addr):
dso = self.dso_map.get(dso_path)
if dso is None:
dso = self.dso_map[dso_path] = self.Dso()
if addr not in dso.addrs:
dso.addrs[addr] = self.Addr(func_addr)
def convert_addrs_to_lines(self):
for dso_path in self.dso_map:
self._convert_addrs_in_one_dso(dso_path, self.dso_map[dso_path])
def _convert_addrs_in_one_dso(self, dso_path, dso):
real_path = find_real_dso_path(dso_path, self.binary_cache_path)
if not real_path:
if dso_path not in ['//anon', 'unknown', '[kernel.kallsyms]']:
log_debug("Can't find dso %s" % dso_path)
return
if not self._check_debug_line_section(real_path):
log_debug("file %s doesn't contain .debug_line section." % real_path)
return
addr_step = self._get_addr_step(real_path)
self._collect_line_info(dso, real_path, [0])
self._collect_line_info(dso, real_path, range(-addr_step, -addr_step * 4 - 1, -addr_step))
self._collect_line_info(dso, real_path,
range(-addr_step * 5, -addr_step * 128 - 1, -addr_step))
def _check_debug_line_section(self, real_path):
return '.debug_line' in self.readelf.get_sections(real_path)
def _get_addr_step(self, real_path):
arch = self.readelf.get_arch(real_path)
if arch == 'arm64':
return 4
if arch == 'arm':
return 2
return 1
def _collect_line_info(self, dso, real_path, addr_shifts):
""" Use addr2line to get line info in a dso, with given addr shifts. """
# 1. Collect addrs to send to addr2line.
addr_set = set()
for addr in dso.addrs:
addr_obj = dso.addrs[addr]
if addr_obj.source_lines: # already has source line, no need to search.
continue
for shift in addr_shifts:
# The addr after shift shouldn't change to another function.
shifted_addr = max(addr + shift, addr_obj.func_addr)
addr_set.add(shifted_addr)
if shifted_addr == addr_obj.func_addr:
break
if not addr_set:
return
addr_request = '\n'.join(['%x' % addr for addr in sorted(addr_set)])
# 2. Use addr2line to collect line info.
try:
subproc = subprocess.Popen([self.addr2line_path, '-ai', '-e', real_path],
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
(stdoutdata, _) = subproc.communicate(str_to_bytes(addr_request))
stdoutdata = bytes_to_str(stdoutdata)
except:
return
addr_map = {}
cur_line_list = None
for line in stdoutdata.strip().split('\n'):
if line[:2] == '0x':
# a new address
cur_line_list = addr_map[int(line, 16)] = []
else:
# a file:line.
if cur_line_list is None:
continue
# Handle lines like "C:\Users\...\file:32".
items = line.rsplit(':', 1)
if len(items) != 2:
continue
if '?' in line:
# if ? in line, it doesn't have a valid line info.
# An addr can have a list of (file, line), when the addr belongs to an inlined
# function. Sometimes only part of the list has ? mark. In this case, we think
# the line info is valid if the first line doesn't have ? mark.
if not cur_line_list:
cur_line_list = None
continue
(file_path, line_number) = items
line_number = line_number.split()[0] # Remove comments after line number
try:
line_number = int(line_number)
except ValueError:
continue
file_id = self._get_file_id(file_path)
cur_line_list.append((file_id, line_number))
# 3. Fill line info in dso.addrs.
for addr in dso.addrs:
addr_obj = dso.addrs[addr]
if addr_obj.source_lines:
continue
for shift in addr_shifts:
shifted_addr = max(addr + shift, addr_obj.func_addr)
lines = addr_map.get(shifted_addr)
if lines:
addr_obj.source_lines = lines
break
if shifted_addr == addr_obj.func_addr:
break
def _get_file_id(self, file_path):
file_id = self.file_name_to_id.get(file_path)
if file_id is None:
file_id = self.file_name_to_id[file_path] = len(self.file_id_to_name)
self.file_id_to_name.append(file_path)
return file_id
def get_dso(self, dso_path):
return self.dso_map.get(dso_path)
def get_addr_source(self, dso, addr):
source = dso.addrs[addr].source_lines
if source is None:
return None
return [(self.file_id_to_name[file_id], line) for (file_id, line) in source]
class Objdump(object):
""" A wrapper of objdump to disassemble code. """
def __init__(self, ndk_path, binary_cache_path):
self.ndk_path = ndk_path
self.binary_cache_path = binary_cache_path
self.readelf = ReadElf(ndk_path)
self.objdump_paths = {}
def disassemble_code(self, dso_path, start_addr, addr_len):
""" Disassemble [start_addr, start_addr + addr_len] of dso_path.
Return a list of pair (disassemble_code_line, addr).
"""
# 1. Find real path.
real_path = find_real_dso_path(dso_path, self.binary_cache_path)
if real_path is None:
return None
# 2. Get path of objdump.
arch = self.readelf.get_arch(real_path)
if arch == 'unknown':
return None
objdump_path = self.objdump_paths.get(arch)
if not objdump_path:
objdump_path = find_tool_path('objdump', self.ndk_path, arch)
if not objdump_path:
log_exit("Can't find objdump. Please set ndk path with --ndk_path option.")
self.objdump_paths[arch] = objdump_path
# 3. Run objdump.
args = [objdump_path, '-dlC', '--no-show-raw-insn',
'--start-address=0x%x' % start_addr,
'--stop-address=0x%x' % (start_addr + addr_len),
real_path]
try:
subproc = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
(stdoutdata, _) = subproc.communicate()
stdoutdata = bytes_to_str(stdoutdata)
except:
return None
if not stdoutdata:
return None
result = []
for line in stdoutdata.split('\n'):
line = line.rstrip() # Remove '\r' on Windows.
items = line.split(':', 1)
try:
addr = int(items[0], 16)
except ValueError:
addr = 0
result.append((line, addr))
return result
class ReadElf(object):
""" A wrapper of readelf. """
def __init__(self, ndk_path):
self.readelf_path = find_tool_path('readelf', ndk_path)
if not self.readelf_path:
log_exit("Can't find readelf. Please set ndk path with --ndk_path option.")
def get_arch(self, elf_file_path):
""" Get arch of an elf file. """
try:
output = subprocess.check_output([self.readelf_path, '-h', elf_file_path])
if output.find('AArch64') != -1:
return 'arm64'
if output.find('ARM') != -1:
return 'arm'
if output.find('X86-64') != -1:
return 'x86_64'
if output.find('80386') != -1:
return 'x86'
except subprocess.CalledProcessError:
pass
return 'unknown'
def get_build_id(self, elf_file_path):
""" Get build id of an elf file. """
try:
output = subprocess.check_output([self.readelf_path, '-n', elf_file_path])
output = bytes_to_str(output)
result = re.search(r'Build ID:\s*(\S+)', output)
if result:
build_id = result.group(1)
if len(build_id) < 40:
build_id += '0' * (40 - len(build_id))
else:
build_id = build_id[:40]
build_id = '0x' + build_id
return build_id
except subprocess.CalledProcessError:
pass
return ""
def get_sections(self, elf_file_path):
""" Get sections of an elf file. """
section_names = []
try:
output = subprocess.check_output([self.readelf_path, '-SW', elf_file_path])
output = bytes_to_str(output)
for line in output.split('\n'):
# Parse line like:" [ 1] .note.android.ident NOTE 0000000000400190 ...".
result = re.search(r'^\s+\[\s*\d+\]\s(.+?)\s', line)
if result:
section_name = result.group(1).strip()
if section_name:
section_names.append(section_name)
except subprocess.CalledProcessError:
pass
return section_names
def extant_dir(arg):
"""ArgumentParser type that only accepts extant directories.
Args:
arg: The string argument given on the command line.
Returns: The argument as a realpath.
Raises:
argparse.ArgumentTypeError: The given path isn't a directory.
"""
path = os.path.realpath(arg)
if not os.path.isdir(path):
import argparse
raise argparse.ArgumentTypeError('{} is not a directory.'.format(path))
return path
logging.getLogger().setLevel(logging.DEBUG)