Use experimental_flamegraph function for native profiles.
Change-Id: Ie5ab30a415b388b75e60a80e01c896bb909ea2c6
diff --git a/ui/src/controller/heap_profile_controller.ts b/ui/src/controller/heap_profile_controller.ts
index 973a92f..eadb704 100644
--- a/ui/src/controller/heap_profile_controller.ts
+++ b/ui/src/controller/heap_profile_controller.ts
@@ -177,23 +177,23 @@
let sizeIndex = 4;
switch (viewingOption) {
case SPACE_MEMORY_ALLOCATED_NOT_FREED_KEY:
- orderBy = `where size > 0 order by depth, parent_hash, size desc, name`;
+ orderBy = `where cumulative_size > 0 order by depth, parent_id,
+ cumulative_size desc, name`;
sizeIndex = 4;
break;
case ALLOC_SPACE_MEMORY_ALLOCATED_KEY:
- orderBy =
- `where alloc_size > 0 order by depth, parent_hash, alloc_size desc,
- name`;
+ orderBy = `where cumulative_alloc_size > 0 order by depth, parent_id,
+ cumulative_alloc_size desc, name`;
sizeIndex = 5;
break;
case OBJECTS_ALLOCATED_NOT_FREED_KEY:
- orderBy =
- `where count > 0 order by depth, parent_hash, count desc, name`;
+ orderBy = `where cumulative_count > 0 order by depth, parent_id,
+ cumulative_count desc, name`;
sizeIndex = 6;
break;
case OBJECTS_ALLOCATED_KEY:
- orderBy = `where alloc_count > 0 order by depth, parent_hash,
- alloc_count desc, name`;
+ orderBy = `where cumulative_alloc_count > 0 order by depth, parent_id,
+ cumulative_alloc_count desc, name`;
sizeIndex = 7;
break;
default:
@@ -201,8 +201,9 @@
}
const callsites = await this.args.engine.query(
- `SELECT hash, name, parent_hash, depth, size, alloc_size, count,
- alloc_count, map_name, self_size from ${tableName} ${orderBy}`);
+ `SELECT id, name, parent_id, depth, cumulative_size,
+ cumulative_alloc_size, cumulative_count,
+ cumulative_alloc_count, map_name, size from ${tableName} ${orderBy}`);
const flamegraphData: CallsiteInfo[] = new Array();
const hashToindex: Map<number, number> = new Map();
@@ -230,102 +231,15 @@
Promise<string> {
// Creating unique names for views so we can reuse and not delete them
// for each marker.
- const tableNameCallsiteNameSize =
- this.tableName(`callsite_with_name_and_size`);
- const tableNameCallsiteHashNameSize =
- this.tableName(`callsite_hash_name_size`);
const tableNameGroupedCallsitesForFlamegraph =
this.tableName(`grouped_callsites_for_flamegraph`);
- // Joining the callsite table with frame table then with alloc table to get
- // the size and name for each callsite.
- // TODO(taylori): Make frame name nullable in the trace processor for
- // consistency with the other columns.
- await this.args.engine.query(
- `create view if not exists ${tableNameCallsiteNameSize} as
- select id, parent_id, depth, IFNULL(DEMANGLE(name), name) as name,
- map_name, size, alloc_size, count, alloc_count from (
- select cs.id as id, parent_id, depth,
- coalesce(symbols.name,
- case when fr.name != '' then fr.name else map.name end) as name,
- map.name as map_name,
- SUM(IFNULL(size, 0)) as size,
- SUM(IFNULL(size, 0)) as size,
- SUM(case when size > 0 then size else 0 end) as alloc_size,
- SUM(IFNULL(count, 0)) as count,
- SUM(case when count > 0 then count else 0 end) as alloc_count
- from stack_profile_callsite cs
- join stack_profile_frame fr on cs.frame_id = fr.id
- join stack_profile_mapping map on fr.mapping = map.id
- left join (
- select symbol_set_id, FIRST_VALUE(name) OVER(PARTITION BY
- symbol_set_id) as name
- from stack_profile_symbol GROUP BY symbol_set_id
- ) as symbols using(symbol_set_id)
- left join heap_profile_allocation alloc on alloc.callsite_id = cs.id
- and alloc.ts <= ${ts} and alloc.upid = ${upid} group by cs.id)`);
- // Recursive query to compute the hash for each callsite based on names
- // rather than ids.
- // We get all the children of the row in question and emit a row with hash
- // equal hash(name, parent.hash). Roots without the parent will have -1 as
- // hash. Slices will be merged into a big slice.
- await this.args.engine.query(
- `create view if not exists ${tableNameCallsiteHashNameSize} as
- with recursive callsite_table_names(
- id, hash, name, map_name, size, alloc_size, count, alloc_count,
- parent_hash, depth) AS (
- select id, hash(name) as hash, name, map_name, size, alloc_size, count,
- alloc_count, -1, depth
- from ${tableNameCallsiteNameSize}
- where depth = 0
- union all
- select cs.id, hash(cs.name, ctn.hash) as hash, cs.name, cs.map_name,
- cs.size, cs.alloc_size, cs.count, cs.alloc_count, ctn.hash, cs.depth
- from callsite_table_names ctn
- inner join ${tableNameCallsiteNameSize} cs ON ctn.id = cs.parent_id
- )
- select hash, name, map_name, parent_hash, depth, SUM(size) as size,
- SUM(case when alloc_size > 0 then alloc_size else 0 end)
- as alloc_size, SUM(count) as count,
- SUM(case when alloc_count > 0 then alloc_count else 0 end)
- as alloc_count
- from callsite_table_names
- group by hash`);
-
- // Recursive query to compute the cumulative size of each callsite.
- // Base case: We get all the callsites where the size is non-zero.
- // Recursive case: We get the callsite which is the parent of the current
- // callsite(in terms of hashes) and emit a row with the size of the current
- // callsite plus all the info of the parent.
- // Grouping: For each callsite, our recursive table has n rows where n is
- // the number of descendents with a non-zero self size. We need to group on
- // the hash and sum all the sizes to get the cumulative size for each
- // callsite hash.
await this.args.engine.query(`create temp table if not exists ${
- tableNameGroupedCallsitesForFlamegraph}
- as with recursive callsite_children(
- hash, name, map_name, parent_hash, depth, size, alloc_size, count,
- alloc_count, self_size, self_alloc_size, self_count, self_alloc_count)
- as (
- select hash, name, map_name, parent_hash, depth, size, alloc_size,
- count, alloc_count, size as self_size, alloc_size as self_alloc_size,
- count as self_count, alloc_count as self_alloc_count
- from ${tableNameCallsiteHashNameSize}
- union all
- select chns.hash, chns.name, chns.map_name, chns.parent_hash,
- chns.depth, cc.size, cc.alloc_size, cc.count, cc.alloc_count,
- chns.size, chns.alloc_size, chns.count, chns.alloc_count
- from ${tableNameCallsiteHashNameSize} chns
- inner join callsite_children cc on chns.hash = cc.parent_hash
- )
- select hash, name, map_name, parent_hash, depth, SUM(size) as size,
- SUM(case when alloc_size > 0 then alloc_size else 0 end)
- as alloc_size, SUM(count) as count,
- SUM(case when alloc_count > 0 then alloc_count else 0 end) as
- alloc_count,
- self_size, self_alloc_size, self_count, self_alloc_count
- from callsite_children
- group by hash`);
+ tableNameGroupedCallsitesForFlamegraph} as
+ select id, name, map_name, parent_id, depth, cumulative_size,
+ cumulative_alloc_size, cumulative_count, cumulative_alloc_count,
+ size, alloc_size, count, alloc_count
+ from experimental_flamegraph(${ts}, ${upid}, 'native')`);
return tableNameGroupedCallsitesForFlamegraph;
}
