power_parser.js revision 66a37686207944273ced825e0e8b6b6375f8c3de 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5'use strict';
6
7/**
8 * @fileoverview Parses power events in the Linux event trace format.
9 */
10base.require('tracing.importer.linux_perf.parser');
11base.exportTo('tracing.importer.linux_perf', function() {
12
13  var Parser = tracing.importer.linux_perf.Parser;
14
15  /**
16   * Parses linux power trace events.
17   * @constructor
18   */
19  function PowerParser(importer) {
20    Parser.call(this, importer);
21
22    // NB: old-style power events, deprecated
23    importer.registerEventHandler('power_start',
24        PowerParser.prototype.powerStartEvent.bind(this));
25    importer.registerEventHandler('power_frequency',
26        PowerParser.prototype.powerFrequencyEvent.bind(this));
27
28    importer.registerEventHandler('cpu_frequency',
29        PowerParser.prototype.cpuFrequencyEvent.bind(this));
30    importer.registerEventHandler('cpu_idle',
31        PowerParser.prototype.cpuIdleEvent.bind(this));
32  }
33
34  PowerParser.prototype = {
35    __proto__: Parser.prototype,
36
37    cpuStateSlice: function(ts, targetCpuNumber, eventType, cpuState) {
38      var targetCpu = this.importer.getOrCreateCpuState(targetCpuNumber);
39      var powerCounter;
40      if (eventType != '1') {
41        this.importer.importError('Don\'t understand power_start events of ' +
42            'type ' + eventType);
43        return;
44      }
45      powerCounter = targetCpu.cpu.getOrCreateCounter('', 'C-State');
46      if (powerCounter.numSeries == 0) {
47        powerCounter.seriesNames.push('state');
48        powerCounter.seriesColors.push(
49            tracing.getStringColorId(powerCounter.name + '.' + 'state'));
50      }
51      powerCounter.timestamps.push(ts);
52      powerCounter.samples.push(cpuState);
53    },
54
55    cpuIdleSlice: function(ts, targetCpuNumber, cpuState) {
56      var targetCpu = this.importer.getOrCreateCpuState(targetCpuNumber);
57      var powerCounter = targetCpu.cpu.getOrCreateCounter('', 'C-State');
58      if (powerCounter.numSeries == 0) {
59        powerCounter.seriesNames.push('state');
60        powerCounter.seriesColors.push(
61            tracing.getStringColorId(powerCounter.name));
62      }
63      // NB: 4294967295/-1 means an exit from the current state
64      if (cpuState != 4294967295)
65        powerCounter.samples.push(cpuState);
66      else
67        powerCounter.samples.push(0);
68      powerCounter.timestamps.push(ts);
69    },
70
71    cpuFrequencySlice: function(ts, targetCpuNumber, powerState) {
72      var targetCpu = this.importer.getOrCreateCpuState(targetCpuNumber);
73      var powerCounter =
74          targetCpu.cpu.getOrCreateCounter('', 'Clock Frequency');
75      if (powerCounter.numSeries == 0) {
76        powerCounter.seriesNames.push('state');
77        powerCounter.seriesColors.push(
78            tracing.getStringColorId(powerCounter.name + '.' + 'state'));
79      }
80      powerCounter.timestamps.push(ts);
81      powerCounter.samples.push(powerState);
82    },
83
84    /**
85     * Parses power events and sets up state in the importer.
86     */
87    powerStartEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
88      var event = /type=(\d+) state=(\d) cpu_id=(\d)+/.exec(eventBase.details);
89      if (!event)
90        return false;
91
92      var targetCpuNumber = parseInt(event[3]);
93      var cpuState = parseInt(event[2]);
94      this.cpuStateSlice(ts, targetCpuNumber, event[1], cpuState);
95      return true;
96    },
97
98    powerFrequencyEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
99      var event = /type=(\d+) state=(\d+) cpu_id=(\d)+/
100          .exec(eventBase.details);
101      if (!event)
102        return false;
103
104      var targetCpuNumber = parseInt(event[3]);
105      var powerState = parseInt(event[2]);
106      this.cpuFrequencySlice(ts, targetCpuNumber, powerState);
107      return true;
108    },
109
110    cpuFrequencyEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
111      var event = /state=(\d+) cpu_id=(\d)+/.exec(eventBase.details);
112      if (!event)
113        return false;
114
115      var targetCpuNumber = parseInt(event[2]);
116      var powerState = parseInt(event[1]);
117      this.cpuFrequencySlice(ts, targetCpuNumber, powerState);
118      return true;
119    },
120
121    cpuIdleEvent: function(eventName, cpuNumber, pid, ts, eventBase) {
122      var event = /state=(\d+) cpu_id=(\d)+/.exec(eventBase.details);
123      if (!event)
124        return false;
125
126      var targetCpuNumber = parseInt(event[2]);
127      var cpuState = parseInt(event[1]);
128      this.cpuIdleSlice(ts, targetCpuNumber, cpuState);
129      return true;
130    }
131  };
132
133  Parser.registerSubtype(PowerParser);
134
135  return {
136    PowerParser: PowerParser
137  };
138});
139