Home | History | Annotate | Download | only in timeline 
      1 /*
      2  * Copyright 2014 The Chromium Authors. All rights reserved.
      3  * Use of this source code is governed by a BSD-style license that can be
      4  * found in the LICENSE file.
      5  */
      6 
      7 /**
      8  * @constructor
      9  * @extends {WebInspector.TargetAwareObject}
     10  */
     11 WebInspector.TracingModel = function(target)
     12 {
     13     WebInspector.TargetAwareObject.call(this, target);
     14     this.reset();
     15     this._active = false;
     16     InspectorBackend.registerTracingDispatcher(new WebInspector.TracingDispatcher(this));
     17 }
     18 
     19 WebInspector.TracingModel.Events = {
     20     "BufferUsage": "BufferUsage"
     21 }
     22 
     23 /** @typedef {!{
     24         cat: string,
     25         pid: number,
     26         tid: number,
     27         ts: number,
     28         ph: string,
     29         name: string,
     30         args: !Object,
     31         dur: number,
     32         id: number,
     33         s: string
     34     }}
     35  */
     36 WebInspector.TracingModel.EventPayload;
     37 
     38 /**
     39  * @enum {string}
     40  */
     41 WebInspector.TracingModel.Phase = {
     42     Begin: "B",
     43     End: "E",
     44     Complete: "X",
     45     Instant: "i",
     46     AsyncBegin: "S",
     47     AsyncStepInto: "T",
     48     AsyncStepPast: "p",
     49     AsyncEnd: "F",
     50     FlowBegin: "s",
     51     FlowStep: "t",
     52     FlowEnd: "f",
     53     Metadata: "M",
     54     Counter: "C",
     55     Sample: "P",
     56     CreateObject: "N",
     57     SnapshotObject: "O",
     58     DeleteObject: "D"
     59 };
     60 
     61 WebInspector.TracingModel.MetadataEvent = {
     62     ProcessSortIndex: "process_sort_index",
     63     ProcessName: "process_name",
     64     ThreadSortIndex: "thread_sort_index",
     65     ThreadName: "thread_name"
     66 }
     67 
     68 WebInspector.TracingModel.DevToolsMetadataEventCategory = "disabled-by-default-devtools.timeline";
     69 
     70 WebInspector.TracingModel.FrameLifecycleEventCategory = "cc,devtools";
     71 
     72 WebInspector.TracingModel.DevToolsMetadataEvent = {
     73     TracingStartedInPage: "TracingStartedInPage",
     74 };
     75 
     76 WebInspector.TracingModel.prototype = {
     77     /**
     78      * @return {!Array.<!WebInspector.TracingModel.Event>}
     79      */
     80     devtoolsMetadataEvents: function()
     81     {
     82         return this._devtoolsMetadataEvents;
     83     },
     84 
     85     /**
     86      * @param {string} categoryFilter
     87      * @param {string} options
     88      * @param {function(?string)=} callback
     89      */
     90     start: function(categoryFilter, options, callback)
     91     {
     92         this.reset();
     93         var bufferUsageReportingIntervalMs = 500;
     94         /**
     95          * @param {?string} error
     96          * @param {string} sessionId
     97          * @this {WebInspector.TracingModel}
     98          */
     99         function callbackWrapper(error, sessionId)
    100         {
    101             this._sessionId = sessionId;
    102             if (callback)
    103                 callback(error);
    104         }
    105         TracingAgent.start(categoryFilter, options, bufferUsageReportingIntervalMs, callbackWrapper.bind(this));
    106         this._active = true;
    107     },
    108 
    109     /**
    110      * @param {function()} callback
    111      */
    112     stop: function(callback)
    113     {
    114         if (!this._active) {
    115             callback();
    116             return;
    117         }
    118         this._pendingStopCallback = callback;
    119         TracingAgent.end();
    120     },
    121 
    122     /**
    123      * @return {?string}
    124      */
    125     sessionId: function()
    126     {
    127         return this._sessionId;
    128     },
    129 
    130     /**
    131      * @param {string} sessionId
    132      * @param {!Array.<!WebInspector.TracingModel.EventPayload>} events
    133      */
    134     setEventsForTest: function(sessionId, events)
    135     {
    136         this.reset();
    137         this._sessionId = sessionId;
    138         this._eventsCollected(events);
    139         this._tracingComplete();
    140     },
    141 
    142     /**
    143      * @param {number} usage
    144      */
    145     _bufferUsage: function(usage)
    146     {
    147         this.dispatchEventToListeners(WebInspector.TracingModel.Events.BufferUsage, usage);
    148     },
    149 
    150     /**
    151      * @param {!Array.<!WebInspector.TracingModel.EventPayload>} events
    152      */
    153     _eventsCollected: function(events)
    154     {
    155         for (var i = 0; i < events.length; ++i)
    156             this._addEvent(events[i]);
    157     },
    158 
    159     _tracingComplete: function()
    160     {
    161         this._active = false;
    162         if (!this._pendingStopCallback)
    163             return;
    164         this._pendingStopCallback();
    165         this._pendingStopCallback = null;
    166     },
    167 
    168     reset: function()
    169     {
    170         this._processById = {};
    171         this._minimumRecordTime = 0;
    172         this._maximumRecordTime = 0;
    173         this._sessionId = null;
    174         this._devtoolsMetadataEvents = [];
    175     },
    176 
    177     /**
    178       * @param {!WebInspector.TracingModel.EventPayload} payload
    179       */
    180     _addEvent: function(payload)
    181     {
    182         var process = this._processById[payload.pid];
    183         if (!process) {
    184             process = new WebInspector.TracingModel.Process(payload.pid);
    185             this._processById[payload.pid] = process;
    186         }
    187         var thread = process.threadById(payload.tid);
    188         if (payload.ph !== WebInspector.TracingModel.Phase.Metadata) {
    189             var timestamp = payload.ts / 1000;
    190             // We do allow records for unrelated threads to arrive out-of-order,
    191             // so there's a chance we're getting records from the past.
    192             if (timestamp && (!this._minimumRecordTime || timestamp < this._minimumRecordTime))
    193                 this._minimumRecordTime = timestamp;
    194             if (!this._maximumRecordTime || timestamp > this._maximumRecordTime)
    195                 this._maximumRecordTime = timestamp;
    196             var event = thread.addEvent(payload);
    197             if (payload.ph === WebInspector.TracingModel.Phase.SnapshotObject)
    198                 process.addObject(event);
    199             if (event && event.name === WebInspector.TracingModel.DevToolsMetadataEvent.TracingStartedInPage &&
    200                 event.category === WebInspector.TracingModel.DevToolsMetadataEventCategory &&
    201                 event.args["sessionId"] === this._sessionId)
    202                 this._devtoolsMetadataEvents.push(event);
    203             return;
    204         }
    205         switch (payload.name) {
    206         case WebInspector.TracingModel.MetadataEvent.ProcessSortIndex:
    207             process._setSortIndex(payload.args["sort_index"]);
    208             break;
    209         case WebInspector.TracingModel.MetadataEvent.ProcessName:
    210             process._setName(payload.args["name"]);
    211             break;
    212         case WebInspector.TracingModel.MetadataEvent.ThreadSortIndex:
    213             thread._setSortIndex(payload.args["sort_index"]);
    214             break;
    215         case WebInspector.TracingModel.MetadataEvent.ThreadName:
    216             thread._setName(payload.args["name"]);
    217             break;
    218         }
    219     },
    220 
    221     /**
    222      * @return {number}
    223      */
    224     minimumRecordTime: function()
    225     {
    226         return this._minimumRecordTime;
    227     },
    228 
    229     /**
    230      * @return {number}
    231      */
    232     maximumRecordTime: function()
    233     {
    234         return this._maximumRecordTime;
    235     },
    236 
    237     /**
    238      * @return {!Array.<!WebInspector.TracingModel.Process>}
    239      */
    240     sortedProcesses: function()
    241     {
    242         return WebInspector.TracingModel.NamedObject._sort(Object.values(this._processById));
    243     },
    244 
    245     __proto__: WebInspector.TargetAwareObject.prototype
    246 }
    247 
    248 /**
    249  * @constructor
    250  * @param {!WebInspector.TracingModel.EventPayload} payload
    251  * @param {number} level
    252  * @param {?WebInspector.TracingModel.Thread} thread
    253  */
    254 WebInspector.TracingModel.Event = function(payload, level, thread)
    255 {
    256     this.name = payload.name;
    257     this.category = payload.cat;
    258     this.startTime = payload.ts / 1000;
    259     this.args = payload.args;
    260     this.phase = payload.ph;
    261     this.level = level;
    262 
    263     if (payload.dur)
    264         this._setEndTime((payload.ts + payload.dur) / 1000);
    265 
    266     if (payload.id)
    267         this.id = payload.id;
    268 
    269     this.thread = thread;
    270 
    271     /** @type {?string} */
    272     this.warning = null;
    273     /** @type {?WebInspector.TracingModel.Event} */
    274     this.initiator = null;
    275     /** @type {?Array.<!ConsoleAgent.CallFrame>} */
    276     this.stackTrace = null;
    277     /** @type {?Element} */
    278     this.previewElement = null;
    279     /** @type {?string} */
    280     this.imageURL = null;
    281     /** @type {number} */
    282     this.backendNodeId = 0;
    283 
    284     /** @type {number} */
    285     this.selfTime = 0;
    286 }
    287 
    288 WebInspector.TracingModel.Event.prototype = {
    289     /**
    290      * @param {number} endTime
    291      */
    292     _setEndTime: function(endTime)
    293     {
    294         if (endTime < this.startTime) {
    295             console.assert(false, "Event out of order: " + this.name);
    296             return;
    297         }
    298         this.endTime = endTime;
    299         this.duration = endTime - this.startTime;
    300     },
    301 
    302     /**
    303      * @param {!WebInspector.TracingModel.EventPayload} payload
    304      */
    305     _complete: function(payload)
    306     {
    307         if (this.name !== payload.name) {
    308             console.assert(false, "Open/close event mismatch: " + this.name + " vs. " + payload.name);
    309             return;
    310         }
    311         if (payload.args) {
    312             for (var name in payload.args) {
    313                 if (name in this.args)
    314                     console.error("Same argument name (" + name +  ") is used for begin and end phases of " + this.name);
    315                 this.args[name] = payload.args[name];
    316             }
    317         }
    318         this._setEndTime(payload.ts / 1000);
    319     }
    320 }
    321 
    322 /**
    323  * @param {!WebInspector.TracingModel.Event} a
    324  * @param {!WebInspector.TracingModel.Event} b
    325  * @return {number}
    326  */
    327 WebInspector.TracingModel.Event.compareStartTime = function (a, b)
    328 {
    329     return a.startTime - b.startTime;
    330 }
    331 
    332 /**
    333  * @constructor
    334  */
    335 WebInspector.TracingModel.NamedObject = function()
    336 {
    337 }
    338 
    339 WebInspector.TracingModel.NamedObject.prototype =
    340 {
    341     /**
    342      * @param {string} name
    343      */
    344     _setName: function(name)
    345     {
    346         this._name = name;
    347     },
    348 
    349     /**
    350      * @return {string}
    351      */
    352     name: function()
    353     {
    354         return this._name;
    355     },
    356 
    357     /**
    358      * @param {number} sortIndex
    359      */
    360     _setSortIndex: function(sortIndex)
    361     {
    362         this._sortIndex = sortIndex;
    363     },
    364 }
    365 
    366 /**
    367  * @param {!Array.<!WebInspector.TracingModel.NamedObject>} array
    368  */
    369 WebInspector.TracingModel.NamedObject._sort = function(array)
    370 {
    371     /**
    372      * @param {!WebInspector.TracingModel.NamedObject} a
    373      * @param {!WebInspector.TracingModel.NamedObject} b
    374      */
    375     function comparator(a, b)
    376     {
    377         return a._sortIndex !== b._sortIndex ? a._sortIndex - b._sortIndex : a.name().localeCompare(b.name());
    378     }
    379     return array.sort(comparator);
    380 }
    381 
    382 /**
    383  * @constructor
    384  * @extends {WebInspector.TracingModel.NamedObject}
    385  * @param {number} id
    386  */
    387 WebInspector.TracingModel.Process = function(id)
    388 {
    389     WebInspector.TracingModel.NamedObject.call(this);
    390     this._setName("Process " + id);
    391     this._threads = {};
    392     this._objects = {};
    393 }
    394 
    395 WebInspector.TracingModel.Process.prototype = {
    396     /**
    397      * @param {number} id
    398      * @return {!WebInspector.TracingModel.Thread}
    399      */
    400     threadById: function(id)
    401     {
    402         var thread = this._threads[id];
    403         if (!thread) {
    404             thread = new WebInspector.TracingModel.Thread(this, id);
    405             this._threads[id] = thread;
    406         }
    407         return thread;
    408     },
    409 
    410     /**
    411      * @param {!WebInspector.TracingModel.Event} event
    412      */
    413     addObject: function(event)
    414     {
    415         this.objectsByName(event.name).push(event);
    416     },
    417 
    418     /**
    419      * @param {string} name
    420      * @return {!Array.<!WebInspector.TracingModel.Event>}
    421      */
    422     objectsByName: function(name)
    423     {
    424         var objects = this._objects[name];
    425         if (!objects) {
    426             objects = [];
    427             this._objects[name] = objects;
    428         }
    429         return objects;
    430     },
    431 
    432     /**
    433      * @return {!Array.<string>}
    434      */
    435     sortedObjectNames: function()
    436     {
    437         return Object.keys(this._objects).sort();
    438     },
    439 
    440     /**
    441      * @return {!Array.<!WebInspector.TracingModel.Thread>}
    442      */
    443     sortedThreads: function()
    444     {
    445         return WebInspector.TracingModel.NamedObject._sort(Object.values(this._threads));
    446     },
    447 
    448     __proto__: WebInspector.TracingModel.NamedObject.prototype
    449 }
    450 
    451 /**
    452  * @constructor
    453  * @extends {WebInspector.TracingModel.NamedObject}
    454  * @param {!WebInspector.TracingModel.Process} process
    455  * @param {number} id
    456  */
    457 WebInspector.TracingModel.Thread = function(process, id)
    458 {
    459     WebInspector.TracingModel.NamedObject.call(this);
    460     this._process = process;
    461     this._setName("Thread " + id);
    462     this._events = [];
    463     this._stack = [];
    464     this._maxStackDepth = 0;
    465 }
    466 
    467 WebInspector.TracingModel.Thread.prototype = {
    468     /**
    469      * @param {!WebInspector.TracingModel.EventPayload} payload
    470      * @return {?WebInspector.TracingModel.Event} event
    471      */
    472     addEvent: function(payload)
    473     {
    474         for (var top = this._stack.peekLast(); top && top.endTime && top.endTime <= payload.ts / 1000;) {
    475             this._stack.pop();
    476             top = this._stack.peekLast();
    477         }
    478         if (payload.ph === WebInspector.TracingModel.Phase.End) {
    479             var openEvent = this._stack.pop();
    480             // Quietly ignore unbalanced close events, they're legit (we could have missed start one).
    481             if (openEvent)
    482                 openEvent._complete(payload);
    483             return null;
    484         }
    485 
    486         var event = new WebInspector.TracingModel.Event(payload, this._stack.length, this);
    487         if (payload.ph === WebInspector.TracingModel.Phase.Begin || payload.ph === WebInspector.TracingModel.Phase.Complete) {
    488             this._stack.push(event);
    489             if (this._maxStackDepth < this._stack.length)
    490                 this._maxStackDepth = this._stack.length;
    491         }
    492         if (this._events.length && this._events.peekLast().startTime > event.startTime)
    493             console.assert(false, "Event is our of order: " + event.name);
    494         this._events.push(event);
    495         return event;
    496     },
    497 
    498     /**
    499      * @return {!WebInspector.TracingModel.Process}
    500      */
    501     process: function()
    502     {
    503         return this._process;
    504     },
    505 
    506     /**
    507      * @return {!Array.<!WebInspector.TracingModel.Event>}
    508      */
    509     events: function()
    510     {
    511         return this._events;
    512     },
    513 
    514     /**
    515      * @return {number}
    516      */
    517     maxStackDepth: function()
    518     {
    519         // Reserve one for non-container events.
    520         return this._maxStackDepth + 1;
    521     },
    522 
    523     __proto__: WebInspector.TracingModel.NamedObject.prototype
    524 }
    525 
    526 
    527 /**
    528  * @constructor
    529  * @implements {TracingAgent.Dispatcher}
    530  * @param {!WebInspector.TracingModel} tracingModel
    531  */
    532 WebInspector.TracingDispatcher = function(tracingModel)
    533 {
    534     this._tracingModel = tracingModel;
    535 }
    536 
    537 WebInspector.TracingDispatcher.prototype = {
    538     /**
    539      * @param {number} usage
    540      */
    541     bufferUsage: function(usage)
    542     {
    543         this._tracingModel._bufferUsage(usage);
    544     },
    545 
    546     /**
    547      * @param {!Array.<!WebInspector.TracingModel.EventPayload>} data
    548      */
    549     dataCollected: function(data)
    550     {
    551         this._tracingModel._eventsCollected(data);
    552     },
    553 
    554     tracingComplete: function()
    555     {
    556         this._tracingModel._tracingComplete();
    557     }
    558 }
    559