Implemented processing of compressed log files.

tools/tickprocessor.js

 // Copyright 2009 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 34 matching lines @@
 function readFile(fileName) {
   try {
     return read(fileName);
   } catch (e) {
     print(fileName + ': ' + (e.message || e));
     throw e;
   }
 }
 
 
+function inherits(childCtor, parentCtor) {
+  function tempCtor() {};
+  tempCtor.prototype = parentCtor.prototype;
+  childCtor.prototype = new tempCtor();
+};
+
+
 function TickProcessor(
     cppEntriesProvider, separateIc, ignoreUnknown, stateFilter) {
+  devtools.profiler.LogReader.call(this, {
+      'shared-library': { parsers: [null, parseInt, parseInt],
+          processor: this.processSharedLibrary },
+      'code-creation': {
+          parsers: [null, this.createAddressParser('code'), parseInt, null],
+          processor: this.processCodeCreation, backrefs: true },
+      'code-move': { parsers: [this.createAddressParser('code'),
+          this.createAddressParser('code-move-to')],
+          processor: this.processCodeMove, backrefs: true },
+      'code-delete': { parsers: [this.createAddressParser('code')],
+          processor: this.processCodeDelete, backrefs: true },
+      'tick': { parsers: [this.createAddressParser('code'),
+          this.createAddressParser('stack'), parseInt, 'var-args'],
+          processor: this.processTick, backrefs: true },
+      'profiler': null,
+      // Obsolete row types.
+      'code-allocate': null,
+      'begin-code-region': null,
+      'end-code-region': null });
+
   this.cppEntriesProvider_ = cppEntriesProvider;
   this.ignoreUnknown_ = ignoreUnknown;
   this.stateFilter_ = stateFilter;
   var ticks = this.ticks_ =
     { total: 0, unaccounted: 0, excluded: 0, gc: 0 };
 
   Profile.prototype.handleUnknownCode = function(
       operation, addr, opt_stackPos) {
     var op = devtools.profiler.Profile.Operation;
     switch (operation) {
@@ skipping 12 matching lines @@
         }
         break;
     }
   };
 
   this.profile_ = new Profile(separateIc);
   this.codeTypes_ = {};
   // Count each tick as a time unit.
   this.viewBuilder_ = new devtools.profiler.ViewBuilder(1);
   this.lastLogFileName_ = null;
-  this.aliases_ = {};
 };
+inherits(TickProcessor, devtools.profiler.LogReader);
 
 
 TickProcessor.VmStates = {
   JS: 0,
   GC: 1,
   COMPILER: 2,
   OTHER: 3,
   EXTERNAL: 4
 };
 
 
 TickProcessor.CodeTypes = {
   CPP: 0,
   SHARED_LIB: 1
 };
 // Otherwise, this is JS-related code. We are not adding it to
 // codeTypes_ map because there can be zillions of them.
 
 
-TickProcessor.RecordsDispatch = {
-  'shared-library': { parsers: [null, parseInt, parseInt],
-                      processor: 'processSharedLibrary' },
-  'code-creation': { parsers: [null, parseInt, parseInt, null],
-                   processor: 'processCodeCreation' },
-  'code-move': { parsers: [parseInt, parseInt],
-                 processor: 'processCodeMove' },
-  'code-delete': { parsers: [parseInt], processor: 'processCodeDelete' },
-  'tick': { parsers: [parseInt, parseInt, parseInt, 'var-args'],
-            processor: 'processTick' },
-  'alias': { parsers: [null, null], processor: 'processAlias' },
-  'profiler': null,
-  // Obsolete row types.
-  'code-allocate': null,
-  'begin-code-region': null,
-  'end-code-region': null
+TickProcessor.CALL_PROFILE_CUTOFF_PCT = 2.0;
+
+
+/**
+ * @override
+ */
+TickProcessor.prototype.printError = function(str) {
+  print(str);
 };
 
-TickProcessor.CALL_PROFILE_CUTOFF_PCT = 2.0;
-
 
 TickProcessor.prototype.setCodeType = function(name, type) {
   this.codeTypes_[name] = TickProcessor.CodeTypes[type];
 };
 
 
 TickProcessor.prototype.isSharedLibrary = function(name) {
   return this.codeTypes_[name] == TickProcessor.CodeTypes.SHARED_LIB;
 };
 
 
 TickProcessor.prototype.isCppCode = function(name) {
   return this.codeTypes_[name] == TickProcessor.CodeTypes.CPP;
 };
 
 
 TickProcessor.prototype.isJsCode = function(name) {
   return !(name in this.codeTypes_);
 };
 
 
 TickProcessor.prototype.processLogFile = function(fileName) {
   this.lastLogFileName_ = fileName;
   var contents = readFile(fileName);
-  this.processLog(contents.split('\n'));
+  this.processLogChunk(contents);
 };
 
 
-TickProcessor.prototype.processLog = function(lines) {
-  var csvParser = new devtools.profiler.CsvParser();
-  for (var i = 0, n = lines.length; i < n; ++i) {
-    var line = lines[i];
-    if (!line) {
-      continue;
-    }
-    var fields = csvParser.parseLine(line);
-    this.dispatchLogRow(fields);
-  }
-};
-
-
-TickProcessor.prototype.dispatchLogRow = function(fields) {
-  // Obtain the dispatch.
-  var command = fields[0];
-  if (!(command in TickProcessor.RecordsDispatch)) {
-    throw new Error('unknown command: ' + command);
-  }
-  var dispatch = TickProcessor.RecordsDispatch[command];
-
-  if (dispatch === null) {
-    return;
-  }
-
-  // Parse fields.
-  var parsedFields = [];
-  for (var i = 0; i < dispatch.parsers.length; ++i) {
-    var parser = dispatch.parsers[i];
-    if (parser === null) {
-      parsedFields.push(fields[1 + i]);
-    } else if (typeof parser == 'function') {
-      parsedFields.push(parser(fields[1 + i]));
-    } else {
-      // var-args
-      parsedFields.push(fields.slice(1 + i));
-      break;
-    }
-  }
-
-  // Run the processor.
-  this[dispatch.processor].apply(this, parsedFields);
-};
-
-
 TickProcessor.prototype.processSharedLibrary = function(
     name, startAddr, endAddr) {
   var entry = this.profile_.addStaticCode(name, startAddr, endAddr);
   this.setCodeType(entry.getName(), 'SHARED_LIB');
 
   var self = this;
   var libFuncs = this.cppEntriesProvider_.parseVmSymbols(
       name, startAddr, endAddr, function(fName, fStart, fEnd) {
     self.profile_.addStaticCode(fName, fStart, fEnd);
     self.setCodeType(fName, 'CPP');
   });
 };
 
 
-TickProcessor.prototype.processAlias = function(symbol, expansion) {
-  if (expansion in TickProcessor.RecordsDispatch) {
-    TickProcessor.RecordsDispatch[symbol] =
-      TickProcessor.RecordsDispatch[expansion];
-  } else {
-    this.aliases_[symbol] = expansion;
-  }
-};
-
-
 TickProcessor.prototype.processCodeCreation = function(
     type, start, size, name) {
-  if (type in this.aliases_) {
-    type = this.aliases_[type];
-  }
-  var entry = this.profile_.addCode(type, name, start, size);
+  var entry = this.profile_.addCode(
+      this.expandAlias(type), name, start, size);
 };
 
 
 TickProcessor.prototype.processCodeMove = function(from, to) {
   this.profile_.moveCode(from, to);
 };
 
 
 TickProcessor.prototype.processCodeDelete = function(start) {
   this.profile_.deleteCode(start);
 };
 
 
 TickProcessor.prototype.includeTick = function(vmState) {
   return this.stateFilter_ == null || this.stateFilter_ == vmState;
 };
 
 
 TickProcessor.prototype.processTick = function(pc, sp, vmState, stack) {
   this.ticks_.total++;
   if (vmState == TickProcessor.VmStates.GC) this.ticks_.gc++;
   if (!this.includeTick(vmState)) {
     this.ticks_.excluded++;
     return;
   }
 
-  var fullStack = [pc];
-  var prevFrame = pc;
-  for (var i = 0, n = stack.length; i < n; ++i) {
-    var frame = stack[i];
-    var firstChar = frame.charAt(0);
-    // Leave only numbers starting with 0x. Filter possible 'overflow' string.
-    if (firstChar == '0') {
-      fullStack.push(parseInt(frame, 16));
-    } else if (firstChar == '+' || firstChar == '-') {
-      // An offset from the previous frame.
-      prevFrame += parseInt(frame, 16);
-      fullStack.push(prevFrame);
-    }
-  }
-  this.profile_.recordTick(fullStack);
+  this.profile_.recordTick(this.processStack(pc, stack));
 };
 
 
 TickProcessor.prototype.printStatistics = function() {
   print('Statistical profiling result from ' + this.lastLogFileName_ +
         ', (' + this.ticks_.total +
         ' ticks, ' + this.ticks_.unaccounted + ' unaccounted, ' +
         this.ticks_.excluded + ' excluded).');
 
   if (this.ticks_.total == 0) return;
@@ skipping 173 matching lines @@
 
 CppEntriesProvider.prototype.loadSymbols = function(libName) {
 };
 
 
 CppEntriesProvider.prototype.parseNextLine = function() {
   return false;
 };
 
 
-function inherits(childCtor, parentCtor) {
-  function tempCtor() {};
-  tempCtor.prototype = parentCtor.prototype;
-  childCtor.prototype = new tempCtor();
-};
-
-
 function UnixCppEntriesProvider() {
   this.symbols = [];
   this.parsePos = 0;
 };
 inherits(UnixCppEntriesProvider, CppEntriesProvider);
 
 
 UnixCppEntriesProvider.FUNC_RE = /^([0-9a-fA-F]{8}) [tTwW] (.*)$/;
 
 
 UnixCppEntriesProvider.prototype.loadSymbols = function(libName) {
   this.parsePos = 0;
   try {
     this.symbols = [
       os.system('nm', ['-C', '-n', libName], -1, -1),
       os.system('nm', ['-C', '-n', '-D', libName], -1, -1)
     ];
   } catch (e) {
     // If the library cannot be found on this system let's not panic.
-    this.symbols = [ '', '' ];
+    this.symbols = ['', ''];
   }
 };
 
 
 UnixCppEntriesProvider.prototype.parseNextLine = function() {
   if (this.symbols.length == 0) {
     return false;
   }
   var lineEndPos = this.symbols[0].indexOf('\n', this.parsePos);
   if (lineEndPos == -1) {
@@ skipping 149 matching lines @@
 
 var params = processArguments(arguments);
 var tickProcessor = new TickProcessor(
     params.platform == 'unix' ? new UnixCppEntriesProvider() :
         new WindowsCppEntriesProvider(),
     params.separateIc,
     params.ignoreUnknown,
     params.stateFilter);
 tickProcessor.processLogFile(params.logFileName);
 tickProcessor.printStatistics();