Javascript
|
1000行
|
35.24 KB
// 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 Imports text files in the Linux event trace format into the
* timeline model. This format is output both by sched_trace and by Linux's perf
* tool.
*
* This importer assumes the events arrive as a string. The unit tests provide
* examples of the trace format.
*
* Linux scheduler traces use a definition for 'pid' that is different than
* tracing uses. Whereas tracing uses pid to identify a specific process, a pid
* in a linux trace refers to a specific thread within a process. Within this
* file, we the definition used in Linux traces, as it improves the importing
* code's readability.
*/
cr.define('tracing', function() {
/**
* Represents the scheduling state for a single thread.
* @constructor
*/
function CpuState(cpu) {
this.cpu = cpu;
}
CpuState.prototype = {
__proto__: Object.prototype,
/**
* Switches the active pid on this Cpu. If necessary, add a TimelineSlice
* to the cpu representing the time spent on that Cpu since the last call to
* switchRunningLinuxPid.
*/
switchRunningLinuxPid: function(importer, prevState, ts, pid, comm, prio) {
// Generate a slice if the last active pid was not the idle task
if (this.lastActivePid !== undefined && this.lastActivePid != 0) {
var duration = ts - this.lastActiveTs;
var thread = importer.threadsByLinuxPid[this.lastActivePid];
if (thread)
name = thread.userFriendlyName;
else
name = this.lastActiveComm;
var slice = new tracing.TimelineSlice(name,
tracing.getStringColorId(name),
this.lastActiveTs,
{
comm: this.lastActiveComm,
tid: this.lastActivePid,
prio: this.lastActivePrio,
stateWhenDescheduled: prevState
},
duration);
this.cpu.slices.push(slice);
}
this.lastActiveTs = ts;
this.lastActivePid = pid;
this.lastActiveComm = comm;
this.lastActivePrio = prio;
}
};
function ThreadState(tid) {
this.openSlices = [];
}
/**
* Imports linux perf events into a specified model.
* @constructor
*/
function LinuxPerfImporter(model, events, isAdditionalImport) {
this.isAdditionalImport_ = isAdditionalImport;
this.model_ = model;
this.events_ = events;
this.clockSyncRecords_ = [];
this.cpuStates_ = {};
this.kernelThreadStates_ = {};
this.buildMapFromLinuxPidsToTimelineThreads();
this.lineNumber = -1;
// To allow simple indexing of threads, we store all the threads by their
// kernel KPID. The KPID is a unique key for a thread in the trace.
this.threadStateByKPID_ = {};
}
TestExports = {};
// Matches the generic trace record:
// <idle>-0 [001] .... 1.23: sched_switch
var lineRE = /^\s*(.+?)\s+\[(\d+)\]\s*([d.][N.][sh.][\d.])?\s*(\d+\.\d+):\s+(\S+):\s(.*)$/;
TestExports.lineRE = lineRE;
// Matches the trace_event_clock_sync record
// 0: trace_event_clock_sync: parent_ts=19581477508
var traceEventClockSyncRE = /trace_event_clock_sync: parent_ts=(\d+\.?\d*)/;
TestExports.traceEventClockSyncRE = traceEventClockSyncRE;
/**
* Guesses whether the provided events is a Linux perf string.
* Looks for the magic string "# tracer" at the start of the file,
* or the typical task-pid-cpu-timestamp-function sequence of a typical
* trace's body.
*
* @return {boolean} True when events is a linux perf array.
*/
LinuxPerfImporter.canImport = function(events) {
if (!(typeof(events) === 'string' || events instanceof String))
return false;
if (/^# tracer:/.exec(events))
return true;
var m = /^(.+)\n/.exec(events);
if (m)
events = m[1];
if (lineRE.exec(events))
return true;
return false;
};
LinuxPerfImporter.prototype = {
__proto__: Object.prototype,
/**
* Precomputes a lookup table from linux pids back to existing
* TimelineThreads. This is used during importing to add information to each
* timeline thread about whether it was running, descheduled, sleeping, et
* cetera.
*/
buildMapFromLinuxPidsToTimelineThreads: function() {
this.threadsByLinuxPid = {};
this.model_.getAllThreads().forEach(
function(thread) {
this.threadsByLinuxPid[thread.tid] = thread;
}.bind(this));
},
/**
* @return {CpuState} A CpuState corresponding to the given cpuNumber.
*/
getOrCreateCpuState: function(cpuNumber) {
if (!this.cpuStates_[cpuNumber]) {
var cpu = this.model_.getOrCreateCpu(cpuNumber);
this.cpuStates_[cpuNumber] = new CpuState(cpu);
}
return this.cpuStates_[cpuNumber];
},
/**
* @return {number} The pid extracted from the kernel thread name.
*/
parsePid: function(kernelThreadName) {
var pid = /.+-(\d+)/.exec(kernelThreadName)[1];
pid = parseInt(pid);
return pid;
},
/**
* @return {number} The string portion of the thread extracted from the
* kernel thread name.
*/
parseThreadName: function(kernelThreadName) {
return /(.+)-\d+/.exec(kernelThreadName)[1];
},
/**
* @return {TimelinThread} A thread corresponding to the kernelThreadName.
*/
getOrCreateKernelThread: function(kernelThreadName, opt_pid, opt_tid) {
if (!this.kernelThreadStates_[kernelThreadName]) {
var pid = opt_pid;
if (pid == undefined) {
pid = this.parsePid(kernelThreadName);
}
var tid = opt_tid;
if (tid == undefined)
tid = pid;
var thread = this.model_.getOrCreateProcess(pid).getOrCreateThread(tid);
thread.name = kernelThreadName;
this.kernelThreadStates_[kernelThreadName] = {
pid: pid,
thread: thread,
openSlice: undefined,
openSliceTS: undefined,
asyncSlices: {}
};
this.threadsByLinuxPid[pid] = thread;
}
return this.kernelThreadStates_[kernelThreadName];
},
/**
* Imports the data in this.events_ into model_.
*/
importEvents: function() {
this.importCpuData();
if (!this.alignClocks())
return;
this.buildPerThreadCpuSlicesFromCpuState();
},
/**
* Called by the TimelineModel after all other importers have imported their
* events.
*/
finalizeImport: function() {
},
/**
* Builds the cpuSlices array on each thread based on our knowledge of what
* each Cpu is doing. This is done only for TimelineThreads that are
* already in the model, on the assumption that not having any traced data
* on a thread means that it is not of interest to the user.
*/
buildPerThreadCpuSlicesFromCpuState: function() {
// Push the cpu slices to the threads that they run on.
for (var cpuNumber in this.cpuStates_) {
var cpuState = this.cpuStates_[cpuNumber];
var cpu = cpuState.cpu;
for (var i = 0; i < cpu.slices.length; i++) {
var slice = cpu.slices[i];
var thread = this.threadsByLinuxPid[slice.args.tid];
if (!thread)
continue;
if (!thread.tempCpuSlices)
thread.tempCpuSlices = [];
// Because Chrome's Array.sort is not a stable sort, we need to keep
// the slice index around to keep slices with identical start times in
// the proper order when sorting them.
slice.index = i;
thread.tempCpuSlices.push(slice);
}
}
// Create slices for when the thread is not running.
var runningId = tracing.getColorIdByName('running');
var runnableId = tracing.getColorIdByName('runnable');
var sleepingId = tracing.getColorIdByName('sleeping');
var ioWaitId = tracing.getColorIdByName('iowait');
this.model_.getAllThreads().forEach(function(thread) {
if (!thread.tempCpuSlices)
return;
var origSlices = thread.tempCpuSlices;
delete thread.tempCpuSlices;
origSlices.sort(function(x, y) {
var delta = x.start - y.start;
if (delta == 0) {
// Break ties using the original slice ordering.
return x.index - y.index;
} else {
return delta;
}
});
// Walk the slice list and put slices between each original slice
// to show when the thread isn't running
var slices = [];
if (origSlices.length) {
var slice = origSlices[0];
slices.push(new tracing.TimelineSlice('Running', runningId,
slice.start, {}, slice.duration));
}
for (var i = 1; i < origSlices.length; i++) {
var prevSlice = origSlices[i - 1];
var nextSlice = origSlices[i];
var midDuration = nextSlice.start - prevSlice.end;
if (prevSlice.args.stateWhenDescheduled == 'S') {
slices.push(new tracing.TimelineSlice('Sleeping', sleepingId,
prevSlice.end, {}, midDuration));
} else if (prevSlice.args.stateWhenDescheduled == 'R' ||
prevSlice.args.stateWhenDescheduled == 'R+') {
slices.push(new tracing.TimelineSlice('Runnable', runnableId,
prevSlice.end, {}, midDuration));
} else if (prevSlice.args.stateWhenDescheduled == 'D') {
slices.push(new tracing.TimelineSlice(
'Uninterruptible Sleep', ioWaitId,
prevSlice.end, {}, midDuration));
} else if (prevSlice.args.stateWhenDescheduled == 'T') {
slices.push(new tracing.TimelineSlice('__TASK_STOPPED', ioWaitId,
prevSlice.end, {}, midDuration));
} else if (prevSlice.args.stateWhenDescheduled == 't') {
slices.push(new tracing.TimelineSlice('debug', ioWaitId,
prevSlice.end, {}, midDuration));
} else if (prevSlice.args.stateWhenDescheduled == 'Z') {
slices.push(new tracing.TimelineSlice('Zombie', ioWaitId,
prevSlice.end, {}, midDuration));
} else if (prevSlice.args.stateWhenDescheduled == 'X') {
slices.push(new tracing.TimelineSlice('Exit Dead', ioWaitId,
prevSlice.end, {}, midDuration));
} else if (prevSlice.args.stateWhenDescheduled == 'x') {
slices.push(new tracing.TimelineSlice('Task Dead', ioWaitId,
prevSlice.end, {}, midDuration));
} else if (prevSlice.args.stateWhenDescheduled == 'W') {
slices.push(new tracing.TimelineSlice('WakeKill', ioWaitId,
prevSlice.end, {}, midDuration));
} else if (prevSlice.args.stateWhenDescheduled == 'D|W') {
slices.push(new tracing.TimelineSlice(
'Uninterruptible Sleep | WakeKill', ioWaitId,
prevSlice.end, {}, midDuration));
} else {
throw 'Unrecognized state: ' + prevSlice.args.stateWhenDescheduled;
}
slices.push(new tracing.TimelineSlice('Running', runningId,
nextSlice.start, {}, nextSlice.duration));
}
thread.cpuSlices = slices;
});
},
/**
* Walks the slices stored on this.cpuStates_ and adjusts their timestamps
* based on any alignment metadata we discovered.
*/
alignClocks: function() {
if (this.clockSyncRecords_.length == 0) {
// If this is an additional import, and no clock syncing records were
// found, then abort the import. Otherwise, just skip clock alignment.
if (!this.isAdditionalImport_)
return;
// Remove the newly imported CPU slices from the model.
this.abortImport();
return false;
}
// Shift all the slice times based on the sync record.
var sync = this.clockSyncRecords_[0];
// NB: parentTS of zero denotes no times-shift; this is
// used when user and kernel event clocks are identical.
if (sync.parentTS == 0 || sync.parentTS == sync.perfTS)
return true;
var timeShift = sync.parentTS - sync.perfTS;
for (var cpuNumber in this.cpuStates_) {
var cpuState = this.cpuStates_[cpuNumber];
var cpu = cpuState.cpu;
for (var i = 0; i < cpu.slices.length; i++) {
var slice = cpu.slices[i];
slice.start = slice.start + timeShift;
slice.duration = slice.duration;
}
for (var counterName in cpu.counters) {
var counter = cpu.counters[counterName];
for (var sI = 0; sI < counter.timestamps.length; sI++)
counter.timestamps[sI] = (counter.timestamps[sI] + timeShift);
}
}
for (var kernelThreadName in this.kernelThreadStates_) {
var kthread = this.kernelThreadStates_[kernelThreadName];
var thread = kthread.thread;
for (var i = 0; i < thread.subRows[0].length; i++) {
thread.subRows[0][i].start += timeShift;
}
}
return true;
},
/**
* Removes any data that has been added to the model because of an error
* detected during the import.
*/
abortImport: function() {
if (this.pushedEventsToThreads)
throw 'Cannot abort, have alrady pushedCpuDataToThreads.';
for (var cpuNumber in this.cpuStates_)
delete this.model_.cpus[cpuNumber];
for (var kernelThreadName in this.kernelThreadStates_) {
var kthread = this.kernelThreadStates_[kernelThreadName];
var thread = kthread.thread;
var process = thread.parent;
delete process.threads[thread.tid];
delete this.model_.processes[process.pid];
}
this.model_.importErrors.push(
'Cannot import kernel trace without a clock sync.');
},
/**
* Records the fact that a pid has become runnable. This data will
* eventually get used to derive each thread's cpuSlices array.
*/
markPidRunnable: function(ts, pid, comm, prio) {
// TODO(nduca): implement this functionality.
},
importError: function(message) {
this.model_.importErrors.push('Line ' + (this.lineNumber + 1) +
': ' + message);
},
malformedEvent: function(eventName) {
this.importError('Malformed ' + eventName + ' event');
},
/**
* Helper to open a kernel thread slice.
*/
openSlice: function(kthread, name, ts) {
kthread.openSliceTS = ts;
kthread.openSlice = name;
},
/**
* Helper to close a kernel thread slice.
*/
closeSlice: function(kthread, ts, data) {
if (kthread.openSlice) {
var slice = new tracing.TimelineSlice(kthread.openSlice,
tracing.getStringColorId(kthread.openSlice),
kthread.openSliceTS,
data,
ts - kthread.openSliceTS);
kthread.thread.subRows[0].push(slice);
kthread.openSlice = undefined;
}
},
/**
* Helper to open an async slice.
*/
openAsyncSlice: function(kthread, key, ts, name) {
var slice = new tracing.TimelineAsyncSlice(name,
tracing.getStringColorId(name), ts);
slice.startThread = kthread.thread;
kthread.asyncSlices[key] = slice;
},
/**
* Helper to close an async slice.
*/
closeAsyncSlice: function(kthread, key, ts, data) {
var slice = kthread.asyncSlices[key];
if (slice) {
slice.duration = ts - slice.start;
slice.args = data;
slice.endThread = kthread.thread;
slice.subSlices = [ new tracing.TimelineSlice(slice.title,
slice.colorId, slice.start, slice.args, slice.duration) ];
kthread.thread.asyncSlices.push(slice);
delete kthread.asyncSlices[key];
}
},
/**
* Helper to get a ThreadState for a given taskId.
*/
getThreadState: function(taskId) {
var kpid = this.parsePid(taskId);
return this.threadStateByKPID_[kpid];
},
/**
* Helper to get or create a ThreadState for a given taskId.
*/
getOrCreateThreadState: function(taskId, pid) {
var kpid = this.parsePid(taskId);
var state = this.threadStateByKPID_[kpid];
if (!state) {
state = new ThreadState();
state.threadName = this.parseThreadName(taskId);
state.tid = kpid;
state.pid = pid;
state.thread = this.model_.getOrCreateProcess(pid).
getOrCreateThread(kpid);
this.threadsByLinuxPid[kpid] = state.thread;
if (!state.thread.name) {
state.thread.name = state.threadName;
}
this.threadStateByKPID_[kpid] = state;
}
return state;
},
/**
* Helper to process a 'begin' event (e.g. initiate a slice).
* @param {string} name The trace event name.
* @param {number} ts The trace event begin timestamp.
*/
processBegin: function(taskId, name, ts, pid) {
var state = this.getOrCreateThreadState(taskId, pid);
var colorId = tracing.getStringColorId(name);
var slice = new tracing.TimelineThreadSlice(name, colorId, ts, null);
state.openSlices.push(slice);
},
/**
* Helper to process an 'end' event (e.g. close a slice).
* @param {number} ts The trace event begin timestamp.
*/
processEnd: function(taskId, ts) {
var state = this.getThreadState(taskId);
if (!state || state.openSlices.length == 0) {
// Ignore E events that are unmatched.
return;
}
var slice = state.openSlices.pop();
slice.duration = ts - slice.start;
// Store the slice on the correct subrow.
var subRowIndex = state.openSlices.length;
state.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.subSlices.push(slice);
}
},
/**
* 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.
var openTimestamps = [];
for (var kpid in this.threadStateByKPID_) {
var state = this.threadStateByKPID_[kpid];
for (var i = 0; i < state.openSlices.length; i++) {
var slice = state.openSlices[i];
openTimestamps.push(slice.start);
for (var s = 0; s < slice.subSlices.length; s++) {
var subSlice = slice.subSlices[s];
openTimestamps.push(subSlice.start);
if (subSlice.duration)
openTimestamps.push(subSlice.end);
}
}
}
// Figure out the maximum value of model.maxTimestamp and
// Math.max(openTimestamps). Made complicated by the fact that the model
// timestamps might be undefined.
var realMaxTimestamp;
if (this.model_.maxTimestamp) {
realMaxTimestamp = Math.max(this.model_.maxTimestamp,
Math.max.apply(Math, openTimestamps));
} else {
realMaxTimestamp = Math.max.apply(Math, openTimestamps);
}
// Automatically close any slices are still open. These occur in a number
// of reasonable situations, e.g. deadlock. This pass ensures the open
// slices make it into the final model.
for (var kpid in this.threadStateByKPID_) {
var state = this.threadStateByKPID_[kpid];
while (state.openSlices.length > 0) {
var slice = state.openSlices.pop();
slice.duration = realMaxTimestamp - slice.start;
slice.didNotFinish = true;
// Store the slice on the correct subrow.
var subRowIndex = state.openSlices.length;
state.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.subSlices.push(slice);
}
}
}
},
/**
* Helper that creates and adds samples to a TimelineCounter object based on
* 'C' phase events.
*/
processCounter: function(name, ts, value, pid) {
var ctr = this.model_.getOrCreateProcess(pid)
.getOrCreateCounter('', name);
// Initialize the counter's series fields if needed.
//
if (ctr.numSeries == 0) {
ctr.seriesNames.push('state');
ctr.seriesColors.push(
tracing.getStringColorId(ctr.name + '.' + 'state'));
}
// Add the sample values.
ctr.timestamps.push(ts);
ctr.samples.push(value);
},
/**
* Walks the this.events_ structure and creates TimelineCpu objects.
*/
importCpuData: function() {
this.lines_ = this.events_.split('\n');
for (this.lineNumber = 0; this.lineNumber < this.lines_.length;
++this.lineNumber) {
var line = this.lines_[this.lineNumber];
if (/^#/.exec(line) || line.length == 0)
continue;
var eventBase = lineRE.exec(line);
if (!eventBase) {
this.importError('Unrecognized line: ' + line);
continue;
}
var taskId = eventBase[1];
var cpuNum = eventBase[2];
var taskInfo = eventBase[3];
var timestamp = eventBase[4];
var eventName = eventBase[5];
var eventInfo = eventBase[6];
var eventDefinition = this.eventDefinitions[eventName];
if (eventDefinition) {
// Parse the event info.
var event;
if (eventDefinition.format) {
event = eventDefinition.format.exec(eventInfo);
if (!event) {
this.malformedEvent(eventName);
continue;
}
} else {
event = {};
}
// Add the basic event properties.
event.timestamp = parseFloat(timestamp) * 1000;
event.name = eventName;
event.info = eventInfo;
event.taskId = taskId;
event.cpuState = this.getOrCreateCpuState(parseInt(cpuNum));
// Invoke the handler.
if (eventDefinition.handler) {
eventDefinition.handler(this, event);
}
} else {
console.log('unknown event ' + eventName);
}
}
},
/**
* Table of supported events represented as an associative array indexed by event name.
* Each event definition has the following properties:
*
* format: A regular expression to parse the event info.
* If omitted, the event information is not parsed but the other basic
* properties are still provided to the event handler.
* handler: A handler function to invoke to handle the event.
* If omitted, the event is parsed but not handled.
*
* The event object passed as a parameter to the handler has the matched groups from
* from the regular expression and in addition has the following properties:
*
* timestamp: The uptime in milliseconds.
* name: The event name.
* info: The unparsed event info.
* taskId: The task ID.
* cpuState: The CPU state object for the CPU associated with the event.
*/
eventDefinitions: {
'sched_switch': {
format: new RegExp(
'prev_comm=(.+) prev_pid=(\\d+) prev_prio=(\\d+) prev_state=(\\S+) ==> ' +
'next_comm=(.+) next_pid=(\\d+) next_prio=(\\d+)'),
handler: function(importer, event) {
var prevState = event[4];
var nextComm = event[5];
var nextPid = parseInt(event[6]);
var nextPrio = parseInt(event[7]);
event.cpuState.switchRunningLinuxPid(
importer, prevState, event.timestamp, nextPid, nextComm, nextPrio);
}
},
'sched_wakeup': {
format: /comm=(.+) pid=(\d+) prio=(\d+) success=(\d+) target_cpu=(\d+)/,
handler: function(importer, event) {
var comm = event[1];
var pid = parseInt(event[2]);
var prio = parseInt(event[3]);
importer.markPidRunnable(event.timestamp, pid, comm, prio);
}
},
'power_start': { // NB: old-style power event, deprecated
format: /type=(\d+) state=(\d) cpu_id=(\d)+/,
handler: function(importer, event) {
var targetCpuNumber = parseInt(event[3]);
var targetCpu = importer.getOrCreateCpuState(targetCpuNumber);
var powerCounter;
if (event[1] == '1') {
powerCounter = targetCpu.cpu.getOrCreateCounter('', 'C-State');
} else {
importer.importError('Don\'t understand power_start events of ' +
'type ' + event[1]);
return;
}
if (powerCounter.numSeries == 0) {
powerCounter.seriesNames.push('state');
powerCounter.seriesColors.push(
tracing.getStringColorId(powerCounter.name + '.' + 'state'));
}
var powerState = parseInt(event[2]);
powerCounter.timestamps.push(event.timestamp);
powerCounter.samples.push(powerState);
}
},
'power_frequency': { // NB: old-style power event, deprecated
format: /type=(\d+) state=(\d+) cpu_id=(\d)+/,
handler: function(importer, event) {
var targetCpuNumber = parseInt(event[3]);
var targetCpu = importer.getOrCreateCpuState(targetCpuNumber);
var powerCounter = targetCpu.cpu.getOrCreateCounter('', 'Power Frequency');
if (powerCounter.numSeries == 0) {
powerCounter.seriesNames.push('state');
powerCounter.seriesColors.push(
tracing.getStringColorId(powerCounter.name + '.' + 'state'));
}
var powerState = parseInt(event[2]);
powerCounter.timestamps.push(event.timestamp);
powerCounter.samples.push(powerState);
}
},
'cpu_frequency': {
format: /state=(\d+) cpu_id=(\d)+/,
handler: function(importer, event) {
var targetCpuNumber = parseInt(event[2]);
var targetCpu = importer.getOrCreateCpuState(targetCpuNumber);
var powerCounter = targetCpu.cpu.getOrCreateCounter('', 'Clock Frequency');
if (powerCounter.numSeries == 0) {
powerCounter.seriesNames.push('state');
powerCounter.seriesColors.push(
tracing.getStringColorId(powerCounter.name + '.' + 'state'));
}
var powerState = parseInt(event[1]);
powerCounter.timestamps.push(event.timestamp);
powerCounter.samples.push(powerState);
}
},
'cpu_idle': {
format: /state=(\d+) cpu_id=(\d)+/,
handler: function(importer, event) {
var targetCpuNumber = parseInt(event[2]);
var targetCpu = importer.getOrCreateCpuState(targetCpuNumber);
var powerCounter = targetCpu.cpu.getOrCreateCounter('', 'C-State');
if (powerCounter.numSeries == 0) {
powerCounter.seriesNames.push('state');
powerCounter.seriesColors.push(
tracing.getStringColorId(powerCounter.name));
}
var powerState = parseInt(event[1]);
// NB: 4294967295/-1 means an exit from the current state
if (powerState != 4294967295)
powerCounter.samples.push(powerState);
else
powerCounter.samples.push(0);
powerCounter.timestamps.push(event.timestamp);
}
},
'workqueue_execute_start': {
// workqueue_execute_start: work struct c7a8a89c: function MISRWrapper
format: /work struct (.+): function (\S+)/,
handler: function(importer, event) {
var kthread = importer.getOrCreateKernelThread(event.taskId);
importer.openSlice(kthread, event[2], event.timestamp);
}
},
'workqueue_execute_end': {
// workqueue_execute_end: work struct c7a8a89c
format: /work struct (.+)/,
handler: function(importer, event) {
var kthread = importer.getOrCreateKernelThread(event.taskId);
importer.closeSlice(kthread, event.timestamp, {});
}
},
'workqueue_queue_work': {
// ignored for now
},
'workqueue_activate_work': {
// ignored for now
},
'ext4_sync_file_enter': {
// ext4_sync_file_enter: dev 179,9 ino 114914 parent 114912 datasync 1
format: /dev (\d+,\d+) ino (\d+) parent (\d+) datasync (\d+)/,
handler: function(importer, event) {
var kthread = importer.getOrCreateKernelThread('ext4:' + event.taskId);
var device = event[1];
var inode = event[2];
var datasync = event[4] == 1;
var key = device + '-' + inode;
importer.openAsyncSlice(kthread, key, event.timestamp,
datasync ? 'fdatasync' : 'fsync');
}
},
'ext4_sync_file_exit': {
// ext4_sync_file_exit: dev 179,9 ino 114912 ret 0
format: /dev (\d+,\d+) ino (\d+) ret (\d+)/,
handler: function(importer, event) {
var kthread = importer.getOrCreateKernelThread('ext4:' + event.taskId);
var device = event[1];
var inode = event[2];
var error = parseInt(event[3]);
var key = device + '-' + inode;
importer.closeAsyncSlice(kthread, key, event.timestamp, {
device: device,
inode: inode,
error: error
});
}
},
'block_rq_issue': {
// block_rq_issue: 179,0 WS 0 () 9182248 + 8 [mmcqd/0]
format: /(\d+,\d+) (F)?([DWRN])(F)?(A)?(S)?(M)? \d+ \(.*\) (\d+) \+ (\d+) \[.*\]/,
handler: function(importer, event) {
var action;
switch (event[3]) {
case 'D':
action = 'discard';
break;
case 'W':
action = 'write';
break;
case 'R':
action = 'read';
break;
case 'N':
action = 'none';
break;
default:
action = 'unknown';
break;
}
if (event[2]) {
action += ' flush';
}
if (event[4] == 'F') {
action += ' fua';
}
if (event[5] == 'A') {
action += ' ahead';
}
if (event[6] == 'S') {
action += ' sync';
}
if (event[7] == 'M') {
action += ' meta';
}
var device = event[1]
var sector = parseInt(event[8])
var numSectors = parseInt(event[9])
var kthread = importer.getOrCreateKernelThread('block:' + event.taskId);
var key = device + '-' + sector + '-' + numSectors;
importer.openAsyncSlice(kthread, key, event.timestamp, action);
}
},
'block_rq_complete': {
// block_rq_complete: 179,0 WS () 9182248 + 8 [0]
format: /(\d+,\d+) (F)?([DWRN])(F)?(A)?(S)?(M)? \(.*\) (\d+) \+ (\d+) \[(.*)\]/,
handler: function(importer, event) {
var device = event[1]
var sector = parseInt(event[8])
var numSectors = parseInt(event[9])
var error = parseInt(event[10])
var kthread = importer.getOrCreateKernelThread('block:' + event.taskId);
var key = device + '-' + sector + '-' + numSectors;
importer.closeAsyncSlice(kthread, key, event.timestamp, {
device: device,
sector: sector,
numSectors: numSectors,
error: error
});
}
},
'i915_gem_object_pwrite': {
format: /obj=(.+), offset=(\d+), len=(\d+)/,
handler: function(importer, event) {
var obj = event[1];
var offset = parseInt(event[2]);
var len = parseInt(event[3]);
var kthread = importer.getOrCreateKernelThread('i915_gem', 0, 1);
importer.openSlice(kthread, 'pwrite:' + obj, event.timestamp);
importer.closeSlice(kthread, event.timestamp, {
obj: obj,
offset: offset,
len: len
});
}
},
'i915_flip_request': {
format: /plane=(\d+), obj=(.+)/,
handler: function(importer, event) {
var plane = parseInt(event[1]);
var obj = event[2];
// use i915_obj_plane?
var kthread = importer.getOrCreateKernelThread('i915_flip', 0, 2);
importer.openSlice(kthread, 'flip:' + obj + '/' + plane, event.timestamp);
}
},
'i915_flip_complete': {
format: /plane=(\d+), obj=(.+)/,
handler: function(importer, event) {
var plane = parseInt(event[1]);
var obj = event[2];
// use i915_obj_plane?
var kthread = importer.getOrCreateKernelThread('i915_flip', 0, 2);
importer.closeSlice(kthread, event.timestamp, {
obj: obj,
plane: plane
});
}
},
'tracing_mark_write': {
handler: function(importer, event) {
var eventData = traceEventClockSyncRE.exec(event.info);
if (eventData) {
importer.clockSyncRecords_.push({
perfTS: event.timestamp,
parentTS: eventData[1] * 1000
});
} else {
var eventData = event.info.split('|')
switch (eventData[0]) {
case 'B':
var pid = parseInt(eventData[1]);
var name = eventData[2];
importer.processBegin(event.taskId, name, event.timestamp, pid);
break;
case 'E':
importer.processEnd(event.taskId, event.timestamp);
break;
case 'C':
var pid = parseInt(eventData[1]);
var name = eventData[2];
var value = parseInt(eventData[3]);
importer.processCounter(name, event.timestamp, value, pid);
break;
default:
importer.malformedEvent(event.name);
break;
}
}
}
},
}
};
// NB: old-style trace markers; deprecated
LinuxPerfImporter.prototype.eventDefinitions['0'] =
LinuxPerfImporter.prototype.eventDefinitions['tracing_mark_write'];
TestExports.eventDefinitions = LinuxPerfImporter.prototype.eventDefinitions;
tracing.TimelineModel.registerImporter(LinuxPerfImporter);
return {
LinuxPerfImporter: LinuxPerfImporter,
_LinuxPerfImporterTestExports: TestExports
};
});