Add option to limit tick processor to a time range.

tools/plot-timer-events.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 214 matching lines @@
   if (entry) FindCodeKind(entry.kind).in_execution.push(tick);
 
   for (var i = 0; i < kStackFrames; i++) {
     if (!stack[i]) break;
     var entry = code_map.findEntry(stack[i]);
     if (entry) FindCodeKind(entry.kind).stack_frames[i].push(tick);
   }
 }
 
 
-function ProcessDistortion(distortion_in_picoseconds) {
-  distortion_per_entry = distortion_in_picoseconds / 1000000;
-}
-
-
-function ProcessPlotRange(start, end) {
-  xrange_start_override = start;
-  xrange_end_override = end;
-}
-
-
 function FindPlotRange() {
   var start_found = (xrange_start_override || xrange_start_override == 0);
   var end_found = (xrange_end_override || xrange_end_override == 0);
   xrange_start = start_found ? xrange_start_override : Infinity;
   xrange_end = end_found ? xrange_end_override : -Infinity;
 
   if (start_found && end_found) return;
 
   for (name in TimerEvents) {
     var ranges = TimerEvents[name].ranges;
@@ skipping 24 matching lines @@
   pause_tolerance = (xrange_end - xrange_start) / kResX / 10;
 }
 
 
 function parseTimeStamp(timestamp) {
   distortion += distortion_per_entry;
   return parseInt(timestamp) / 1000 - distortion;
 }
 
 
+function ParseArguments(args) {
+  var processor = new ArgumentsProcessor(args);
+  do {
+    if (!processor.parse()) break;
+    var result = processor.result();
+    var distortion = parseInt(result.distortion);
+    if (isNaN(distortion)) break;
+    // Convert picoseconds to milliseconds.
+    distortion_per_entry = distortion / 1000000;
+    var rangelimits = result.range.split(",");
+    var range_start = parseInt(rangelimits[0]);
+    var range_end = parseInt(rangelimits[1]);
+    xrange_start_override = isNaN(range_start) ? undefined : range_start;
+    xrange_end_override = isNaN(range_end) ? undefined : range_end;
+    return;
+  } while (false);
+  processor.printUsageAndExit();
+}
+
+
 function CollectData() {
   // Collect data from log.
   var logreader = new LogReader(
     { 'timer-event-start': { parsers: [null, parseTimeStamp],
                              processor: ProcessTimerEventStart },
       'timer-event-end':   { parsers: [null, parseTimeStamp],
                              processor: ProcessTimerEventEnd },
       'shared-library': { parsers: [null, parseInt, parseInt],
                           processor: ProcessSharedLibrary },
       'code-creation':  { parsers: [null, parseInt, parseInt, parseInt, null],
                           processor: ProcessCodeCreateEvent },
       'code-move':      { parsers: [parseInt, parseInt],
                           processor: ProcessCodeMoveEvent },
       'code-delete':    { parsers: [parseInt],
                           processor: ProcessCodeDeleteEvent },
       'tick':           { parsers: [parseInt, parseInt, parseTimeStamp,
                                     null, null, parseInt, 'var-args'],
-                          processor: ProcessTickEvent },
-      'distortion':     { parsers: [parseInt],
-                          processor: ProcessDistortion },
-      'plot-range':     { parsers: [parseInt, parseInt],
-                          processor: ProcessPlotRange },
+                          processor: ProcessTickEvent }
     });
 
   var line;
   while (line = readline()) {
     logreader.processLogLine(line);
   }
 
   // Collect execution pauses.
   for (name in TimerEvents) {
     var event = TimerEvents[name];
@@ skipping 56 matching lines @@
     if (ranges[i].start <= end && ranges[i].end >= start) {
       result.push(new Range(Math.max(ranges[i].start, start),
                             Math.min(ranges[i].end, end)));
     }
   }
   return result;
 }
 
 
 function GnuplotOutput() {
-  FindPlotRange();
-
   print("set terminal pngcairo size " + kResX + "," + kResY +
         " enhanced font 'Helvetica,10'");
   print("set yrange [0:" + (num_timer_event + 1) + "]");
   print("set xlabel \"execution time in ms\"");
   print("set xrange [" + xrange_start + ":" + xrange_end + "]");
   print("set style fill pattern 2 bo 1");
   print("set style rect fs solid 1 noborder");
   print("set style line 1 lt 1 lw 1 lc rgb \"#000000\"");
   print("set xtics out nomirror");
   print("unset key");
@@ skipping 94 matching lines @@
   // Plot graph with impulses as data set.
   print("plot '-' using 1:2 axes x1y2 with impulses ls 1");
   for (var i = 0; i < execution_pauses.length; i++) {
     var pause = execution_pauses[i];
     print(pause.end + " " + pause.duration());
   }
   print("e");
 }
 
 
+ParseArguments(arguments);
 CollectData();
+FindPlotRange();
 GnuplotOutput();