src/third_party/trace-viewer/trace_viewer/tracing/importer/linux_perf/sync_parser.html

   1 <!DOCTYPE html>
   2 <!--
   3 Copyright (c) 2012 The Chromium Authors. All rights reserved.
   4 Use of this source code is governed by a BSD-style license that can be
   5 found in the LICENSE file.
   6 -->
   7
   8 <link rel="import" href="/tracing/importer/linux_perf/parser.html">
   9
  10 <script>
  11 'use strict';
  12
  13 /**
  14  * @fileoverview Parses sync events in the Linux event trace format.
  15  */
  16 tvcm.exportTo('tracing.importer.linux_perf', function() {
  17
  18   var Parser = tracing.importer.linux_perf.Parser;
  19
  20   /**
  21    * Parses linux sync trace events.
  22    * @constructor
  23    */
  24   function SyncParser(importer) {
  25     Parser.call(this, importer);
  26
  27     importer.registerEventHandler(
  28         'sync_timeline',
  29         SyncParser.prototype.timelineEvent.bind(this));
  30     importer.registerEventHandler(
  31         'sync_wait',
  32         SyncParser.prototype.syncWaitEvent.bind(this));
  33     importer.registerEventHandler(
  34         'sync_pt',
  35         SyncParser.prototype.syncPtEvent.bind(this));
  36     this.model_ = importer.model_;
  37   }
  38
  39   var syncTimelineRE = /name=(\S+) value=(\S*)/;
  40   var syncWaitRE = /(\S+) name=(\S+) state=(\d+)/;
  41   var syncPtRE = /name=(\S+) value=(\S*)/;
  42
  43   SyncParser.prototype = {
  44     __proto__: Parser.prototype,
  45
  46     /**
  47      * Parses sync events and sets up state in the importer.
  48      */
  49     timelineEvent: function(eventName, cpuNumber, pid,
  50                             ts, eventBase) {
  51       var event = syncTimelineRE.exec(eventBase.details);
  52       if (!event)
  53         return false;
  54
  55       var thread = this.importer.getOrCreatePseudoThread(event[1]);
  56
  57       if (thread.lastActiveTs !== undefined) {
  58         var duration = ts - thread.lastActiveTs;
  59         var value = thread.lastActiveValue;
  60         if (value == undefined)
  61           value = ' ';
  62         var slice = new tracing.trace_model.Slice(
  63             '', value,
  64             tvcm.ui.getStringColorId(value),
  65             thread.lastActiveTs, {},
  66             duration);
  67         thread.thread.sliceGroup.pushSlice(slice);
  68       }
  69       thread.lastActiveTs = ts;
  70       thread.lastActiveValue = event[2];
  71       return true;
  72     },
  73
  74     syncWaitEvent: function(eventName, cpuNumber, pid, ts,
  75                             eventBase) {
  76       var event = syncWaitRE.exec(eventBase.details);
  77       if (!event)
  78         return false;
  79
  80       if (eventBase.tgid === undefined) {
  81         return false;
  82       }
  83
  84       var tgid = parseInt(eventBase.tgid);
  85       var thread = this.model_.getOrCreateProcess(tgid)
  86         .getOrCreateThread(pid);
  87       thread.name = eventBase.threadName;
  88       var slices = thread.kernelSliceGroup;
  89       if (!slices.isTimestampValidForBeginOrEnd(ts)) {
  90         this.model_.importWarning({
  91           type: 'parse_error',
  92           message: 'Timestamps are moving backward.'
  93         });
  94         return false;
  95       }
  96
  97       var name = 'fence_wait("' + event[2] + '")';
  98       if (event[1] == 'begin') {
  99         var slice = slices.beginSlice(null, name, ts, {
 100           'Start state': event[3]
 101         });
 102       } else if (event[1] == 'end') {
 103         if (slices.openSliceCount > 0) {
 104           slices.endSlice(ts);
 105         }
 106       } else {
 107         return false;
 108       }
 109
 110       return true;
 111     },
 112
 113     syncPtEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
 114       var event = syncPtRE.exec(eventBase.details);
 115       if (!event)
 116         return false;
 117
 118       return true;
 119
 120       var thread = this.importer.getOrCreateKernelThread(
 121           eventBase[1]).thread;
 122       thread.syncWaitSyncPts[event[1]] = event[2];
 123       return true;
 124     }
 125   };
 126
 127   Parser.registerSubtype(SyncParser);
 128
 129   return {
 130     SyncParser: SyncParser
 131   };
 132 });
 133 </script>
 134