* Copyright (C) 2022 Huawei Device Co., Ltd.
* 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.
*/
let temp_query_cpu_data = `create table temp_query_cpu_data as
with list as (SELECT IP.name as processName,
IP.name processCmdLine,
IP.pid as processId,
B.cpu,
A.name,
C.id as schedId,
A.tid,
A.id,
A.type,
B.dur,
B.ts - TR.start_ts AS startTime,
C.priority,
C.end_state
from thread_state AS B
left join thread as A on B.itid = A.id
left join sched_slice AS C on B.itid = C.itid and B.ts = C.ts
left join trace_range AS TR
left join process AS IP on A.ipid = IP.id
where C.itid is not null
order by B.id)
select *
from list;
create index temp_query_cpu_data_idx on temp_query_cpu_data (cpu, startTime);
`;
let temp_query_freq_data = `create table temp_query_freq_data as
select cpu, value, ts - tb.start_ts as startNS
from measure c,
trace_range tb
inner join cpu_measure_filter t on c.filter_id = t.id
where (name = 'cpufreq' or name = 'cpu_frequency')
order by ts;
create index temp_query_freq_data_idx on temp_query_freq_data (cpu);
`;
let temp_query_process_data = `create table temp_query_process_data as
select ta.id,
type,
ts,
dur,
ta.cpu,
itid as utid,
state,
ts - tb.start_ts as startTime,
tc.tid,
tc.pid,
tc.process,
tc.thread
from thread_state ta,
trace_range tb
left join (select it.id,
tid,
pid,
ip.name as process,
it.name as thread
from thread as it
left join process ip on it.ipid = ip.id) tc on ta.itid = tc.id
where ta.cpu is not null
order by startTime;
create index temp_query_process_data_idx on temp_query_process_data (pid, startTime);
`;
let temp_query_thread_function = `create table temp_query_thread_function as
select tid,
A.name as threadName,
is_main_thread,
c.callid as track_id,
c.ts - D.start_ts as startTs,
c.dur,
c.name as funName,
c.parent_id,
c.id,
c.depth,
c.argsetid
from thread A,
trace_range D
left join callstack C on A.id = C.callid
where startTs not null and c.cookie is null;
create index temp_query_thread_function_idx on temp_query_thread_function (tid);
`;
let temp_query_thread_data = `create table temp_query_thread_data as
select A.id
, A.type
, A.tid
, A.name
, A.start_ts
, A.end_ts
, A.ipid as upid
, A.is_main_thread
, B.cpu
, B.ts - TR.start_ts AS startTime
, B.dur
, B.state
, IP.pid
, IP.name as processName
from thread_state AS B
left join thread as A on A.id = B.itid
left join trace_range AS TR
left join process AS IP on IP.id = A.ipid;
create index temp_query_thread_data_idx on temp_query_thread_data (tid);`;
let temp_view = `CREATE VIEW IF NOT EXISTS thread_view AS SELECT id as itid, * FROM thread;
CREATE VIEW IF NOT EXISTS process_view AS SELECT id as ipid, * FROM process;
CREATE VIEW IF NOT EXISTS sched_view AS SELECT *, ts + dur as ts_end FROM sched_slice;
CREATE VIEW IF NOT EXISTS instants_view AS SELECT *, 0.0 as value FROM instant;
CREATE VIEW IF NOT EXISTS trace_section AS select start_ts, end_ts from trace_range;`;
let temp_query_cpu_freq = `create table temp_query_cpu_freq as
select cpu
from cpu_measure_filter
where (name = 'cpufreq' or name = 'cpu_frequency')
order by cpu;`;
let temp_query_cpu_max_freq = `create table temp_query_cpu_max_freq as
select max(value) as maxFreq
from measure c
inner join cpu_measure_filter t on c.filter_id = t.id
where (name = 'cpufreq' or name = 'cpu_frequency');`;
let temp_get_tab_states_group_by_process = `create table temp_get_tab_states_group_by_process as
select IP.name as process,
IP.pid as processId,
dur,
Ip.id as id,
(ts - B.start_ts + dur) as end_ts,
(ts - B.start_ts) as start_ts
from thread_state as A,
trace_range as B
left join thread as C on A.itid = C.id
left join process AS IP on C.ipid = IP.id
where A.dur > 0
and processId not null and (ts - B.start_ts)>0;
create index temp_get_tab_states_group_by_process_idx on temp_get_tab_states_group_by_process (end_ts, start_ts);
`;
let temp_get_process_thread_state_data = ` create table temp_get_process_thread_state_data as
select IP.name as process,
IP.pid as processId,
A.name as thread,
B.state as state,
A.tid as threadId,
B.dur,
(B.ts - TR.start_ts + B.dur) as end_ts,
(B.ts - TR.start_ts) as start_ts,
B.cpu,
C.priority,
'-' as note
from thread_state as B
left join thread as A on B.itid = A.id
left join process as IP on A.ipid = IP.id
left join trace_range as TR
left join sched_slice as C on B.itid = C.itid and C.ts = B.ts
where B.dur > 0
and IP.pid not null and (B.ts - TR.start_ts) >= 0;
create index temp_get_process_thread_state_data_idx on temp_get_process_thread_state_data (end_ts, start_ts);
`;
let temp_get_tab_states_group_by_state_pid_tid = ` create table temp_get_tab_states_group_by_state_pid_tid as
select IP.name as process,
IP.pid as processId,
A.name as thread,
B.state as state,
A.tid as threadId,
B.dur as dur,
A.tid as tid,
(B.ts - TR.start_ts + B.dur) as end_ts,
(B.ts - TR.start_ts) as start_ts
from thread_state AS B
left join thread as A on B.itid = A.id
left join process AS IP on A.ipid = IP.id
left join trace_range AS TR
where B.dur > 0
and IP.pid not null and (B.ts - TR.start_ts > 0);
create index temp_get_tab_states_group_by_state_pid_tid_idx0 on temp_get_tab_states_group_by_state_pid_tid (process, processId, thread, threadId, state);
create index temp_get_tab_states_group_by_state_pid_tid_idx1 on temp_get_tab_states_group_by_state_pid_tid (end_ts, start_ts);
create index temp_get_tab_states_group_by_state_pid_tid_idx3 on temp_get_tab_states_group_by_state_pid_tid (end_ts, start_ts, process, processId, thread, threadId, state);
`;
let temp_get_tab_states_group_by_state_pid = `create table temp_get_tab_states_group_by_state_pid as
select IP.name as process,
IP.pid as processId,
B.state as state,
B.dur as dur,
A.tid as tid,
(ts - TR.start_ts + dur) as end_ts,
(ts - TR.start_ts) as start_ts
from thread_state AS B
left join thread as A on B.itid = A.id
left join process AS IP on A.ipid = IP.id
left join trace_range AS TR
where pid not null and
B.dur > 0 and (ts - TR.start_ts > 0);
create index temp_get_tab_states_group_by_state_pid_idx0 on temp_get_tab_states_group_by_state_pid (process, processId, state);
create index temp_get_tab_states_group_by_state_pid_idx1 on temp_get_tab_states_group_by_state_pid (start_ts, end_ts);
`;
let temp_get_tab_states_group_by_state = `create table temp_get_tab_states_group_by_state as
select state,
dur,
(ts - B.start_ts + dur) as end_ts,
(ts - B.start_ts) as start_ts
from thread_state as A,
trace_range as B
left join thread as C on A.itid = C.id
left join process AS IP on C.ipid = IP.id
where A.dur > 0
and IP.pid not null and (ts - B.start_ts > 0);
create index temp_get_tab_states_group_by_state_idx0 on temp_get_tab_states_group_by_state (state);
create index temp_get_tab_states_group_by_state_idx1 on temp_get_tab_states_group_by_state (start_ts, end_ts);
`;
let temp_get_tab_states_group_by_process_thread = `create table temp_get_tab_states_group_by_process_thread as
select IP.name as process,
IP.pid as processId,
A.name as thread,
a.tid as threadId,
B.dur as dur,
A.tid as tid,
(ts - TR.start_ts + dur) as end_ts,
(ts - TR.start_ts) as start_ts
from thread_state AS B
left join
thread as A on B.itid = A.id
left join
process AS IP on A.ipid = IP.id
left join
trace_range AS TR
where pid not null
and
B.dur > 0
and
(ts - TR.start_ts)>0;
create index temp_get_tab_states_group_by_process_thread_idx0 on temp_get_tab_states_group_by_process_thread (process, processId, thread, threadId);
create index temp_get_tab_states_group_by_process_thread_idx1 on temp_get_tab_states_group_by_process_thread (start_ts, end_ts);
`;
let temp_get_cpu_rate = `create table temp_get_cpu_rate as
with cpu as (select cpu,
ts,
dur,
(case when ro < 99 then ro else 99 end) as ro,
(case when ro < 99 then stime + ro * cell else stime + 99 * cell end) as st,
(case when ro < 99 then stime + (ro + 1) * cell else etime end) as et
from (select cpu,
ts,
A.dur,
((ts + A.dur) - D.start_ts) / ((D.end_ts - D.start_ts) / 100) as ro,
D.start_ts as stime,
D.end_ts etime,
(D.end_ts - D.start_ts) / 100 as cell
from sched_slice A
left join
trace_range D
left join
thread B on A.itid = B.id
left join
process C on B.ipid = C.id
where tid != 0
and (A.ts)
between D.start_ts and D.end_ts))
select cpu,
ro,
sum(case
when ts <= st and ts + dur <= et then (ts + dur - st)
when ts <= st and ts + dur > et then et - st
when ts > st and ts + dur <= et then dur
when ts > st and ts + dur > et then et - ts end) / cast(et - st as float) as rate
from cpu
group by cpu, ro;
`;
let temp_get_tab_thread_states = `create table temp_get_tab_thread_states as
select IP.name as process,
IP.pid as pid,
A.name as thread,
A.tid as tid,
B.state as state,
B.dur as dur,
(B.ts - TR.start_ts + ifnull(B.dur, 0)) as end_ts,
(B.ts - TR.start_ts) as start_ts
from thread_state AS B
left join
thread as A
on
A.id = B.itid
left join
trace_range AS TR
left join
process AS IP
on
IP.id = A.ipid
where (B.ts - TR.start_ts > 0);
create index temp_get_tab_thread_states_idx0 on temp_get_tab_thread_states (process, pid, thread, tid, state);
create index temp_get_tab_thread_states_idx1 on temp_get_tab_thread_states (start_ts, end_ts);
`;
let temp_get_tab_slices = `create table temp_get_tab_slices as
select c.name as name,
c.dur as dur,
A.tid as tid,
(C.ts - D.start_ts + C.dur) as end_ts,
(C.ts - D.start_ts) as start_ts
from thread A,
trace_range D
left join
callstack C on A.id = C.callid
where C.ts not null
and c.dur >= 0
and (C.ts - D.start_ts > 0);
create index temp_get_tab_slices_idx0 on temp_get_tab_slices (name);
`;
let createProcessNoId = `
insert into process(id, ipid, type, pid, name, start_ts)
SELECT null, null, 'process' as type, tid as pid, t.name, t.start_ts
from thread t
where ipid is null
and tid != 0;
update process
set id = ROWID - 1,
ipid = ROWID - 1
where id is null;
update thread
set ipid = (select id from process where thread.tid = process.pid)
where thread.ipid is null;
`;
let temp_create_cpu_freq_view = `CREATE VIEW cpu_freq_view AS SELECT B.cpu, A.ts, LEAD(A.ts, 1, (SELECT end_ts FROM trace_range)) OVER (PARTITION BY A.filter_id ORDER BY ts) AS end_ts,LEAD(A.ts, 1, (SELECT end_ts FROM trace_range)) OVER (PARTITION BY A.filter_id ORDER BY ts) - ts AS dur,value AS freq FROM measure AS A, cpu_measure_filter AS B WHERE B.name = 'cpu_frequency' AND A.filter_id = B.id`;
let temp_create_virtual_table = `CREATE VIRTUAL table result USING SPAN_JOIN(cpu_freq_view partitioned cpu, sched_slice partitioned cpu)`;
let queryThreadWakeUpFrom = `
select TB.tid, TB.name as thread, TA.cpu, (TA.ts - TR.start_ts) as ts, TC.pid, TC.name as process
from (select ts as wakeTs, wakeup_from as wakeupFromTid
from instant,
trace_range
where name = 'sched_wakeup'
and ref = $itid
and ts > start_ts + $startTime
and ts < start_ts + $startTime + $dur
order by ts) TW
left join thread_state TA
on TW.wakeupFromTid = TA.itid and TA.ts < TW.wakeTs and TA.ts + TA.dur >= TW.wakeTs
left join thread TB on TA.itid = TB.id
left join process TC on TB.ipid = TC.id
left join trace_range TR
where TB.ipid not null
limit 1;
`;
let queryThreadWakeUp = `
select TB.tid, TB.name as thread, min(TA.ts - TR.start_ts) as ts, TC.pid, TC.name as process
from (select min(ts) as wakeTs, ref as itid
from instant,
trace_range
where name = 'sched_wakeup'
and wakeup_from = $itid
and ts > start_ts + $startTime
and ts < start_ts + $startTime + $dur
group by ref) TW
left join thread_state TA on TW.itid = TA.itid and TA.ts > TW.wakeTs
left join thread TB on TA.itid = TB.id
left join process TC on TB.ipid = TC.id
left join trace_range TR
where TB.ipid not null
group by TB.tid, TB.name, TC.pid, TC.name;
`;
let delete_callstack_binder_data = `DELETE
FROM callstack
WHERE dur < -1
or name = 'binder transaction async'
or name = 'binder async rcv';`;
let temp_init_sql_list = [];
export { temp_init_sql_list };
