1/*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15import { query } from '../SqlLite';
16import { Smaps } from '../../bean/SmapsStruct';
17
18export const querySmapsExits = (): Promise<Array<unknown>> =>
19  query(
20    'querySmapsExits',
21    `select
22      event_name
23      from stat s
24      where s.event_name = 'trace_smaps'
25      and s.stat_type ='received' and s.count > 0`
26  );
27
28export const querySmapsData = (columnName: string): Promise<Array<unknown>> =>
29  query(
30    'querySmapsCounterData',
31    `SELECT 
32    (A.timestamp - B.start_ts) as startNs, 
33    sum(${columnName}) * 1024 as value, 
34    $columnName as name 
35    FROM smaps A,trace_range B WHERE A.timestamp < B.end_ts GROUP by A.timestamp;`,
36    { $columnName: columnName }
37  );
38
39export const querySmapsDataMax = (columnName: string): Promise<Array<unknown>> =>
40  query(
41    'querySmapsDataMax',
42    `
43   SELECT 
44   (A.timestamp - B.start_ts) as startNS,
45   sum(${columnName}) as max_value 
46   FROM smaps A,trace_range B GROUP by A.timestamp order by max_value desc LIMIT 1`
47  );
48
49export const getTabSmapsMaxSize = (leftNs: number, rightNs: number, dur: number):
50  Promise<Array<unknown>> =>
51  query<Smaps>(
52    'getTabSmapsMaxRss',
53    `
54      SELECT 
55      (A.timestamp - B.start_ts) as startNS, 
56      sum(virtaul_size) *1024 as max_value 
57      FROM smaps A,trace_range B where startNS <= $rightNs and (startNS+$dur)>=$leftNs`,
58    { $rightNs: rightNs, $leftNs: leftNs, $dur: dur }
59  );
60
61export const getTabSmapsData = (leftNs: number, rightNs: number, dur: number):
62  Promise<Array<Smaps>> =>
63  query<Smaps>(
64    'getTabSmapsData',
65    `
66    SELECT
67     (A.timestamp - t.start_ts) AS startNs,
68     start_addr as startAddr,
69     end_addr as endAddr,
70     A.type,
71     resident_size * 1024 AS rss,
72     protection_id as pid,
73     pss * 1024 as pss,virtaul_size * 1024 AS size,reside,A.path_id AS path,
74     shared_clean * 1024 as sharedClean,
75     shared_dirty * 1024 as sharedDirty,
76     private_clean * 1024 as privateClean,
77     private_dirty * 1024 as privateDirty,swap * 1024 as swap,swap_pss * 1024 as swapPss
78     FROM smaps A,
79     trace_range AS t
80     WHERE (startNs) <= $rightNs and (startNs+$dur) >=$leftNs`,
81    { $rightNs: rightNs, $leftNs: leftNs, $dur: dur },
82  );
83export const getTabSmapsSampleData = (leftNs: number): Promise<Array<Smaps>> =>
84  query<Smaps>(
85    'getTabSmapsSampleData',
86    `
87      SELECT
88     (A.timestamp - t.start_ts) AS startNs,
89     start_addr as startAddr,
90     end_addr as endAddr,
91     A.type,
92     resident_size * 1024 AS rss,
93     protection_id as pid,
94     pss * 1024 as pss,virtaul_size * 1024 AS size,reside,A.path_id AS path,
95     shared_clean * 1024 as sharedClean,
96     shared_dirty * 1024 as sharedDirty,
97     private_clean * 1024 as privateClean,
98     private_dirty * 1024 as privateDirty,swap * 1024 as swap,swap_pss * 1024 as swapPss
99     FROM smaps A,
100     trace_range AS t
101     WHERE (startNs) = ${leftNs}`,
102    { $leftNs: leftNs },
103  );
104// VM Tracker Smaps Record Tab页
105export const querySmapsRecordTabData = (
106  startNs: number,
107  ipid: number,
108  pixelmapId: number,
109  typeId: number
110): Promise<Array<{ name: string; size: number }>> =>
111  query(
112    'querySmapsRecordTabData',
113    `select  'RenderServiceCpu' as name, IFNULL(sum(mem_size), 0) as size 
114    from memory_rs_image, trace_range tr
115    where ipid = ${ipid} and (ts - tr.start_ts) = ${startNs} and type_id = ${pixelmapId}
116    union all
117    select 'SkiaCpu' as name, total_size as size from memory_cpu,trace_range
118    where (ts - start_ts) = ${startNs}
119    union all
120    select 'GLESHostCache' as name, 0
121    union all
122    select 'VirtaulSize' as name, sum(virtaul_size) * 1024 as size from smaps, trace_range
123    where type = ${typeId} and (timeStamp - start_ts) = ${startNs}`
124  );
125
126export const getTabSmapsStatisticMaxSize = (rightNs: number): Promise<Array<unknown>> =>
127  query<Smaps>(
128    'getTabSmapsStatisticMaxRss',
129    `
130    SELECT 
131    (A.timestamp - B.start_ts) as startNS, 
132    sum(virtaul_size) * 1024 as max_value 
133    FROM smaps A,trace_range B where startNS = $rightNs`,
134    { $rightNs: rightNs }
135  );
136
137export const getTabSmapsStatisticData = (rightNs: number): Promise<Array<Smaps>> =>
138  query<Smaps>(
139    'getTabSmapsStatisticData',
140    `SELECT
141     (A.timestamp - t.start_ts) AS startNs,
142     start_addr as startAddr,
143     end_addr as endAddr,
144     A.type,
145     sum(resident_size) * 1024 AS rss,
146     protection_id as pid,
147     count(A.path_id) as count,
148     sum(pss) * 1024 as pss ,
149     sum(virtaul_size) * 1024 AS size,
150     sum(reside) as reside,
151     A.path_id AS path,
152     sum(shared_clean) * 1024 as sharedClean,sum(shared_dirty) * 1024 as sharedDirty,
153     sum(private_clean) * 1024 as privateClean,sum(private_dirty) * 1024 as privateDirty,
154     sum(swap) * 1024 as swap,sum(swap_pss) * 1024 as swapPss
155     FROM smaps A,
156     trace_range AS t
157     WHERE (startNs) =$rightNs
158     group by type,path`,
159    { $rightNs: rightNs }
160  );
161
162
163export const getTabSmapsStatisticSelectData = (leftNs: number, rightNs: number, dur: number):
164  Promise<Array<Smaps>> =>
165  query<Smaps>(
166    'getTabSmapsStatisticData',
167    `SELECT
168     (A.timestamp - t.start_ts) AS startNs,
169     start_addr as startAddr,
170     end_addr as endAddr,
171     A.type,
172     sum(resident_size) * 1024 AS rss,
173     protection_id as pid,
174     count(A.path_id) as count,
175     sum(pss) * 1024 as pss ,sum(virtaul_size) * 1024 AS size,sum(reside) as reside,
176     A.path_id AS path,
177     sum(shared_clean) * 1024 as sharedClean,sum(shared_dirty) * 1024 as sharedDirty,
178     sum(private_clean) * 1024 as privateClean,sum(private_dirty) * 1024 as privateDirty,
179     sum(swap) * 1024 as swap,sum(swap_pss) * 1024 as swapPss
180     FROM smaps A,
181     trace_range AS t
182     WHERE (startNs) <=$rightNs and (startNs+$dur)>=$leftNs
183     group by type,path`,
184    { $rightNs: rightNs, $leftNs: leftNs, $dur: dur },
185  );
186