| // Copyright (C) 2023 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| import {Trace} from '../../public/trace'; |
| import {PerfettoPlugin} from '../../public/plugin'; |
| import {Engine} from '../../trace_processor/engine'; |
| import { |
| SimpleSliceTrack, |
| SimpleSliceTrackConfig, |
| } from '../../frontend/simple_slice_track'; |
| import {CounterOptions} from '../../frontend/base_counter_track'; |
| import { |
| SimpleCounterTrack, |
| SimpleCounterTrackConfig, |
| } from '../../frontend/simple_counter_track'; |
| import {TrackNode} from '../../public/workspace'; |
| |
| interface ContainedTrace { |
| uuid: string; |
| subscription: string; |
| trigger: string; |
| // NB: these are millis. |
| ts: number; |
| dur: number; |
| } |
| |
| const PACKAGE_LOOKUP = ` |
| create or replace perfetto table package_name_lookup as |
| with installed as ( |
| select uid, string_agg(package_name, ',') as name |
| from package_list |
| where uid >= 10000 |
| group by 1 |
| ), |
| system(uid, name) as ( |
| values |
| (0, 'AID_ROOT'), |
| (1000, 'AID_SYSTEM_USER'), |
| (1001, 'AID_RADIO'), |
| (1082, 'AID_ARTD') |
| ) |
| select uid, name from installed |
| union all |
| select uid, name from system |
| order by uid; |
| |
| -- Adds a "package_name" column by joining on "uid" from the source table. |
| create or replace perfetto macro add_package_name(src TableOrSubquery) returns TableOrSubquery as ( |
| select A.*, ifnull(B.name, "uid=" || A.uid) as package_name |
| from $src as A |
| left join package_name_lookup as B |
| on (B.uid = (A.uid % 100000)) |
| ); |
| `; |
| |
| const DEFAULT_NETWORK = ` |
| with base as ( |
| select |
| ts, |
| substr(s.name, 6) as conn |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'battery_stats.conn' |
| ), |
| diff as ( |
| select |
| ts, |
| conn, |
| conn != lag(conn) over (order by ts) as keep |
| from base |
| ) |
| select |
| ts, |
| ifnull(lead(ts) over (order by ts), (select end_ts from trace_bounds)) - ts as dur, |
| case |
| when conn like '-1:%' then 'Disconnected' |
| when conn like '0:%' then 'Modem' |
| when conn like '1:%' then 'WiFi' |
| when conn like '4:%' then 'VPN' |
| else conn |
| end as name |
| from diff where keep is null or keep`; |
| |
| const RADIO_TRANSPORT_TYPE = ` |
| create or replace perfetto view radio_transport_data_conn as |
| select ts, safe_dur AS dur, value_name as data_conn, value AS data_conn_val |
| from android_battery_stats_state |
| where track_name = "battery_stats.data_conn"; |
| |
| create or replace perfetto view radio_transport_nr_state as |
| select ts, safe_dur AS dur, value AS nr_state_val |
| from android_battery_stats_state |
| where track_name = "battery_stats.nr_state"; |
| |
| drop table if exists radio_transport_join; |
| create virtual table radio_transport_join |
| using span_left_join(radio_transport_data_conn, radio_transport_nr_state); |
| |
| create or replace perfetto view radio_transport as |
| select |
| ts, dur, |
| case data_conn_val |
| -- On LTE with NR connected is 5G NSA. |
| when 13 then iif(nr_state_val = 3, '5G (NSA)', data_conn) |
| -- On NR with NR state present, is 5G SA. |
| when 20 then iif(nr_state_val is null, '5G (SA or NSA)', '5G (SA)') |
| else data_conn |
| end as name |
| from radio_transport_join;`; |
| |
| const TETHERING = ` |
| with base as ( |
| select |
| ts as ts_end, |
| EXTRACT_ARG(arg_set_id, 'network_tethering_reported.duration_millis') * 1000000 as dur |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'network_tethering_reported' |
| ) |
| select ts_end - dur as ts, dur, 'Tethering' as name from base`; |
| |
| const NETWORK_SUMMARY = ` |
| create or replace perfetto table network_summary as |
| with base as ( |
| select |
| cast(ts / 5000000000 as int64) * 5000000000 AS ts, |
| case |
| when track_name glob '*wlan*' then 'wifi' |
| when track_name glob '*rmnet*' then 'modem' |
| else 'unknown' |
| end as dev_type, |
| package_name as pkg, |
| sum(packet_length) AS value |
| from android_network_packets |
| where (track_name glob '*wlan*' or track_name glob '*rmnet*') |
| group by 1,2,3 |
| ), |
| zeroes as ( |
| select |
| ts, |
| dev_type, |
| pkg, |
| value |
| from base |
| union all |
| select |
| ts + 5000000000 as ts, |
| dev_type, |
| pkg, |
| 0 as value |
| from base |
| ), |
| final as ( |
| select |
| ts, |
| dev_type, |
| pkg, |
| sum(value) as value |
| from zeroes |
| group by 1, 2, 3 |
| ) |
| select * from final where ts is not null`; |
| |
| const MODEM_RIL_STRENGTH = ` |
| DROP VIEW IF EXISTS ScreenOn; |
| CREATE VIEW ScreenOn AS |
| SELECT ts, dur FROM ( |
| SELECT |
| ts, value, |
| LEAD(ts, 1, TRACE_END()) OVER (ORDER BY ts)-ts AS dur |
| FROM counter, track ON (counter.track_id = track.id) |
| WHERE track.name = 'ScreenState' |
| ) WHERE value = 2; |
| |
| DROP VIEW IF EXISTS RilSignalStrength; |
| CREATE VIEW RilSignalStrength AS |
| With RilMessages AS ( |
| SELECT |
| ts, slice.name, |
| LEAD(ts, 1, TRACE_END()) OVER (ORDER BY ts)-ts AS dur |
| FROM slice, track |
| ON (slice.track_id = track.id) |
| WHERE track.name = 'RIL' |
| AND slice.name GLOB 'UNSOL_SIGNAL_STRENGTH*' |
| ), |
| BandTypes(band_ril, band_name) AS ( |
| VALUES ("CellSignalStrengthLte:", "LTE"), |
| ("CellSignalStrengthNr:", "NR") |
| ), |
| ValueTypes(value_ril, value_name) AS ( |
| VALUES ("rsrp=", "rsrp"), |
| ("rssi=", "rssi") |
| ), |
| Extracted AS ( |
| SELECT ts, dur, band_name, value_name, ( |
| SELECT CAST(SUBSTR(key_str, start_idx+1, end_idx-start_idx-1) AS INT64) AS value |
| FROM ( |
| SELECT key_str, INSTR(key_str, "=") AS start_idx, INSTR(key_str, " ") AS end_idx |
| FROM ( |
| SELECT SUBSTR(band_str, INSTR(band_str, value_ril)) AS key_str |
| FROM (SELECT SUBSTR(name, INSTR(name, band_ril)) AS band_str) |
| ) |
| ) |
| ) AS value |
| FROM RilMessages |
| JOIN BandTypes |
| JOIN ValueTypes |
| ) |
| SELECT |
| ts, dur, band_name, value_name, value, |
| value_name || "=" || IIF(value = 2147483647, "unknown", ""||value) AS name, |
| ROW_NUMBER() OVER (ORDER BY ts) as id, |
| DENSE_RANK() OVER (ORDER BY band_name, value_name) AS track_id |
| FROM Extracted; |
| |
| DROP TABLE IF EXISTS RilScreenOn; |
| CREATE VIRTUAL TABLE RilScreenOn |
| USING SPAN_JOIN(RilSignalStrength PARTITIONED track_id, ScreenOn)`; |
| |
| const MODEM_RIL_CHANNELS_PREAMBLE = ` |
| CREATE OR REPLACE PERFETTO FUNCTION EXTRACT_KEY_VALUE(source STRING, key_name STRING) RETURNS STRING AS |
| SELECT SUBSTR(trimmed, INSTR(trimmed, "=")+1, INSTR(trimmed, ",") - INSTR(trimmed, "=") - 1) |
| FROM (SELECT SUBSTR($source, INSTR($source, $key_name)) AS trimmed);`; |
| |
| const MODEM_RIL_CHANNELS = ` |
| With RawChannelConfig AS ( |
| SELECT ts, slice.name AS raw_config |
| FROM slice, track |
| ON (slice.track_id = track.id) |
| WHERE track.name = 'RIL' |
| AND slice.name LIKE 'UNSOL_PHYSICAL_CHANNEL_CONFIG%' |
| ), |
| Attributes(attribute, attrib_name) AS ( |
| VALUES ("mCellBandwidthDownlinkKhz", "downlink"), |
| ("mCellBandwidthUplinkKhz", "uplink"), |
| ("mNetworkType", "network"), |
| ("mBand", "band") |
| ), |
| Slots(idx, slot_name) AS ( |
| VALUES (0, "primary"), |
| (1, "secondary 1"), |
| (2, "secondary 2") |
| ), |
| Stage1 AS ( |
| SELECT *, IFNULL(EXTRACT_KEY_VALUE(STR_SPLIT(raw_config, "}, {", idx), attribute), "") AS name |
| FROM RawChannelConfig |
| JOIN Attributes |
| JOIN Slots |
| ), |
| Stage2 AS ( |
| SELECT *, LAG(name) OVER (PARTITION BY idx, attribute ORDER BY ts) AS last_name |
| FROM Stage1 |
| ), |
| Stage3 AS ( |
| SELECT *, LEAD(ts, 1, TRACE_END()) OVER (PARTITION BY idx, attribute ORDER BY ts) - ts AS dur |
| FROM Stage2 WHERE name != last_name |
| ) |
| SELECT ts, dur, slot_name || "-" || attrib_name || "=" || name AS name |
| FROM Stage3`; |
| |
| const MODEM_CELL_RESELECTION = ` |
| with base as ( |
| select |
| ts, |
| s.name as raw_ril, |
| ifnull(str_split(str_split(s.name, 'CellIdentityLte{', 1), ', operatorNames', 0), |
| str_split(str_split(s.name, 'CellIdentityNr{', 1), ', operatorNames', 0)) as cell_id |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'RIL' and s.name like '%DATA_REGISTRATION_STATE%' |
| ), |
| base2 as ( |
| select |
| ts, |
| raw_ril, |
| case |
| when cell_id like '%earfcn%' then 'LTE ' || cell_id |
| when cell_id like '%nrarfcn%' then 'NR ' || cell_id |
| when cell_id is null then 'Unknown' |
| else cell_id |
| end as cell_id |
| from base |
| ), |
| base3 as ( |
| select ts, cell_id , lag(cell_id) over (order by ts) as lag_cell_id, raw_ril |
| from base2 |
| ) |
| select ts, 0 as dur, cell_id as name, raw_ril |
| from base3 |
| where cell_id != lag_cell_id |
| order by ts`; |
| |
| const SUSPEND_RESUME = ` |
| SELECT |
| ts, |
| dur, |
| 'Suspended' AS name |
| FROM android_suspend_state |
| WHERE power_state = 'suspended'`; |
| |
| const SCREEN_STATE = ` |
| WITH _counter AS ( |
| SELECT counter.id, ts, 0 AS track_id, value |
| FROM counter |
| JOIN counter_track ON counter_track.id = counter.track_id |
| WHERE name = 'ScreenState' |
| ) |
| SELECT |
| ts, |
| dur, |
| CASE value |
| WHEN 1 THEN 'Screen off' |
| WHEN 2 THEN 'Screen on' |
| WHEN 3 THEN 'Always-on display (doze)' |
| ELSE 'unknown' |
| END AS name |
| FROM counter_leading_intervals!(_counter)`; |
| |
| // See DeviceIdleController.java for where these states come from and how |
| // they transition. |
| const DOZE_LIGHT = ` |
| WITH _counter AS ( |
| SELECT counter.id, ts, 0 AS track_id, value |
| FROM counter |
| JOIN counter_track ON counter_track.id = counter.track_id |
| WHERE name = 'DozeLightState' |
| ) |
| SELECT |
| ts, |
| dur, |
| CASE value |
| WHEN 0 THEN 'active' |
| WHEN 1 THEN 'inactive' |
| WHEN 4 THEN 'idle' |
| WHEN 5 THEN 'waiting_for_network' |
| WHEN 6 THEN 'idle_maintenance' |
| WHEN 7 THEN 'override' |
| ELSE 'unknown' |
| END AS name |
| FROM counter_leading_intervals!(_counter)`; |
| |
| const DOZE_DEEP = ` |
| WITH _counter AS ( |
| SELECT counter.id, ts, 0 AS track_id, value |
| FROM counter |
| JOIN counter_track ON counter_track.id = counter.track_id |
| WHERE name = 'DozeDeepState' |
| ) |
| SELECT |
| ts, |
| dur, |
| CASE value |
| WHEN 0 THEN 'active' |
| WHEN 1 THEN 'inactive' |
| WHEN 2 THEN 'idle_pending' |
| WHEN 3 THEN 'sensing' |
| WHEN 4 THEN 'locating' |
| WHEN 5 THEN 'idle' |
| WHEN 6 THEN 'idle_maintenance' |
| WHEN 7 THEN 'quick_doze_delay' |
| ELSE 'unknown' |
| END AS name |
| FROM counter_leading_intervals!(_counter)`; |
| |
| const CHARGING = ` |
| WITH _counter AS ( |
| SELECT counter.id, ts, 0 AS track_id, value |
| FROM counter |
| JOIN counter_track ON counter_track.id = counter.track_id |
| WHERE name = 'BatteryStatus' |
| ) |
| SELECT |
| ts, |
| dur, |
| CASE value |
| -- 0 and 1 are both unknown |
| WHEN 2 THEN 'Charging' |
| WHEN 3 THEN 'Discharging' |
| -- special case when charger is present but battery isn't charging |
| WHEN 4 THEN 'Not charging' |
| WHEN 5 THEN 'Full' |
| ELSE 'unknown' |
| END AS name |
| FROM counter_leading_intervals!(_counter)`; |
| |
| const THERMAL_THROTTLING = ` |
| with step1 as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'thermal_throttling_severity_state_changed.sensor_type') as sensor_type, |
| EXTRACT_ARG(arg_set_id, 'thermal_throttling_severity_state_changed.sensor_name') as sensor_name, |
| EXTRACT_ARG(arg_set_id, 'thermal_throttling_severity_state_changed.temperature_deci_celsius') / 10.0 as temperature_celcius, |
| EXTRACT_ARG(arg_set_id, 'thermal_throttling_severity_state_changed.severity') as severity |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'thermal_throttling_severity_state_changed' |
| ), |
| step2 as ( |
| select |
| ts, |
| lead(ts) over (partition by sensor_type, sensor_name order by ts) - ts as dur, |
| sensor_type, |
| sensor_name, |
| temperature_celcius, |
| severity |
| from step1 |
| where sensor_type not like 'TEMPERATURE_TYPE_BCL_%' |
| ) |
| select |
| ts, |
| dur, |
| case sensor_name |
| when 'VIRTUAL-SKIN' then '' |
| else sensor_name || ' is ' |
| end || severity || ' (' || temperature_celcius || 'C)' as name |
| from step2 |
| where severity != 'NONE'`; |
| |
| const KERNEL_WAKELOCKS = ` |
| create or replace perfetto table kernel_wakelocks as |
| with kernel_wakelock_args as ( |
| select |
| arg_set_id, |
| min(iif(key = 'kernel_wakelock.name', string_value, null)) as wakelock_name, |
| min(iif(key = 'kernel_wakelock.count', int_value, null)) as count, |
| min(iif(key = 'kernel_wakelock.time_micros', int_value, null)) as time_micros |
| from args |
| where key in ( |
| 'kernel_wakelock.name', |
| 'kernel_wakelock.count', |
| 'kernel_wakelock.time_micros' |
| ) |
| group by 1 |
| ), |
| interesting as ( |
| select wakelock_name |
| from ( |
| select wakelock_name, max(time_micros)-min(time_micros) as delta_us |
| from kernel_wakelock_args |
| group by 1 |
| ) |
| -- Only consider wakelocks with over 1 second of time during the whole trace |
| where delta_us > 1e6 |
| ), |
| step1 as ( |
| select ts, wakelock_name, count, time_micros |
| from kernel_wakelock_args |
| join interesting using (wakelock_name) |
| join slice using (arg_set_id) |
| ), |
| step2 as ( |
| select |
| ts, |
| wakelock_name, |
| lead(ts) over (partition by wakelock_name order by ts) as ts_end, |
| lead(count) over (partition by wakelock_name order by ts) - count as count, |
| (lead(time_micros) over (partition by wakelock_name order by ts) - time_micros) * 1000 as wakelock_dur |
| from step1 |
| ), |
| step3 as ( |
| select |
| ts, |
| ts_end, |
| ifnull((select sum(dur) from android_suspend_state s |
| where power_state = 'suspended' |
| and s.ts > step2.ts |
| and s.ts < step2.ts_end), 0) as suspended_dur, |
| wakelock_name, |
| count, |
| wakelock_dur |
| from step2 |
| where wakelock_dur is not null |
| and wakelock_dur >= 0 |
| ) |
| select |
| ts, |
| ts_end - ts as dur, |
| wakelock_name, |
| min(100.0 * wakelock_dur / (ts_end - ts - suspended_dur), 100) as value |
| from step3`; |
| |
| const KERNEL_WAKELOCKS_SUMMARY = ` |
| select wakelock_name, max(value) as max_value |
| from kernel_wakelocks |
| where wakelock_name not in ('PowerManager.SuspendLockout', 'PowerManagerService.Display') |
| group by 1 |
| having max_value > 1 |
| order by 1;`; |
| |
| const HIGH_CPU = ` |
| create or replace perfetto table high_cpu as |
| with cpu_cycles_args AS ( |
| select |
| arg_set_id, |
| min(iif(key = 'cpu_cycles_per_uid_cluster.uid', int_value, null)) as uid, |
| min(iif(key = 'cpu_cycles_per_uid_cluster.cluster', int_value, null)) as cluster, |
| min(iif(key = 'cpu_cycles_per_uid_cluster.time_millis', int_value, null)) as time_millis |
| from args |
| where key in ( |
| 'cpu_cycles_per_uid_cluster.uid', |
| 'cpu_cycles_per_uid_cluster.cluster', |
| 'cpu_cycles_per_uid_cluster.time_millis' |
| ) |
| group by 1 |
| ), |
| interesting AS ( |
| select uid, cluster |
| from ( |
| select uid, cluster, max(time_millis)-min(time_millis) as delta_ms |
| from cpu_cycles_args |
| group by 1, 2 |
| ) |
| -- Only consider tracks with over 1 second of cpu during the whole trace |
| where delta_ms > 1e3 |
| ), |
| base as ( |
| select ts, uid, cluster, sum(time_millis) as time_millis |
| from cpu_cycles_args |
| join interesting using (uid, cluster) |
| join slice using (arg_set_id) |
| group by 1, 2, 3 |
| ), |
| with_windows as ( |
| select |
| ts, |
| uid, |
| cluster, |
| lead(ts) over (partition by uid, cluster order by ts) - ts as dur, |
| (lead(time_millis) over (partition by uid, cluster order by ts) - time_millis) * 1000000.0 as cpu_dur |
| from base |
| ), |
| with_ratio as ( |
| select |
| ts, |
| iif(dur is null, 0, max(0, 100.0 * cpu_dur / dur)) as value, |
| case cluster when 0 then 'little' when 1 then 'mid' when 2 then 'big' else 'cl-' || cluster end as cluster, |
| package_name as pkg |
| from add_package_name!(with_windows) |
| ) |
| select ts, sum(value) as value, cluster, pkg |
| from with_ratio |
| group by 1, 3, 4`; |
| |
| const WAKEUPS = ` |
| drop table if exists wakeups; |
| create table wakeups as |
| with wakeup_reason as ( |
| select |
| ts, |
| substr(i.name, 0, instr(i.name, ' ')) as id_timestamp, |
| substr(i.name, instr(i.name, ' ') + 1) as raw_wakeup |
| from track t join instant i on t.id = i.track_id |
| where t.name = 'wakeup_reason' |
| ), |
| wakeup_attribution as ( |
| select |
| substr(i.name, 0, instr(i.name, ' ')) as id_timestamp, |
| substr(i.name, instr(i.name, ' ') + 1) as attribution |
| from track t join instant i on t.id = i.track_id |
| where t.name = 'wakeup_attribution' |
| ), |
| step1 as( |
| select |
| ts, |
| raw_wakeup, |
| attribution, |
| null as raw_backoff |
| from wakeup_reason r |
| left outer join wakeup_attribution using(id_timestamp) |
| union all |
| select |
| ts, |
| null as raw_wakeup, |
| null as attribution, |
| i.name as raw_backoff |
| from track t join instant i on t.id = i.track_id |
| where t.name = 'suspend_backoff' |
| ), |
| step2 as ( |
| select |
| ts, |
| raw_wakeup, |
| attribution, |
| lag(raw_backoff) over (order by ts) as raw_backoff |
| from step1 |
| ), |
| step3 as ( |
| select |
| ts, |
| raw_wakeup, |
| attribution, |
| str_split(raw_backoff, ' ', 0) as suspend_quality, |
| str_split(raw_backoff, ' ', 1) as backoff_state, |
| str_split(raw_backoff, ' ', 2) as backoff_reason, |
| cast(str_split(raw_backoff, ' ', 3) as int) as backoff_count, |
| cast(str_split(raw_backoff, ' ', 4) as int) as backoff_millis, |
| false as suspend_end |
| from step2 |
| where raw_wakeup is not null |
| union all |
| select |
| ts, |
| null as raw_wakeup, |
| null as attribution, |
| null as suspend_quality, |
| null as backoff_state, |
| null as backoff_reason, |
| null as backoff_count, |
| null as backoff_millis, |
| true as suspend_end |
| from android_suspend_state |
| where power_state = 'suspended' |
| ), |
| step4 as ( |
| select |
| ts, |
| case suspend_quality |
| when 'good' then |
| min( |
| lead(ts, 1, ts + 5e9) over (order by ts) - ts, |
| 5e9 |
| ) |
| when 'bad' then backoff_millis * 1000000 |
| else 0 |
| end as dur, |
| raw_wakeup, |
| attribution, |
| suspend_quality, |
| backoff_state, |
| backoff_reason, |
| backoff_count, |
| backoff_millis, |
| suspend_end |
| from step3 |
| ), |
| step5 as ( |
| select |
| ts, |
| dur, |
| raw_wakeup, |
| attribution, |
| suspend_quality, |
| backoff_state, |
| backoff_reason, |
| backoff_count, |
| backoff_millis |
| from step4 |
| where not suspend_end |
| ), |
| step6 as ( |
| select |
| ts, |
| dur, |
| raw_wakeup, |
| attribution, |
| suspend_quality, |
| backoff_state, |
| backoff_reason, |
| backoff_count, |
| backoff_millis, |
| case |
| when raw_wakeup like 'Abort: Pending Wakeup Sources: %' then 'abort_pending' |
| when raw_wakeup like 'Abort: Last active Wakeup Source: %' then 'abort_last_active' |
| when raw_wakeup like 'Abort: %' then 'abort_other' |
| else 'normal' |
| end as type, |
| case |
| when raw_wakeup like 'Abort: Pending Wakeup Sources: %' then substr(raw_wakeup, 32) |
| when raw_wakeup like 'Abort: Last active Wakeup Source: %' then substr(raw_wakeup, 35) |
| when raw_wakeup like 'Abort: %' then substr(raw_wakeup, 8) |
| else raw_wakeup |
| end as main, |
| case |
| when raw_wakeup like 'Abort: Pending Wakeup Sources: %' then ' ' |
| when raw_wakeup like 'Abort: %' then 'no delimiter needed' |
| else ':' |
| end as delimiter |
| from step5 |
| ), |
| step7 as ( |
| select |
| ts, |
| dur, |
| raw_wakeup, |
| attribution, |
| suspend_quality, |
| backoff_state, |
| backoff_reason, |
| backoff_count, |
| backoff_millis, |
| type, |
| str_split(main, delimiter, 0) as item_0, |
| str_split(main, delimiter, 1) as item_1, |
| str_split(main, delimiter, 2) as item_2, |
| str_split(main, delimiter, 3) as item_3 |
| from step6 |
| ), |
| step8 as ( |
| select ts, dur, raw_wakeup, attribution, suspend_quality, backoff_state, backoff_reason, backoff_count, backoff_millis, type, item_0 as item from step7 |
| union all |
| select ts, dur, raw_wakeup, attribution, suspend_quality, backoff_state, backoff_reason, backoff_count, backoff_millis, type, item_1 as item from step7 where item_1 is not null |
| union all |
| select ts, dur, raw_wakeup, attribution, suspend_quality, backoff_state, backoff_reason, backoff_count, backoff_millis, type, item_2 as item from step7 where item_2 is not null |
| union all |
| select ts, dur, raw_wakeup, attribution, suspend_quality, backoff_state, backoff_reason, backoff_count, backoff_millis, type, item_3 as item from step7 where item_3 is not null |
| ) |
| select |
| ts, |
| dur, |
| ts + dur as ts_end, |
| raw_wakeup, |
| attribution, |
| suspend_quality, |
| backoff_state, |
| ifnull(backoff_reason, 'none') as backoff_reason, |
| backoff_count, |
| backoff_millis, |
| type, |
| case when type = 'normal' then ifnull(str_split(item, ' ', 1), item) else item end as item |
| from step8`; |
| |
| const WAKEUPS_COLUMNS = [ |
| 'item', |
| 'type', |
| 'raw_wakeup', |
| 'attribution', |
| 'suspend_quality', |
| 'backoff_state', |
| 'backoff_reason', |
| 'backoff_count', |
| 'backoff_millis', |
| ]; |
| |
| function bleScanQuery(condition: string) { |
| return ` |
| with step1 as ( |
| select |
| ts, |
| extract_arg(arg_set_id, 'ble_scan_state_changed.attribution_node[0].tag') as name, |
| extract_arg(arg_set_id, 'ble_scan_state_changed.is_opportunistic') as opportunistic, |
| extract_arg(arg_set_id, 'ble_scan_state_changed.is_filtered') as filtered, |
| extract_arg(arg_set_id, 'ble_scan_state_changed.state') as state |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'ble_scan_state_changed' |
| ), |
| step2 as ( |
| select |
| ts, |
| name, |
| state, |
| opportunistic, |
| filtered, |
| lead(ts) over (partition by name order by ts) - ts as dur |
| from step1 |
| ) |
| select ts, dur, name from step2 where state = 'ON' and ${condition} and dur is not null`; |
| } |
| |
| const BLE_RESULTS = ` |
| with step1 as ( |
| select |
| ts, |
| extract_arg(arg_set_id, 'ble_scan_result_received.attribution_node[0].tag') as name, |
| extract_arg(arg_set_id, 'ble_scan_result_received.num_results') as num_results |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'ble_scan_result_received' |
| ) |
| select |
| ts, |
| 0 as dur, |
| name || ' (' || num_results || ' results)' as name |
| from step1`; |
| |
| const BT_A2DP_AUDIO = ` |
| with step1 as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_a2dp_playback_state_changed.playback_state') as playback_state, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_a2dp_playback_state_changed.audio_coding_mode') as audio_coding_mode, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_a2dp_playback_state_changed.metric_id') as metric_id |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_a2dp_playback_state_changed' |
| ), |
| step2 as ( |
| select |
| ts, |
| lead(ts) over (partition by metric_id order by ts) - ts as dur, |
| playback_state, |
| audio_coding_mode, |
| metric_id |
| from step1 |
| ) |
| select |
| ts, |
| dur, |
| audio_coding_mode as name |
| from step2 |
| where playback_state = 'PLAYBACK_STATE_PLAYING'`; |
| |
| const BT_CONNS_ACL = ` |
| with acl1 as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_acl_connection_state_changed.state') as state, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_acl_connection_state_changed.transport') as transport, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_acl_connection_state_changed.metric_id') as metric_id |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_acl_connection_state_changed' |
| ), |
| acl2 as ( |
| select |
| ts, |
| lead(ts) over (partition by metric_id, transport order by ts) - ts as dur, |
| state, |
| transport, |
| metric_id |
| from acl1 |
| ) |
| select |
| ts, |
| dur, |
| 'Device ' || metric_id || |
| ' (' || case transport when 'TRANSPORT_TYPE_BREDR' then 'Classic' when 'TRANSPORT_TYPE_LE' then 'BLE' end || ')' as name |
| from acl2 |
| where state != 'CONNECTION_STATE_DISCONNECTED' and dur is not null`; |
| |
| const BT_CONNS_SCO = ` |
| with sco1 as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_sco_connection_state_changed.state') as state, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_sco_connection_state_changed.codec') as codec, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_sco_connection_state_changed.metric_id') as metric_id |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_sco_connection_state_changed' |
| ), |
| sco2 as ( |
| select |
| ts, |
| lead(ts) over (partition by metric_id, codec order by ts) - ts as dur, |
| state, |
| codec, |
| metric_id |
| from sco1 |
| ) |
| select |
| ts, |
| dur, |
| case state when 'CONNECTION_STATE_CONNECTED' then '' when 'CONNECTION_STATE_CONNECTING' then 'Connecting ' when 'CONNECTION_STATE_DISCONNECTING' then 'Disconnecting ' else 'unknown ' end || |
| 'Device ' || metric_id || ' (' || |
| case codec when 'SCO_CODEC_CVSD' then 'CVSD' when 'SCO_CODEC_MSBC' then 'MSBC' end || ')' as name |
| from sco2 |
| where state != 'CONNECTION_STATE_DISCONNECTED' and dur is not null`; |
| |
| const BT_LINK_LEVEL_EVENTS = ` |
| with base as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.direction') as direction, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.type') as type, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.hci_cmd') as hci_cmd, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.hci_event') as hci_event, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.hci_ble_event') as hci_ble_event, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.cmd_status') as cmd_status, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.reason_code') as reason_code, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_link_layer_connection_event.metric_id') as metric_id |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_link_layer_connection_event' |
| ) |
| select |
| *, |
| 0 as dur, |
| 'Device '|| metric_id as name |
| from base`; |
| |
| const BT_LINK_LEVEL_EVENTS_COLUMNS = [ |
| 'direction', |
| 'type', |
| 'hci_cmd', |
| 'hci_event', |
| 'hci_ble_event', |
| 'cmd_status', |
| 'reason_code', |
| 'metric_id', |
| ]; |
| |
| const BT_QUALITY_REPORTS = ` |
| with base as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.quality_report_id') as quality_report_id, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.packet_types') as packet_types, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.connection_handle') as connection_handle, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.connection_role') as connection_role, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.tx_power_level') as tx_power_level, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.rssi') as rssi, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.snr') as snr, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.unused_afh_channel_count') as unused_afh_channel_count, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.afh_select_unideal_channel_count') as afh_select_unideal_channel_count, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.lsto') as lsto, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.connection_piconet_clock') as connection_piconet_clock, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.retransmission_count') as retransmission_count, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.no_rx_count') as no_rx_count, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.nak_count') as nak_count, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.flow_off_count') as flow_off_count, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.buffer_overflow_bytes') as buffer_overflow_bytes, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_quality_report_reported.buffer_underflow_bytes') as buffer_underflow_bytes |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_quality_report_reported' |
| ) |
| select |
| *, |
| 0 as dur, |
| 'Connection '|| connection_handle as name |
| from base`; |
| |
| const BT_QUALITY_REPORTS_COLUMNS = [ |
| 'quality_report_id', |
| 'packet_types', |
| 'connection_handle', |
| 'connection_role', |
| 'tx_power_level', |
| 'rssi', |
| 'snr', |
| 'unused_afh_channel_count', |
| 'afh_select_unideal_channel_count', |
| 'lsto', |
| 'connection_piconet_clock', |
| 'retransmission_count', |
| 'no_rx_count', |
| 'nak_count', |
| 'flow_off_count', |
| 'buffer_overflow_bytes', |
| 'buffer_underflow_bytes', |
| ]; |
| |
| const BT_RSSI_REPORTS = ` |
| with base as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_device_rssi_reported.connection_handle') as connection_handle, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_device_rssi_reported.hci_status') as hci_status, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_device_rssi_reported.rssi') as rssi, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_device_rssi_reported.metric_id') as metric_id |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_device_rssi_reported' |
| ) |
| select |
| *, |
| 0 as dur, |
| 'Connection '|| connection_handle as name |
| from base`; |
| |
| const BT_RSSI_REPORTS_COLUMNS = [ |
| 'connection_handle', |
| 'hci_status', |
| 'rssi', |
| 'metric_id', |
| ]; |
| |
| const BT_CODE_PATH_COUNTER = ` |
| with base as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_code_path_counter.key') as key, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_code_path_counter.number') as number |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_code_path_counter' |
| ) |
| select |
| *, |
| 0 as dur, |
| key as name |
| from base`; |
| |
| const BT_CODE_PATH_COUNTER_COLUMNS = ['key', 'number']; |
| |
| const BT_HAL_CRASHES = ` |
| with base as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_hal_crash_reason_reported.metric_id') as metric_id, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_hal_crash_reason_reported.error_code') as error_code, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_hal_crash_reason_reported.vendor_error_code') as vendor_error_code |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_hal_crash_reason_reported' |
| ) |
| select |
| *, |
| 0 as dur, |
| 'Device ' || metric_id as name |
| from base`; |
| |
| const BT_HAL_CRASHES_COLUMNS = ['metric_id', 'error_code', 'vendor_error_code']; |
| |
| const BT_BYTES = ` |
| with step1 as ( |
| select |
| ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_bytes_transfer.uid') as uid, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_bytes_transfer.tx_bytes') as tx_bytes, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_bytes_transfer.rx_bytes') as rx_bytes |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_bytes_transfer' |
| ), |
| step2 as ( |
| select |
| ts, |
| lead(ts) over (partition by uid order by ts) - ts as dur, |
| uid, |
| lead(tx_bytes) over (partition by uid order by ts) - tx_bytes as tx_bytes, |
| lead(rx_bytes) over (partition by uid order by ts) - rx_bytes as rx_bytes |
| from step1 |
| ), |
| step3 as ( |
| select |
| ts, |
| dur, |
| uid % 100000 as uid, |
| sum(tx_bytes) as tx_bytes, |
| sum(rx_bytes) as rx_bytes |
| from step2 |
| where tx_bytes >=0 and rx_bytes >=0 |
| group by 1,2,3 |
| having tx_bytes > 0 or rx_bytes > 0 |
| ) |
| select |
| ts, |
| dur, |
| format("%s: TX %d bytes / RX %d bytes", package_name, tx_bytes, rx_bytes) as name |
| from add_package_name!(step3) |
| `; |
| |
| // See go/bt_system_context_report for reference on the bit-twiddling. |
| const BT_ACTIVITY = ` |
| create perfetto table bt_activity as |
| with step1 as ( |
| select |
| EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.timestamp_millis') * 1000000 as ts, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.bluetooth_stack_state') as bluetooth_stack_state, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.controller_idle_time_millis') * 1000000 as controller_idle_dur, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.controller_tx_time_millis') * 1000000 as controller_tx_dur, |
| EXTRACT_ARG(arg_set_id, 'bluetooth_activity_info.controller_rx_time_millis') * 1000000 as controller_rx_dur |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms' |
| and s.name = 'bluetooth_activity_info' |
| ), |
| step2 as ( |
| select |
| ts, |
| lead(ts) over (order by ts) - ts as dur, |
| bluetooth_stack_state, |
| lead(controller_idle_dur) over (order by ts) - controller_idle_dur as controller_idle_dur, |
| lead(controller_tx_dur) over (order by ts) - controller_tx_dur as controller_tx_dur, |
| lead(controller_rx_dur) over (order by ts) - controller_rx_dur as controller_rx_dur |
| from step1 |
| ) |
| select |
| ts, |
| dur, |
| bluetooth_stack_state & 0x0000000F as acl_active_count, |
| bluetooth_stack_state & 0x000000F0 >> 4 as acl_sniff_count, |
| bluetooth_stack_state & 0x00000F00 >> 8 as acl_ble_count, |
| bluetooth_stack_state & 0x0000F000 >> 12 as advertising_count, |
| case bluetooth_stack_state & 0x000F0000 >> 16 |
| when 0 then 0 |
| when 1 then 5 |
| when 2 then 10 |
| when 3 then 25 |
| when 4 then 100 |
| else -1 |
| end as le_scan_duty_cycle, |
| bluetooth_stack_state & 0x00100000 >> 20 as inquiry_active, |
| bluetooth_stack_state & 0x00200000 >> 21 as sco_active, |
| bluetooth_stack_state & 0x00400000 >> 22 as a2dp_active, |
| bluetooth_stack_state & 0x00800000 >> 23 as le_audio_active, |
| max(0, 100.0 * controller_idle_dur / dur) as controller_idle_pct, |
| max(0, 100.0 * controller_tx_dur / dur) as controller_tx_pct, |
| max(0, 100.0 * controller_rx_dur / dur) as controller_rx_pct |
| from step2 |
| `; |
| |
| export default class implements PerfettoPlugin { |
| static readonly id = 'dev.perfetto.AndroidLongBatteryTracing'; |
| private readonly groups = new Map<string, TrackNode>(); |
| |
| private addTrack(ctx: Trace, track: TrackNode, groupName?: string): void { |
| if (groupName) { |
| const existingGroup = this.groups.get(groupName); |
| if (existingGroup) { |
| existingGroup.addChildInOrder(track); |
| } else { |
| const group = new TrackNode({title: groupName, isSummary: true}); |
| group.addChildInOrder(track); |
| this.groups.set(groupName, group); |
| ctx.workspace.addChildInOrder(group); |
| } |
| } else { |
| ctx.workspace.addChildInOrder(track); |
| } |
| } |
| |
| addSliceTrack( |
| ctx: Trace, |
| name: string, |
| query: string, |
| groupName?: string, |
| columns: string[] = [], |
| ): void { |
| const config: SimpleSliceTrackConfig = { |
| data: { |
| sqlSource: query, |
| columns: ['ts', 'dur', 'name', ...columns], |
| }, |
| columns: {ts: 'ts', dur: 'dur', name: 'name'}, |
| argColumns: columns, |
| }; |
| |
| const uri = `/long_battery_tracing_${name}`; |
| const track = new SimpleSliceTrack(ctx, {trackUri: uri}, config); |
| ctx.tracks.registerTrack({ |
| uri, |
| title: name, |
| track, |
| }); |
| const trackNode = new TrackNode({uri, title: name}); |
| this.addTrack(ctx, trackNode, groupName); |
| } |
| |
| addCounterTrack( |
| ctx: Trace, |
| name: string, |
| query: string, |
| groupName: string, |
| options?: Partial<CounterOptions>, |
| ): void { |
| const config: SimpleCounterTrackConfig = { |
| data: { |
| sqlSource: query, |
| columns: ['ts', 'value'], |
| }, |
| columns: {ts: 'ts', value: 'value'}, |
| options, |
| }; |
| |
| const uri = `/long_battery_tracing_${name}`; |
| ctx.tracks.registerTrack({ |
| uri, |
| title: name, |
| track: new SimpleCounterTrack(ctx, {trackUri: uri}, config), |
| }); |
| const track = new TrackNode({uri, title: name}); |
| this.addTrack(ctx, track, groupName); |
| } |
| |
| addBatteryStatsState( |
| ctx: Trace, |
| name: string, |
| track: string, |
| groupName: string, |
| features: Set<string>, |
| ): void { |
| if (!features.has(`track.${track}`)) { |
| return; |
| } |
| this.addSliceTrack( |
| ctx, |
| name, |
| `SELECT ts, safe_dur AS dur, value_name AS name |
| FROM android_battery_stats_state |
| WHERE track_name = "${track}"`, |
| groupName, |
| ); |
| } |
| |
| addBatteryStatsEvent( |
| ctx: Trace, |
| name: string, |
| track: string, |
| groupName: string | undefined, |
| features: Set<string>, |
| ): void { |
| if (!features.has(`track.${track}`)) { |
| return; |
| } |
| |
| this.addSliceTrack( |
| ctx, |
| name, |
| `SELECT ts, safe_dur AS dur, str_value AS name |
| FROM android_battery_stats_event_slices |
| WHERE track_name = "${track}"`, |
| groupName, |
| ); |
| } |
| |
| async addDeviceState(ctx: Trace, features: Set<string>): Promise<void> { |
| if (!features.has('track.battery_stats.*')) { |
| return; |
| } |
| |
| const query = (name: string, track: string) => |
| this.addBatteryStatsEvent(ctx, name, track, undefined, features); |
| |
| const e = ctx.engine; |
| await e.query(`INCLUDE PERFETTO MODULE android.battery_stats;`); |
| await e.query(`INCLUDE PERFETTO MODULE android.suspend;`); |
| await e.query(`INCLUDE PERFETTO MODULE counters.intervals;`); |
| |
| this.addSliceTrack(ctx, 'Device State: Screen state', SCREEN_STATE); |
| this.addSliceTrack(ctx, 'Device State: Charging', CHARGING); |
| this.addSliceTrack(ctx, 'Device State: Suspend / resume', SUSPEND_RESUME); |
| this.addSliceTrack(ctx, 'Device State: Doze light state', DOZE_LIGHT); |
| this.addSliceTrack(ctx, 'Device State: Doze deep state', DOZE_DEEP); |
| |
| query('Device State: Top app', 'battery_stats.top'); |
| |
| this.addSliceTrack( |
| ctx, |
| 'Device State: Long wakelocks', |
| `SELECT |
| ts - 60000000000 as ts, |
| safe_dur + 60000000000 as dur, |
| str_value AS name, |
| package_name as package |
| FROM add_package_name!(( |
| select *, int_value as uid |
| from android_battery_stats_event_slices |
| WHERE track_name = "battery_stats.longwake" |
| ))`, |
| undefined, |
| ['package'], |
| ); |
| |
| query('Device State: Foreground apps', 'battery_stats.fg'); |
| query('Device State: Jobs', 'battery_stats.job'); |
| |
| if (features.has('atom.thermal_throttling_severity_state_changed')) { |
| this.addSliceTrack( |
| ctx, |
| 'Device State: Thermal throttling', |
| THERMAL_THROTTLING, |
| ); |
| } |
| } |
| |
| async addAtomCounters(ctx: Trace): Promise<void> { |
| const e = ctx.engine; |
| |
| try { |
| await e.query( |
| `INCLUDE PERFETTO MODULE |
| google3.wireless.android.telemetry.trace_extractor.modules.atom_counters_slices`, |
| ); |
| } catch (e) { |
| return; |
| } |
| |
| const counters = await e.query( |
| `select distinct ui_group, ui_name, ui_unit, counter_name |
| from atom_counters |
| where ui_name is not null`, |
| ); |
| const countersIt = counters.iter({ |
| ui_group: 'str', |
| ui_name: 'str', |
| ui_unit: 'str', |
| counter_name: 'str', |
| }); |
| for (; countersIt.valid(); countersIt.next()) { |
| const unit = countersIt.ui_unit; |
| const opts = |
| unit === '%' |
| ? {yOverrideMaximum: 100, unit: '%'} |
| : unit !== undefined |
| ? {unit} |
| : undefined; |
| |
| this.addCounterTrack( |
| ctx, |
| countersIt.ui_name, |
| `select ts, ${unit === '%' ? 100.0 : 1.0} * counter_value as value |
| from atom_counters |
| where counter_name = '${countersIt.counter_name}'`, |
| countersIt.ui_group, |
| opts, |
| ); |
| } |
| } |
| |
| async addAtomSlices(ctx: Trace): Promise<void> { |
| const e = ctx.engine; |
| |
| try { |
| await e.query( |
| `INCLUDE PERFETTO MODULE |
| google3.wireless.android.telemetry.trace_extractor.modules.atom_counters_slices`, |
| ); |
| } catch (e) { |
| return; |
| } |
| |
| const sliceTracks = await e.query( |
| `select distinct ui_group, ui_name, atom, field |
| from atom_slices |
| where ui_name is not null |
| order by 1, 2, 3, 4`, |
| ); |
| const slicesIt = sliceTracks.iter({ |
| atom: 'str', |
| ui_group: 'str', |
| ui_name: 'str', |
| field: 'str', |
| }); |
| |
| const tracks = new Map< |
| string, |
| { |
| ui_group: string; |
| ui_name: string; |
| } |
| >(); |
| const fields = new Map<string, string[]>(); |
| for (; slicesIt.valid(); slicesIt.next()) { |
| const atom = slicesIt.atom; |
| let args = fields.get(atom); |
| if (args === undefined) { |
| args = []; |
| fields.set(atom, args); |
| } |
| args.push(slicesIt.field); |
| tracks.set(atom, { |
| ui_group: slicesIt.ui_group, |
| ui_name: slicesIt.ui_name, |
| }); |
| } |
| |
| for (const [atom, args] of fields) { |
| function safeArg(arg: string) { |
| return arg.replaceAll(/[[\]]/g, '').replaceAll(/\./g, '_'); |
| } |
| |
| // We need to make arg names compatible with SQL here because they pass through several |
| // layers of SQL without being quoted in "". |
| function argSql(arg: string) { |
| return `max(case when field = '${arg}' then ifnull(string_value, int_value) end) |
| as ${safeArg(arg)}`; |
| } |
| |
| this.addSliceTrack( |
| ctx, |
| tracks.get(atom)!.ui_name, |
| `select ts, dur, slice_name as name, ${args.map((a) => argSql(a)).join(', ')} |
| from atom_slices |
| where atom = '${atom}' |
| group by ts, dur, name`, |
| tracks.get(atom)!.ui_group, |
| args.map((a) => safeArg(a)), |
| ); |
| } |
| } |
| |
| async addNetworkSummary(ctx: Trace, features: Set<string>): Promise<void> { |
| if (!features.has('net.modem') && !features.has('net.wifi')) { |
| return; |
| } |
| |
| const groupName = 'Network Summary'; |
| |
| const e = ctx.engine; |
| await e.query(`INCLUDE PERFETTO MODULE android.battery_stats;`); |
| await e.query(`INCLUDE PERFETTO MODULE android.network_packets;`); |
| await e.query(NETWORK_SUMMARY); |
| await e.query(RADIO_TRANSPORT_TYPE); |
| |
| this.addSliceTrack(ctx, 'Default network', DEFAULT_NETWORK, groupName); |
| |
| if (features.has('atom.network_tethering_reported')) { |
| this.addSliceTrack(ctx, 'Tethering', TETHERING, groupName); |
| } |
| if (features.has('net.wifi')) { |
| this.addCounterTrack( |
| ctx, |
| 'Wifi total bytes', |
| `select ts, sum(value) as value from network_summary where dev_type = 'wifi' group by 1`, |
| groupName, |
| {yDisplay: 'log', yRangeSharingKey: 'net_bytes', unit: 'byte'}, |
| ); |
| const result = await e.query( |
| `select pkg, sum(value) from network_summary where dev_type='wifi' group by 1 order by 2 desc limit 10`, |
| ); |
| const it = result.iter({pkg: 'str'}); |
| for (; it.valid(); it.next()) { |
| this.addCounterTrack( |
| ctx, |
| `Top wifi: ${it.pkg}`, |
| `select ts, value from network_summary where dev_type = 'wifi' and pkg = '${it.pkg}'`, |
| groupName, |
| {yDisplay: 'log', yRangeSharingKey: 'net_bytes', unit: 'byte'}, |
| ); |
| } |
| } |
| this.addBatteryStatsState( |
| ctx, |
| 'Wifi interface', |
| 'battery_stats.wifi_radio', |
| groupName, |
| features, |
| ); |
| this.addBatteryStatsState( |
| ctx, |
| 'Wifi supplicant state', |
| 'battery_stats.wifi_suppl', |
| groupName, |
| features, |
| ); |
| this.addBatteryStatsState( |
| ctx, |
| 'Wifi strength', |
| 'battery_stats.wifi_signal_strength', |
| groupName, |
| features, |
| ); |
| if (features.has('net.modem')) { |
| this.addCounterTrack( |
| ctx, |
| 'Modem total bytes', |
| `select ts, sum(value) as value from network_summary where dev_type = 'modem' group by 1`, |
| groupName, |
| {yDisplay: 'log', yRangeSharingKey: 'net_bytes', unit: 'byte'}, |
| ); |
| const result = await e.query( |
| `select pkg, sum(value) from network_summary where dev_type='modem' group by 1 order by 2 desc limit 10`, |
| ); |
| const it = result.iter({pkg: 'str'}); |
| for (; it.valid(); it.next()) { |
| this.addCounterTrack( |
| ctx, |
| `Top modem: ${it.pkg}`, |
| `select ts, value from network_summary where dev_type = 'modem' and pkg = '${it.pkg}'`, |
| groupName, |
| {yDisplay: 'log', yRangeSharingKey: 'net_bytes', unit: 'byte'}, |
| ); |
| } |
| } |
| this.addBatteryStatsState( |
| ctx, |
| 'Cellular interface', |
| 'battery_stats.mobile_radio', |
| groupName, |
| features, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'Cellular connection', |
| `select ts, dur, name from radio_transport`, |
| groupName, |
| ); |
| this.addBatteryStatsState( |
| ctx, |
| 'Cellular strength', |
| 'battery_stats.phone_signal_strength', |
| groupName, |
| features, |
| ); |
| } |
| |
| async addModemDetail(ctx: Trace, features: Set<string>): Promise<void> { |
| const groupName = 'Modem Detail'; |
| if (features.has('track.ril')) { |
| await this.addModemRil(ctx, groupName); |
| } |
| await this.addModemTeaData(ctx, groupName); |
| } |
| |
| async addModemRil(ctx: Trace, groupName: string): Promise<void> { |
| const rilStrength = (band: string, value: string): void => |
| this.addSliceTrack( |
| ctx, |
| `Modem signal strength ${band} ${value}`, |
| `SELECT ts, dur, name FROM RilScreenOn WHERE band_name = '${band}' AND value_name = '${value}'`, |
| groupName, |
| ); |
| |
| const e = ctx.engine; |
| |
| await e.query(MODEM_RIL_STRENGTH); |
| await e.query(MODEM_RIL_CHANNELS_PREAMBLE); |
| |
| rilStrength('LTE', 'rsrp'); |
| rilStrength('LTE', 'rssi'); |
| rilStrength('NR', 'rsrp'); |
| rilStrength('NR', 'rssi'); |
| |
| this.addSliceTrack( |
| ctx, |
| 'Modem channel config', |
| MODEM_RIL_CHANNELS, |
| groupName, |
| ); |
| |
| this.addSliceTrack( |
| ctx, |
| 'Modem cell reselection', |
| MODEM_CELL_RESELECTION, |
| groupName, |
| ['raw_ril'], |
| ); |
| } |
| |
| async addModemTeaData(ctx: Trace, groupName: string): Promise<void> { |
| const e = ctx.engine; |
| |
| try { |
| await e.query( |
| `INCLUDE PERFETTO MODULE |
| google3.wireless.android.telemetry.trace_extractor.modules.modem_tea_metrics`, |
| ); |
| } catch { |
| return; |
| } |
| |
| const counters = await e.query( |
| `select distinct name from pixel_modem_counters`, |
| ); |
| const countersIt = counters.iter({name: 'str'}); |
| for (; countersIt.valid(); countersIt.next()) { |
| this.addCounterTrack( |
| ctx, |
| countersIt.name, |
| `select ts, value from pixel_modem_counters where name = '${countersIt.name}'`, |
| groupName, |
| ); |
| } |
| const slices = await e.query( |
| `select distinct track_name from pixel_modem_slices`, |
| ); |
| const slicesIt = slices.iter({track_name: 'str'}); |
| for (; slicesIt.valid(); slicesIt.next()) { |
| this.addSliceTrack( |
| ctx, |
| slicesIt.track_name, |
| `select ts, dur, slice_name as name from pixel_modem_slices |
| where track_name = '${slicesIt.track_name}'`, |
| groupName, |
| ); |
| } |
| } |
| |
| async addKernelWakelocks(ctx: Trace, features: Set<string>): Promise<void> { |
| if (!features.has('atom.kernel_wakelock')) { |
| return; |
| } |
| const groupName = 'Kernel Wakelock Summary'; |
| |
| const e = ctx.engine; |
| await e.query(`INCLUDE PERFETTO MODULE android.suspend;`); |
| await e.query(KERNEL_WAKELOCKS); |
| const result = await e.query(KERNEL_WAKELOCKS_SUMMARY); |
| const it = result.iter({wakelock_name: 'str'}); |
| for (; it.valid(); it.next()) { |
| this.addCounterTrack( |
| ctx, |
| it.wakelock_name, |
| `select ts, dur, value from kernel_wakelocks where wakelock_name = "${it.wakelock_name}"`, |
| groupName, |
| {yRangeSharingKey: 'kernel_wakelock', unit: '%'}, |
| ); |
| } |
| } |
| |
| async addWakeups(ctx: Trace, features: Set<string>): Promise<void> { |
| if (!features.has('track.suspend_backoff')) { |
| return; |
| } |
| |
| const e = ctx.engine; |
| const groupName = 'Wakeups'; |
| await e.query(`INCLUDE PERFETTO MODULE android.suspend;`); |
| await e.query(WAKEUPS); |
| const result = await e.query(`select |
| item, |
| sum(dur) as sum_dur |
| from wakeups |
| group by 1 |
| having sum_dur > 600e9`); |
| const it = result.iter({item: 'str'}); |
| const sqlPrefix = `select |
| ts, |
| dur, |
| item || case backoff_reason |
| when 'short' then ' (Short suspend backoff)' |
| when 'failed' then ' (Failed suspend backoff)' |
| else '' |
| end as name, |
| item, |
| type, |
| raw_wakeup, |
| attribution, |
| suspend_quality, |
| backoff_state, |
| backoff_reason, |
| backoff_count, |
| backoff_millis |
| from wakeups`; |
| const items = []; |
| let labelOther = false; |
| for (; it.valid(); it.next()) { |
| labelOther = true; |
| this.addSliceTrack( |
| ctx, |
| `Wakeup ${it.item}`, |
| `${sqlPrefix} where item="${it.item}"`, |
| groupName, |
| WAKEUPS_COLUMNS, |
| ); |
| items.push(it.item); |
| } |
| this.addSliceTrack( |
| ctx, |
| labelOther ? 'Other wakeups' : 'Wakeups', |
| `${sqlPrefix} where item not in ('${items.join("','")}')`, |
| groupName, |
| WAKEUPS_COLUMNS, |
| ); |
| } |
| |
| async addHighCpu(ctx: Trace, features: Set<string>): Promise<void> { |
| if (!features.has('atom.cpu_cycles_per_uid_cluster')) { |
| return; |
| } |
| const groupName = 'CPU per UID (major users)'; |
| |
| const e = ctx.engine; |
| |
| await e.query(HIGH_CPU); |
| const result = await e.query( |
| `select distinct pkg, cluster from high_cpu where value > 10 order by 1, 2`, |
| ); |
| const it = result.iter({pkg: 'str', cluster: 'str'}); |
| for (; it.valid(); it.next()) { |
| this.addCounterTrack( |
| ctx, |
| `CPU (${it.cluster}): ${it.pkg}`, |
| `select ts, value from high_cpu where pkg = "${it.pkg}" and cluster="${it.cluster}"`, |
| groupName, |
| {yOverrideMaximum: 100, unit: '%'}, |
| ); |
| } |
| } |
| |
| async addBluetooth(ctx: Trace, features: Set<string>): Promise<void> { |
| if ( |
| !Array.from(features.values()).some( |
| (f) => f.startsWith('atom.bluetooth_') || f.startsWith('atom.ble_'), |
| ) |
| ) { |
| return; |
| } |
| const groupName = 'Bluetooth'; |
| this.addSliceTrack( |
| ctx, |
| 'BLE Scans (opportunistic)', |
| bleScanQuery('opportunistic'), |
| groupName, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'BLE Scans (filtered)', |
| bleScanQuery('filtered'), |
| groupName, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'BLE Scans (unfiltered)', |
| bleScanQuery('not filtered'), |
| groupName, |
| ); |
| this.addSliceTrack(ctx, 'BLE Scan Results', BLE_RESULTS, groupName); |
| this.addSliceTrack(ctx, 'Connections (ACL)', BT_CONNS_ACL, groupName); |
| this.addSliceTrack(ctx, 'Connections (SCO)', BT_CONNS_SCO, groupName); |
| this.addSliceTrack( |
| ctx, |
| 'Link-level Events', |
| BT_LINK_LEVEL_EVENTS, |
| groupName, |
| BT_LINK_LEVEL_EVENTS_COLUMNS, |
| ); |
| this.addSliceTrack(ctx, 'A2DP Audio', BT_A2DP_AUDIO, groupName); |
| this.addSliceTrack( |
| ctx, |
| 'Bytes Transferred (L2CAP/RFCOMM)', |
| BT_BYTES, |
| groupName, |
| ); |
| await ctx.engine.query(BT_ACTIVITY); |
| this.addCounterTrack( |
| ctx, |
| 'ACL Classic Active Count', |
| 'select ts, dur, acl_active_count as value from bt_activity', |
| groupName, |
| ); |
| this.addCounterTrack( |
| ctx, |
| 'ACL Classic Sniff Count', |
| 'select ts, dur, acl_sniff_count as value from bt_activity', |
| groupName, |
| ); |
| this.addCounterTrack( |
| ctx, |
| 'ACL BLE Count', |
| 'select ts, dur, acl_ble_count as value from bt_activity', |
| groupName, |
| ); |
| this.addCounterTrack( |
| ctx, |
| 'Advertising Instance Count', |
| 'select ts, dur, advertising_count as value from bt_activity', |
| groupName, |
| ); |
| this.addCounterTrack( |
| ctx, |
| 'LE Scan Duty Cycle Maximum', |
| 'select ts, dur, le_scan_duty_cycle as value from bt_activity', |
| groupName, |
| {unit: '%'}, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'Inquiry Active', |
| "select ts, dur, 'Active' as name from bt_activity where inquiry_active", |
| groupName, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'SCO Active', |
| "select ts, dur, 'Active' as name from bt_activity where sco_active", |
| groupName, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'A2DP Active', |
| "select ts, dur, 'Active' as name from bt_activity where a2dp_active", |
| groupName, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'LE Audio Active', |
| "select ts, dur, 'Active' as name from bt_activity where le_audio_active", |
| groupName, |
| ); |
| this.addCounterTrack( |
| ctx, |
| 'Controller Idle Time', |
| 'select ts, dur, controller_idle_pct as value from bt_activity', |
| groupName, |
| {yRangeSharingKey: 'bt_controller_time', unit: '%'}, |
| ); |
| this.addCounterTrack( |
| ctx, |
| 'Controller TX Time', |
| 'select ts, dur, controller_tx_pct as value from bt_activity', |
| groupName, |
| {yRangeSharingKey: 'bt_controller_time', unit: '%'}, |
| ); |
| this.addCounterTrack( |
| ctx, |
| 'Controller RX Time', |
| 'select ts, dur, controller_rx_pct as value from bt_activity', |
| groupName, |
| {yRangeSharingKey: 'bt_controller_time', unit: '%'}, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'Quality reports', |
| BT_QUALITY_REPORTS, |
| groupName, |
| BT_QUALITY_REPORTS_COLUMNS, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'RSSI Reports', |
| BT_RSSI_REPORTS, |
| groupName, |
| BT_RSSI_REPORTS_COLUMNS, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'HAL Crashes', |
| BT_HAL_CRASHES, |
| groupName, |
| BT_HAL_CRASHES_COLUMNS, |
| ); |
| this.addSliceTrack( |
| ctx, |
| 'Code Path Counter', |
| BT_CODE_PATH_COUNTER, |
| groupName, |
| BT_CODE_PATH_COUNTER_COLUMNS, |
| ); |
| } |
| |
| async addContainedTraces( |
| ctx: Trace, |
| containedTraces: ContainedTrace[], |
| ): Promise<void> { |
| const bySubscription = new Map<string, ContainedTrace[]>(); |
| for (const trace of containedTraces) { |
| if (!bySubscription.has(trace.subscription)) { |
| bySubscription.set(trace.subscription, []); |
| } |
| bySubscription.get(trace.subscription)!.push(trace); |
| } |
| |
| bySubscription.forEach((traces, subscription) => |
| this.addSliceTrack( |
| ctx, |
| subscription, |
| traces |
| .map( |
| (t) => `SELECT |
| CAST(${t.ts} * 1e6 AS int) AS ts, |
| CAST(${t.dur} * 1e6 AS int) AS dur, |
| '${t.trigger === '' ? 'Trace' : t.trigger}' AS name, |
| 'http://go/trace-uuid/${t.uuid}' AS link |
| `, |
| ) |
| .join(' UNION ALL '), |
| 'Other traces', |
| ['link'], |
| ), |
| ); |
| } |
| |
| async findFeatures(e: Engine): Promise<Set<string>> { |
| const features = new Set<string>(); |
| |
| const addFeatures = async (q: string) => { |
| const result = await e.query(q); |
| const it = result.iter({feature: 'str'}); |
| for (; it.valid(); it.next()) { |
| features.add(it.feature); |
| } |
| }; |
| |
| await addFeatures(` |
| select distinct 'atom.' || s.name as feature |
| from track t join slice s on t.id = s.track_id |
| where t.name = 'Statsd Atoms'`); |
| |
| await addFeatures(` |
| select distinct |
| case when name like '%wlan%' then 'net.wifi' |
| when name like '%rmnet%' then 'net.modem' |
| else 'net.other' |
| end as feature |
| from track |
| where name like '%Transmitted' or name like '%Received'`); |
| |
| await addFeatures(` |
| select distinct 'track.' || lower(name) as feature |
| from track where name in ('RIL', 'suspend_backoff') or name like 'battery_stats.%'`); |
| |
| await addFeatures(` |
| select distinct 'track.battery_stats.*' as feature |
| from track where name like 'battery_stats.%'`); |
| |
| return features; |
| } |
| |
| async addTracks(ctx: Trace): Promise<void> { |
| const features: Set<string> = await this.findFeatures(ctx.engine); |
| |
| const containedTraces = (ctx.openerPluginArgs?.containedTraces ?? |
| []) as ContainedTrace[]; |
| |
| await ctx.engine.query(PACKAGE_LOOKUP); |
| await this.addNetworkSummary(ctx, features); |
| await this.addBluetooth(ctx, features); |
| await this.addAtomCounters(ctx); |
| await this.addAtomSlices(ctx); |
| await this.addModemDetail(ctx, features); |
| await this.addKernelWakelocks(ctx, features); |
| await this.addWakeups(ctx, features); |
| await this.addDeviceState(ctx, features); |
| await this.addHighCpu(ctx, features); |
| await this.addContainedTraces(ctx, containedTraces); |
| } |
| |
| async onTraceLoad(ctx: Trace): Promise<void> { |
| await this.addTracks(ctx); |
| } |
| } |
