| // 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 |
| }; |
| |
| }); |
