ui: Use plugin deps to add tracks to process groups
Currently, plugins that add tracks to process or track groups get
access to the group by looking up these groups via their well known ids.
The problem is getTrackById isn't particularly efficient and is called
frequently during trace load.
This CL switches to using plugin dependencies to solve the issue of
multiple plugins adding to a shared group instead.
We have the ProcessThreadGroups plugin which exposes a
getGroupForProcess and getGroupForThread method. Other plugins can use
these methods to look up the correct group for their track, and the
dependencies list means that that this plugin is run before any
dependent plugin so these groups are guraranteed to exist by the time
the dependent plugins are run.
Change-Id: Ic1c3e077c2fbe7f145401c361e5e408a4da7a908
diff --git a/ui/src/plugins/dev.perfetto.AndroidDmabuf/index.ts b/ui/src/plugins/dev.perfetto.AndroidDmabuf/index.ts
index a946cc2..b9d0919 100644
--- a/ui/src/plugins/dev.perfetto.AndroidDmabuf/index.ts
+++ b/ui/src/plugins/dev.perfetto.AndroidDmabuf/index.ts
@@ -17,13 +17,10 @@
SqlDataSource,
} from '../../public/lib/tracks/query_counter_track';
import {PerfettoPlugin} from '../../public/plugin';
-import {
- getOrCreateGroupForProcess,
- getOrCreateGroupForThread,
-} from '../../public/standard_groups';
import {Trace} from '../../public/trace';
import {TrackNode} from '../../public/workspace';
import {NUM_NULL} from '../../trace_processor/query_result';
+import ProcessThreadGroupsPlugin from '../dev.perfetto.ProcessThreadGroups';
async function registerAllocsTrack(
ctx: Trace,
@@ -44,6 +41,8 @@
export default class implements PerfettoPlugin {
static readonly id = 'dev.perfetto.AndroidDmabuf';
+ static readonly dependencies = [ProcessThreadGroupsPlugin];
+
async onTraceLoad(ctx: Trace): Promise<void> {
const e = ctx.engine;
await e.query(`INCLUDE PERFETTO MODULE android.memory.dmabuf`);
@@ -66,9 +65,10 @@
WHERE upid = ${it.upid}`,
};
await registerAllocsTrack(ctx, uri, config);
- getOrCreateGroupForProcess(ctx.workspace, it.upid).addChildInOrder(
- new TrackNode({uri, title: 'dmabuf allocs'}),
- );
+ ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForProcess(it.upid)
+ ?.addChildInOrder(new TrackNode({uri, title: 'dmabuf allocs'}));
} else if (it.utid != null) {
const uri = `/android_process_dmabuf_utid_${it.utid}`;
const config: SqlDataSource = {
@@ -76,9 +76,10 @@
WHERE utid = ${it.utid}`,
};
await registerAllocsTrack(ctx, uri, config);
- getOrCreateGroupForThread(ctx.workspace, it.utid).addChildInOrder(
- new TrackNode({uri, title: 'dmabuf allocs'}),
- );
+ ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForThread(it.utid)
+ ?.addChildInOrder(new TrackNode({uri, title: 'dmabuf allocs'}));
}
}
}
diff --git a/ui/src/plugins/dev.perfetto.AsyncSlices/index.ts b/ui/src/plugins/dev.perfetto.AsyncSlices/index.ts
index ecd8dab..e5940cd 100644
--- a/ui/src/plugins/dev.perfetto.AsyncSlices/index.ts
+++ b/ui/src/plugins/dev.perfetto.AsyncSlices/index.ts
@@ -20,19 +20,18 @@
import {getThreadUriPrefix, getTrackName} from '../../public/utils';
import {NUM, NUM_NULL, STR, STR_NULL} from '../../trace_processor/query_result';
import {AsyncSliceTrack} from './async_slice_track';
-import {
- getOrCreateGroupForProcess,
- getOrCreateGroupForThread,
-} from '../../public/standard_groups';
import {exists} from '../../base/utils';
import {assertExists, assertTrue} from '../../base/logging';
import {SliceSelectionAggregator} from './slice_selection_aggregator';
import {sqlTableRegistry} from '../../frontend/widgets/sql/table/sql_table_registry';
import {getSliceTable} from './table';
import {extensions} from '../../public/lib/extensions';
+import ProcessThreadGroupsPlugin from '../dev.perfetto.ProcessThreadGroups';
export default class implements PerfettoPlugin {
static readonly id = 'dev.perfetto.AsyncSlices';
+ static readonly dependencies = [ProcessThreadGroupsPlugin];
+
async onTraceLoad(ctx: Trace): Promise<void> {
const trackIdsToUris = new Map<number, string>();
@@ -298,8 +297,10 @@
if (parent !== false && parent !== undefined) {
parent.trackNode.addChildInOrder(t.trackNode);
} else {
- const processGroup = getOrCreateGroupForProcess(ctx.workspace, t.upid);
- processGroup.addChildInOrder(t.trackNode);
+ const processGroup = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForProcess(t.upid);
+ processGroup?.addChildInOrder(t.trackNode);
}
});
}
@@ -399,8 +400,10 @@
if (parent !== false && parent !== undefined) {
parent.trackNode.addChildInOrder(t.trackNode);
} else {
- const group = getOrCreateGroupForThread(ctx.workspace, t.utid);
- group.addChildInOrder(t.trackNode);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForThread(t.utid);
+ group?.addChildInOrder(t.trackNode);
}
});
}
diff --git a/ui/src/plugins/dev.perfetto.Counter/index.ts b/ui/src/plugins/dev.perfetto.Counter/index.ts
index ef063ca..47a8f61 100644
--- a/ui/src/plugins/dev.perfetto.Counter/index.ts
+++ b/ui/src/plugins/dev.perfetto.Counter/index.ts
@@ -27,11 +27,8 @@
import {TraceProcessorCounterTrack} from './trace_processor_counter_track';
import {exists} from '../../base/utils';
import {TrackNode} from '../../public/workspace';
-import {
- getOrCreateGroupForProcess,
- getOrCreateGroupForThread,
-} from '../../public/standard_groups';
import {CounterSelectionAggregator} from './counter_selection_aggregator';
+import ProcessThreadGroupsPlugin from '../dev.perfetto.ProcessThreadGroups';
const NETWORK_TRACK_REGEX = new RegExp('^.* (Received|Transmitted)( KB)?$');
const ENTITY_RESIDENCY_REGEX = new RegExp('^Entity residency:');
@@ -108,6 +105,8 @@
export default class implements PerfettoPlugin {
static readonly id = 'dev.perfetto.Counter';
+ static readonly dependencies = [ProcessThreadGroupsPlugin];
+
async onTraceLoad(ctx: Trace): Promise<void> {
await this.addCounterTracks(ctx);
await this.addGpuFrequencyTracks(ctx);
@@ -313,9 +312,11 @@
name,
),
});
- const group = getOrCreateGroupForThread(ctx.workspace, utid);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForThread(utid);
const track = new TrackNode({uri, title: name, sortOrder: 30});
- group.addChildInOrder(track);
+ group?.addChildInOrder(track);
}
}
@@ -371,9 +372,11 @@
name,
),
});
- const group = getOrCreateGroupForProcess(ctx.workspace, upid);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForProcess(upid);
const track = new TrackNode({uri, title: name, sortOrder: 20});
- group.addChildInOrder(track);
+ group?.addChildInOrder(track);
}
}
diff --git a/ui/src/plugins/dev.perfetto.CpuProfile/index.ts b/ui/src/plugins/dev.perfetto.CpuProfile/index.ts
index e33e341..05718df 100644
--- a/ui/src/plugins/dev.perfetto.CpuProfile/index.ts
+++ b/ui/src/plugins/dev.perfetto.CpuProfile/index.ts
@@ -19,11 +19,13 @@
import {CpuProfileTrack} from './cpu_profile_track';
import {getThreadUriPrefix} from '../../public/utils';
import {exists} from '../../base/utils';
-import {getOrCreateGroupForThread} from '../../public/standard_groups';
import {TrackNode} from '../../public/workspace';
+import ProcessThreadGroupsPlugin from '../dev.perfetto.ProcessThreadGroups';
export default class implements PerfettoPlugin {
static readonly id = 'dev.perfetto.CpuProfile';
+ static readonly dependencies = [ProcessThreadGroupsPlugin];
+
async onTraceLoad(ctx: Trace): Promise<void> {
const result = await ctx.engine.query(`
with thread_cpu_sample as (
@@ -62,9 +64,11 @@
},
track: new CpuProfileTrack(ctx, uri, utid),
});
- const group = getOrCreateGroupForThread(ctx.workspace, utid);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForThread(utid);
const track = new TrackNode({uri, title, sortOrder: -40});
- group.addChildInOrder(track);
+ group?.addChildInOrder(track);
}
}
}
diff --git a/ui/src/plugins/dev.perfetto.Frames/index.ts b/ui/src/plugins/dev.perfetto.Frames/index.ts
index 8d3abec..d9df86c 100644
--- a/ui/src/plugins/dev.perfetto.Frames/index.ts
+++ b/ui/src/plugins/dev.perfetto.Frames/index.ts
@@ -18,16 +18,18 @@
} from '../../public/track_kinds';
import {Trace} from '../../public/trace';
import {PerfettoPlugin} from '../../public/plugin';
-import {getOrCreateGroupForProcess} from '../../public/standard_groups';
import {getTrackName} from '../../public/utils';
import {TrackNode} from '../../public/workspace';
import {NUM, NUM_NULL, STR, STR_NULL} from '../../trace_processor/query_result';
import {ActualFramesTrack} from './actual_frames_track';
import {ExpectedFramesTrack} from './expected_frames_track';
import {FrameSelectionAggregator} from './frame_selection_aggregator';
+import ProcessThreadGroupsPlugin from '../dev.perfetto.ProcessThreadGroups';
export default class implements PerfettoPlugin {
static readonly id = 'dev.perfetto.Frames';
+ static readonly dependencies = [ProcessThreadGroupsPlugin];
+
async onTraceLoad(ctx: Trace): Promise<void> {
this.addExpectedFrames(ctx);
this.addActualFrames(ctx);
@@ -88,9 +90,11 @@
kind: EXPECTED_FRAMES_SLICE_TRACK_KIND,
},
});
- const group = getOrCreateGroupForProcess(ctx.workspace, upid);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForProcess(upid);
const track = new TrackNode({uri, title, sortOrder: -50});
- group.addChildInOrder(track);
+ group?.addChildInOrder(track);
}
}
@@ -151,9 +155,11 @@
kind: ACTUAL_FRAMES_SLICE_TRACK_KIND,
},
});
- const group = getOrCreateGroupForProcess(ctx.workspace, upid);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForProcess(upid);
const track = new TrackNode({uri, title, sortOrder: -50});
- group.addChildInOrder(track);
+ group?.addChildInOrder(track);
}
}
}
diff --git a/ui/src/plugins/dev.perfetto.HeapProfile/index.ts b/ui/src/plugins/dev.perfetto.HeapProfile/index.ts
index 2e0591f..fcd79a3 100644
--- a/ui/src/plugins/dev.perfetto.HeapProfile/index.ts
+++ b/ui/src/plugins/dev.perfetto.HeapProfile/index.ts
@@ -17,9 +17,9 @@
import {PerfettoPlugin} from '../../public/plugin';
import {LONG, NUM, STR} from '../../trace_processor/query_result';
import {HeapProfileTrack} from './heap_profile_track';
-import {getOrCreateGroupForProcess} from '../../public/standard_groups';
import {TrackNode} from '../../public/workspace';
import {createPerfettoTable} from '../../trace_processor/sql_utils';
+import ProcessThreadGroupsPlugin from '../dev.perfetto.ProcessThreadGroups';
function getUriForTrack(upid: number): string {
return `/process_${upid}/heap_profile`;
@@ -27,6 +27,8 @@
export default class implements PerfettoPlugin {
static readonly id = 'dev.perfetto.HeapProfile';
+ static readonly dependencies = [ProcessThreadGroupsPlugin];
+
async onTraceLoad(ctx: Trace): Promise<void> {
const it = await ctx.engine.query(`
select value from stats
@@ -94,9 +96,11 @@
},
track: new HeapProfileTrack(ctx, uri, tableName, upid, incomplete),
});
- const group = getOrCreateGroupForProcess(ctx.workspace, upid);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForProcess(upid);
const track = new TrackNode({uri, title, sortOrder: -30});
- group.addChildInOrder(track);
+ group?.addChildInOrder(track);
}
ctx.addEventListener('traceready', async () => {
diff --git a/ui/src/plugins/dev.perfetto.PerfSamplesProfile/index.ts b/ui/src/plugins/dev.perfetto.PerfSamplesProfile/index.ts
index 04e8b13..1488376 100644
--- a/ui/src/plugins/dev.perfetto.PerfSamplesProfile/index.ts
+++ b/ui/src/plugins/dev.perfetto.PerfSamplesProfile/index.ts
@@ -23,11 +23,8 @@
ThreadPerfSamplesProfileTrack,
} from './perf_samples_profile_track';
import {getThreadUriPrefix} from '../../public/utils';
-import {
- getOrCreateGroupForProcess,
- getOrCreateGroupForThread,
-} from '../../public/standard_groups';
import {TrackNode} from '../../public/workspace';
+import ProcessThreadGroupsPlugin from '../dev.perfetto.ProcessThreadGroups';
export interface Data extends TrackData {
tsStarts: BigInt64Array;
@@ -39,6 +36,8 @@
export default class implements PerfettoPlugin {
static readonly id = 'dev.perfetto.PerfSamplesProfile';
+ static readonly dependencies = [ProcessThreadGroupsPlugin];
+
async onTraceLoad(ctx: Trace): Promise<void> {
const pResult = await ctx.engine.query(`
select distinct upid
@@ -59,9 +58,11 @@
},
track: new ProcessPerfSamplesProfileTrack(ctx, uri, upid),
});
- const group = getOrCreateGroupForProcess(ctx.workspace, upid);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForProcess(upid);
const track = new TrackNode({uri, title, sortOrder: -40});
- group.addChildInOrder(track);
+ group?.addChildInOrder(track);
}
const tResult = await ctx.engine.query(`
select distinct
@@ -99,9 +100,11 @@
},
track: new ThreadPerfSamplesProfileTrack(ctx, uri, utid),
});
- const group = getOrCreateGroupForThread(ctx.workspace, utid);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForThread(utid);
const track = new TrackNode({uri, title, sortOrder: -50});
- group.addChildInOrder(track);
+ group?.addChildInOrder(track);
}
ctx.addEventListener('traceready', async () => {
diff --git a/ui/src/plugins/dev.perfetto.ProcessThreadGroups/index.ts b/ui/src/plugins/dev.perfetto.ProcessThreadGroups/index.ts
index 60aa11c..eb720c9 100644
--- a/ui/src/plugins/dev.perfetto.ProcessThreadGroups/index.ts
+++ b/ui/src/plugins/dev.perfetto.ProcessThreadGroups/index.ts
@@ -14,10 +14,6 @@
import {Trace} from '../../public/trace';
import {PerfettoPlugin} from '../../public/plugin';
-import {
- getOrCreateGroupForProcess,
- getOrCreateGroupForThread,
-} from '../../public/standard_groups';
import {TrackNode} from '../../public/workspace';
import {NUM, STR, STR_NULL} from '../../trace_processor/query_result';
@@ -41,24 +37,35 @@
// including the kernel groups, sorting, and adding summary tracks.
export default class implements PerfettoPlugin {
static readonly id = 'dev.perfetto.ProcessThreadGroups';
- async onTraceLoad(ctx: Trace): Promise<void> {
- const processGroups = new Map<number, TrackNode>();
- const threadGroups = new Map<number, TrackNode>();
+ private readonly processGroups = new Map<number, TrackNode>();
+ private readonly threadGroups = new Map<number, TrackNode>();
+
+ constructor(private readonly ctx: Trace) {}
+
+ getGroupForProcess(upid: number): TrackNode | undefined {
+ return this.processGroups.get(upid);
+ }
+
+ getGroupForThread(utid: number): TrackNode | undefined {
+ return this.threadGroups.get(utid);
+ }
+
+ async onTraceLoad(ctx: Trace): Promise<void> {
// Pre-group all kernel "threads" (actually processes) if this is a linux
// system trace. Below, addProcessTrackGroups will skip them due to an
// existing group uuid, and addThreadStateTracks will fill in the
// per-thread tracks. Quirk: since all threads will appear to be
// TrackKindPriority.MAIN_THREAD, any process-level tracks will end up
// pushed to the bottom of the group in the UI.
- await this.addKernelThreadGrouping(ctx, threadGroups);
+ await this.addKernelThreadGrouping();
// Create the per-process track groups. Note that this won't necessarily
// create a track per process. If a process has been completely idle and has
// no sched events, no track group will be emitted.
// Will populate this.addTrackGroupActions
- await this.addProcessGroups(ctx, processGroups, threadGroups);
- await this.addThreadGroups(ctx, processGroups, threadGroups);
+ await this.addProcessGroups();
+ await this.addThreadGroups();
ctx.addEventListener('traceready', () => {
// If, by the time the trace has finished loading, some of the process or
@@ -68,15 +75,12 @@
g.remove();
}
};
- processGroups.forEach(removeIfEmpty);
- threadGroups.forEach(removeIfEmpty);
+ this.processGroups.forEach(removeIfEmpty);
+ this.threadGroups.forEach(removeIfEmpty);
});
}
- private async addKernelThreadGrouping(
- ctx: Trace,
- threadGroups: Map<number, TrackNode>,
- ): Promise<void> {
+ private async addKernelThreadGrouping(): Promise<void> {
// Identify kernel threads if this is a linux system trace, and sufficient
// process information is available. Kernel threads are identified by being
// children of kthreadd (always pid 2).
@@ -86,7 +90,7 @@
// which has pid 0 but appears as a distinct process (with its own comm) on
// each cpu. It'd make sense to exclude its thread state track, but still
// put process-scoped tracks in this group.
- const result = await ctx.engine.query(`
+ const result = await this.ctx.engine.query(`
select
t.utid, p.upid, (case p.pid when 2 then 1 else 0 end) isKthreadd
from
@@ -123,28 +127,27 @@
sortOrder: 50,
isSummary: true,
});
- ctx.workspace.addChildInOrder(kernelThreadsGroup);
+ this.ctx.workspace.addChildInOrder(kernelThreadsGroup);
// Set the group for all kernel threads (including kthreadd itself).
for (; it.valid(); it.next()) {
const {utid} = it;
- const threadGroup = getOrCreateGroupForThread(ctx.workspace, utid);
- threadGroup.headless = true;
+ const threadGroup = new TrackNode({
+ uri: `thread${utid}`,
+ title: `Thread ${utid}`,
+ isSummary: true,
+ headless: true,
+ });
kernelThreadsGroup.addChildInOrder(threadGroup);
-
- threadGroups.set(utid, threadGroup);
+ this.threadGroups.set(utid, threadGroup);
}
}
// Adds top level groups for processes and thread that don't belong to a
// process.
- private async addProcessGroups(
- ctx: Trace,
- processGroups: Map<number, TrackNode>,
- threadGroups: Map<number, TrackNode>,
- ): Promise<void> {
- const result = await ctx.engine.query(`
+ private async addProcessGroups(): Promise<void> {
+ const result = await this.ctx.engine.query(`
with processGroups as (
select
upid,
@@ -231,7 +234,7 @@
if (kind === 'process') {
// Ignore kernel process groups
- if (processGroups.has(uid)) {
+ if (this.processGroups.has(uid)) {
continue;
}
@@ -247,41 +250,41 @@
}
const displayName = getProcessDisplayName(name ?? undefined, id);
- const group = getOrCreateGroupForProcess(ctx.workspace, uid);
- group.title = displayName;
- group.uri = `/process_${uid}`; // Summary track URI
- group.sortOrder = 50;
+ const group = new TrackNode({
+ uri: `/process_${uid}`,
+ title: displayName,
+ isSummary: true,
+ sortOrder: 50,
+ });
// Re-insert the child node to sort it
- ctx.workspace.addChildInOrder(group);
- processGroups.set(uid, group);
+ this.ctx.workspace.addChildInOrder(group);
+ this.processGroups.set(uid, group);
} else {
// Ignore kernel process groups
- if (threadGroups.has(uid)) {
+ if (this.threadGroups.has(uid)) {
continue;
}
const displayName = getThreadDisplayName(name ?? undefined, id);
- const group = getOrCreateGroupForThread(ctx.workspace, uid);
- group.title = displayName;
- group.uri = `/thread_${uid}`; // Summary track URI
- group.sortOrder = 50;
+ const group = new TrackNode({
+ uri: `/thread_${uid}`,
+ title: displayName,
+ isSummary: true,
+ sortOrder: 50,
+ });
// Re-insert the child node to sort it
- ctx.workspace.addChildInOrder(group);
- threadGroups.set(uid, group);
+ this.ctx.workspace.addChildInOrder(group);
+ this.threadGroups.set(uid, group);
}
}
}
// Create all the nested & headless thread groups that live inside existing
// process groups.
- private async addThreadGroups(
- ctx: Trace,
- processGroups: Map<number, TrackNode>,
- threadGroups: Map<number, TrackNode>,
- ): Promise<void> {
- const result = await ctx.engine.query(`
+ private async addThreadGroups(): Promise<void> {
+ const result = await this.ctx.engine.query(`
with threadGroups as (
select
utid,
@@ -329,15 +332,18 @@
const {utid, tid, upid, threadName} = it;
// Ignore kernel thread groups
- if (threadGroups.has(utid)) {
+ if (this.threadGroups.has(utid)) {
continue;
}
- const group = getOrCreateGroupForThread(ctx.workspace, utid);
- group.title = getThreadDisplayName(threadName ?? undefined, tid);
- threadGroups.set(utid, group);
- group.headless = true;
- processGroups.get(upid)?.addChildInOrder(group);
+ const group = new TrackNode({
+ uri: `/thread_${utid}`,
+ title: getThreadDisplayName(threadName ?? undefined, tid),
+ isSummary: true,
+ headless: true,
+ });
+ this.threadGroups.set(utid, group);
+ this.processGroups.get(upid)?.addChildInOrder(group);
}
}
}
diff --git a/ui/src/plugins/dev.perfetto.ThreadState/index.ts b/ui/src/plugins/dev.perfetto.ThreadState/index.ts
index 155b35f..d7c2363 100644
--- a/ui/src/plugins/dev.perfetto.ThreadState/index.ts
+++ b/ui/src/plugins/dev.perfetto.ThreadState/index.ts
@@ -22,9 +22,9 @@
import {getThreadStateTable} from './table';
import {sqlTableRegistry} from '../../frontend/widgets/sql/table/sql_table_registry';
import {TrackNode} from '../../public/workspace';
-import {getOrCreateGroupForThread} from '../../public/standard_groups';
import {ThreadStateSelectionAggregator} from './thread_state_selection_aggregator';
import {extensions} from '../../public/lib/extensions';
+import ProcessThreadGroupsPlugin from '../dev.perfetto.ProcessThreadGroups';
function uriForThreadStateTrack(upid: number | null, utid: number): string {
return `${getThreadUriPrefix(upid, utid)}_state`;
@@ -32,6 +32,8 @@
export default class implements PerfettoPlugin {
static readonly id = 'dev.perfetto.ThreadState';
+ static readonly dependencies = [ProcessThreadGroupsPlugin];
+
async onTraceLoad(ctx: Trace): Promise<void> {
const {engine} = ctx;
@@ -87,9 +89,11 @@
track: new ThreadStateTrack(ctx, uri, utid),
});
- const group = getOrCreateGroupForThread(ctx.workspace, utid);
+ const group = ctx.plugins
+ .getPlugin(ProcessThreadGroupsPlugin)
+ .getGroupForThread(utid);
const track = new TrackNode({uri, title, sortOrder: 10});
- group.addChildInOrder(track);
+ group?.addChildInOrder(track);
}
sqlTableRegistry['thread_state'] = getThreadStateTable();
diff --git a/ui/src/public/standard_groups.ts b/ui/src/public/standard_groups.ts
index 61b844a..2bc7570 100644
--- a/ui/src/public/standard_groups.ts
+++ b/ui/src/public/standard_groups.ts
@@ -15,40 +15,6 @@
import {TrackNode, TrackNodeArgs, Workspace} from './workspace';
/**
- * Gets or creates a group for a given process given the normal grouping
- * conventions.
- *
- * @param workspace - The workspace to search for the group on.
- * @param upid - The upid of teh process to find.
- */
-export function getOrCreateGroupForProcess(
- workspace: Workspace,
- upid: number,
-): TrackNode {
- return getOrCreateGroup(workspace, `process${upid}`, {
- title: `Process ${upid}`,
- isSummary: true,
- });
-}
-
-/**
- * Gets or creates a group for a given thread given the normal grouping
- * conventions.
- *
- * @param workspace - The workspace to search for the group on.
- * @param utid - The utid of the thread to find.
- */
-export function getOrCreateGroupForThread(
- workspace: Workspace,
- utid: number,
-): TrackNode {
- return getOrCreateGroup(workspace, `thread${utid}`, {
- title: `Thread ${utid}`,
- isSummary: true,
- });
-}
-
-/**
* Gets or creates a group for user interaction
*
* @param workspace - The workspace on which to create the group.
