Profiler tick processor now counts IC ticks on behalf of a caller.

tools/tickprocessor.py

 # Copyright 2008 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.
 
-import csv, splaytree, sys
+import csv, splaytree, sys, re
 from operator import itemgetter
-import getopt, os
+import getopt, os, string
 
 class CodeEntry(object):
 
   def __init__(self, start_addr, name):
     self.start_addr = start_addr
     self.tick_count = 0
     self.name = name
     self.stacks = {}
 
   def Tick(self, pc, stack):
     self.tick_count += 1
     if len(stack) > 0:
       stack.insert(0, self.ToString())
       stack_key = tuple(stack)
       self.stacks[stack_key] = self.stacks.setdefault(stack_key, 0) + 1
 
   def RegionTicks(self):
     return None
 
   def SetStartAddress(self, start_addr):
     self.start_addr = start_addr
 
   def ToString(self):
     return self.name
 
   def IsSharedLibraryEntry(self):
     return False
 
+  def IsICEntry(self):
+    return False
+
 
 class SharedLibraryEntry(CodeEntry):
 
   def __init__(self, start_addr, name):
     CodeEntry.__init__(self, start_addr, name)
 
   def IsSharedLibraryEntry(self):
     return True
 
 
 class JSCodeEntry(CodeEntry):
 
   def __init__(self, start_addr, name, type, size, assembler):
     CodeEntry.__init__(self, start_addr, name)
     self.type = type
     self.size = size
     self.assembler = assembler
     self.region_ticks = None
+    self.builtin_ic_re = re.compile('^(Keyed)?(Call|Load|Store)IC_')
 
   def Tick(self, pc, stack):
     super(JSCodeEntry, self).Tick(pc, stack)
     if not pc is None:
       offset = pc - self.start_addr
       seen = []
       narrowest = None
       narrowest_width = None
       for region in self.Regions():
         if region.Contains(offset):
@@ skipping 22 matching lines @@
       return []
 
   def ToString(self):
     name = self.name
     if name == '':
       name = '<anonymous>'
     elif name.startswith(' '):
       name = '<anonymous>' + name
     return self.type + ': ' + name
 
+  def IsICEntry(self):
+    return self.type in ('CallIC', 'LoadIC', 'StoreIC') or \
+      (self.type == 'Builtin' and self.builtin_ic_re.match(self.name))
+
 
 class CodeRegion(object):
 
   def __init__(self, start_offset, name):
     self.start_offset = start_offset
     self.name = name
     self.end_offset = None
 
   def Contains(self, pc):
     return (self.start_offset <= pc) and (pc <= self.end_offset)
@@ skipping 23 matching lines @@
     self.assemblers = {}
     self.js_entries = splaytree.SplayTree()
     self.cpp_entries = splaytree.SplayTree()
     self.total_number_of_ticks = 0
     self.number_of_library_ticks = 0
     self.unaccounted_number_of_ticks = 0
     self.excluded_number_of_ticks = 0
     # Flag indicating whether to ignore unaccounted ticks in the report
     self.ignore_unknown = False
 
-  def ProcessLogfile(self, filename, included_state = None, ignore_unknown = False):
+  def ProcessLogfile(self, filename, included_state = None, ignore_unknown = False, separate_ic = False):
     self.log_file = filename
     self.included_state = included_state
     self.ignore_unknown = ignore_unknown
+    self.separate_ic = separate_ic
 
     try:
       logfile = open(filename, 'rb')
     except IOError:
       sys.exit("Could not open logfile: " + filename)
     try:
       logreader = csv.reader(logfile)
       for row in logreader:
         if row[0] == 'tick':
-          self.ProcessTick(int(row[1], 16), int(row[2], 16), int(row[3]), row[4:])
+          self.ProcessTick(int(row[1], 16), int(row[2], 16), int(row[3]), self.PreprocessStack(row[4:]))
         elif row[0] == 'code-creation':
           self.ProcessCodeCreation(row[1], int(row[2], 16), int(row[3]), row[4])
         elif row[0] == 'code-move':
           self.ProcessCodeMove(int(row[1], 16), int(row[2], 16))
         elif row[0] == 'code-delete':
           self.ProcessCodeDelete(int(row[1], 16))
         elif row[0] == 'shared-library':
           self.AddSharedLibraryEntry(row[1], int(row[2], 16), int(row[3], 16))
           self.ParseVMSymbols(row[1], int(row[2], 16), int(row[3], 16))
         elif row[0] == 'begin-code-region':
@@ skipping 68 matching lines @@
       if entry != None:
         return entry.value
       else:
         return entry
     max = self.js_entries.FindMax()
     min = self.js_entries.FindMin()
     if max != None and pc < (max.key + max.value.size) and pc > min.key:
       return self.js_entries.FindGreatestsLessThan(pc).value
     return None
 
+  def PreprocessStack(self, stack):
+    # remove all non-addresses (e.g. 'overflow') and convert to int
+    result = []
+    for frame in stack:
+      if frame.startswith('0x'):
+        result.append(int(frame, 16))
+    return result
+
   def ProcessStack(self, stack):
     result = []
     for frame in stack:
-      if frame.startswith('0x'):
-        entry = self.FindEntry(int(frame, 16))
-        if entry != None:
-          result.append(entry.ToString())
+      entry = self.FindEntry(frame)
+      if entry != None:
+        result.append(entry.ToString())
     return result
 
   def ProcessTick(self, pc, sp, state, stack):
     if not self.IncludeTick(pc, sp, state):
       self.excluded_number_of_ticks += 1;
       return
     self.total_number_of_ticks += 1
     entry = self.FindEntry(pc)
     if entry == None:
       self.unaccounted_number_of_ticks += 1
       return
     if entry.IsSharedLibraryEntry():
       self.number_of_library_ticks += 1
-    entry.Tick(pc, self.ProcessStack(stack))
+    if entry.IsICEntry() and not self.separate_ic:
+      if len(stack) > 0:
+        caller_pc = stack.pop(0)
+        self.total_number_of_ticks -= 1
+        self.ProcessTick(caller_pc, sp, state, stack)
+      else:
+        self.unaccounted_number_of_ticks += 1
+    else:
+      entry.Tick(pc, self.ProcessStack(stack))
 
   def PrintResults(self):
     print('Statistical profiling result from %s, (%d ticks, %d unaccounted, %d excluded).' %
           (self.log_file,
            self.total_number_of_ticks,
            self.unaccounted_number_of_ticks,
            self.excluded_number_of_ticks))
     if self.total_number_of_ticks > 0:
       js_entries = self.js_entries.ExportValueList()
       js_entries.extend(self.deleted_code)
@@ skipping 70 matching lines @@
       total_percentage = count * 100.0 / total_stacks
       print('  %(total)5.1f%%  %(call_path)s' % {
         'total' : total_percentage,
         'call_path' : stack[0] + '  <-  ' + stack[1]
       })
 
 
 class CmdLineProcessor(object):
 
   def __init__(self):
+    self.options = ["js", "gc", "compiler", "other", "ignore-unknown", "separate-ic"]
     # default values
     self.state = None
     self.ignore_unknown = False
     self.log_file = None
+    self.separate_ic = False
 
   def ProcessArguments(self):
     try:
-      opts, args = getopt.getopt(sys.argv[1:], "jgco", ["js", "gc", "compiler", "other", "ignore-unknown"])
+      opts, args = getopt.getopt(sys.argv[1:], "jgco", self.options)
     except getopt.GetoptError:
       self.PrintUsageAndExit()
     for key, value in opts:
       if key in ("-j", "--js"):
         self.state = 0
       if key in ("-g", "--gc"):
         self.state = 1
       if key in ("-c", "--compiler"):
         self.state = 2
       if key in ("-o", "--other"):
         self.state = 3
       if key in ("--ignore-unknown"):
         self.ignore_unknown = True
+      if key in ("--separate-ic"):
+        self.separate_ic = True
     self.ProcessRequiredArgs(args)
 
   def ProcessRequiredArgs(self, args):
     return
 
   def GetRequiredArgsNames(self):
     return
 
   def PrintUsageAndExit(self):
-    print('Usage: %(script_name)s --{js,gc,compiler,other} %(req_opts)s' % {
+    print('Usage: %(script_name)s --{%(opts)s} %(req_opts)s' % {
         'script_name': os.path.basename(sys.argv[0]),
+        'opts': string.join(self.options, ','),
         'req_opts': self.GetRequiredArgsNames()
     })
     sys.exit(2)
 
   def RunLogfileProcessing(self, tick_processor):
-    tick_processor.ProcessLogfile(self.log_file, self.state, self.ignore_unknown)
+    tick_processor.ProcessLogfile(self.log_file, self.state, self.ignore_unknown, self.separate_ic)
 
 
 if __name__ == '__main__':
   sys.exit('You probably want to run windows-tick-processor.py or linux-tick-processor.py.')