7315d7b3d7
There are now less that 400 days until the end of life of Python 2(aka _legacy_ Python) https://pythonclock.org/ . The code compatibility check for python2 and python3 used the following tools: futurize, flake8 You can see the reports here: https://travis-ci.com/bmsdave/v8/builds This CL was uploaded by git cl split. Bug: v8:8594 Change-Id: I661c52a70527e8ddde841fee6d4dcba282b4a938 Reviewed-on: https://chromium-review.googlesource.com/c/1470123 Commit-Queue: Sergiy Belozorov <sergiyb@chromium.org> Reviewed-by: Sergiy Belozorov <sergiyb@chromium.org> Cr-Commit-Position: refs/heads/master@{#59675}
993 lines
32 KiB
Python
Executable File
993 lines
32 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#
|
|
# Copyright 2012 the V8 project authors. All rights reserved.
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met:
|
|
#
|
|
# * Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above
|
|
# copyright notice, this list of conditions and the following
|
|
# disclaimer in the documentation and/or other materials provided
|
|
# with the distribution.
|
|
# * Neither the name of Google Inc. nor the names of its
|
|
# contributors may be used to endorse or promote products derived
|
|
# from this software without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
# for py2/py3 compatibility
|
|
from __future__ import print_function
|
|
|
|
import bisect
|
|
import collections
|
|
import ctypes
|
|
import disasm
|
|
import mmap
|
|
import optparse
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
|
|
USAGE="""usage: %prog [OPTION]...
|
|
|
|
Analyses V8 and perf logs to produce profiles.
|
|
|
|
Perf logs can be collected using a command like:
|
|
$ perf record -R -e cycles -c 10000 -f -i ./d8 bench.js --ll-prof
|
|
# -R: collect all data
|
|
# -e cycles: use cpu-cycles event (run "perf list" for details)
|
|
# -c 10000: write a sample after each 10000 events
|
|
# -f: force output file overwrite
|
|
# -i: limit profiling to our process and the kernel
|
|
# --ll-prof shell flag enables the right V8 logs
|
|
This will produce a binary trace file (perf.data) that %prog can analyse.
|
|
|
|
IMPORTANT:
|
|
The kernel has an internal maximum for events per second, it is 100K by
|
|
default. That's not enough for "-c 10000". Set it to some higher value:
|
|
$ echo 10000000 | sudo tee /proc/sys/kernel/perf_event_max_sample_rate
|
|
You can also make the warning about kernel address maps go away:
|
|
$ echo 0 | sudo tee /proc/sys/kernel/kptr_restrict
|
|
|
|
We have a convenience script that handles all of the above for you:
|
|
$ tools/run-llprof.sh ./d8 bench.js
|
|
|
|
Examples:
|
|
# Print flat profile with annotated disassembly for the 10 top
|
|
# symbols. Use default log names.
|
|
$ %prog --disasm-top=10
|
|
|
|
# Print flat profile with annotated disassembly for all used symbols.
|
|
# Use default log names and include kernel symbols into analysis.
|
|
$ %prog --disasm-all --kernel
|
|
|
|
# Print flat profile. Use custom log names.
|
|
$ %prog --log=foo.log --trace=foo.data
|
|
"""
|
|
|
|
|
|
JS_ORIGIN = "js"
|
|
|
|
|
|
class Code(object):
|
|
"""Code object."""
|
|
|
|
_id = 0
|
|
UNKNOWN = 0
|
|
V8INTERNAL = 1
|
|
FULL_CODEGEN = 2
|
|
OPTIMIZED = 3
|
|
|
|
def __init__(self, name, start_address, end_address, origin, origin_offset):
|
|
self.id = Code._id
|
|
Code._id += 1
|
|
self.name = name
|
|
self.other_names = None
|
|
self.start_address = start_address
|
|
self.end_address = end_address
|
|
self.origin = origin
|
|
self.origin_offset = origin_offset
|
|
self.self_ticks = 0
|
|
self.self_ticks_map = None
|
|
self.callee_ticks = None
|
|
if name.startswith("LazyCompile:*"):
|
|
self.codetype = Code.OPTIMIZED
|
|
elif name.startswith("LazyCompile:"):
|
|
self.codetype = Code.FULL_CODEGEN
|
|
elif name.startswith("v8::internal::"):
|
|
self.codetype = Code.V8INTERNAL
|
|
else:
|
|
self.codetype = Code.UNKNOWN
|
|
|
|
def AddName(self, name):
|
|
assert self.name != name
|
|
if self.other_names is None:
|
|
self.other_names = [name]
|
|
return
|
|
if not name in self.other_names:
|
|
self.other_names.append(name)
|
|
|
|
def FullName(self):
|
|
if self.other_names is None:
|
|
return self.name
|
|
self.other_names.sort()
|
|
return "%s (aka %s)" % (self.name, ", ".join(self.other_names))
|
|
|
|
def IsUsed(self):
|
|
return self.self_ticks > 0 or self.callee_ticks is not None
|
|
|
|
def Tick(self, pc):
|
|
self.self_ticks += 1
|
|
if self.self_ticks_map is None:
|
|
self.self_ticks_map = collections.defaultdict(lambda: 0)
|
|
offset = pc - self.start_address
|
|
self.self_ticks_map[offset] += 1
|
|
|
|
def CalleeTick(self, callee):
|
|
if self.callee_ticks is None:
|
|
self.callee_ticks = collections.defaultdict(lambda: 0)
|
|
self.callee_ticks[callee] += 1
|
|
|
|
def PrintAnnotated(self, arch, options):
|
|
if self.self_ticks_map is None:
|
|
ticks_map = []
|
|
else:
|
|
ticks_map = self.self_ticks_map.items()
|
|
# Convert the ticks map to offsets and counts arrays so that later
|
|
# we can do binary search in the offsets array.
|
|
ticks_map.sort(key=lambda t: t[0])
|
|
ticks_offsets = [t[0] for t in ticks_map]
|
|
ticks_counts = [t[1] for t in ticks_map]
|
|
# Get a list of disassembled lines and their addresses.
|
|
lines = self._GetDisasmLines(arch, options)
|
|
if len(lines) == 0:
|
|
return
|
|
# Print annotated lines.
|
|
address = lines[0][0]
|
|
total_count = 0
|
|
for i in range(len(lines)):
|
|
start_offset = lines[i][0] - address
|
|
if i == len(lines) - 1:
|
|
end_offset = self.end_address - self.start_address
|
|
else:
|
|
end_offset = lines[i + 1][0] - address
|
|
# Ticks (reported pc values) are not always precise, i.e. not
|
|
# necessarily point at instruction starts. So we have to search
|
|
# for ticks that touch the current instruction line.
|
|
j = bisect.bisect_left(ticks_offsets, end_offset)
|
|
count = 0
|
|
for offset, cnt in reversed(zip(ticks_offsets[:j], ticks_counts[:j])):
|
|
if offset < start_offset:
|
|
break
|
|
count += cnt
|
|
total_count += count
|
|
percent = 100.0 * count / self.self_ticks
|
|
offset = lines[i][0]
|
|
if percent >= 0.01:
|
|
# 5 spaces for tick count
|
|
# 1 space following
|
|
# 1 for '|'
|
|
# 1 space following
|
|
# 6 for the percentage number, incl. the '.'
|
|
# 1 for the '%' sign
|
|
# => 15
|
|
print("%5d | %6.2f%% %x(%d): %s" % (count, percent, offset, offset, lines[i][1]))
|
|
else:
|
|
print("%s %x(%d): %s" % (" " * 15, offset, offset, lines[i][1]))
|
|
print()
|
|
assert total_count == self.self_ticks, \
|
|
"Lost ticks (%d != %d) in %s" % (total_count, self.self_ticks, self)
|
|
|
|
def __str__(self):
|
|
return "%s [0x%x, 0x%x) size: %d origin: %s" % (
|
|
self.name,
|
|
self.start_address,
|
|
self.end_address,
|
|
self.end_address - self.start_address,
|
|
self.origin)
|
|
|
|
def _GetDisasmLines(self, arch, options):
|
|
if self.origin == JS_ORIGIN:
|
|
inplace = False
|
|
filename = options.log + ".ll"
|
|
else:
|
|
inplace = True
|
|
filename = self.origin
|
|
return disasm.GetDisasmLines(filename,
|
|
self.origin_offset,
|
|
self.end_address - self.start_address,
|
|
arch,
|
|
inplace)
|
|
|
|
|
|
class CodePage(object):
|
|
"""Group of adjacent code objects."""
|
|
|
|
SHIFT = 20 # 1M pages
|
|
SIZE = (1 << SHIFT)
|
|
MASK = ~(SIZE - 1)
|
|
|
|
@staticmethod
|
|
def PageAddress(address):
|
|
return address & CodePage.MASK
|
|
|
|
@staticmethod
|
|
def PageId(address):
|
|
return address >> CodePage.SHIFT
|
|
|
|
@staticmethod
|
|
def PageAddressFromId(id):
|
|
return id << CodePage.SHIFT
|
|
|
|
def __init__(self, address):
|
|
self.address = address
|
|
self.code_objects = []
|
|
|
|
def Add(self, code):
|
|
self.code_objects.append(code)
|
|
|
|
def Remove(self, code):
|
|
self.code_objects.remove(code)
|
|
|
|
def Find(self, pc):
|
|
code_objects = self.code_objects
|
|
for i, code in enumerate(code_objects):
|
|
if code.start_address <= pc < code.end_address:
|
|
code_objects[0], code_objects[i] = code, code_objects[0]
|
|
return code
|
|
return None
|
|
|
|
def __iter__(self):
|
|
return self.code_objects.__iter__()
|
|
|
|
|
|
class CodeMap(object):
|
|
"""Code object map."""
|
|
|
|
def __init__(self):
|
|
self.pages = {}
|
|
self.min_address = 1 << 64
|
|
self.max_address = -1
|
|
|
|
def Add(self, code, max_pages=-1):
|
|
page_id = CodePage.PageId(code.start_address)
|
|
limit_id = CodePage.PageId(code.end_address + CodePage.SIZE - 1)
|
|
pages = 0
|
|
while page_id < limit_id:
|
|
if max_pages >= 0 and pages > max_pages:
|
|
print("Warning: page limit (%d) reached for %s [%s]" % (
|
|
max_pages, code.name, code.origin), file=sys.stderr)
|
|
break
|
|
if page_id in self.pages:
|
|
page = self.pages[page_id]
|
|
else:
|
|
page = CodePage(CodePage.PageAddressFromId(page_id))
|
|
self.pages[page_id] = page
|
|
page.Add(code)
|
|
page_id += 1
|
|
pages += 1
|
|
self.min_address = min(self.min_address, code.start_address)
|
|
self.max_address = max(self.max_address, code.end_address)
|
|
|
|
def Remove(self, code):
|
|
page_id = CodePage.PageId(code.start_address)
|
|
limit_id = CodePage.PageId(code.end_address + CodePage.SIZE - 1)
|
|
removed = False
|
|
while page_id < limit_id:
|
|
if page_id not in self.pages:
|
|
page_id += 1
|
|
continue
|
|
page = self.pages[page_id]
|
|
page.Remove(code)
|
|
removed = True
|
|
page_id += 1
|
|
return removed
|
|
|
|
def AllCode(self):
|
|
for page in self.pages.itervalues():
|
|
for code in page:
|
|
if CodePage.PageAddress(code.start_address) == page.address:
|
|
yield code
|
|
|
|
def UsedCode(self):
|
|
for code in self.AllCode():
|
|
if code.IsUsed():
|
|
yield code
|
|
|
|
def Print(self):
|
|
for code in self.AllCode():
|
|
print(code)
|
|
|
|
def Find(self, pc):
|
|
if pc < self.min_address or pc >= self.max_address:
|
|
return None
|
|
page_id = CodePage.PageId(pc)
|
|
if page_id not in self.pages:
|
|
return None
|
|
return self.pages[page_id].Find(pc)
|
|
|
|
|
|
class CodeInfo(object):
|
|
"""Generic info about generated code objects."""
|
|
|
|
def __init__(self, arch, header_size):
|
|
self.arch = arch
|
|
self.header_size = header_size
|
|
|
|
|
|
class LogReader(object):
|
|
"""V8 low-level (binary) log reader."""
|
|
|
|
_ARCH_TO_POINTER_TYPE_MAP = {
|
|
"ia32": ctypes.c_uint32,
|
|
"arm": ctypes.c_uint32,
|
|
"mips": ctypes.c_uint32,
|
|
"x64": ctypes.c_uint64,
|
|
"arm64": ctypes.c_uint64
|
|
}
|
|
|
|
_CODE_CREATE_TAG = "C"
|
|
_CODE_MOVE_TAG = "M"
|
|
_CODE_MOVING_GC_TAG = "G"
|
|
|
|
def __init__(self, log_name, code_map):
|
|
self.log_file = open(log_name, "r")
|
|
self.log = mmap.mmap(self.log_file.fileno(), 0, mmap.MAP_PRIVATE)
|
|
self.log_pos = 0
|
|
self.code_map = code_map
|
|
|
|
self.arch = self.log[:self.log.find("\0")]
|
|
self.log_pos += len(self.arch) + 1
|
|
assert self.arch in LogReader._ARCH_TO_POINTER_TYPE_MAP, \
|
|
"Unsupported architecture %s" % self.arch
|
|
pointer_type = LogReader._ARCH_TO_POINTER_TYPE_MAP[self.arch]
|
|
|
|
self.code_create_struct = LogReader._DefineStruct([
|
|
("name_size", ctypes.c_int32),
|
|
("code_address", pointer_type),
|
|
("code_size", ctypes.c_int32)])
|
|
|
|
self.code_move_struct = LogReader._DefineStruct([
|
|
("from_address", pointer_type),
|
|
("to_address", pointer_type)])
|
|
|
|
self.code_delete_struct = LogReader._DefineStruct([
|
|
("address", pointer_type)])
|
|
|
|
def ReadUpToGC(self):
|
|
while self.log_pos < self.log.size():
|
|
tag = self.log[self.log_pos]
|
|
self.log_pos += 1
|
|
|
|
if tag == LogReader._CODE_MOVING_GC_TAG:
|
|
return
|
|
|
|
if tag == LogReader._CODE_CREATE_TAG:
|
|
event = self.code_create_struct.from_buffer(self.log, self.log_pos)
|
|
self.log_pos += ctypes.sizeof(event)
|
|
start_address = event.code_address
|
|
end_address = start_address + event.code_size
|
|
name = self.log[self.log_pos:self.log_pos + event.name_size]
|
|
origin = JS_ORIGIN
|
|
self.log_pos += event.name_size
|
|
origin_offset = self.log_pos
|
|
self.log_pos += event.code_size
|
|
code = Code(name, start_address, end_address, origin, origin_offset)
|
|
conficting_code = self.code_map.Find(start_address)
|
|
if conficting_code:
|
|
if not (conficting_code.start_address == code.start_address and
|
|
conficting_code.end_address == code.end_address):
|
|
self.code_map.Remove(conficting_code)
|
|
else:
|
|
LogReader._HandleCodeConflict(conficting_code, code)
|
|
# TODO(vitalyr): this warning is too noisy because of our
|
|
# attempts to reconstruct code log from the snapshot.
|
|
# print >>sys.stderr, \
|
|
# "Warning: Skipping duplicate code log entry %s" % code
|
|
continue
|
|
self.code_map.Add(code)
|
|
continue
|
|
|
|
if tag == LogReader._CODE_MOVE_TAG:
|
|
event = self.code_move_struct.from_buffer(self.log, self.log_pos)
|
|
self.log_pos += ctypes.sizeof(event)
|
|
old_start_address = event.from_address
|
|
new_start_address = event.to_address
|
|
if old_start_address == new_start_address:
|
|
# Skip useless code move entries.
|
|
continue
|
|
code = self.code_map.Find(old_start_address)
|
|
if not code:
|
|
print("Warning: Not found %x" % old_start_address, file=sys.stderr)
|
|
continue
|
|
assert code.start_address == old_start_address, \
|
|
"Inexact move address %x for %s" % (old_start_address, code)
|
|
self.code_map.Remove(code)
|
|
size = code.end_address - code.start_address
|
|
code.start_address = new_start_address
|
|
code.end_address = new_start_address + size
|
|
self.code_map.Add(code)
|
|
continue
|
|
|
|
assert False, "Unknown tag %s" % tag
|
|
|
|
def Dispose(self):
|
|
self.log.close()
|
|
self.log_file.close()
|
|
|
|
@staticmethod
|
|
def _DefineStruct(fields):
|
|
class Struct(ctypes.Structure):
|
|
_fields_ = fields
|
|
return Struct
|
|
|
|
@staticmethod
|
|
def _HandleCodeConflict(old_code, new_code):
|
|
assert (old_code.start_address == new_code.start_address and
|
|
old_code.end_address == new_code.end_address), \
|
|
"Conficting code log entries %s and %s" % (old_code, new_code)
|
|
if old_code.name == new_code.name:
|
|
return
|
|
# Code object may be shared by a few functions. Collect the full
|
|
# set of names.
|
|
old_code.AddName(new_code.name)
|
|
|
|
|
|
class Descriptor(object):
|
|
"""Descriptor of a structure in the binary trace log."""
|
|
|
|
CTYPE_MAP = {
|
|
"u16": ctypes.c_uint16,
|
|
"u32": ctypes.c_uint32,
|
|
"u64": ctypes.c_uint64
|
|
}
|
|
|
|
def __init__(self, fields):
|
|
class TraceItem(ctypes.Structure):
|
|
_fields_ = Descriptor.CtypesFields(fields)
|
|
|
|
def __str__(self):
|
|
return ", ".join("%s: %s" % (field, self.__getattribute__(field))
|
|
for field, _ in TraceItem._fields_)
|
|
|
|
self.ctype = TraceItem
|
|
|
|
def Read(self, trace, offset):
|
|
return self.ctype.from_buffer(trace, offset)
|
|
|
|
@staticmethod
|
|
def CtypesFields(fields):
|
|
return [(field, Descriptor.CTYPE_MAP[format]) for (field, format) in fields]
|
|
|
|
|
|
# Please see http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=tree;f=tools/perf
|
|
# for the gory details.
|
|
|
|
|
|
# Reference: struct perf_file_header in kernel/tools/perf/util/header.h
|
|
TRACE_HEADER_DESC = Descriptor([
|
|
("magic", "u64"),
|
|
("size", "u64"),
|
|
("attr_size", "u64"),
|
|
("attrs_offset", "u64"),
|
|
("attrs_size", "u64"),
|
|
("data_offset", "u64"),
|
|
("data_size", "u64"),
|
|
("event_types_offset", "u64"),
|
|
("event_types_size", "u64")
|
|
])
|
|
|
|
|
|
# Reference: /usr/include/linux/perf_event.h
|
|
PERF_EVENT_ATTR_DESC = Descriptor([
|
|
("type", "u32"),
|
|
("size", "u32"),
|
|
("config", "u64"),
|
|
("sample_period_or_freq", "u64"),
|
|
("sample_type", "u64"),
|
|
("read_format", "u64"),
|
|
("flags", "u64"),
|
|
("wakeup_events_or_watermark", "u32"),
|
|
("bp_type", "u32"),
|
|
("bp_addr", "u64"),
|
|
("bp_len", "u64")
|
|
])
|
|
|
|
|
|
# Reference: /usr/include/linux/perf_event.h
|
|
PERF_EVENT_HEADER_DESC = Descriptor([
|
|
("type", "u32"),
|
|
("misc", "u16"),
|
|
("size", "u16")
|
|
])
|
|
|
|
|
|
# Reference: kernel/tools/perf/util/event.h
|
|
PERF_MMAP_EVENT_BODY_DESC = Descriptor([
|
|
("pid", "u32"),
|
|
("tid", "u32"),
|
|
("addr", "u64"),
|
|
("len", "u64"),
|
|
("pgoff", "u64")
|
|
])
|
|
|
|
# Reference: kernel/tools/perf/util/event.h
|
|
PERF_MMAP2_EVENT_BODY_DESC = Descriptor([
|
|
("pid", "u32"),
|
|
("tid", "u32"),
|
|
("addr", "u64"),
|
|
("len", "u64"),
|
|
("pgoff", "u64"),
|
|
("maj", "u32"),
|
|
("min", "u32"),
|
|
("ino", "u64"),
|
|
("ino_generation", "u64"),
|
|
("prot", "u32"),
|
|
("flags","u32")
|
|
])
|
|
|
|
# perf_event_attr.sample_type bits control the set of
|
|
# perf_sample_event fields.
|
|
PERF_SAMPLE_IP = 1 << 0
|
|
PERF_SAMPLE_TID = 1 << 1
|
|
PERF_SAMPLE_TIME = 1 << 2
|
|
PERF_SAMPLE_ADDR = 1 << 3
|
|
PERF_SAMPLE_READ = 1 << 4
|
|
PERF_SAMPLE_CALLCHAIN = 1 << 5
|
|
PERF_SAMPLE_ID = 1 << 6
|
|
PERF_SAMPLE_CPU = 1 << 7
|
|
PERF_SAMPLE_PERIOD = 1 << 8
|
|
PERF_SAMPLE_STREAM_ID = 1 << 9
|
|
PERF_SAMPLE_RAW = 1 << 10
|
|
|
|
|
|
# Reference: /usr/include/perf_event.h, the comment for PERF_RECORD_SAMPLE.
|
|
PERF_SAMPLE_EVENT_BODY_FIELDS = [
|
|
("ip", "u64", PERF_SAMPLE_IP),
|
|
("pid", "u32", PERF_SAMPLE_TID),
|
|
("tid", "u32", PERF_SAMPLE_TID),
|
|
("time", "u64", PERF_SAMPLE_TIME),
|
|
("addr", "u64", PERF_SAMPLE_ADDR),
|
|
("id", "u64", PERF_SAMPLE_ID),
|
|
("stream_id", "u64", PERF_SAMPLE_STREAM_ID),
|
|
("cpu", "u32", PERF_SAMPLE_CPU),
|
|
("res", "u32", PERF_SAMPLE_CPU),
|
|
("period", "u64", PERF_SAMPLE_PERIOD),
|
|
# Don't want to handle read format that comes after the period and
|
|
# before the callchain and has variable size.
|
|
("nr", "u64", PERF_SAMPLE_CALLCHAIN)
|
|
# Raw data follows the callchain and is ignored.
|
|
]
|
|
|
|
|
|
PERF_SAMPLE_EVENT_IP_FORMAT = "u64"
|
|
|
|
|
|
PERF_RECORD_MMAP = 1
|
|
PERF_RECORD_MMAP2 = 10
|
|
PERF_RECORD_SAMPLE = 9
|
|
|
|
|
|
class TraceReader(object):
|
|
"""Perf (linux-2.6/tools/perf) trace file reader."""
|
|
|
|
_TRACE_HEADER_MAGIC = 4993446653023372624
|
|
|
|
def __init__(self, trace_name):
|
|
self.trace_file = open(trace_name, "r")
|
|
self.trace = mmap.mmap(self.trace_file.fileno(), 0, mmap.MAP_PRIVATE)
|
|
self.trace_header = TRACE_HEADER_DESC.Read(self.trace, 0)
|
|
if self.trace_header.magic != TraceReader._TRACE_HEADER_MAGIC:
|
|
print("Warning: unsupported trace header magic", file=sys.stderr)
|
|
self.offset = self.trace_header.data_offset
|
|
self.limit = self.trace_header.data_offset + self.trace_header.data_size
|
|
assert self.limit <= self.trace.size(), \
|
|
"Trace data limit exceeds trace file size"
|
|
self.header_size = ctypes.sizeof(PERF_EVENT_HEADER_DESC.ctype)
|
|
assert self.trace_header.attrs_size != 0, \
|
|
"No perf event attributes found in the trace"
|
|
perf_event_attr = PERF_EVENT_ATTR_DESC.Read(self.trace,
|
|
self.trace_header.attrs_offset)
|
|
self.sample_event_body_desc = self._SampleEventBodyDesc(
|
|
perf_event_attr.sample_type)
|
|
self.callchain_supported = \
|
|
(perf_event_attr.sample_type & PERF_SAMPLE_CALLCHAIN) != 0
|
|
if self.callchain_supported:
|
|
self.ip_struct = Descriptor.CTYPE_MAP[PERF_SAMPLE_EVENT_IP_FORMAT]
|
|
self.ip_size = ctypes.sizeof(self.ip_struct)
|
|
|
|
def ReadEventHeader(self):
|
|
if self.offset >= self.limit:
|
|
return None, 0
|
|
offset = self.offset
|
|
header = PERF_EVENT_HEADER_DESC.Read(self.trace, self.offset)
|
|
self.offset += header.size
|
|
return header, offset
|
|
|
|
def ReadMmap(self, header, offset):
|
|
mmap_info = PERF_MMAP_EVENT_BODY_DESC.Read(self.trace,
|
|
offset + self.header_size)
|
|
# Read null-terminated filename.
|
|
filename = self.trace[offset + self.header_size + ctypes.sizeof(mmap_info):
|
|
offset + header.size]
|
|
mmap_info.filename = HOST_ROOT + filename[:filename.find(chr(0))]
|
|
return mmap_info
|
|
|
|
def ReadMmap2(self, header, offset):
|
|
mmap_info = PERF_MMAP2_EVENT_BODY_DESC.Read(self.trace,
|
|
offset + self.header_size)
|
|
# Read null-terminated filename.
|
|
filename = self.trace[offset + self.header_size + ctypes.sizeof(mmap_info):
|
|
offset + header.size]
|
|
mmap_info.filename = HOST_ROOT + filename[:filename.find(chr(0))]
|
|
return mmap_info
|
|
|
|
def ReadSample(self, header, offset):
|
|
sample = self.sample_event_body_desc.Read(self.trace,
|
|
offset + self.header_size)
|
|
if not self.callchain_supported:
|
|
return sample
|
|
sample.ips = []
|
|
offset += self.header_size + ctypes.sizeof(sample)
|
|
for _ in range(sample.nr):
|
|
sample.ips.append(
|
|
self.ip_struct.from_buffer(self.trace, offset).value)
|
|
offset += self.ip_size
|
|
return sample
|
|
|
|
def Dispose(self):
|
|
self.trace.close()
|
|
self.trace_file.close()
|
|
|
|
def _SampleEventBodyDesc(self, sample_type):
|
|
assert (sample_type & PERF_SAMPLE_READ) == 0, \
|
|
"Can't hande read format in samples"
|
|
fields = [(field, format)
|
|
for (field, format, bit) in PERF_SAMPLE_EVENT_BODY_FIELDS
|
|
if (bit & sample_type) != 0]
|
|
return Descriptor(fields)
|
|
|
|
|
|
OBJDUMP_SECTION_HEADER_RE = re.compile(
|
|
r"^\s*\d+\s(\.\S+)\s+[a-f0-9]")
|
|
OBJDUMP_SYMBOL_LINE_RE = re.compile(
|
|
r"^([a-f0-9]+)\s(.{7})\s(\S+)\s+([a-f0-9]+)\s+(?:\.hidden\s+)?(.*)$")
|
|
OBJDUMP_DYNAMIC_SYMBOLS_START_RE = re.compile(
|
|
r"^DYNAMIC SYMBOL TABLE")
|
|
OBJDUMP_SKIP_RE = re.compile(
|
|
r"^.*ld\.so\.cache$")
|
|
KERNEL_ALLSYMS_FILE = "/proc/kallsyms"
|
|
PERF_KERNEL_ALLSYMS_RE = re.compile(
|
|
r".*kallsyms.*")
|
|
KERNEL_ALLSYMS_LINE_RE = re.compile(
|
|
r"^([a-f0-9]+)\s(?:t|T)\s(\S+)$")
|
|
|
|
|
|
class LibraryRepo(object):
|
|
def __init__(self):
|
|
self.infos = []
|
|
self.names = set()
|
|
self.ticks = {}
|
|
|
|
|
|
def HasDynamicSymbols(self, filename):
|
|
if filename.endswith(".ko"): return False
|
|
process = subprocess.Popen(
|
|
"%s -h %s" % (OBJDUMP_BIN, filename),
|
|
shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
|
pipe = process.stdout
|
|
try:
|
|
for line in pipe:
|
|
match = OBJDUMP_SECTION_HEADER_RE.match(line)
|
|
if match and match.group(1) == 'dynsym': return True
|
|
finally:
|
|
pipe.close()
|
|
assert process.wait() == 0, "Failed to objdump -h %s" % filename
|
|
return False
|
|
|
|
|
|
def Load(self, mmap_info, code_map, options):
|
|
# Skip kernel mmaps when requested using the fact that their tid
|
|
# is 0.
|
|
if mmap_info.tid == 0 and not options.kernel:
|
|
return True
|
|
if OBJDUMP_SKIP_RE.match(mmap_info.filename):
|
|
return True
|
|
if PERF_KERNEL_ALLSYMS_RE.match(mmap_info.filename):
|
|
return self._LoadKernelSymbols(code_map)
|
|
self.infos.append(mmap_info)
|
|
mmap_info.ticks = 0
|
|
mmap_info.unique_name = self._UniqueMmapName(mmap_info)
|
|
if not os.path.exists(mmap_info.filename):
|
|
return True
|
|
# Request section headers (-h), symbols (-t), and dynamic symbols
|
|
# (-T) from objdump.
|
|
# Unfortunately, section headers span two lines, so we have to
|
|
# keep the just seen section name (from the first line in each
|
|
# section header) in the after_section variable.
|
|
if self.HasDynamicSymbols(mmap_info.filename):
|
|
dynamic_symbols = "-T"
|
|
else:
|
|
dynamic_symbols = ""
|
|
process = subprocess.Popen(
|
|
"%s -h -t %s -C %s" % (OBJDUMP_BIN, dynamic_symbols, mmap_info.filename),
|
|
shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
|
pipe = process.stdout
|
|
after_section = None
|
|
code_sections = set()
|
|
reloc_sections = set()
|
|
dynamic = False
|
|
try:
|
|
for line in pipe:
|
|
if after_section:
|
|
if line.find("CODE") != -1:
|
|
code_sections.add(after_section)
|
|
if line.find("RELOC") != -1:
|
|
reloc_sections.add(after_section)
|
|
after_section = None
|
|
continue
|
|
|
|
match = OBJDUMP_SECTION_HEADER_RE.match(line)
|
|
if match:
|
|
after_section = match.group(1)
|
|
continue
|
|
|
|
if OBJDUMP_DYNAMIC_SYMBOLS_START_RE.match(line):
|
|
dynamic = True
|
|
continue
|
|
|
|
match = OBJDUMP_SYMBOL_LINE_RE.match(line)
|
|
if match:
|
|
start_address = int(match.group(1), 16)
|
|
origin_offset = start_address
|
|
flags = match.group(2)
|
|
section = match.group(3)
|
|
if section in code_sections:
|
|
if dynamic or section in reloc_sections:
|
|
start_address += mmap_info.addr
|
|
size = int(match.group(4), 16)
|
|
name = match.group(5)
|
|
origin = mmap_info.filename
|
|
code_map.Add(Code(name, start_address, start_address + size,
|
|
origin, origin_offset))
|
|
finally:
|
|
pipe.close()
|
|
assert process.wait() == 0, "Failed to objdump %s" % mmap_info.filename
|
|
|
|
def Tick(self, pc):
|
|
for i, mmap_info in enumerate(self.infos):
|
|
if mmap_info.addr <= pc < (mmap_info.addr + mmap_info.len):
|
|
mmap_info.ticks += 1
|
|
self.infos[0], self.infos[i] = mmap_info, self.infos[0]
|
|
return True
|
|
return False
|
|
|
|
def _UniqueMmapName(self, mmap_info):
|
|
name = mmap_info.filename
|
|
index = 1
|
|
while name in self.names:
|
|
name = "%s-%d" % (mmap_info.filename, index)
|
|
index += 1
|
|
self.names.add(name)
|
|
return name
|
|
|
|
def _LoadKernelSymbols(self, code_map):
|
|
if not os.path.exists(KERNEL_ALLSYMS_FILE):
|
|
print("Warning: %s not found" % KERNEL_ALLSYMS_FILE, file=sys.stderr)
|
|
return False
|
|
kallsyms = open(KERNEL_ALLSYMS_FILE, "r")
|
|
code = None
|
|
for line in kallsyms:
|
|
match = KERNEL_ALLSYMS_LINE_RE.match(line)
|
|
if match:
|
|
start_address = int(match.group(1), 16)
|
|
end_address = start_address
|
|
name = match.group(2)
|
|
if code:
|
|
code.end_address = start_address
|
|
code_map.Add(code, 16)
|
|
code = Code(name, start_address, end_address, "kernel", 0)
|
|
return True
|
|
|
|
|
|
def PrintReport(code_map, library_repo, arch, ticks, options):
|
|
print("Ticks per symbol:")
|
|
used_code = [code for code in code_map.UsedCode()]
|
|
used_code.sort(key=lambda x: x.self_ticks, reverse=True)
|
|
for i, code in enumerate(used_code):
|
|
code_ticks = code.self_ticks
|
|
print("%10d %5.1f%% %s [%s]" % (code_ticks, 100. * code_ticks / ticks,
|
|
code.FullName(), code.origin))
|
|
if options.disasm_all or i < options.disasm_top:
|
|
code.PrintAnnotated(arch, options)
|
|
print()
|
|
print("Ticks per library:")
|
|
mmap_infos = [m for m in library_repo.infos if m.ticks > 0]
|
|
mmap_infos.sort(key=lambda m: m.ticks, reverse=True)
|
|
for mmap_info in mmap_infos:
|
|
mmap_ticks = mmap_info.ticks
|
|
print("%10d %5.1f%% %s" % (mmap_ticks, 100. * mmap_ticks / ticks,
|
|
mmap_info.unique_name))
|
|
|
|
|
|
def PrintDot(code_map, options):
|
|
print("digraph G {")
|
|
for code in code_map.UsedCode():
|
|
if code.self_ticks < 10:
|
|
continue
|
|
print("n%d [shape=box,label=\"%s\"];" % (code.id, code.name))
|
|
if code.callee_ticks:
|
|
for callee, ticks in code.callee_ticks.iteritems():
|
|
print("n%d -> n%d [label=\"%d\"];" % (code.id, callee.id, ticks))
|
|
print("}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = optparse.OptionParser(USAGE)
|
|
parser.add_option("--log",
|
|
default="v8.log",
|
|
help="V8 log file name [default: %default]")
|
|
parser.add_option("--trace",
|
|
default="perf.data",
|
|
help="perf trace file name [default: %default]")
|
|
parser.add_option("--kernel",
|
|
default=False,
|
|
action="store_true",
|
|
help="process kernel entries [default: %default]")
|
|
parser.add_option("--disasm-top",
|
|
default=0,
|
|
type="int",
|
|
help=("number of top symbols to disassemble and annotate "
|
|
"[default: %default]"))
|
|
parser.add_option("--disasm-all",
|
|
default=False,
|
|
action="store_true",
|
|
help=("disassemble and annotate all used symbols "
|
|
"[default: %default]"))
|
|
parser.add_option("--dot",
|
|
default=False,
|
|
action="store_true",
|
|
help="produce dot output (WIP) [default: %default]")
|
|
parser.add_option("--quiet", "-q",
|
|
default=False,
|
|
action="store_true",
|
|
help="no auxiliary messages [default: %default]")
|
|
parser.add_option("--gc-fake-mmap",
|
|
default="/tmp/__v8_gc__",
|
|
help="gc fake mmap file [default: %default]")
|
|
parser.add_option("--objdump",
|
|
default="/usr/bin/objdump",
|
|
help="objdump tool to use [default: %default]")
|
|
parser.add_option("--host-root",
|
|
default="",
|
|
help="Path to the host root [default: %default]")
|
|
options, args = parser.parse_args()
|
|
|
|
if not options.quiet:
|
|
print("V8 log: %s, %s.ll" % (options.log, options.log))
|
|
print("Perf trace file: %s" % options.trace)
|
|
|
|
V8_GC_FAKE_MMAP = options.gc_fake_mmap
|
|
HOST_ROOT = options.host_root
|
|
if os.path.exists(options.objdump):
|
|
disasm.OBJDUMP_BIN = options.objdump
|
|
OBJDUMP_BIN = options.objdump
|
|
else:
|
|
print("Cannot find %s, falling back to default objdump" % options.objdump)
|
|
|
|
# Stats.
|
|
events = 0
|
|
ticks = 0
|
|
missed_ticks = 0
|
|
really_missed_ticks = 0
|
|
optimized_ticks = 0
|
|
generated_ticks = 0
|
|
v8_internal_ticks = 0
|
|
mmap_time = 0
|
|
sample_time = 0
|
|
|
|
# Initialize the log reader.
|
|
code_map = CodeMap()
|
|
log_reader = LogReader(log_name=options.log + ".ll",
|
|
code_map=code_map)
|
|
if not options.quiet:
|
|
print("Generated code architecture: %s" % log_reader.arch)
|
|
print()
|
|
sys.stdout.flush()
|
|
|
|
# Process the code and trace logs.
|
|
library_repo = LibraryRepo()
|
|
log_reader.ReadUpToGC()
|
|
trace_reader = TraceReader(options.trace)
|
|
while True:
|
|
header, offset = trace_reader.ReadEventHeader()
|
|
if not header:
|
|
break
|
|
events += 1
|
|
if header.type == PERF_RECORD_MMAP:
|
|
start = time.time()
|
|
mmap_info = trace_reader.ReadMmap(header, offset)
|
|
if mmap_info.filename == HOST_ROOT + V8_GC_FAKE_MMAP:
|
|
log_reader.ReadUpToGC()
|
|
else:
|
|
library_repo.Load(mmap_info, code_map, options)
|
|
mmap_time += time.time() - start
|
|
elif header.type == PERF_RECORD_MMAP2:
|
|
start = time.time()
|
|
mmap_info = trace_reader.ReadMmap2(header, offset)
|
|
if mmap_info.filename == HOST_ROOT + V8_GC_FAKE_MMAP:
|
|
log_reader.ReadUpToGC()
|
|
else:
|
|
library_repo.Load(mmap_info, code_map, options)
|
|
mmap_time += time.time() - start
|
|
elif header.type == PERF_RECORD_SAMPLE:
|
|
ticks += 1
|
|
start = time.time()
|
|
sample = trace_reader.ReadSample(header, offset)
|
|
code = code_map.Find(sample.ip)
|
|
if code:
|
|
code.Tick(sample.ip)
|
|
if code.codetype == Code.OPTIMIZED:
|
|
optimized_ticks += 1
|
|
elif code.codetype == Code.FULL_CODEGEN:
|
|
generated_ticks += 1
|
|
elif code.codetype == Code.V8INTERNAL:
|
|
v8_internal_ticks += 1
|
|
else:
|
|
missed_ticks += 1
|
|
if not library_repo.Tick(sample.ip) and not code:
|
|
really_missed_ticks += 1
|
|
if trace_reader.callchain_supported:
|
|
for ip in sample.ips:
|
|
caller_code = code_map.Find(ip)
|
|
if caller_code:
|
|
if code:
|
|
caller_code.CalleeTick(code)
|
|
code = caller_code
|
|
sample_time += time.time() - start
|
|
|
|
if options.dot:
|
|
PrintDot(code_map, options)
|
|
else:
|
|
PrintReport(code_map, library_repo, log_reader.arch, ticks, options)
|
|
|
|
if not options.quiet:
|
|
def PrintTicks(number, total, description):
|
|
print("%10d %5.1f%% ticks in %s" %
|
|
(number, 100.0*number/total, description))
|
|
print()
|
|
print("Stats:")
|
|
print("%10d total trace events" % events)
|
|
print("%10d total ticks" % ticks)
|
|
print("%10d ticks not in symbols" % missed_ticks)
|
|
unaccounted = "unaccounted ticks"
|
|
if really_missed_ticks > 0:
|
|
unaccounted += " (probably in the kernel, try --kernel)"
|
|
PrintTicks(really_missed_ticks, ticks, unaccounted)
|
|
PrintTicks(optimized_ticks, ticks, "ticks in optimized code")
|
|
PrintTicks(generated_ticks, ticks, "ticks in other lazily compiled code")
|
|
PrintTicks(v8_internal_ticks, ticks, "ticks in v8::internal::*")
|
|
print("%10d total symbols" % len([c for c in code_map.AllCode()]))
|
|
print("%10d used symbols" % len([c for c in code_map.UsedCode()]))
|
|
print("%9.2fs library processing time" % mmap_time)
|
|
print("%9.2fs tick processing time" % sample_time)
|
|
|
|
log_reader.Dispose()
|
|
trace_reader.Dispose()
|