about:tracing support for TRACE_ASYNC_START/FINISH events.

chrome/browser/resources/tracing/trace_event_importer.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview TraceEventImporter imports TraceEvent-formatted data
  * into the provided timeline model.
  */
 cr.define('tracing', function() {
   function ThreadState(tid) {
     this.openSlices = [];
-    this.openNonNestedSlices = {};
   }
 
   function TraceEventImporter(model, eventData) {
     this.model_ = model;
 
     if (typeof(eventData) === 'string' || eventData instanceof String) {
       // If the event data begins with a [, then we know it should end with a ].
       // The reason we check for this is because some tracing implementations
       // cannot guarantee that a ']' gets written to the trace file. So, we are
       // forgiving and if this is obviously the case, we fix it up before
@@ skipping 19 matching lines @@
     // inside a container. E.g { ... , traceEvents: [ ] }
     //
     // If we see that, just pull out the trace events.
     if (this.events_.traceEvents)
       this.events_ = this.events_.traceEvents;
 
     // To allow simple indexing of threads, we store all the threads by a
     // PTID. A ptid is a pid and tid joined together x:y fashion, eg
     // 1024:130. The ptid is a unique key for a thread in the trace.
     this.threadStateByPTID_ = {};
+
+    // Async events need to be processed durign finalizeEvents
+    this.allAsyncEvents_ = [];
   }
 
   /**
    * @return {boolean} Whether obj is a TraceEvent array.
    */
   TraceEventImporter.canImport = function(eventData) {
     // May be encoded JSON. But we dont want to parse it fully yet.
     // Use a simple heuristic:
     //   - eventData that starts with [ are probably trace_event
     //   - eventData that starts with { are probably trace_event
@@ skipping 16 matching lines @@
 
   TraceEventImporter.prototype = {
 
     __proto__: Object.prototype,
 
     /**
      * Helper to process a 'begin' event (e.g. initiate a slice).
      * @param {ThreadState} state Thread state (holds slices).
      * @param {Object} event The current trace event.
      */
-    processBegin: function(index, state, event) {
+    processBeginEvent: function(index, state, event) {
       var colorId = tracing.getStringColorId(event.name);
       var slice =
           { index: index,
-            slice: new tracing.TimelineSlice(event.name, colorId,
-                                             event.ts / 1000,
-                                             event.args) };
+            slice: new tracing.TimelineThreadSlice(event.name, colorId,
+                                                   event.ts / 1000,
+                                                   event.args) };
 
       if (event.uts)
         slice.slice.startInUserTime = event.uts / 1000;
 
       if (event.args['ui-nest'] === '0') {
-        var sliceID = event.name;
-        for (var x in event.args)
-          sliceID += ';' + event.args[x];
-        if (state.openNonNestedSlices[sliceID])
-          this.model_.importErrors.push('Event ' + sliceID + ' already open.');
-        state.openNonNestedSlices[sliceID] = slice;
-      } else {
-        state.openSlices.push(slice);
+        this.model_.importErrors.push('ui-nest no longer supported.')
+        return;
       }
+
+      state.openSlices.push(slice);
     },
 
     /**
      * Helper to process an 'end' event (e.g. close a slice).
      * @param {ThreadState} state Thread state (holds slices).
      * @param {Object} event The current trace event.
      */
-    processEnd: function(state, event) {
+    processEndEvent: function(state, event) {
       if (event.args['ui-nest'] === '0') {
-        var sliceID = event.name;
-        for (var x in event.args)
-          sliceID += ';' + event.args[x];
-        var slice = state.openNonNestedSlices[sliceID];
-        if (!slice)
-          return;
-        slice.slice.duration = (event.ts / 1000) - slice.slice.start;
-        if (event.uts)
-          slice.durationInUserTime = (event.uts / 1000) -
-              slice.slice.startInUserTime;
+        this.model_.importErrors.push('ui-nest no longer supported.')
+        return;
+      }
+      if (state.openSlices.length == 0) {
+        // Ignore E events that are unmatched.
+        return;
+      }
+      var slice = state.openSlices.pop().slice;
+      slice.duration = (event.ts / 1000) - slice.start;
+      if (event.uts)
+        slice.durationInUserTime = (event.uts / 1000) - slice.startInUserTime;
 
-        // Store the slice in a non-nested subrow.
-        var thread =
-            this.model_.getOrCreateProcess(event.pid).
-                getOrCreateThread(event.tid);
-        thread.addNonNestedSlice(slice.slice);
-        delete state.openNonNestedSlices[name];
-      } else {
-        if (state.openSlices.length == 0) {
-          // Ignore E events that are unmatched.
-          return;
-        }
-        var slice = state.openSlices.pop().slice;
-        slice.duration = (event.ts / 1000) - slice.start;
-        if (event.uts)
-          slice.durationInUserTime = (event.uts / 1000) - slice.startInUserTime;
+      // Store the slice on the correct subrow.
+      var thread = this.model_.getOrCreateProcess(event.pid).
+          getOrCreateThread(event.tid);
+      var subRowIndex = state.openSlices.length;
+      thread.getSubrow(subRowIndex).push(slice);
 
-        // Store the slice on the correct subrow.
-        var thread = this.model_.getOrCreateProcess(event.pid).
-            getOrCreateThread(event.tid);
-        var subRowIndex = state.openSlices.length;
-        thread.getSubrow(subRowIndex).push(slice);
+      // Add the slice to the subSlices array of its parent.
+      if (state.openSlices.length) {
+        var parentSlice = state.openSlices[state.openSlices.length - 1];
+        parentSlice.slice.subSlices.push(slice);
+      }
+    },
 
-        // Add the slice to the subSlices array of its parent.
-        if (state.openSlices.length) {
-          var parentSlice = state.openSlices[state.openSlices.length - 1];
-          parentSlice.slice.subSlices.push(slice);
-        }
-      }
+    /**
+     * Helper to process an 'async finish' event, which will close an open slice
+     * on a TimelineAsyncSliceGroup object.
+     **/
+    processAsyncEvent: function(index, state, event) {
+      var thread = this.model_.getOrCreateProcess(event.pid).
+          getOrCreateThread(event.tid);
+      this.allAsyncEvents_.push({
+        event: event,
+        thread: thread});
     },
 
     /**
      * Helper function that closes any open slices. This happens when a trace
      * ends before an 'E' phase event can get posted. When that happens, this
      * closes the slice at the highest timestamp we recorded and sets the
      * didNotFinish flag to true.
      */
     autoCloseOpenSlices: function() {
       // We need to know the model bounds in order to assign an end-time to
       // the open slices.
       this.model_.updateBounds();
 
       // The model's max value in the trace is wrong at this point if there are
       // un-closed events. To close those events, we need the true global max
       // value. To compute this, build a list of timestamps that weren't
-      // included in the max calculation, then compute the real maximum based
-      // on that.
+      // included in the max calculation, then compute the real maximum based on
+      // that.
       var openTimestamps = [];
       for (var ptid in this.threadStateByPTID_) {
         var state = this.threadStateByPTID_[ptid];
         for (var i = 0; i < state.openSlices.length; i++) {
           var slice = state.openSlices[i];
           openTimestamps.push(slice.slice.start);
           for (var s = 0; s < slice.slice.subSlices.length; s++) {
             var subSlice = slice.slice.subSlices[s];
             openTimestamps.push(subSlice.start);
             if (subSlice.duration)
@@ skipping 36 matching lines @@
             parentSlice.slice.subSlices.push(slice.slice);
           }
         }
       }
     },
 
     /**
      * Helper that creates and adds samples to a TimelineCounter object based on
      * 'C' phase events.
      */
-    processCounter: function(event) {
+    processCounterEvent: function(event) {
       var ctr_name;
       if (event.id !== undefined)
         ctr_name = event.name + '[' + event.id + ']';
       else
         ctr_name = event.name;
 
       var ctr = this.model_.getOrCreateProcess(event.pid)
           .getOrCreateCounter(event.cat, ctr_name);
       // Initialize the counter's series fields if needed.
       if (ctr.numSeries == 0) {
@@ skipping 23 matching lines @@
       }
     },
 
     /**
      * Walks through the events_ list and outputs the structures discovered to
      * model_.
      */
     importEvents: function() {
       // Walk through events
       var events = this.events_;
+      // Some events cannot be handled until we have done a first pass over the
+      // data set.  So, accumulate them into a temporary data structure.
+      var second_pass_events = [];
       for (var eI = 0; eI < events.length; eI++) {
         var event = events[eI];
-        var ptid = event.pid + ':' + event.tid;
+        var ptid = tracing.TimelineThread.getPTIDFromPidAndTid(
+            event.pid, event.tid);
 
         if (!(ptid in this.threadStateByPTID_))
           this.threadStateByPTID_[ptid] = new ThreadState();
         var state = this.threadStateByPTID_[ptid];
 
         if (event.ph == 'B') {
-          this.processBegin(eI, state, event);
+          this.processBeginEvent(eI, state, event);
         } else if (event.ph == 'E') {
-          this.processEnd(state, event);
+          this.processEndEvent(state, event);
+        } else if (event.ph == 'S') {
+          this.processAsyncEvent(eI, state, event);
+        } else if (event.ph == 'F') {
+          this.processAsyncEvent(eI, state, event);
         } else if (event.ph == 'I') {
           // Treat an Instant event as a duration 0 slice.
           // TimelineSliceTrack's redraw() knows how to handle this.
-          this.processBegin(eI, state, event);
-          this.processEnd(state, event);
+          this.processBeginEvent(eI, state, event);
+          this.processEndEvent(state, event);
         } else if (event.ph == 'C') {
-          this.processCounter(event);
+          this.processCounterEvent(event);
         } else if (event.ph == 'M') {
           if (event.name == 'thread_name') {
             var thread = this.model_.getOrCreateProcess(event.pid)
                              .getOrCreateThread(event.tid);
             thread.name = event.args.name;
           } else {
             this.model_.importErrors.push(
                 'Unrecognized metadata name: ' + event.name);
           }
         } else {
           this.model_.importErrors.push(
-              'Unrecognized event phase: ' + event.ph +
+            'Unrecognized event phase: ' + event.ph +
               '(' + event.name + ')');
         }
       }
 
       // Autoclose any open slices.
       var hasOpenSlices = false;
       for (var ptid in this.threadStateByPTID_) {
         var state = this.threadStateByPTID_[ptid];
         hasOpenSlices |= state.openSlices.length > 0;
       }
       if (hasOpenSlices)
         this.autoCloseOpenSlices();
+    },
+
+    /**
+     * Called by the TimelineModel after all other importers have imported their
+     * events. This function creates async slices for any async events we saw.
+     */
+    finalizeImport: function() {
+      if (this.allAsyncEvents_.length == 0)
+        return;
+
+      this.allAsyncEvents_.sort(function(x,y) {
+        return x.event.ts - y.event.ts;
+      });
+
+      var startEventStatesByNameThenID = {}
+
+      var allAsyncEvents = this.allAsyncEvents_;
+      for( var i = 0; i < allAsyncEvents.length; i++) {
+        var asyncEventState = allAsyncEvents[i];
+
+        var event = asyncEventState.event;
+        var name = event.name;
+        if (name === undefined) {
+          this.model_.importErrors.push(
+              'Async events (ph: S or F) require an name parameter.')
+          continue;
+        }
+
+        var id = event.id;
+        if (id === undefined) {
+          this.model_.importErrors.push(
+              'Async events (ph: S or F) require an id parameter.')
+          continue;
+        }
+
+        if (event.ph == 'S') {
+          if (startEventStatesByNameThenID[name] === undefined)
+            startEventStatesByNameThenID[name] = {};
+          if (startEventStatesByNameThenID[name][id]) {
+            this.model_.importErrors.push(
+                'At ' + event.ts + ', an slice of the same id ' + id +
+                ' was alrady open.')
+            continue;
+          }
+          startEventStatesByNameThenID[name][id] = asyncEventState;
+        } else {
+          if (startEventStatesByNameThenID[name] === undefined) {
+            this.model_.importErrors.push(
+                'At ' + event.ts + ', no slice named ' + name +
+                ' was open.')
+            continue;
+          }
+          if (startEventStatesByNameThenID[name][id] === undefined) {
+            this.model_.importErrors.push(
+                'At ' + event.ts + ', no slice named ' + name +
+                ' with id=' + id + ' was open.')
+            continue;
+          }
+          var startAsyncEventState = startEventStatesByNameThenID[name][id];
+          delete startEventStatesByNameThenID[name][id];
+
+          // Create a slice from startAsyncEventState to asyncEventState
+          var slice = new tracing.TimelineAsyncSlice(
+              name,
+              tracing.getStringColorId(name),
+              startAsyncEventState.event.ts / 1000);
+
+          slice.duration =
+              (event.ts / 1000) - (startAsyncEventState.event.ts / 1000);
+
+          slice.startThread = startAsyncEventState.thread;
+          slice.endThread = asyncEventState.thread;
+          slice.id = id;
+          if (startAsyncEventState.event.args)
+            slice.args = startAsyncEventState.event.args;
+          else
+            slice.args = {};
+
+          // Add it to the start-thread's asyncSlices.
+          slice.startThread.asyncSlices.push(slice);
+        }
+      }
     }
   };
 
   tracing.TimelineModel.registerImporter(TraceEventImporter);
 
   return {
     TraceEventImporter: TraceEventImporter
   };
 });