Add option to limit tick processor to a time range.

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 133 matching lines @@
   return entry ? entry.getRawName() : null;
 };
 
 
 function TickProcessor(
     cppEntriesProvider,
     separateIc,
     callGraphSize,
     ignoreUnknown,
     stateFilter,
-    snapshotLogProcessor) {
+    snapshotLogProcessor,
+    distortion,
+    range) {
   LogReader.call(this, {
       'shared-library': { parsers: [null, 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 },
       'snapshot-pos': { parsers: [parseInt, parseInt],
           processor: this.processSnapshotPosition },
       'tick': {
           parsers: [parseInt, 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 },
+      'timer-event-end' : { parsers: [null, null, null],
+                            processor: this.advanceDistortion },
       // Ignored events.
       'profiler': null,
       'function-creation': null,
       'function-move': null,
       'function-delete': null,
       'heap-sample-item': null,
       // Obsolete row types.
       'code-allocate': null,
       'begin-code-region': null,
       'end-code-region': null });
 
   this.cppEntriesProvider_ = cppEntriesProvider;
   this.callGraphSize_ = callGraphSize;
   this.ignoreUnknown_ = ignoreUnknown;
   this.stateFilter_ = stateFilter;
   this.snapshotLogProcessor_ = snapshotLogProcessor;
   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.split(",");
+  var range_start = parseInt(rangelimits[0]);
+  var range_end = parseInt(rangelimits[1]);
+  // Convert milliseconds to nanoseconds.
+  this.range_start = isNaN(range_start) ? -Infinity : (range_start * 1000);
+  this.range_end = isNaN(range_end) ? Infinity : (range_end * 1000)
+
   V8Profile.prototype.handleUnknownCode = function(
       operation, addr, opt_stackPos) {
     var op = Profile.Operation;
     switch (operation) {
       case op.MOVE:
         print('Code move event for unknown code: 0x' + addr.toString(16));
         break;
       case op.DELETE:
         print('Code delete event for unknown code: 0x' + addr.toString(16));
         break;
@@ skipping 141 matching lines @@
   return this.stateFilter_ == null || this.stateFilter_ == vmState;
 };
 
 TickProcessor.prototype.processTick = function(pc,
                                                sp,
                                                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;
+  }
   this.ticks_.total++;
   if (vmState == TickProcessor.VmStates.GC) this.ticks_.gc++;
   if (!this.includeTick(vmState)) {
     this.ticks_.excluded++;
     return;
   }
   if (is_external_callback) {
     // Don't use PC when in external callback code, as it can point
     // inside callback's code, and we will erroneously report
     // that a callback calls itself. Instead we use tos_or_external_callback,
     // as simply resetting PC will produce unaccounted ticks.
     pc = tos_or_external_callback;
     tos_or_external_callback = 0;
   } else if (tos_or_external_callback) {
     // Find out, if top of stack was pointing inside a JS function
     // meaning that we have encountered a frameless invocation.
     var funcEntry = this.profile_.findEntry(tos_or_external_callback);
     if (!funcEntry || !funcEntry.isJSFunction || !funcEntry.isJSFunction()) {
       tos_or_external_callback = 0;
     }
   }
 
   this.profile_.recordTick(this.processStack(pc, tos_or_external_callback, stack));
 };
 
 
+TickProcessor.prototype.advanceDistortion = function() {
+  this.distortion += this.distortion_per_entry;
+}
+
+
 TickProcessor.prototype.processHeapSampleBegin = function(space, state, ticks) {
   if (space != 'Heap') return;
   this.currentProducerProfile_ = new CallTree();
 };
 
 
 TickProcessor.prototype.processHeapSampleEnd = function(space, state) {
   if (space != 'Heap' || !this.currentProducerProfile_) return;
 
   print('Generation ' + this.generation_ + ':');
@@ skipping 394 matching lines @@
         'Specify that we are running on *nix platform'],
     '--windows': ['platform', 'windows',
         'Specify that we are running on Windows platform'],
     '--mac': ['platform', 'mac',
         'Specify that we are running on Mac OS X platform'],
     '--nm': ['nm', 'nm',
         'Specify the \'nm\' executable to use (e.g. --nm=/my_dir/nm)'],
     '--target': ['targetRootFS', '',
         'Specify the target root directory for cross environment'],
     '--snapshot-log': ['snapshotLogFileName', 'snapshot.log',
-        'Specify snapshot log file to use (e.g. --snapshot-log=snapshot.log)']
+        'Specify snapshot log file to use (e.g. --snapshot-log=snapshot.log)'],
+    '--range': ['range', 'auto,auto',
+                'Specify the range limit as [start],[end]'],
+    '--distortion': ['distortion', 0,
+                     'Specify the logging overhead in picoseconds']
   };
   this.argsDispatch_['--js'] = this.argsDispatch_['-j'];
   this.argsDispatch_['--gc'] = this.argsDispatch_['-g'];
   this.argsDispatch_['--compiler'] = this.argsDispatch_['-c'];
   this.argsDispatch_['--other'] = this.argsDispatch_['-o'];
   this.argsDispatch_['--external'] = this.argsDispatch_['-e'];
 };
 
 
 ArgumentsProcessor.DEFAULTS = {
   logFileName: 'v8.log',
   snapshotLogFileName: null,
   platform: 'unix',
   stateFilter: null,
   callGraphSize: 5,
   ignoreUnknown: false,
   separateIc: false,
   targetRootFS: '',
-  nm: 'nm'
+  nm: 'nm',
+  range: 'auto,auto',
+  distortion: 0
 };
 
 
 ArgumentsProcessor.prototype.parse = function() {
   while (this.args_.length) {
     var arg = this.args_[0];
     if (arg.charAt(0) != '-') {
       break;
     }
     this.args_.shift();
@@ skipping 44 matching lines @@
       if (arg !== synArg && dispatch === this.argsDispatch_[synArg]) {
         synonims.push(synArg);
         delete this.argsDispatch_[synArg];
       }
     }
     print('  ' + padRight(synonims.join(', '), 20) + dispatch[2]);
   }
   quit(2);
 };