Two small changes regarding GC ticks.

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 = []
 
 
+VMStates = { 'JS': 0, 'GC': 1, 'COMPILER': 2, 'OTHER': 3 }
+
+
 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
 
   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:
@@ skipping 103 matching lines @@
 
   def ProcessStack(self, stack):
     result = []
     for frame in stack:
       entry = self.FindEntry(frame)
       if entry != None:
         result.append(entry.ToString())
     return result
 
   def ProcessTick(self, pc, sp, state, stack):
+    if state == VMStates['GC']:
+      self.number_of_gc_ticks += 1
     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
@@ skipping 13 matching lines @@
            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.
       if not self.ignore_unknown and self.unaccounted_number_of_ticks > 0:
         self.PrintHeader('Unknown')
-        unknown_percentage = self.unaccounted_number_of_ticks * 100.0 / self.total_number_of_ticks
-        print('  %(ticks)5d  %(total)5.1f%%' % {
-          'ticks' : self.unaccounted_number_of_ticks,
-          'total' : unknown_percentage,
-        })
+        self.PrintCounter(self.unaccounted_number_of_ticks)
       # Print the library ticks.
       self.PrintHeader('Shared libraries')
       self.PrintEntries(cpp_entries, lambda e:e.IsSharedLibraryEntry())
       # Print the JavaScript ticks.
       self.PrintHeader('JavaScript')
       self.PrintEntries(js_entries, lambda e:not e.IsSharedLibraryEntry())
       # Print the C++ ticks.
       self.PrintHeader('C++')
       self.PrintEntries(cpp_entries, lambda e:not e.IsSharedLibraryEntry())
+      # Print the GC ticks.
+      self.PrintHeader('GC')
+      self.PrintCounter(self.number_of_gc_ticks)
       # Print call profile.
       print('\n [Call profile]:')
       print('   total  call path')
       js_entries.extend(cpp_entries)
       self.PrintCallProfile(js_entries)
 
   def PrintHeader(self, header_title):
     print('\n [%s]:' % header_title)
     print('   ticks  total  nonlib   name')
 
+  def PrintCounter(self, ticks_count):
+    percentage = ticks_count * 100.0 / self.total_number_of_ticks
+    print('  %(ticks)5d  %(total)5.1f%%' % {
+      'ticks' : ticks_count,
+      'total' : percentage,
+    })
+
   def PrintEntries(self, entries, condition):
     # If ignoring unaccounted ticks don't include these in percentage
     # calculations
     number_of_accounted_ticks = self.total_number_of_ticks
     if self.ignore_unknown:
       number_of_accounted_ticks -= self.unaccounted_number_of_ticks
 
     number_of_non_library_ticks = number_of_accounted_ticks - self.number_of_library_ticks
     entries.sort(key=lambda e:e.tick_count, reverse=True)
     for entry in entries:
@@ skipping 54 matching lines @@
     self.log_file = None
     self.separate_ic = False
 
   def ProcessArguments(self):
     try:
       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
+        self.state = VMStates['JS']
       if key in ("-g", "--gc"):
-        self.state = 1
+        self.state = VMStates['GC']
       if key in ("-c", "--compiler"):
-        self.state = 2
+        self.state = VMStates['COMPILER']
       if key in ("-o", "--other"):
-        self.state = 3
+        self.state = VMStates['OTHER']
       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 --{%(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)
 
 
 if __name__ == '__main__':
   sys.exit('You probably want to run windows-tick-processor.py or linux-tick-processor.py.')