Remove snapshot log parsing and option from tools.

tools/ll_prof.py

 #!/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
@@ skipping 48 matching lines @@
   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 and include the snapshot log.
-  $ %prog --snapshot --disasm-top=10
+  # 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 --snapshot-log=snap-foo.log --trace=foo.data --snapshot
+  $ %prog --log=foo.log --trace=foo.data
 """
 
 
 JS_ORIGIN = "js"
-JS_SNAPSHOT_ORIGIN = "js-snapshot"
+
 
 class Code(object):
   """Code object."""
 
   _id = 0
   UNKNOWN = 0
   V8INTERNAL = 1
   FULL_CODEGEN = 2
   OPTIMIZED = 3
 
@@ skipping 99 matching lines @@
 
   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 or self.origin == JS_SNAPSHOT_ORIGIN:
-      inplace = False
-      filename = options.log + ".ll"
-    else:
-      inplace = True
-      filename = self.origin
+    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."""
 
@@ skipping 103 matching lines @@
 
 
 class CodeInfo(object):
   """Generic info about generated code objects."""
 
   def __init__(self, arch, header_size):
     self.arch = arch
     self.header_size = header_size
 
 
-class SnapshotLogReader(object):
-  """V8 snapshot log reader."""
-
-  _SNAPSHOT_CODE_NAME_RE = re.compile(
-    r"snapshot-code-name,(\d+),\"(.*)\"")
-
-  def __init__(self, log_name):
-    self.log_name = log_name
-
-  def ReadNameMap(self):
-    log = open(self.log_name, "r")
-    try:
-      snapshot_pos_to_name = {}
-      for line in log:
-        match = SnapshotLogReader._SNAPSHOT_CODE_NAME_RE.match(line)
-        if match:
-          pos = int(match.group(1))
-          name = match.group(2)
-          snapshot_pos_to_name[pos] = name
-    finally:
-      log.close()
-    return snapshot_pos_to_name
-
-
 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"
-  _SNAPSHOT_POSITION_TAG = "P"
   _CODE_MOVING_GC_TAG = "G"
 
-  def __init__(self, log_name, code_map, snapshot_pos_to_name):
+  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.snapshot_pos_to_name = snapshot_pos_to_name
-    self.address_to_snapshot_name = {}
 
     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)])
 
-    self.snapshot_position_struct = LogReader._DefineStruct([
-        ("address", pointer_type),
-        ("position", ctypes.c_int32)])
-
   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:
-        self.address_to_snapshot_name.clear()
         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
-        if start_address in self.address_to_snapshot_name:
-          name = self.address_to_snapshot_name[start_address]
-          origin = JS_SNAPSHOT_ORIGIN
-        else:
-          name = self.log[self.log_pos:self.log_pos + event.name_size]
-          origin = JS_ORIGIN
+        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:
@@ skipping 20 matching lines @@
           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
 
-      if tag == LogReader._SNAPSHOT_POSITION_TAG:
-        event = self.snapshot_position_struct.from_buffer(self.log,
-                                                          self.log_pos)
-        self.log_pos += ctypes.sizeof(event)
-        start_address = event.address
-        snapshot_pos = event.position
-        if snapshot_pos in self.snapshot_pos_to_name:
-          self.address_to_snapshot_name[start_address] = \
-              self.snapshot_pos_to_name[snapshot_pos]
-        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
@@ skipping 395 matching lines @@
       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("--snapshot-log",
-                    default="obj/release/snapshot.log",
-                    help="V8 snapshot log file name [default: %default]")
   parser.add_option("--log",
                     default="v8.log",
                     help="V8 log file name [default: %default]")
-  parser.add_option("--snapshot",
-                    default=False,
-                    action="store_true",
-                    help="process V8 snapshot log [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",
@@ skipping 17 matching lines @@
                     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:
-    if options.snapshot:
-      print "V8 logs: %s, %s, %s.ll" % (options.snapshot_log,
-                                        options.log,
-                                        options.log)
-    else:
-      print "V8 log: %s, %s.ll (no snapshot)" % (options.log, options.log)
+    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
 
-  # Process the snapshot log to fill the snapshot name map.
-  snapshot_name_map = {}
-  if options.snapshot:
-    snapshot_log_reader = SnapshotLogReader(log_name=options.snapshot_log)
-    snapshot_name_map = snapshot_log_reader.ReadNameMap()
-
   # Initialize the log reader.
   code_map = CodeMap()
   log_reader = LogReader(log_name=options.log + ".ll",
-                         code_map=code_map,
-                         snapshot_pos_to_name=snapshot_name_map)
+                         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:
@@ skipping 64 matching lines @@
       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()