Javascript
|
1076行
|
30.9 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.
'use strict';
/**
* @fileoverview TimelineModel is a parsed representation of the
* TraceEvents obtained from base/trace_event in which the begin-end
* tokens are converted into a hierarchy of processes, threads,
* subrows, and slices.
*
* The building block of the model is a slice. A slice is roughly
* equivalent to function call executing on a specific thread. As a
* result, slices may have one or more subslices.
*
* A thread contains one or more subrows of slices. Row 0 corresponds to
* the "root" slices, e.g. the topmost slices. Row 1 contains slices that
* are nested 1 deep in the stack, and so on. We use these subrows to draw
* nesting tasks.
*
*/
cr.define('tracing', function() {
/**
* A TimelineSlice represents an interval of time plus parameters associated
* with that interval.
*
* All time units are stored in milliseconds.
* @constructor
*/
function TimelineSlice(title, colorId, start, args, opt_duration) {
this.title = title;
this.start = start;
this.colorId = colorId;
this.args = args;
this.didNotFinish = false;
if (opt_duration !== undefined)
this.duration = opt_duration;
}
TimelineSlice.prototype = {
selected: false,
duration: undefined,
get end() {
return this.start + this.duration;
}
};
/**
* A TimelineThreadSlice represents an interval of time on a thread resource
* with associated nestinged slice information.
*
* ThreadSlices are typically associated with a specific trace event pair on a
* specific thread.
* For example,
* TRACE_EVENT_BEGIN1("x","myArg", 7) at time=0.1ms
* TRACE_EVENT_END0() at time=0.3ms
* This results in a single timeline slice from 0.1 with duration 0.2 on a
* specific thread.
*
* @constructor
*/
function TimelineThreadSlice(title, colorId, start, args, opt_duration) {
TimelineSlice.call(this, title, colorId, start, args, opt_duration);
this.subSlices = [];
}
TimelineThreadSlice.prototype = {
__proto__: TimelineSlice.prototype
};
/**
* A TimelineAsyncSlice represents an interval of time during which an
* asynchronous operation is in progress. An AsyncSlice consumes no CPU time
* itself and so is only associated with Threads at its start and end point.
*
* @constructor
*/
function TimelineAsyncSlice(title, colorId, start, args) {
TimelineSlice.call(this, title, colorId, start, args);
};
TimelineAsyncSlice.prototype = {
__proto__: TimelineSlice.prototype,
id: undefined,
startThread: undefined,
endThread: undefined,
subSlices: undefined
};
/**
* A TimelineThread stores all the trace events collected for a particular
* thread. We organize the synchronous slices on a thread by "subrows," where
* subrow 0 has all the root slices, subrow 1 those nested 1 deep, and so on.
* The asynchronous slices are stored in an TimelineAsyncSliceGroup object.
*
* The slices stored on a TimelineThread should be instances of
* TimelineThreadSlice.
*
* @constructor
*/
function TimelineThread(parent, tid) {
if (!parent)
throw 'Parent must be provided.';
this.parent = parent;
this.tid = tid;
this.subRows = [[]];
this.asyncSlices = new TimelineAsyncSliceGroup(this.ptid);
}
var ptidMap = {};
/**
* @return {String} A string that can be used as a unique key for a specific
* thread within a process.
*/
TimelineThread.getPTIDFromPidAndTid = function(pid, tid) {
if (!ptidMap[pid])
ptidMap[pid] = {};
if (!ptidMap[pid][tid])
ptidMap[pid][tid] = pid + ':' + tid;
return ptidMap[pid][tid];
}
TimelineThread.prototype = {
/**
* Name of the thread, if present.
*/
name: undefined,
/**
* @return {string} A concatenation of the parent id and the thread's
* tid. Can be used to uniquely identify a thread.
*/
get ptid() {
return TimelineThread.getPTIDFromPidAndTid(this.tid, this.parent.pid);
},
getSubrow: function(i) {
while (i >= this.subRows.length)
this.subRows.push([]);
return this.subRows[i];
},
shiftSubRow_: function(subRow, amount) {
for (var tS = 0; tS < subRow.length; tS++) {
var slice = subRow[tS];
slice.start = (slice.start + amount);
}
},
/**
* Shifts all the timestamps inside this thread forward by the amount
* specified.
*/
shiftTimestampsForward: function(amount) {
if (this.cpuSlices)
this.shiftSubRow_(this.cpuSlices, amount);
for (var tSR = 0; tSR < this.subRows.length; tSR++) {
this.shiftSubRow_(this.subRows[tSR], amount);
}
this.asyncSlices.shiftTimestampsForward(amount);
},
/**
* Updates the minTimestamp and maxTimestamp fields based on the
* current objects associated with the thread.
*/
updateBounds: function() {
var values = [];
var slices;
if (this.subRows[0].length != 0) {
slices = this.subRows[0];
values.push(slices[0].start);
values.push(slices[slices.length - 1].end);
}
if (this.asyncSlices.slices.length) {
this.asyncSlices.updateBounds();
values.push(this.asyncSlices.minTimestamp);
values.push(this.asyncSlices.maxTimestamp);
}
if (values.length) {
this.minTimestamp = Math.min.apply(Math, values);
this.maxTimestamp = Math.max.apply(Math, values);
} else {
this.minTimestamp = undefined;
this.maxTimestamp = undefined;
}
},
/**
* @return {String} A user-friendly name for this thread.
*/
get userFriendlyName() {
var tname = this.name || this.tid;
return this.parent.pid + ': ' + tname;
},
/**
* @return {String} User friendly details about this thread.
*/
get userFriendlyDetails() {
return 'pid: ' + this.parent.pid +
', tid: ' + this.tid +
(this.name ? ', name: ' + this.name : '');
}
};
/**
* Comparison between threads that orders first by pid,
* then by names, then by tid.
*/
TimelineThread.compare = function(x, y) {
if (x.parent.pid != y.parent.pid) {
return TimelineProcess.compare(x.parent, y.parent.pid);
}
if (x.name && y.name) {
var tmp = x.name.localeCompare(y.name);
if (tmp == 0)
return x.tid - y.tid;
return tmp;
} else if (x.name) {
return -1;
} else if (y.name) {
return 1;
} else {
return x.tid - y.tid;
}
};
/**
* Stores all the samples for a given counter.
* @constructor
*/
function TimelineCounter(parent, id, name) {
this.parent = parent;
this.id = id;
this.name = name;
this.seriesNames = [];
this.seriesColors = [];
this.timestamps = [];
this.samples = [];
}
TimelineCounter.prototype = {
__proto__: Object.prototype,
get numSeries() {
return this.seriesNames.length;
},
get numSamples() {
return this.timestamps.length;
},
/**
* Shifts all the timestamps inside this counter forward by the amount
* specified.
*/
shiftTimestampsForward: function(amount) {
for (var sI = 0; sI < this.timestamps.length; sI++)
this.timestamps[sI] = (this.timestamps[sI] + amount);
},
/**
* Updates the bounds for this counter based on the samples it contains.
*/
updateBounds: function() {
if (this.seriesNames.length != this.seriesColors.length)
throw 'seriesNames.length must match seriesColors.length';
if (this.numSeries * this.numSamples != this.samples.length)
throw 'samples.length must be a multiple of numSamples.';
this.totals = [];
if (this.samples.length == 0) {
this.minTimestamp = undefined;
this.maxTimestamp = undefined;
this.maxTotal = 0;
return;
}
this.minTimestamp = this.timestamps[0];
this.maxTimestamp = this.timestamps[this.timestamps.length - 1];
var numSeries = this.numSeries;
var maxTotal = -Infinity;
for (var i = 0; i < this.timestamps.length; i++) {
var total = 0;
for (var j = 0; j < numSeries; j++) {
total += this.samples[i * numSeries + j];
this.totals.push(total);
}
if (total > maxTotal)
maxTotal = total;
}
this.maxTotal = maxTotal;
}
};
/**
* Comparison between counters that orders by pid, then name.
*/
TimelineCounter.compare = function(x, y) {
if (x.parent.pid != y.parent.pid) {
return TimelineProcess.compare(x.parent, y.parent.pid);
}
var tmp = x.name.localeCompare(y.name);
if (tmp == 0)
return x.tid - y.tid;
return tmp;
};
/**
* The TimelineProcess represents a single process in the
* trace. Right now, we keep this around purely for bookkeeping
* reasons.
* @constructor
*/
function TimelineProcess(pid) {
this.pid = pid;
this.threads = {};
this.counters = {};
};
TimelineProcess.prototype = {
get numThreads() {
var n = 0;
for (var p in this.threads) {
n++;
}
return n;
},
/**
* Shifts all the timestamps inside this process forward by the amount
* specified.
*/
shiftTimestampsForward: function(amount) {
for (var tid in this.threads)
this.threads[tid].shiftTimestampsForward(amount);
for (var id in this.counters)
this.counters[id].shiftTimestampsForward(amount);
},
/**
* @return {TimlineThread} The thread identified by tid on this process,
* creating it if it doesn't exist.
*/
getOrCreateThread: function(tid) {
if (!this.threads[tid])
this.threads[tid] = new TimelineThread(this, tid);
return this.threads[tid];
},
/**
* @return {TimlineCounter} The counter on this process named 'name',
* creating it if it doesn't exist.
*/
getOrCreateCounter: function(cat, name) {
var id = cat + '.' + name;
if (!this.counters[id])
this.counters[id] = new TimelineCounter(this, id, name);
return this.counters[id];
}
};
/**
* Comparison between processes that orders by pid.
*/
TimelineProcess.compare = function(x, y) {
return x.pid - y.pid;
};
/**
* The TimelineCpu represents a Cpu from the kernel's point of view.
* @constructor
*/
function TimelineCpu(number) {
this.cpuNumber = number;
this.slices = [];
this.counters = {};
};
TimelineCpu.prototype = {
/**
* @return {TimlineCounter} The counter on this process named 'name',
* creating it if it doesn't exist.
*/
getOrCreateCounter: function(cat, name) {
var id;
if (cat.length)
id = cat + '.' + name;
else
id = name;
if (!this.counters[id])
this.counters[id] = new TimelineCounter(this, id, name);
return this.counters[id];
},
/**
* Shifts all the timestamps inside this CPU forward by the amount
* specified.
*/
shiftTimestampsForward: function(amount) {
for (var sI = 0; sI < this.slices.length; sI++)
this.slices[sI].start = (this.slices[sI].start + amount);
for (var id in this.counters)
this.counters[id].shiftTimestampsForward(amount);
},
/**
* Updates the minTimestamp and maxTimestamp fields based on the
* current slices attached to the cpu.
*/
updateBounds: function() {
var values = [];
if (this.slices.length) {
this.minTimestamp = this.slices[0].start;
this.maxTimestamp = this.slices[this.slices.length - 1].end;
} else {
this.minTimestamp = undefined;
this.maxTimestamp = undefined;
}
}
};
/**
* Comparison between processes that orders by cpuNumber.
*/
TimelineCpu.compare = function(x, y) {
return x.cpuNumber - y.cpuNumber;
};
/**
* A group of AsyncSlices.
* @constructor
*/
function TimelineAsyncSliceGroup(name) {
this.name = name;
this.slices = [];
}
TimelineAsyncSliceGroup.prototype = {
__proto__: Object.prototype,
/**
* Helper function that pushes the provided slice onto the slices array.
*/
push: function(slice) {
this.slices.push(slice);
},
/**
* @return {Number} The number of slices in this group.
*/
get length() {
return this.slices.length;
},
/**
* Built automatically by rebuildSubRows().
*/
subRows_: undefined,
/**
* Updates the bounds for this group based on the slices it contains.
*/
sortSlices_: function() {
this.slices.sort(function(x, y) {
return x.start - y.start;
});
},
/**
* Shifts all the timestamps inside this group forward by the amount
* specified.
*/
shiftTimestampsForward: function(amount) {
for (var sI = 0; sI < this.slices.length; sI++) {
var slice = this.slices[sI];
slice.start = (slice.start + amount);
for (var sJ = 0; sJ < slice.subSlices.length; sJ++)
slice.subSlices[sJ].start += amount;
}
},
/**
* Updates the bounds for this group based on the slices it contains.
*/
updateBounds: function() {
this.sortSlices_();
if (this.slices.length) {
this.minTimestamp = this.slices[0].start;
this.maxTimestamp = this.slices[this.slices.length - 1].end;
} else {
this.minTimestamp = undefined;
this.maxTimestamp = undefined;
}
this.subRows_ = undefined;
},
get subRows() {
if (!this.subRows_)
this.rebuildSubRows_();
return this.subRows_;
},
/**
* Breaks up the list of slices into N rows, each of which is a list of
* slices that are non overlapping.
*
* It uses a very simple approach: walk through the slices in sorted order
* by start time. For each slice, try to fit it in an existing subRow. If it
* doesn't fit in any subrow, make another subRow.
*/
rebuildSubRows_: function() {
this.sortSlices_();
var subRows = [];
for (var i = 0; i < this.slices.length; i++) {
var slice = this.slices[i];
var found = false;
for (var j = 0; j < subRows.length; j++) {
var subRow = subRows[j];
var lastSliceInSubRow = subRow[subRow.length - 1];
if (slice.start >= lastSliceInSubRow.end) {
found = true;
// Instead of plotting one big slice for the entire
// TimelineAsyncEvent, we plot each of the subSlices.
if (slice.subSlices === undefined || slice.subSlices.length < 1)
throw 'TimelineAsyncEvent missing subSlices: ' + slice.name;
for (var k = 0; k < slice.subSlices.length; k++)
subRow.push(slice.subSlices[k]);
break;
}
}
if (!found) {
var subRow = [];
if (slice.subSlices !== undefined) {
for (var k = 0; k < slice.subSlices.length; k++)
subRow.push(slice.subSlices[k]);
subRows.push(subRow);
}
}
}
this.subRows_ = subRows;
},
/**
* Breaks up this group into slices based on start thread.
*
* @return {Array} An array of TimelineAsyncSliceGroups where each group has
* slices that started on the same thread.
**/
computeSubGroups: function() {
var subGroupsByPTID = {};
for (var i = 0; i < this.slices.length; ++i) {
var slice = this.slices[i];
var slicePTID = slice.startThread.ptid;
if (!subGroupsByPTID[slicePTID])
subGroupsByPTID[slicePTID] = new TimelineAsyncSliceGroup(this.name);
subGroupsByPTID[slicePTID].slices.push(slice);
}
var groups = [];
for (var ptid in subGroupsByPTID) {
var group = subGroupsByPTID[ptid];
group.updateBounds();
groups.push(group);
}
return groups;
}
};
/**
* Comparison between counters that orders by pid, then name.
*/
TimelineCounter.compare = function(x, y) {
if (x.parent.pid != y.parent.pid) {
return TimelineProcess.compare(x.parent, y.parent.pid);
}
var tmp = x.name.localeCompare(y.name);
if (tmp == 0)
return x.tid - y.tid;
return tmp;
};
// The color pallette is split in half, with the upper
// half of the pallette being the "highlighted" verison
// of the base color. So, color 7's highlighted form is
// 7 + (pallette.length / 2).
//
// These bright versions of colors are automatically generated
// from the base colors.
//
// Within the color pallette, there are "regular" colors,
// which can be used for random color selection, and
// reserved colors, which are used when specific colors
// need to be used, e.g. where red is desired.
var palletteBase = [
{r: 138, g: 113, b: 152},
{r: 175, g: 112, b: 133},
{r: 127, g: 135, b: 225},
{r: 93, g: 81, b: 137},
{r: 116, g: 143, b: 119},
{r: 178, g: 214, b: 122},
{r: 87, g: 109, b: 147},
{r: 119, g: 155, b: 95},
{r: 114, g: 180, b: 160},
{r: 132, g: 85, b: 103},
{r: 157, g: 210, b: 150},
{r: 148, g: 94, b: 86},
{r: 164, g: 108, b: 138},
{r: 139, g: 191, b: 150},
{r: 110, g: 99, b: 145},
{r: 80, g: 129, b: 109},
{r: 125, g: 140, b: 149},
{r: 93, g: 124, b: 132},
{r: 140, g: 85, b: 140},
{r: 104, g: 163, b: 162},
{r: 132, g: 141, b: 178},
{r: 131, g: 105, b: 147},
{r: 135, g: 183, b: 98},
{r: 152, g: 134, b: 177},
{r: 141, g: 188, b: 141},
{r: 133, g: 160, b: 210},
{r: 126, g: 186, b: 148},
{r: 112, g: 198, b: 205},
{r: 180, g: 122, b: 195},
{r: 203, g: 144, b: 152},
// Reserved Entires
{r: 182, g: 125, b: 143},
{r: 126, g: 200, b: 148},
{r: 133, g: 160, b: 210},
{r: 240, g: 240, b: 240}];
// Make sure this number tracks the number of reserved entries in the
// pallette.
var numReservedColorIds = 4;
function brighten(c) {
var k;
if (c.r >= 240 && c.g >= 240 && c.b >= 240)
k = -0.20;
else
k = 0.45;
return {r: Math.min(255, c.r + Math.floor(c.r * k)),
g: Math.min(255, c.g + Math.floor(c.g * k)),
b: Math.min(255, c.b + Math.floor(c.b * k))};
}
function colorToString(c) {
return 'rgb(' + c.r + ',' + c.g + ',' + c.b + ')';
}
/**
* The number of color IDs that getStringColorId can choose from.
*/
var numRegularColorIds = palletteBase.length - numReservedColorIds;
var highlightIdBoost = palletteBase.length;
var pallette = palletteBase.concat(palletteBase.map(brighten)).
map(colorToString);
/**
* Computes a simplistic hashcode of the provide name. Used to chose colors
* for slices.
* @param {string} name The string to hash.
*/
function getStringHash(name) {
var hash = 0;
for (var i = 0; i < name.length; ++i)
hash = (hash + 37 * hash + 11 * name.charCodeAt(i)) % 0xFFFFFFFF;
return hash;
}
/**
* Gets the color pallette.
*/
function getPallette() {
return pallette;
}
/**
* @return {Number} The value to add to a color ID to get its highlighted
* colro ID. E.g. 7 + getPalletteHighlightIdBoost() yields a brightened from
* of 7's base color.
*/
function getPalletteHighlightIdBoost() {
return highlightIdBoost;
}
/**
* @param {String} name The color name.
* @return {Number} The color ID for the given color name.
*/
function getColorIdByName(name) {
if (name == 'iowait')
return numRegularColorIds;
if (name == 'running')
return numRegularColorIds + 1;
if (name == 'runnable')
return numRegularColorIds + 2;
if (name == 'sleeping')
return numRegularColorIds + 3;
throw 'Unrecognized color ' + name;
}
// Previously computed string color IDs. They are based on a stable hash, so
// it is safe to save them throughout the program time.
var stringColorIdCache = {};
/**
* @return {Number} A color ID that is stably associated to the provided via
* the getStringHash method. The color ID will be chosen from the regular
* ID space only, e.g. no reserved ID will be used.
*/
function getStringColorId(string) {
if (stringColorIdCache[string] === undefined) {
var hash = getStringHash(string);
stringColorIdCache[string] = hash % numRegularColorIds;
}
return stringColorIdCache[string];
}
/**
* Builds a model from an array of TraceEvent objects.
* @param {Object=} opt_data The event data to import into the new model.
* See TimelineModel.importEvents for details and more advanced ways to
* import data.
* @param {bool=} opt_zeroAndBoost Whether to align to zero and boost the
* by 15%. Defaults to true.
* @constructor
*/
function TimelineModel(opt_eventData, opt_zeroAndBoost) {
this.cpus = {};
this.processes = {};
this.importErrors = [];
this.asyncSliceGroups = {};
if (opt_eventData)
this.importEvents(opt_eventData, opt_zeroAndBoost);
}
var importerConstructors = [];
/**
* Registers an importer. All registered importers are considered
* when processing an import request.
*
* @param {Function} importerConstructor The importer's constructor function.
*/
TimelineModel.registerImporter = function(importerConstructor) {
importerConstructors.push(importerConstructor);
};
function TimelineModelEmptyImporter(events) {
};
TimelineModelEmptyImporter.canImport = function(eventData) {
if (eventData instanceof Array && eventData.length == 0)
return true;
if (typeof(eventData) === 'string' || eventData instanceof String) {
return eventData.length == 0;
}
return false;
};
TimelineModelEmptyImporter.prototype = {
__proto__: Object.prototype,
importEvents: function() {
},
finalizeImport: function() {
}
};
TimelineModel.registerImporter(TimelineModelEmptyImporter);
TimelineModel.prototype = {
__proto__: cr.EventTarget.prototype,
get numProcesses() {
var n = 0;
for (var p in this.processes)
n++;
return n;
},
/**
* @return {TimelineProcess} Gets a specific TimelineCpu or creates one if
* it does not exist.
*/
getOrCreateCpu: function(cpuNumber) {
if (!this.cpus[cpuNumber])
this.cpus[cpuNumber] = new TimelineCpu(cpuNumber);
return this.cpus[cpuNumber];
},
/**
* @return {TimelineProcess} Gets a TimlineProcess for a specified pid or
* creates one if it does not exist.
*/
getOrCreateProcess: function(pid) {
if (!this.processes[pid])
this.processes[pid] = new TimelineProcess(pid);
return this.processes[pid];
},
/**
* The import takes an array of json-ified TraceEvents and adds them into
* the TimelineModel as processes, threads, and slices.
*/
/**
* Removes threads from the model that are fully empty.
*/
pruneEmptyThreads: function() {
for (var pid in this.processes) {
var process = this.processes[pid];
var prunedThreads = {};
for (var tid in process.threads) {
var thread = process.threads[tid];
// Begin-events without matching end events leave a thread in a state
// where the toplevel subrows are empty but child subrows have
// entries. The autocloser will fix this up later. But, for the
// purposes of pruning, such threads need to be treated as having
// content.
var hasNonEmptySubrow = false;
for (var s = 0; s < thread.subRows.length; s++)
hasNonEmptySubrow |= thread.subRows[s].length > 0;
if (hasNonEmptySubrow || thread.asyncSlices.length > 0)
prunedThreads[tid] = thread;
}
process.threads = prunedThreads;
}
},
updateBounds: function() {
var wmin = Infinity;
var wmax = -wmin;
var hasData = false;
var threads = this.getAllThreads();
for (var tI = 0; tI < threads.length; tI++) {
var thread = threads[tI];
thread.updateBounds();
if (thread.minTimestamp != undefined &&
thread.maxTimestamp != undefined) {
wmin = Math.min(wmin, thread.minTimestamp);
wmax = Math.max(wmax, thread.maxTimestamp);
hasData = true;
}
}
var counters = this.getAllCounters();
for (var tI = 0; tI < counters.length; tI++) {
var counter = counters[tI];
counter.updateBounds();
if (counter.minTimestamp != undefined &&
counter.maxTimestamp != undefined) {
hasData = true;
wmin = Math.min(wmin, counter.minTimestamp);
wmax = Math.max(wmax, counter.maxTimestamp);
}
}
for (var cpuNumber in this.cpus) {
var cpu = this.cpus[cpuNumber];
cpu.updateBounds();
if (cpu.minTimestamp != undefined &&
cpu.maxTimestamp != undefined) {
hasData = true;
wmin = Math.min(wmin, cpu.minTimestamp);
wmax = Math.max(wmax, cpu.maxTimestamp);
}
}
if (hasData) {
this.minTimestamp = wmin;
this.maxTimestamp = wmax;
} else {
this.maxTimestamp = undefined;
this.minTimestamp = undefined;
}
},
shiftWorldToZero: function() {
if (this.minTimestamp === undefined)
return;
var timeBase = this.minTimestamp;
for (var pid in this.processes)
this.processes[pid].shiftTimestampsForward(-timeBase);
for (var cpuNumber in this.cpus)
this.cpus[cpuNumber].shiftTimestampsForward(-timeBase);
this.updateBounds();
},
getAllThreads: function() {
var threads = [];
for (var pid in this.processes) {
var process = this.processes[pid];
for (var tid in process.threads) {
threads.push(process.threads[tid]);
}
}
return threads;
},
/**
* @return {Array} An array of all cpus in the model.
*/
getAllCpus: function() {
var cpus = [];
for (var cpu in this.cpus)
cpus.push(this.cpus[cpu]);
return cpus;
},
/**
* @return {Array} An array of all processes in the model.
*/
getAllProcesses: function() {
var processes = [];
for (var pid in this.processes)
processes.push(this.processes[pid]);
return processes;
},
/**
* @return {Array} An array of all the counters in the model.
*/
getAllCounters: function() {
var counters = [];
for (var pid in this.processes) {
var process = this.processes[pid];
for (var tid in process.counters) {
counters.push(process.counters[tid]);
}
}
for (var cpuNumber in this.cpus) {
var cpu = this.cpus[cpuNumber];
for (var counterName in cpu.counters)
counters.push(cpu.counters[counterName]);
}
return counters;
},
/**
* Imports the provided events into the model. The eventData type
* is undefined and will be passed to all the timeline importers registered
* via TimelineModel.registerImporter. The first importer that returns true
* for canImport(events) will be used to import the events.
*
* @param {Object} events Events to import.
* @param {boolean} isAdditionalImport True the eventData being imported is
* an additional trace after the primary eventData.
* @return {TimelineModelImporter} The importer used for the eventData.
*/
importOneTrace_: function(eventData, isAdditionalImport) {
var importerConstructor;
for (var i = 0; i < importerConstructors.length; ++i) {
if (importerConstructors[i].canImport(eventData)) {
importerConstructor = importerConstructors[i];
break;
}
}
if (!importerConstructor)
throw 'Could not find an importer for the provided eventData.';
var importer = new importerConstructor(
this, eventData, isAdditionalImport);
importer.importEvents();
return importer;
},
/**
* Imports the provided traces into the model. The eventData type
* is undefined and will be passed to all the timeline importers registered
* via TimelineModel.registerImporter. The first importer that returns true
* for canImport(events) will be used to import the events.
*
* The primary trace is provided via the eventData variable. If multiple
* traces are to be imported, specify the first one as events, and the
* remainder in the opt_additionalEventData array.
*
* @param {Object} eventData Events to import.
* @param {bool=} opt_zeroAndBoost Whether to align to zero and boost the
* by 15%. Defaults to true.
* @param {Array=} opt_additionalEventData An array of eventData objects
* (e.g. array of arrays) to
* import after importing the primary events.
*/
importEvents: function(eventData,
opt_zeroAndBoost, opt_additionalEventData) {
if (opt_zeroAndBoost === undefined)
opt_zeroAndBoost = true;
var activeImporters = [];
var importer = this.importOneTrace_(eventData, false);
activeImporters.push(importer);
if (opt_additionalEventData) {
for (var i = 0; i < opt_additionalEventData.length; ++i) {
importer = this.importOneTrace_(opt_additionalEventData[i], true);
activeImporters.push(importer);
}
}
for (var i = 0; i < activeImporters.length; ++i)
activeImporters[i].finalizeImport();
for (var i = 0; i < activeImporters.length; ++i)
this.pruneEmptyThreads();
this.updateBounds();
if (opt_zeroAndBoost)
this.shiftWorldToZero();
if (opt_zeroAndBoost &&
this.minTimestamp !== undefined &&
this.maxTimestamp !== undefined) {
var boost = (this.maxTimestamp - this.minTimestamp) * 0.15;
this.minTimestamp = this.minTimestamp - boost;
this.maxTimestamp = this.maxTimestamp + boost;
}
}
};
/**
* @constructor A filter that can be passed into
* Timeline.findAllObjectsMatchingFilter
*/
function TimelineFilter(text) {
this.text_ = text;
}
TimelineFilter.prototype = {
__proto__: Object.prototype,
matchSlice: function(slice) {
if (this.text_.length == 0)
return false;
return slice.title.indexOf(this.text_) != -1;
}
};
return {
getPallette: getPallette,
getPalletteHighlightIdBoost: getPalletteHighlightIdBoost,
getColorIdByName: getColorIdByName,
getStringHash: getStringHash,
getStringColorId: getStringColorId,
TimelineSlice: TimelineSlice,
TimelineThreadSlice: TimelineThreadSlice,
TimelineAsyncSlice: TimelineAsyncSlice,
TimelineThread: TimelineThread,
TimelineCounter: TimelineCounter,
TimelineProcess: TimelineProcess,
TimelineCpu: TimelineCpu,
TimelineAsyncSliceGroup: TimelineAsyncSliceGroup,
TimelineModel: TimelineModel,
TimelineFilter: TimelineFilter
};
});