[--prof] Adding support for RuntimeCallTimerScope based tick separation

tools/tickprocessor.js

 // 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 63 matching lines @@
     cppEntriesProvider,
     separateIc,
     callGraphSize,
     ignoreUnknown,
     stateFilter,
     distortion,
     range,
     sourceMap,
     timedRange,
     pairwiseTimedRange,
-    onlySummary) {
+    onlySummary,
+    runtimeTimerFilter) {
   LogReader.call(this, {
       'shared-library': { parsers: [null, parseInt, parseInt, parseInt],
           processor: this.processSharedLibrary },
       'code-creation': {
           parsers: [null, parseInt, parseInt, parseInt, null, 'var-args'],
           processor: this.processCodeCreation },
       'code-move': { parsers: [parseInt, parseInt],
           processor: this.processCodeMove },
       'code-delete': { parsers: [parseInt],
           processor: this.processCodeDelete },
       'sfi-move': { parsers: [parseInt, parseInt],
           processor: this.processFunctionMove },
+      'active-runtime-timer': {
+        parsers: [null],
+        processor: this.processRuntimeTimerEvent },
       'tick': {
           parsers: [parseInt, parseInt, parseInt,
                     parseInt, parseInt, 'var-args'],
           processor: this.processTick },
       'heap-sample-begin': { parsers: [null, null, parseInt],
           processor: this.processHeapSampleBegin },
       'heap-sample-end': { parsers: [null, null],
           processor: this.processHeapSampleEnd },
       'timer-event-start' : { parsers: [null, null, null],
                               processor: this.advanceDistortion },
@@ skipping 10 matching lines @@
       'code-allocate': null,
       'begin-code-region': null,
       'end-code-region': null },
       timedRange,
       pairwiseTimedRange);
 
   this.cppEntriesProvider_ = cppEntriesProvider;
   this.callGraphSize_ = callGraphSize;
   this.ignoreUnknown_ = ignoreUnknown;
   this.stateFilter_ = stateFilter;
+  this.runtimeTimerFilter_ = runtimeTimerFilter;
   this.sourceMap = sourceMap;
   this.deserializedEntriesNames_ = [];
   var ticks = this.ticks_ =
     { total: 0, unaccounted: 0, excluded: 0, gc: 0 };
 
   distortion = parseInt(distortion);
   // Convert picoseconds to nanoseconds.
   this.distortion_per_entry = isNaN(distortion) ? 0 : (distortion / 1000);
   this.distortion = 0;
   var rangelimits = range ? range.split(",") : [];
@@ skipping 140 matching lines @@
   this.profile_.deleteCode(start);
 };
 
 
 TickProcessor.prototype.processFunctionMove = function(from, to) {
   this.profile_.moveFunc(from, to);
 };
 
 
 TickProcessor.prototype.includeTick = function(vmState) {
-  return this.stateFilter_ == null || this.stateFilter_ == vmState;
+  if (this.stateFilter_ !== null) {
+    return this.stateFilter_ == vmState;
+  } else if (this.runtimeTimerFilter_ !== null) {
+    return this.currentRuntimeTimer == this.runtimeTimerFilter_;
+  }
+  return true;
 };
 
+TickProcessor.prototype.processRuntimeTimerEvent = function(name) {
+  this.currentRuntimeTimer = name;
+}
+
 TickProcessor.prototype.processTick = function(pc,
                                                ns_since_start,
                                                is_external_callback,
                                                tos_or_external_callback,
                                                vmState,
                                                stack) {
   this.distortion += this.distortion_per_entry;
   ns_since_start -= this.distortion;
   if (ns_since_start < this.range_start || ns_since_start > this.range_end) {
     return;
@@ skipping 474 matching lines @@
     '-j': ['stateFilter', TickProcessor.VmStates.JS,
         'Show only ticks from JS VM state'],
     '-g': ['stateFilter', TickProcessor.VmStates.GC,
         'Show only ticks from GC VM state'],
     '-c': ['stateFilter', TickProcessor.VmStates.COMPILER,
         'Show only ticks from COMPILER VM state'],
     '-o': ['stateFilter', TickProcessor.VmStates.OTHER,
         'Show only ticks from OTHER VM state'],
     '-e': ['stateFilter', TickProcessor.VmStates.EXTERNAL,
         'Show only ticks from EXTERNAL VM state'],
+    '--filter-runtime-timer': ['runtimeTimerFilter', null,
+            'Show only ticks matching the given runtime timer scope'],
     '--call-graph-size': ['callGraphSize', TickProcessor.CALL_GRAPH_SIZE,
         'Set the call graph size'],
     '--ignore-unknown': ['ignoreUnknown', true,
         'Exclude ticks of unknown code entries from processing'],
     '--separate-ic': ['separateIc', true,
         'Separate IC entries'],
     '--unix': ['platform', 'unix',
         'Specify that we are running on *nix platform'],
     '--windows': ['platform', 'windows',
         'Specify that we are running on Windows platform'],
@@ skipping 31 matching lines @@
   stateFilter: null,
   callGraphSize: 5,
   ignoreUnknown: false,
   separateIc: false,
   targetRootFS: '',
   nm: 'nm',
   range: 'auto,auto',
   distortion: 0,
   timedRange: false,
   pairwiseTimedRange: false,
-  onlySummary: false
+  onlySummary: false,
+  runtimeTimerFilter: null,
 };
 
 
 ArgumentsProcessor.prototype.parse = function() {
   while (this.args_.length) {
     var arg = this.args_.shift();
     if (arg.charAt(0) != '-') {
       this.result_.logFileName = arg;
       continue;
     }
@@ skipping 39 matching lines @@
     for (var synArg in this.argsDispatch_) {
       if (arg !== synArg && dispatch === this.argsDispatch_[synArg]) {
         synonyms.push(synArg);
         delete this.argsDispatch_[synArg];
       }
     }
     print('  ' + padRight(synonyms.join(', '), 20) + " " + dispatch[2]);
   }
   quit(2);
 };