diff --git a/src/components/sidebar/CallTreeSidebar.js b/src/components/sidebar/CallTreeSidebar.js index 58553c31f6..4dc6fdd6d8 100644 --- a/src/components/sidebar/CallTreeSidebar.js +++ b/src/components/sidebar/CallTreeSidebar.js @@ -117,13 +117,18 @@ class CategoryBreakdown extends React.PureComponent { .sort(({ value: valueA }, { value: valueB }) => valueB - valueA) .filter(({ value }) => value); - const totalTime = data.reduce((accum, { value }) => accum + value, 0); + // Values can be negative for diffing tracks, that's why we use the absolute + // value to compute the total time. Indeed even if all values average out, + // we want to display a sensible percentage. + const totalTime = data.reduce( + (accum, { value }) => accum + Math.abs(value), + 0 + ); const maxFractionalDigits = isIntervalInteger ? 0 : 1; return (
{data.map(({ category, value, subcategories }) => { - const percentage = Math.round((value / totalTime) * 100); return (
@@ -137,7 +142,7 @@ class CategoryBreakdown extends React.PureComponent {
{formatMilliseconds(value, 3, maxFractionalDigits)} ( - {percentage}%) + {formatPercent(value / totalTime)})
{shouldDisplaySubcategoryInfoForCategory(category) ? subcategories.map(({ name, value }) => ( @@ -252,8 +257,13 @@ class CallTreeSidebar extends React.PureComponent {

This selected call node

- {formatMilliseconds(totalTime.value, 3, maxFractionalDigits)} ( - {totalTimePercent}%) + {totalTime.value + ? `${formatMilliseconds( + totalTime.value, + 3, + maxFractionalDigits + )} (${totalTimePercent}%)` + : '—'} {selfTime.value @@ -296,8 +306,13 @@ class CallTreeSidebar extends React.PureComponent { This function across the entire tree - {formatMilliseconds(totalTimeForFunc.value, 3, maxFractionalDigits)}{' '} - ({totalTimeForFuncPercent}%) + {totalTimeForFunc.value + ? `${formatMilliseconds( + totalTimeForFunc.value, + 3, + maxFractionalDigits + )} (${totalTimeForFuncPercent}%)` + : '—'} {selfTimeForFunc.value diff --git a/src/profile-logic/call-tree.js b/src/profile-logic/call-tree.js index 2218613017..3687b33fb7 100644 --- a/src/profile-logic/call-tree.js +++ b/src/profile-logic/call-tree.js @@ -122,16 +122,23 @@ export class CallTree { children.length < childCount; childCallNodeIndex++ ) { + const childPrefixIndex = this._callNodeTable.prefix[childCallNodeIndex]; + const childTotalTime = this._callNodeTimes.totalTime[ + childCallNodeIndex + ]; + const childChildCount = this._callNodeChildCount[childCallNodeIndex]; + if ( - this._callNodeTable.prefix[childCallNodeIndex] === callNodeIndex && - this._callNodeTimes.totalTime[childCallNodeIndex] !== 0 + childPrefixIndex === callNodeIndex && + (childTotalTime !== 0 || childChildCount !== 0) ) { children.push(childCallNodeIndex); } } children.sort( (a, b) => - this._callNodeTimes.totalTime[b] - this._callNodeTimes.totalTime[a] + Math.abs(this._callNodeTimes.totalTime[b]) - + Math.abs(this._callNodeTimes.totalTime[a]) ); this._children[callNodeIndex] = children; } @@ -227,8 +234,8 @@ export class CallTree { ); displayData = { - totalTime: formattedTotalTime, - totalTimeWithUnit: formattedTotalTime + 'ms', + totalTime: totalTime === 0 ? '—' : formattedTotalTime, + totalTimeWithUnit: totalTime === 0 ? '—' : formattedTotalTime + 'ms', selfTime: selfTime === 0 ? '—' : formattedSelfTime, selfTimeWithUnit: selfTime === 0 ? '—' : formattedSelfTime + 'ms', totalTimePercent: `${formatPercent(totalTimeRelative)}`, @@ -380,19 +387,24 @@ export function computeCallTreeCountsAndTimings( let rootCount = 0; // We loop the call node table in reverse, so that we find the children - // before their parents. + // before their parents, and the total time is known at the time we reach a + // node. for ( let callNodeIndex = callNodeTable.length - 1; callNodeIndex >= 0; callNodeIndex-- ) { callNodeTotalTime[callNodeIndex] += callNodeLeafTime[callNodeIndex]; - if (callNodeTotalTime[callNodeIndex] === 0) { + rootTotalTime += Math.abs(callNodeLeafTime[callNodeIndex]); + const hasChildren = callNodeChildCount[callNodeIndex] !== 0; + const hasTotalTime = callNodeTotalTime[callNodeIndex] !== 0; + + if (!hasChildren && !hasTotalTime) { continue; } + const prefixCallNode = callNodeTable.prefix[callNodeIndex]; if (prefixCallNode === -1) { - rootTotalTime += callNodeTotalTime[callNodeIndex]; rootCount++; } else { callNodeTotalTime[prefixCallNode] += callNodeTotalTime[callNodeIndex]; diff --git a/src/profile-logic/comparison.js b/src/profile-logic/comparison.js index ec7c2ab65d..c2baf844ad 100644 --- a/src/profile-logic/comparison.js +++ b/src/profile-logic/comparison.js @@ -14,24 +14,54 @@ import { adjustSampleTimestamps, adjustMarkerTimestamps, } from './process-profile'; -import { getEmptyProfile } from './data-structures'; +import { + getEmptyProfile, + getEmptyResourceTable, + getEmptySamplesTable, + getEmptyFrameTable, + getEmptyFuncTable, + getEmptyStackTable, + getEmptyRawMarkerTable, +} from './data-structures'; import { filterThreadSamplesToRange, getTimeRangeForThread, getTimeRangeIncludingAllThreads, } from './profile-data'; import { filterRawMarkerTableToRange } from './marker-data'; +import { UniqueStringArray } from '../utils/unique-string-array'; import type { Profile, Thread, IndexIntoCategoryList, CategoryList, + IndexIntoFrameTable, + IndexIntoFuncTable, + IndexIntoResourceTable, + IndexIntoLibs, + IndexIntoStackTable, + IndexIntoSamplesTable, + FuncTable, + FrameTable, + Lib, + ResourceTable, + StackTable, + SamplesTable, } from '../types/profile'; import type { UrlState } from '../types/state'; import type { ImplementationFilter } from '../types/actions'; import type { TransformStacksPerThread } from '../types/transforms'; +import type { Milliseconds } from '../types/units'; +/** + * This function is the entry point for this file. From a list of profile + * sources and a list of states coming from URLs, it computes a new profile + * that's composed of parts of the 2 source profiles. + * It also computes a diffed profile as a last thread. + * It returns this merged profile along the transforms and implementation + * filters as decided by the source states. + */ export function mergeProfiles( profiles: Profile[], profileStates: UrlState[] @@ -40,6 +70,15 @@ export function mergeProfiles( transformStacks: TransformStacksPerThread, implementationFilters: ImplementationFilter[], |} { + if (profiles.length !== profileStates.length) { + throw new Error( + 'Passed arrays do not have the same length. This should not happen.' + ); + } + if (!profiles.length) { + throw new Error('There are no profiles to merge.'); + } + const resultProfile = getEmptyProfile(); resultProfile.meta.interval = Math.min( ...profiles.map(profile => profile.meta.interval) @@ -82,7 +121,7 @@ export function mergeProfiles( implementationFilters.push(profileSpecific.implementation); // We adjust the categories using the maps computed above. - // TODO: Also adjust subcategories. + // TODO issue #2151: Also adjust subcategories. thread.stackTable.category = adjustCategories( thread.stackTable.category, translationMapsForCategories[i] @@ -146,9 +185,30 @@ export function mergeProfiles( resultProfile.threads.push(thread); } + // We can import several profiles in this view, but the comparison thread + // really makes sense when there's only 2 profiles. + if (profiles.length === 2) { + resultProfile.threads.push( + getComparisonThread(translationMapsForCategories, [ + { + thread: resultProfile.threads[0], + interval: profiles[0].meta.interval, + }, + { + thread: resultProfile.threads[1], + interval: profiles[1].meta.interval, + }, + ]) + ); + } + return { profile: resultProfile, implementationFilters, transformStacks }; } +/** + * This is a small utility function that makes it easier to filter a thread + * completely (both markers and samples). + */ function filterThreadToRange( thread: Thread, rangeStart: number, @@ -167,6 +227,18 @@ type TranslationMapForCategories = Map< IndexIntoCategoryList, IndexIntoCategoryList >; +type TranslationMapForFuncs = Map; +type TranslationMapForResources = Map< + IndexIntoResourceTable, + IndexIntoResourceTable +>; +type TranslationMapForFrames = Map; +type TranslationMapForStacks = Map; +type TranslationMapForLibs = Map; +type TranslationMapForSamples = Map< + IndexIntoSamplesTable, + IndexIntoSamplesTable +>; /** * Merges several categories lists into one, resolving duplicates if necessary. @@ -196,8 +268,8 @@ function mergeCategories( } else { // We're assuming that newCategories[newCategoryIndex].subcategories // is the same list of strings as category.subcategories. - // TODO: merge the subcategories too, and make a translationMap for - // those (per category), too. + // TODO issue #2151: merge the subcategories too, and make a + // translationMap for those (per category), too. } translationMap.set(i, newCategoryIndex); }); @@ -253,3 +325,510 @@ function adjustNullableCategories( return result; }); } + +/** + * This combines the library tables for a list of threads. It returns a merged + * Lib array, along with a translation maps that can be used in other functions + * when merging lib references in other tables. + */ +function combineLibTables( + threads: $ReadOnlyArray +): { libs: Lib[], translationMaps: TranslationMapForLibs[] } { + const mapOfInsertedLibs: Map = new Map(); + + const translationMaps = []; + const newLibTable = []; + + threads.forEach(thread => { + const translationMap = new Map(); + const { libs } = thread; + + libs.forEach((lib, i) => { + const insertedLibKey = [lib.name, lib.debugName].join('#'); + const insertedLibIndex = mapOfInsertedLibs.get(insertedLibKey); + if (insertedLibIndex !== undefined) { + translationMap.set(i, insertedLibIndex); + return; + } + + translationMap.set(i, newLibTable.length); + mapOfInsertedLibs.set(insertedLibKey, newLibTable.length); + + newLibTable.push(lib); + }); + + translationMaps.push(translationMap); + }); + + return { libs: newLibTable, translationMaps }; +} + +/** + * This combines the resource tables for a list of threads. It returns the new + * resource table with the translation maps to be used in subsequent merging + * functions. + */ +function combineResourceTables( + translationMapsForLibs: TranslationMapForLibs[], + newStringTable: UniqueStringArray, + threads: $ReadOnlyArray +): { + resourceTable: ResourceTable, + translationMaps: TranslationMapForResources[], +} { + const mapOfInsertedResources: Map = new Map(); + const translationMaps = []; + const newResourceTable = getEmptyResourceTable(); + + threads.forEach((thread, threadIndex) => { + const translationMap = new Map(); + const { resourceTable, stringTable } = thread; + const libTranslationMap = translationMapsForLibs[threadIndex]; + + for (let i = 0; i < resourceTable.length; i++) { + const libIndex = resourceTable.lib[i]; + const newLibIndex = + typeof libIndex === 'number' && libIndex >= 0 + ? libTranslationMap.get(libIndex) + : null; + if (newLibIndex === undefined) { + throw new Error(stripIndent` + We couldn't find the lib of resource ${i} in the translation map. + This is a programming error. + `); + } + + const nameIndex = resourceTable.name[i]; + const newName = nameIndex >= 0 ? stringTable.getString(nameIndex) : null; + + const hostIndex = resourceTable.host[i]; + const newHost = + typeof hostIndex === 'number' && hostIndex >= 0 + ? stringTable.getString(hostIndex) + : undefined; + + const type = resourceTable.type[i]; + + // Duplicate search. + const resourceKey = [newLibIndex, newName || '', type].join('#'); + const insertedResourceIndex = mapOfInsertedResources.get(resourceKey); + if (insertedResourceIndex !== undefined) { + translationMap.set(i, insertedResourceIndex); + continue; + } + + translationMap.set(i, newResourceTable.length); + mapOfInsertedResources.set(resourceKey, newResourceTable.length); + + newResourceTable.lib.push(newLibIndex); + newResourceTable.name.push( + newName === null ? -1 : newStringTable.indexForString(newName) + ); + newResourceTable.host.push( + newHost === undefined + ? undefined + : newStringTable.indexForString(newHost) + ); + newResourceTable.type.push(type); + + newResourceTable.length++; + } + + translationMaps.push(translationMap); + }); + + return { resourceTable: newResourceTable, translationMaps }; +} + +/** + * This combines the function tables for a list of threads. It returns the new + * function table with the translation maps to be used in subsequent merging + * functions. + */ +function combineFuncTables( + translationMapsForResources: TranslationMapForResources[], + newStringTable: UniqueStringArray, + threads: $ReadOnlyArray +): { funcTable: FuncTable, translationMaps: TranslationMapForFuncs[] } { + const mapOfInsertedFuncs: Map = new Map(); + const translationMaps = []; + const newFuncTable = getEmptyFuncTable(); + + threads.forEach((thread, threadIndex) => { + const { funcTable, stringTable } = thread; + const translationMap = new Map(); + const resourceTranslationMap = translationMapsForResources[threadIndex]; + + for (let i = 0; i < funcTable.length; i++) { + const fileNameIndex = funcTable.fileName[i]; + const fileName = + typeof fileNameIndex === 'number' + ? stringTable.getString(fileNameIndex) + : null; + const resourceIndex = funcTable.resource[i]; + const newResourceIndex = + resourceIndex >= 0 + ? resourceTranslationMap.get(funcTable.resource[i]) + : -1; + if (newResourceIndex === undefined) { + throw new Error(stripIndent` + We couldn't find the resource of func ${i} in the translation map. + This is a programming error. + `); + } + const name = stringTable.getString(funcTable.name[i]); + const lineNumber = funcTable.lineNumber[i]; + + // Entries in this table can be either: + // 1. native: in that case they'll have a resource index and a name. The + // name should be unique in a specific resource. + // 2. JS: they'll have a resource index and a name too, but the name is + // not garanteed to be unique in a resource. That's why we use the line + // number as well. + // 3. Label frames: they have no resource, only a name. So we can't do + // better than this. + const funcKey = [name, newResourceIndex, lineNumber].join('#'); + const insertedFuncIndex = mapOfInsertedFuncs.get(funcKey); + if (insertedFuncIndex !== undefined) { + translationMap.set(i, insertedFuncIndex); + continue; + } + mapOfInsertedFuncs.set(funcKey, newFuncTable.length); + translationMap.set(i, newFuncTable.length); + + newFuncTable.address.push(funcTable.address[i]); + newFuncTable.isJS.push(funcTable.isJS[i]); + newFuncTable.name.push(newStringTable.indexForString(name)); + newFuncTable.resource.push(newResourceIndex); + newFuncTable.relevantForJS.push(funcTable.relevantForJS[i]); + newFuncTable.fileName.push( + fileName === null ? null : newStringTable.indexForString(fileName) + ); + newFuncTable.lineNumber.push(lineNumber); + newFuncTable.columnNumber.push(funcTable.columnNumber[i]); + + newFuncTable.length++; + } + + translationMaps.push(translationMap); + }); + + return { funcTable: newFuncTable, translationMaps }; +} + +/** + * This combines the frame tables for a list of threads. It returns the new + * frame table with the translation maps to be used in subsequent merging + * functions. + * Note that we don't try to merge the frames of the source threads, because + * that's not needed to get a diffing call tree. + */ +function combineFrameTables( + translationMapsForCategories: TranslationMapForCategories[], + translationMapsForFuncs: TranslationMapForFuncs[], + newStringTable: UniqueStringArray, + threads: $ReadOnlyArray +): { frameTable: FrameTable, translationMaps: TranslationMapForFrames[] } { + const translationMaps = []; + const newFrameTable = getEmptyFrameTable(); + + threads.forEach((thread, threadIndex) => { + const { frameTable, stringTable } = thread; + const translationMap = new Map(); + const funcTranslationMap = translationMapsForFuncs[threadIndex]; + const categoryTranslationMap = translationMapsForCategories[threadIndex]; + + for (let i = 0; i < frameTable.length; i++) { + const category = frameTable.category[i]; + const newCategory = + category === null ? null : categoryTranslationMap.get(category); + if (newCategory === undefined) { + throw new Error(stripIndent` + We couldn't find the category of frame ${i} in the translation map. + This is a programming error. + `); + } + + const newFunc = funcTranslationMap.get(frameTable.func[i]); + if (newFunc === undefined) { + throw new Error(stripIndent` + We couldn't find the function of frame ${i} in the translation map. + This is a programming error. + `); + } + + const implementationIndex = frameTable.implementation[i]; + const implementation = + typeof implementationIndex === 'number' + ? stringTable.getString(implementationIndex) + : null; + + newFrameTable.address.push(frameTable.address[i]); + newFrameTable.category.push(newCategory); + // TODO issue #2151: we assume that subcategory strings are the same if + // the category is the same, and have no translation maps. But we should + // really implement one. + newFrameTable.subcategory.push(frameTable.subcategory[i]); + newFrameTable.func.push(newFunc); + newFrameTable.implementation.push( + implementation === null + ? null + : newStringTable.indexForString(implementation) + ); + newFrameTable.line.push(frameTable.line[i]); + newFrameTable.column.push(frameTable.column[i]); + newFrameTable.optimizations.push(frameTable.optimizations[i]); + + translationMap.set(i, newFrameTable.length); + newFrameTable.length++; + } + + translationMaps.push(translationMap); + }); + + return { frameTable: newFrameTable, translationMaps }; +} + +/** + * This combines the stack tables for a list of threads. It returns the new + * stack table with the translation maps to be used in subsequent merging + * functions. + * Note that we don't try to merge the stacks of the source threads, because + * that's not needed to get a diffing call tree. + */ +function combineStackTables( + translationMapsForCategories: TranslationMapForCategories[], + translationMapsForFrames: TranslationMapForFrames[], + threads: $ReadOnlyArray +): { stackTable: StackTable, translationMaps: TranslationMapForStacks[] } { + const translationMaps = []; + const newStackTable = getEmptyStackTable(); + + threads.forEach((thread, threadIndex) => { + const { stackTable } = thread; + const translationMap = new Map(); + const frameTranslationMap = translationMapsForFrames[threadIndex]; + const categoryTranslationMap = translationMapsForCategories[threadIndex]; + + for (let i = 0; i < stackTable.length; i++) { + const newFrameIndex = frameTranslationMap.get(stackTable.frame[i]); + if (newFrameIndex === undefined) { + throw new Error(stripIndent` + We couldn't find the frame of stack ${i} in the translation map. + This is a programming error. + `); + } + const newCategory = categoryTranslationMap.get(stackTable.category[i]); + if (newCategory === undefined) { + throw new Error(stripIndent` + We couldn't find the category of stack ${i} in the translation map. + This is a programming error. + `); + } + + const prefix = stackTable.prefix[i]; + const newPrefix = prefix === null ? null : translationMap.get(prefix); + if (newPrefix === undefined) { + throw new Error(stripIndent` + We couldn't find the prefix of stack ${i} in the translation map. + This is a programming error. + `); + } + + newStackTable.frame.push(newFrameIndex); + newStackTable.category.push(newCategory); + // TODO issue #2151: we assume that subcategory strings are the same if + // the category is the same, and have no translation maps. But we should + // really implement one. + newStackTable.subcategory.push(stackTable.subcategory[i]); + newStackTable.prefix.push(newPrefix); + + translationMap.set(i, newStackTable.length); + newStackTable.length++; + } + + translationMaps.push(translationMap); + }); + + return { stackTable: newStackTable, translationMaps }; +} + +/** + * This combines the sample tables for 2 threads. The samples for the first + * thread are added in a negative way while the samples for the second thread + * are added in a positive way, so that they will be diffed when computing the + * call tree and the various other timings in the app. + * It returns the new sample table with the translation maps to be used in + * subsequent merging functions, if necessary. + */ +function combineSamplesDiffing( + translationMapsForStacks: TranslationMapForStacks[], + threadsAndIntervals: [ThreadAndInterval, ThreadAndInterval] +): { samples: SamplesTable, translationMaps: TranslationMapForSamples[] } { + const translationMaps = [new Map(), new Map()]; + const [ + { + thread: { samples: samples1 }, + interval: interval1, + }, + { + thread: { samples: samples2 }, + interval: interval2, + }, + ] = threadsAndIntervals; + + const newSamples = { + ...getEmptySamplesTable(), + duration: [], + }; + + let i = 0; + let j = 0; + while (i < samples1.length || j < samples2.length) { + // We take the next sample from thread 1 if: + // - We still have samples in thread 1 AND + // - EITHER: + // + there's no samples left in thread 2 + // + looking at the next samples for each thread, the earliest is from thread 1. + // Otherwise we take the next samples from thread 2 until we run out of samples. + const nextSampleIsFromThread1 = + i < samples1.length && + (j >= samples2.length || samples1.time[i] < samples2.time[j]); + + if (nextSampleIsFromThread1) { + // Next sample is from thread 1. + const stackIndex = samples1.stack[i]; + const newStackIndex = + stackIndex === null + ? null + : translationMapsForStacks[0].get(stackIndex); + if (newStackIndex === undefined) { + throw new Error(stripIndent` + We couldn't find the stack of sample ${i} in the translation map. + This is a programming error. + `); + } + newSamples.stack.push(newStackIndex); + newSamples.responsiveness.push(samples1.responsiveness[i]); + newSamples.time.push(samples1.time[i]); + // We add the first thread with a negative duration, because this is the + // base profile. + newSamples.duration.push(-interval1); + + translationMaps[0].set(i, newSamples.length); + newSamples.length++; + i++; + } else { + // Next sample is from thread 2. + const stackIndex = samples2.stack[j]; + const newStackIndex = + stackIndex === null + ? null + : translationMapsForStacks[1].get(stackIndex); + if (newStackIndex === undefined) { + throw new Error(stripIndent` + We couldn't find the stack of sample ${j} in the translation map. + This is a programming error. + `); + } + newSamples.stack.push(newStackIndex); + newSamples.responsiveness.push(samples2.responsiveness[j]); + newSamples.time.push(samples2.time[j]); + newSamples.duration.push(interval2); + + translationMaps[1].set(j, newSamples.length); + newSamples.length++; + j++; + } + } + + return { + samples: newSamples, + translationMaps, + }; +} + +type ThreadAndInterval = {| + thread: Thread, + interval: Milliseconds, +|}; + +/** + * This function will compute a diffing thread from 2 different threads, using + * all the previous functions. + */ +function getComparisonThread( + translationMapsForCategories: TranslationMapForCategories[], + threadsAndIntervals: [ThreadAndInterval, ThreadAndInterval] +): Thread { + const newStringTable = new UniqueStringArray(); + + const threads = threadsAndIntervals.map(item => item.thread); + + const { + libs: newLibTable, + translationMaps: translationMapsForLibs, + } = combineLibTables(threads); + const { + resourceTable: newResourceTable, + translationMaps: translationMapsForResources, + } = combineResourceTables(translationMapsForLibs, newStringTable, threads); + const { + funcTable: newFuncTable, + translationMaps: translationMapsForFuncs, + } = combineFuncTables(translationMapsForResources, newStringTable, threads); + const { + frameTable: newFrameTable, + translationMaps: translationMapsForFrames, + } = combineFrameTables( + translationMapsForCategories, + translationMapsForFuncs, + newStringTable, + threads + ); + const { + stackTable: newStackTable, + translationMaps: translationMapsForStacks, + } = combineStackTables( + translationMapsForCategories, + translationMapsForFrames, + threads + ); + const { samples: newSamples } = combineSamplesDiffing( + translationMapsForStacks, + threadsAndIntervals + ); + + const mergedThread = { + processType: 'comparison', + processStartupTime: Math.min( + threads[0].processStartupTime, + threads[1].processStartupTime + ), + processShutdownTime: + Math.max( + threads[0].processShutdownTime || 0, + threads[1].processShutdownTime || 0 + ) || null, + registerTime: Math.min(threads[0].registerTime, threads[1].registerTime), + unregisterTime: + Math.max( + threads[0].unregisterTime || 0, + threads[1].unregisterTime || 0 + ) || null, + pausedRanges: [], + name: 'Diff between 1 and 2', + pid: 'Diff between 1 and 2', + tid: undefined, + samples: newSamples, + markers: getEmptyRawMarkerTable(), + stackTable: newStackTable, + frameTable: newFrameTable, + stringTable: newStringTable, + libs: newLibTable, + funcTable: newFuncTable, + resourceTable: newResourceTable, + }; + + return mergedThread; +} diff --git a/src/profile-logic/profile-data.js b/src/profile-logic/profile-data.js index 395f9d5503..3f1fcfb970 100644 --- a/src/profile-logic/profile-data.js +++ b/src/profile-logic/profile-data.js @@ -468,7 +468,7 @@ export function getTimingsForCallNodeIndex( ? samples.duration[sampleIndex] : interval; - rootTime += duration; + rootTime += Math.abs(duration); const thisNodeIndex = stackIndexToCallNodeIndex[thisStackIndex]; const thisFunc = callNodeTable.func[thisNodeIndex]; diff --git a/src/selectors/per-thread/composed.js b/src/selectors/per-thread/composed.js index 8b3274c499..7bb529b821 100644 --- a/src/selectors/per-thread/composed.js +++ b/src/selectors/per-thread/composed.js @@ -43,9 +43,16 @@ export function getComposedSelectorsPerThread( * when it's absurd. */ const getUsefulTabs: Selector<$ReadOnlyArray> = createSelector( + threadSelectors.getThread, threadSelectors.getIsNetworkChartEmptyInFullRange, threadSelectors.getJsTracerTable, - (isNetworkChartEmpty, jsTracerTable) => { + ({ processType }, isNetworkChartEmpty, jsTracerTable) => { + if (processType === 'comparison') { + // For a diffing tracks, we display only the calltree tab for now, because + // other views make no or not much sense. + return ['calltree']; + } + let visibleTabs = tabSlugs; if (isNetworkChartEmpty) { visibleTabs = visibleTabs.filter( diff --git a/src/test/components/__snapshots__/CallTreeSidebar.test.js.snap b/src/test/components/__snapshots__/CallTreeSidebar.test.js.snap index b5e142a433..e2ca32cd63 100644 --- a/src/test/components/__snapshots__/CallTreeSidebar.test.js.snap +++ b/src/test/components/__snapshots__/CallTreeSidebar.test.js.snap @@ -44,10 +44,7 @@ exports[`CallTreeSidebar matches the snapshots when displaying data about the cu
- 2ms - ( - 50 - %) + 2ms (50%)
2ms ( - 100 - %) + 100% + )

- 2ms - - ( - 50 - %) + 2ms (50%)
- 1ms - ( - 25 - %) + 1ms (25%)
1ms ( - 100 - %) + 100% + )

- 1ms - - ( - 25 - %) + 1ms (25%)
- 2ms - ( - 50 - %) + 2ms (50%)
1ms ( - 50 - %) + 50% + )
1ms ( - 50 - %) + 50% + )

- 2ms - - ( - 50 - %) + 2ms (50%)
- 1ms - ( - 25 - %) + 1ms (25%)
1ms ( - 100 - %) + 100% + )

- 2ms - - ( - 50 - %) + 2ms (50%)
- 2ms - ( - 50 - %) + 2ms (50%)
2ms ( - 100 - %) + 100% + )

- 2ms - - ( - 50 - %) + 2ms (50%)
- 1ms - ( - 25 - %) + 1ms (25%)
1ms ( - 100 - %) + 100% + )

- 2ms - - ( - 50 - %) + 2ms (50%)
- 1ms - ( - 25 - %) + 1ms (25%)
1ms ( - 100 - %) + 100% + )

- 2ms - - ( - 50 - %) + 2ms (50%)
- 1ms - ( - 25 - %) + 1ms (25%)
1ms ( - 100 - %) + 100% + )

- 4ms - - ( - 100 - %) + 4ms (100%)
, + funcNamesDictPerThread: Array<{ [funcName: string]: number }>, +} { + const profilesAndFuncNames = profileStrings.map(str => + getProfileFromTextSamples(str) + ); + const profiles = profilesAndFuncNames.map(({ profile }) => profile); + const profileState = stateFromLocation({ + pathname: '/public/fakehash1/', + search: '?thread=0&v=3', + hash: '', + }); + const { profile } = mergeProfiles(profiles, profiles.map(() => profileState)); + return { + profile, + funcNamesPerThread: profilesAndFuncNames.map( + ({ funcNamesPerThread }) => funcNamesPerThread[0] + ), + funcNamesDictPerThread: profilesAndFuncNames.map( + ({ funcNamesDictPerThread }) => funcNamesDictPerThread[0] + ), + }; +} + type NetworkMarkersOptions = {| uri: string, id: number, diff --git a/src/test/store/profile-view.test.js b/src/test/store/profile-view.test.js index fd4a776cc6..271204fd20 100644 --- a/src/test/store/profile-view.test.js +++ b/src/test/store/profile-view.test.js @@ -8,6 +8,7 @@ import type { TabSlug } from '../../app-logic/tabs-handling'; import { getProfileFromTextSamples, + getMergedProfileFromTextSamples, getProfileWithMarkers, getNetworkTrackProfile, getScreenshotTrackProfile, @@ -443,6 +444,33 @@ describe('actions/ProfileView', function() { }); }); + describe('with a comparison profile', function() { + it('selects the calltree tab when selecting the diffing track', function() { + const diffingTrackReference = { + type: 'global', + trackIndex: 2, + }; + + const { profile } = getMergedProfileFromTextSamples( + 'A B C', + 'A B B' + ); + const { getState, dispatch } = storeWithProfile(profile); + + dispatch(App.changeSelectedTab('flame-graph')); + expect(UrlStateSelectors.getSelectedThreadIndex(getState())).toEqual(0); + expect(UrlStateSelectors.getSelectedTab(getState())).toEqual( + 'flame-graph' + ); + + dispatch(ProfileView.selectTrack(diffingTrackReference)); + expect(UrlStateSelectors.getSelectedThreadIndex(getState())).toEqual(2); + expect(UrlStateSelectors.getSelectedTab(getState())).toEqual( + 'calltree' + ); + }); + }); + describe('when the loaded panel is not the call tree', function() { it('stays in the same panel when selecting another track', function() { const { getState, dispatch, parentTrack } = setup('marker-chart'); diff --git a/src/test/store/receive-profile.test.js b/src/test/store/receive-profile.test.js index 1f0229fd9a..31348a3914 100644 --- a/src/test/store/receive-profile.test.js +++ b/src/test/store/receive-profile.test.js @@ -13,6 +13,7 @@ import { blankStore } from '../fixtures/stores'; import * as ProfileViewSelectors from '../../selectors/profile'; import * as ZippedProfilesSelectors from '../../selectors/zipped-profiles'; import * as UrlStateSelectors from '../../selectors/url-state'; +import { getThreadSelectors } from '../../selectors/per-thread'; import { getView } from '../../selectors/app'; import { viewProfile, @@ -1097,16 +1098,45 @@ describe('actions/receive-profile', function() { }; } - function setupWithLongUrl(urlSearch1: string, urlSearch2: string): * { + function getSomeProfiles() { + const { profile: profile1 } = getProfileFromTextSamples( + `A B C D E`, + `G H I J K` + ); + const { profile: profile2 } = getProfileFromTextSamples( + `L M N O P Ex Ex Ex Ex`, + `Q R S T U Ex Ex Ex Ex` + ); + + return { profile1, profile2 }; + } + + type SetupProfileParams = {| + profile1: Profile, + profile2: Profile, + |}; + + type SetupUrlSearchParams = {| + urlSearch1: string, + urlSearch2: string, + |}; + + function setupWithLongUrl( + profiles: SetupProfileParams, + { urlSearch1, urlSearch2 }: SetupUrlSearchParams = { + urlSearch1: 'thread=0', + urlSearch2: 'thread=0', + } + ): * { const fakeUrl1 = `https://fakeurl.com/public/fakehash1/?${urlSearch1}&v=3`; const fakeUrl2 = `https://fakeurl.com/public/fakehash2/?${urlSearch2}&v=3`; - return setup(fakeUrl1, fakeUrl2); + return setup(profiles, { url1: fakeUrl1, url2: fakeUrl2 }); } async function setupWithShortUrl( - urlSearch1: string, - urlSearch2: string + profiles: SetupProfileParams, + { urlSearch1, urlSearch2 }: SetupUrlSearchParams ): * { const longUrl1 = `https://fakeurl.com/public/fakehash1/?${urlSearch1}&v=3`; const longUrl2 = `https://fakeurl.com/public/fakehash2/?${urlSearch2}&v=3`; @@ -1124,7 +1154,11 @@ describe('actions/receive-profile', function() { } }); - const setupResult = await setup(shortUrl1, shortUrl2); + const setupResult = await setup(profiles, { + url1: shortUrl1, + url2: shortUrl2, + }); + return { ...setupResult, shortUrl1, @@ -1132,16 +1166,15 @@ describe('actions/receive-profile', function() { }; } - async function setup(fakeUrl1: string, fakeUrl2: string): * { - const { profile: profile1 } = getProfileFromTextSamples( - `A B C D E`, - `G H I J K` - ); - const { profile: profile2 } = getProfileFromTextSamples( - `L M N O P Ex Ex Ex Ex`, - `Q R S T U Ex Ex Ex Ex` - ); + type SetupUrlParams = {| + url1: string, + url2: string, + |}; + async function setup( + { profile1, profile2 }: SetupProfileParams, + { url1, url2 }: SetupUrlParams + ): * { profile1.threads.forEach(thread => addMarkersToThreadWithCorrespondingSamples( thread, @@ -1175,7 +1208,7 @@ describe('actions/receive-profile', function() { .mockResolvedValueOnce(fetch200Response(serializeProfile(profile2))); const { dispatch, getState } = blankStore(); - await dispatch(retrieveProfilesToCompare([fakeUrl1, fakeUrl2])); + await dispatch(retrieveProfilesToCompare([url1, url2])); // To find stupid mistakes more easily, check that we didn't get a fatal // error here. If we got one, let's rethrow the error. @@ -1219,7 +1252,10 @@ describe('actions/receive-profile', function() { resultProfile, globalTracks, rootRange, - } = await setupWithLongUrl('thread=0', 'thread=1'); + } = await setupWithLongUrl(getSomeProfiles(), { + urlSearch1: 'thread=0', + urlSearch2: 'thread=1', + }); const expectedThreads = [profile1.threads[0], profile2.threads[1]].map( (thread, i) => ({ @@ -1229,8 +1265,17 @@ describe('actions/receive-profile', function() { unregisterTime: thread.samples.length, }) ); + + // comparison thread + expectedThreads.push( + expect.objectContaining({ + processType: 'comparison', + pid: 'Diff between 1 and 2', + name: 'Diff between 1 and 2', + }) + ); expect(resultProfile.threads).toEqual(expectedThreads); - expect(globalTracks).toHaveLength(2); + expect(globalTracks).toHaveLength(3); // each thread + comparison track expect(rootRange).toEqual({ start: 0, end: 9 }); }); @@ -1240,10 +1285,13 @@ describe('actions/receive-profile', function() { shortUrl2, globalTracks, rootRange, - } = await setupWithShortUrl('thread=0', 'thread=1'); + } = await setupWithShortUrl(getSomeProfiles(), { + urlSearch1: 'thread=0', + urlSearch2: 'thread=1', + }); // Reuse some expectations from the previous test - expect(globalTracks).toHaveLength(2); + expect(globalTracks).toHaveLength(3); // each thread + comparison track expect(rootRange).toEqual({ start: 0, end: 9 }); // Check that expandUrl has been called @@ -1252,28 +1300,28 @@ describe('actions/receive-profile', function() { }); it('filters samples and markers, according to the URL', async function() { - const { resultProfile } = await setupWithLongUrl( - 'thread=0&range=0.0011_0.0043', - 'thread=1' - ); + const { resultProfile } = await setupWithLongUrl(getSomeProfiles(), { + urlSearch1: 'thread=0&range=0.0011_0.0043', + urlSearch2: 'thread=1', + }); expect(resultProfile.threads[0].samples).toHaveLength(3); expect(resultProfile.threads[0].markers).toHaveLength(4); }); it('reuses the implementation information if both profiles used it', async function() { - const { getState } = await setupWithLongUrl( - 'thread=0&implementation=js', - 'thread=1&implementation=js' - ); + const { getState } = await setupWithLongUrl(getSomeProfiles(), { + urlSearch1: 'thread=0&implementation=js', + urlSearch2: 'thread=1&implementation=js', + }); expect(UrlStateSelectors.getImplementationFilter(getState())).toBe('js'); }); it('does not reuse the implementation information if one profile used it', async function() { - const { getState } = await setupWithLongUrl( - 'thread=0&implementation=js', - 'thread=1' - ); + const { getState } = await setupWithLongUrl(getSomeProfiles(), { + urlSearch1: 'thread=0&implementation=js', + urlSearch2: 'thread=1', + }); expect(UrlStateSelectors.getImplementationFilter(getState())).not.toBe( 'js' @@ -1281,10 +1329,10 @@ describe('actions/receive-profile', function() { }); it('reuses transforms', async function() { - const { getState } = await setupWithLongUrl( - 'thread=0&transforms=ff-42', - 'thread=1' - ); + const { getState } = await setupWithLongUrl(getSomeProfiles(), { + urlSearch1: 'thread=0&transforms=ff-42', + urlSearch2: 'thread=1', + }); expect(UrlStateSelectors.getTransformStack(getState(), 0)).toEqual([ { @@ -1293,6 +1341,24 @@ describe('actions/receive-profile', function() { }, ]); }); + + it('creates a diff thread that computes properly diff timings', async function() { + const { profile: baseProfile } = getProfileFromTextSamples('A A'); + const { profile: regressionProfile } = getProfileFromTextSamples( + 'A A A A A A' + ); + const { resultProfile, getState } = await setupWithLongUrl({ + profile1: baseProfile, + profile2: regressionProfile, + }); + + expect(resultProfile.threads).toHaveLength(3); + const selectors = getThreadSelectors(2); + const callTree = selectors.getCallTree(getState()); + const [firstChild] = callTree.getRoots(); + const nodeData = callTree.getNodeData(firstChild); + expect(nodeData.selfTime).toBe(4); + }); }); }); diff --git a/src/test/store/useful-tabs.test.js b/src/test/store/useful-tabs.test.js index cbced03adb..d03fac2db3 100644 --- a/src/test/store/useful-tabs.test.js +++ b/src/test/store/useful-tabs.test.js @@ -11,6 +11,7 @@ import { getProfileWithMarkers, getNetworkMarkers, getProfileWithJsTracerEvents, + getMergedProfileFromTextSamples, } from '../fixtures/profiles/processed-profile'; describe('getUsefulTabs', function() { @@ -51,4 +52,25 @@ describe('getUsefulTabs', function() { 'js-tracer', ]); }); + + it('shows only the call tree when a diffing track is selected', function() { + const { profile } = getMergedProfileFromTextSamples('A B C', 'A B B'); + const { getState, dispatch } = storeWithProfile(profile); + expect(selectedThreadSelectors.getUsefulTabs(getState())).toEqual([ + 'calltree', + 'flame-graph', + 'stack-chart', + 'marker-chart', + 'marker-table', + ]); + + dispatch({ + type: 'SELECT_TRACK', + selectedThreadIndex: 2, + selectedTab: 'calltree', + }); + expect(selectedThreadSelectors.getUsefulTabs(getState())).toEqual([ + 'calltree', + ]); + }); }); diff --git a/src/test/unit/comparison.test.js b/src/test/unit/comparison.test.js index 6c66e7b626..91ea929776 100644 --- a/src/test/unit/comparison.test.js +++ b/src/test/unit/comparison.test.js @@ -7,6 +7,77 @@ import { stateFromLocation } from '../../app-logic/url-handling'; import { getProfileFromTextSamples } from '../fixtures/profiles/processed-profile'; describe('mergeProfiles function', function() { + it('merges the various tables properly in the diffing profile', function() { + const sampleProfileA = getProfileFromTextSamples( + 'A[lib:libA] B[lib:libA]' + ); + const sampleProfileB = getProfileFromTextSamples( + 'A[lib:libA] A[lib:libB] C[lib:libC]' + ); + const profileState = stateFromLocation({ + pathname: '/public/fakehash1/', + search: '?thread=0&v=3', + hash: '', + }); + const { profile: mergedProfile } = mergeProfiles( + [sampleProfileA.profile, sampleProfileB.profile], + [profileState, profileState] + ); + expect(mergedProfile.threads).toHaveLength(3); + + const mergedThread = mergedProfile.threads[2]; + const mergedLibs = mergedThread.libs; + const mergedResources = mergedThread.resourceTable; + const mergedFunctions = mergedThread.funcTable; + const stringTable = mergedThread.stringTable; + + expect(mergedLibs).toHaveLength(3); + expect(mergedResources).toHaveLength(3); + expect(mergedFunctions).toHaveLength(4); + + // Now check that all functions are linked to the right resources. + // We should have 2 A functions, linked to 2 different resources. + // And we should have 1 B function, and 1 C function. + const libsForA = []; + const resourcesForA = []; + for (let funcIndex = 0; funcIndex < mergedFunctions.length; funcIndex++) { + const funcName = stringTable.getString(mergedFunctions.name[funcIndex]); + const resourceIndex = mergedFunctions.resource[funcIndex]; + + let resourceName = ''; + let libName = ''; + if (resourceIndex >= 0) { + const nameIndex = mergedResources.name[resourceIndex]; + if (nameIndex >= 0) { + resourceName = stringTable.getString(nameIndex); + } + + const libIndex = mergedResources.lib[resourceIndex]; + if (libIndex !== null && libIndex !== undefined && libIndex >= 0) { + libName = mergedLibs[libIndex].name; + } + } + + switch (funcName) { + case 'A': + libsForA.push(libName); + resourcesForA.push(resourceName); + break; + case 'B': + expect(libName).toBe('libA'); + expect(resourceName).toBe('libA'); + break; + case 'C': + expect(libName).toBe('libC'); + expect(resourceName).toBe('libC'); + break; + default: + } + } + expect(libsForA).toEqual(['libA', 'libB']); + expect(resourcesForA).toEqual(['libA', 'libB']); + }); + it('should set interval of merged profile to minimum of all intervals', function() { const sampleProfileA = getProfileFromTextSamples('A'); const sampleProfileB = getProfileFromTextSamples('B'); diff --git a/src/test/unit/profile-data.test.js b/src/test/unit/profile-data.test.js index a3af57b36f..22762bd848 100644 --- a/src/test/unit/profile-data.test.js +++ b/src/test/unit/profile-data.test.js @@ -36,6 +36,7 @@ import { ensureExists } from '../../utils/flow'; import getCallNodeProfile from '../fixtures/profiles/call-nodes'; import { getProfileFromTextSamples, + getMergedProfileFromTextSamples, getJsTracerTable, } from '../fixtures/profiles/processed-profile'; import { funcHasRecursiveCall } from '../../profile-logic/transforms'; @@ -1176,6 +1177,70 @@ describe('getTimingsForPath for an inverted tree', function() { }); }); +describe('getTimingsForPath for a diffing track', function() { + function setup() { + const { profile, funcNamesDictPerThread } = getMergedProfileFromTextSamples( + ` + A A A + B B C + D[cat:Layout] E F + `, + ` + A A A + B B B + G[cat:JavaScript] I E + ` + ); + const defaultCategory = profile.meta.categories.findIndex( + c => c.name === 'Other' + ); + const thread = profile.threads[2]; + + const callNodeInfo = getCallNodeInfo( + thread.stackTable, + thread.frameTable, + thread.funcTable, + defaultCategory + ); + const curriedGetTimingsForPath = path => + getTimingsForPath( + path, + callNodeInfo, + profile.meta.interval, + false /* inverted tree */, + thread, + profile.meta.categories + ); + + return { + getTimingsForPath: curriedGetTimingsForPath, + funcNamesDictPerThread, + }; + } + + it('computes the right breakdowns', () => { + const { + getTimingsForPath, + funcNamesDictPerThread: [{ A }], + } = setup(); + const timings = getTimingsForPath([A]); + expect(timings.forPath).toEqual({ + selfTime: { + breakdownByCategory: null, + breakdownByImplementation: null, + value: 0, + }, + totalTime: { + breakdownByCategory: withSingleSubcategory([0, 0, -1, 1, 0, 0, 0, 0]), // Idle, Other, Layout, JavaScript, etc. + breakdownByImplementation: { + native: 0, + }, + value: 0, + }, + }); + }); +}); + describe('getSamplesSelectedStates', function() { const { profile, diff --git a/src/test/unit/profile-tree.test.js b/src/test/unit/profile-tree.test.js index 2e1638004b..1b3d1f701a 100644 --- a/src/test/unit/profile-tree.test.js +++ b/src/test/unit/profile-tree.test.js @@ -2,7 +2,10 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // @flow -import { getProfileFromTextSamples } from '../fixtures/profiles/processed-profile'; +import { + getProfileFromTextSamples, + getMergedProfileFromTextSamples, +} from '../fixtures/profiles/processed-profile'; import { getCallTree, computeCallTreeCountsAndTimings, @@ -14,12 +17,42 @@ import { invertCallstack, getCallNodeIndexFromPath, getOriginAnnotationForFunc, + filterThreadSamplesToRange, } from '../../profile-logic/profile-data'; import { resourceTypes } from '../../profile-logic/data-structures'; import { formatTree, formatTreeIncludeCategories } from '../fixtures/utils'; import type { Profile } from '../../types/profile'; +function callTreeFromProfile( + profile: Profile, + threadIndex: number = 0 +): CallTree { + const thread = profile.threads[threadIndex]; + const { interval, categories } = profile.meta; + const defaultCategory = categories.findIndex(c => c.name === 'Other'); + const callNodeInfo = getCallNodeInfo( + thread.stackTable, + thread.frameTable, + thread.funcTable, + defaultCategory + ); + const callTreeCountsAndTimings = computeCallTreeCountsAndTimings( + thread, + callNodeInfo, + interval, + false + ); + return getCallTree( + thread, + interval, + callNodeInfo, + categories, + 'combined', + callTreeCountsAndTimings + ); +} + describe('unfiltered call tree', function() { // These values are hoisted at the top for the ease of access. In the profile fixture // for the unfiltered call tree, the indexes for funcs, frames, stacks, and callNodes @@ -44,32 +77,6 @@ describe('unfiltered call tree', function() { `).profile; } - function callTreeFromProfile(profile: Profile): CallTree { - const [thread] = profile.threads; - const { interval, categories } = profile.meta; - const defaultCategory = categories.findIndex(c => c.name === 'Other'); - const callNodeInfo = getCallNodeInfo( - thread.stackTable, - thread.frameTable, - thread.funcTable, - defaultCategory - ); - const callTreeCountsAndTimings = computeCallTreeCountsAndTimings( - thread, - callNodeInfo, - interval, - false - ); - return getCallTree( - thread, - interval, - callNodeInfo, - categories, - 'combined', - callTreeCountsAndTimings - ); - } - /** * Before creating a CallTree instance some timings are pre-computed. * This test ensures that these generated values are correct. @@ -526,6 +533,82 @@ describe('inverted call tree', function() { }); }); +describe('diffing trees', function() { + function getProfile() { + const { profile } = getMergedProfileFromTextSamples( + ` + A A A + B B C + D E F + `, + ` + A A A + B B B + G I E + ` + ); + return profile; + } + + it('displays a proper call tree, including nodes with totalTime = 0', () => { + const profile = getProfile(); + const callTree = callTreeFromProfile(profile, /* threadIndex */ 2); + const formattedTree = formatTree(callTree); + expect(formattedTree).toEqual([ + '- A (total: —, self: —)', + ' - B (total: 1, self: —)', + ' - D (total: -1, self: -1)', + ' - G (total: 1, self: 1)', + ' - I (total: 1, self: 1)', + ' - C (total: -1, self: —)', + ' - F (total: -1, self: -1)', + ]); + + // There's no A -> B -> E node because the diff makes it completely disappear. + expect(formattedTree).not.toContainEqual(expect.stringMatching(/^\s*- E/)); + }); + + it('displays a proper call tree, even for range-filtered threads', () => { + const profile = getProfile(); + const rangeStart = 1; + const rangeEnd = 3; + profile.threads = profile.threads.map(thread => + filterThreadSamplesToRange(thread, rangeStart, rangeEnd) + ); + const callTree = callTreeFromProfile(profile, /* threadIndex */ 2); + const formattedTree = formatTree(callTree); + expect(formattedTree).toEqual([ + // A -> B -> D and A -> B -> G should be filtered out by the range filtering. + '- A (total: —, self: —)', + ' - B (total: 1, self: —)', + ' - I (total: 1, self: 1)', + ' - C (total: -1, self: —)', + ' - F (total: -1, self: -1)', + ]); + }); + + it('computes a rootTotalTime that is the absolute count of all intervals', () => { + const profile = getProfile(); + + const thread = profile.threads[2]; + const { interval, categories } = profile.meta; + const defaultCategory = categories.findIndex(c => c.name === 'Other'); + const callNodeInfo = getCallNodeInfo( + thread.stackTable, + thread.frameTable, + thread.funcTable, + defaultCategory + ); + const callTreeCountsAndTimings = computeCallTreeCountsAndTimings( + thread, + callNodeInfo, + interval, + false + ); + expect(callTreeCountsAndTimings.rootTotalTime).toBe(4); + }); +}); + describe('origin annotation', function() { const { profile: { diff --git a/src/types/profile.js b/src/types/profile.js index bd0b2ed5cb..16bae31d1b 100644 --- a/src/types/profile.js +++ b/src/types/profile.js @@ -177,7 +177,7 @@ export type ResourceTable = {| // See https://github.com/firefox-devtools/profiler/issues/652 lib: Array, name: Array, - host: Array, + host: Array, type: resourceTypeEnum[], |};