Include all the code in code creation log events. The code object header size...

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 138 matching lines @@
     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
+    # Flag indicating whether to ignore unaccounted ticks in the report
+    self.ignore_unknown = False
 
-  def ProcessLogfile(self, filename, included_state = None):
+  def ProcessLogfile(self, filename, included_state = None, ignore_unknown = False):
     self.log_file = filename
     self.included_state = included_state
+    self.ignore_unknown = ignore_unknown
+
     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:])
         elif row[0] == 'code-creation':
@@ skipping 73 matching lines @@
   def FindEntry(self, pc):
     page = pc >> 12
     if page in self.vm_extent:
       entry = self.cpp_entries.FindGreatestsLessThan(pc)
       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 and pc > min.key:
+    if max != None and pc < (max.key + max.value.size) and pc > min.key:
       return self.js_entries.FindGreatestsLessThan(pc).value
     return None
 
   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())
@@ skipping 15 matching lines @@
   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)
       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('  %(total)5.1f%%' % {
+          'total' : unknown_percentage,
+        })
       # 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 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('   total  nonlib   name')
 
   def PrintEntries(self, entries, condition):
-    number_of_accounted_ticks = self.total_number_of_ticks - self.unaccounted_number_of_ticks
+    # 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:
       if entry.tick_count > 0 and condition(entry):
         total_percentage = entry.tick_count * 100.0 / number_of_accounted_ticks
         if entry.IsSharedLibraryEntry():
           non_library_percentage = 0
         else:
           non_library_percentage = entry.tick_count * 100.0 / number_of_non_library_ticks
         print('  %(total)5.1f%% %(nonlib)6.1f%%   %(name)s' % {
@@ skipping 24 matching lines @@
     all_stacks_items.sort(key = itemgetter(1), reverse=True)
     for stack, count in all_stacks_items:
       total_percentage = count * 100.0 / total_stacks
       print('  %(total)5.1f%%  %(call_path)s' % {
         'total' : total_percentage,
         'call_path' : stack[0] + '  <-  ' + stack[1]
       })
 
 if __name__ == '__main__':
   sys.exit('You probably want to run windows-tick-processor.py or linux-tick-processor.py.')