Fixed numerous issues that were causing errors in profiler log processing

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
@@ skipping 129 matching lines @@
 
 
 class Assembler(object):
 
   def __init__(self):
     # Mapping from region ids to open regions
     self.pending_regions = {}
     self.regions = []
 
 
+class FunctionEnumerator(object):
+
+  def __init__(self):
+    self.known_funcs = {}
+    self.next_func_id = 0
+
+  def GetFunctionId(self, name):
+    if not self.known_funcs.has_key(name):
+      self.known_funcs[name] = self.next_func_id
+      self.next_func_id += 1
+    return self.known_funcs[name]
+
+  def GetKnownFunctions(self):
+    known_funcs_items = self.known_funcs.items();
+    known_funcs_items.sort(key = itemgetter(1))
+    result = []
+    for func, id_not_used in known_funcs_items:
+      result.append(func)
+    return result
+
+
 VMStates = { 'JS': 0, 'GC': 1, 'COMPILER': 2, 'OTHER': 3, 'EXTERNAL' : 4 }
 
 
 class TickProcessor(object):
 
   def __init__(self):
     self.log_file = ''
     self.deleted_code = []
     self.vm_extent = {}
     # Map from assembler ids to the pending assembler objects
     self.pending_assemblers = {}
     # Map from code addresses the have been allocated but not yet officially
     # created to their assemblers.
     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
     self.number_of_gc_ticks = 0
     # Flag indicating whether to ignore unaccounted ticks in the report
     self.ignore_unknown = False
+    self.func_enum = FunctionEnumerator()
+    self.packed_stacks = []
 
-  def ProcessLogfile(self, filename, included_state = None, ignore_unknown = False, separate_ic = False):
+  def ProcessLogfile(self, filename, included_state = None, ignore_unknown = False, separate_ic = False, call_graph_json = False):
     self.log_file = filename
     self.included_state = included_state
     self.ignore_unknown = ignore_unknown
     self.separate_ic = separate_ic
+    self.call_graph_json = call_graph_json
 
     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]), 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':
-          self.ProcessBeginCodeRegion(int(row[1], 16), int(row[2], 16), int(row[3], 16), row[4])
-        elif row[0] == 'end-code-region':
-          self.ProcessEndCodeRegion(int(row[1], 16), int(row[2], 16), int(row[3], 16))
-        elif row[0] == 'code-allocate':
-          self.ProcessCodeAllocate(int(row[1], 16), int(row[2], 16))
+      try:
+        logreader = csv.reader(logfile)
+        row_num = 1
+        for row in logreader:
+          row_num += 1
+          if row[0] == 'tick':
+            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':
+            self.ProcessBeginCodeRegion(int(row[1], 16), int(row[2], 16), int(row[3], 16), row[4])
+          elif row[0] == 'end-code-region':
+            self.ProcessEndCodeRegion(int(row[1], 16), int(row[2], 16), int(row[3], 16))
+          elif row[0] == 'code-allocate':
+            self.ProcessCodeAllocate(int(row[1], 16), int(row[2], 16))
+      except csv.Error:
+        print("parse error in line " + str(row_num))
+        raise
     finally:
       logfile.close()
 
   def AddSharedLibraryEntry(self, filename, start, end):
     # Mark the pages used by this library.
     i = start
     while i < end:
       page = i >> 12
       self.vm_extent[page] = 1
       i += 4096
@@ skipping 91 matching lines @@
       self.number_of_library_ticks += 1
     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))
+      if self.call_graph_json:
+        self.AddToPackedStacks(pc, stack)
+
+  def AddToPackedStacks(self, pc, stack):
+    full_stack = stack
+    full_stack.insert(0, pc)
+    func_names = self.ProcessStack(full_stack)
+    func_ids = []
+    for func in func_names:
+      func_ids.append(self.func_enum.GetFunctionId(func))
+    self.packed_stacks.append(func_ids)
 
   def PrintResults(self):
+    if not self.call_graph_json:
+      self.PrintStatistics()
+    else:
+      self.PrintCallGraphJSON()
+
+  def PrintStatistics(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)
       cpp_entries = self.cpp_entries.ExportValueList()
       # Print the unknown ticks percentage if they are not ignored.
@@ skipping 78 matching lines @@
       'total' : missing_percentage
     })
     for stack, count in all_stacks_items:
       total_percentage = count * 100.0 / self.total_number_of_ticks
       print('  %(ticks)5d  %(total)5.1f%%  %(call_path)s' % {
         'ticks' : count,
         'total' : total_percentage,
         'call_path' : stack[0] + '  <-  ' + stack[1]
       })
 
+  def PrintCallGraphJSON(self):
+    print('\nvar __profile_funcs = ["' +
+          '",\n"'.join(self.func_enum.GetKnownFunctions()) +
+          '"];')
+    print('var __profile_ticks = [')
+    str_packed_stacks = []
+    for stack in self.packed_stacks:
+      str_packed_stacks.append('[' + ','.join(map(str, stack)) + ']')
+    print(',\n'.join(str_packed_stacks))
+    print('];')
 
 class CmdLineProcessor(object):
 
   def __init__(self):
     self.options = ["js",
                     "gc",
                     "compiler",
                     "other",
                     "external",
                     "ignore-unknown",
-                    "separate-ic"]
+                    "separate-ic",
+                    "call-graph-json"]
     # default values
     self.state = None
     self.ignore_unknown = False
     self.log_file = None
     self.separate_ic = False
+    self.call_graph_json = False
 
   def ProcessArguments(self):
     try:
       opts, args = getopt.getopt(sys.argv[1:], "jgcoe", self.options)
     except getopt.GetoptError:
       self.PrintUsageAndExit()
     for key, value in opts:
       if key in ("-j", "--js"):
         self.state = VMStates['JS']
       if key in ("-g", "--gc"):
         self.state = VMStates['GC']
       if key in ("-c", "--compiler"):
         self.state = VMStates['COMPILER']
       if key in ("-o", "--other"):
         self.state = VMStates['OTHER']
       if key in ("-e", "--external"):
         self.state = VMStates['EXTERNAL']
       if key in ("--ignore-unknown"):
         self.ignore_unknown = True
       if key in ("--separate-ic"):
         self.separate_ic = True
+      if key in ("--call-graph-json"):
+        self.call_graph_json = True
     self.ProcessRequiredArgs(args)
 
   def ProcessRequiredArgs(self, args):
     return
 
   def GetRequiredArgsNames(self):
     return
 
   def PrintUsageAndExit(self):
     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, self.separate_ic)
+    tick_processor.ProcessLogfile(self.log_file, self.state, self.ignore_unknown,
+                                  self.separate_ic, self.call_graph_json)
 
 
 if __name__ == '__main__':
   sys.exit('You probably want to run windows-tick-processor.py or linux-tick-processor.py.')