1 /*
2 * Copyright (C) 2021 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 */
15 #include <iostream>
16 #include <fstream>
17 #include <sstream>
18 #include <algorithm>
19 #include <unistd.h>
20 #include <dirent.h>
21 #include <cstdio>
22 #include <cstdlib>
23 #include <climits>
24 #include <cctype>
25 #include "sys/time.h"
26 #include "securec.h"
27 #include "include/sp_utils.h"
28 #define LARGE_BUFF_MAX_LEN (256)
29 namespace OHOS {
30 namespace SmartPerf {
FileAccess(const std::string & fileName)31 bool SPUtils::FileAccess(const std::string &fileName)
32 {
33 return (access(fileName.c_str(), F_OK) == 0);
34 }
HasNumber(const std::string & str)35 bool SPUtils::HasNumber(const std::string& str)
36 {
37 return std::any_of(str.begin(), str.end(), [](char c) {
38 return std::isdigit(c);
39 });
40 }
Cmp(const std::string & a,const std::string & b)41 bool SPUtils::Cmp(const std::string& a, const std::string& b)
42 {
43 if (HasNumber(a) && HasNumber(b)) {
44 std::string str1 = a.substr(0, a.find_first_of("0123456789"));
45 std::string str2 = b.substr(0, b.find_first_of("0123456789"));
46 if (str1 != str2) {
47 return str1 < str2;
48 }
49 int num1 = std::stoi(a.substr(str1.length()));
50 int num2 = std::stoi(b.substr(str2.length()));
51 return num1 < num2;
52 }
53 return false;
54 }
55
LoadFile(const std::string & filePath,std::string & content)56 bool SPUtils::LoadFile(const std::string &filePath, std::string &content)
57 {
58 char realPath[PATH_MAX] = {0x00};
59 if (realpath(filePath.c_str(), realPath) == nullptr) {
60 std::cout << "" << std::endl;
61 }
62 std::ifstream file(realPath);
63 if (!file.is_open()) {
64 return false;
65 }
66
67 file.seekg(0, std::ios::end);
68 file.tellg();
69
70 content.clear();
71 file.seekg(0, std::ios::beg);
72 copy(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>(), std::back_inserter(content));
73 // remove '' \n\r
74 ReplaceString(content);
75 return true;
76 }
77
LoadCmd(const std::string & cmd,std::string & result)78 bool SPUtils::LoadCmd(const std::string &cmd, std::string &result)
79 {
80 std::string cmdExc = cmd;
81 FILE *fd = popen(cmdExc.c_str(), "r");
82 if (fd == nullptr) {
83 return false;
84 }
85 char buf[1024] = {'\0'};
86 int ret = fread(buf, sizeof(buf), 1, fd);
87 if (ret >= 0) {
88 result = buf;
89 }
90 if (pclose(fd) == -1) {
91 std::cout << "" << std::endl;
92 }
93 // remove '' \n\r
94 ReplaceString(result);
95 return ret >= 0 ? true : false;
96 }
97
IncludePathDelimiter(const std::string & path)98 std::string SPUtils::IncludePathDelimiter(const std::string &path)
99 {
100 if (path.rfind("/") != path.size() - 1) {
101 return path + "/";
102 }
103
104 return path;
105 }
106
ForDirFiles(const std::string & path,std::vector<std::string> & files)107 void SPUtils::ForDirFiles(const std::string &path, std::vector<std::string> &files)
108 {
109 std::string pathStringWithDelimiter;
110 DIR *dir = opendir(path.c_str());
111 if (dir == nullptr) {
112 return;
113 }
114
115 while (true) {
116 struct dirent *ptr = readdir(dir);
117 if (ptr == nullptr) {
118 break;
119 }
120
121 // current dir OR parent dir
122 if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0)) {
123 continue;
124 } else if (ptr->d_type == DT_DIR) {
125 pathStringWithDelimiter = IncludePathDelimiter(path) + std::string(ptr->d_name);
126 ForDirFiles(pathStringWithDelimiter, files);
127 } else {
128 files.push_back(IncludePathDelimiter(path) + std::string(ptr->d_name));
129 }
130 }
131 closedir(dir);
132 }
133
IsSubString(const std::string & str,const std::string & sub)134 bool SPUtils::IsSubString(const std::string &str, const std::string &sub)
135 {
136 if (sub.empty() || str.empty()) {
137 return false;
138 }
139
140 return str.find(sub) != std::string::npos;
141 }
142
StrSplit(const std::string & content,const std::string & sp,std::vector<std::string> & out)143 void SPUtils::StrSplit(const std::string &content, const std::string &sp, std::vector<std::string> &out)
144 {
145 size_t index = 0;
146 while (index != std::string::npos) {
147 size_t tEnd = content.find_first_of(sp, index);
148 std::string tmp = content.substr(index, tEnd - index);
149 if (tmp != "" && tmp != " ") {
150 out.push_back(tmp);
151 }
152 if (tEnd == std::string::npos) {
153 break;
154 }
155 index = tEnd + 1;
156 }
157 }
158
ExtractNumber(const std::string & str)159 std::string SPUtils::ExtractNumber(const std::string &str)
160 {
161 int cntInt = 0;
162 const int shift = 10;
163 for (int i = 0; str[i] != '\0'; ++i) {
164 if (str[i] >= '0' && str[i] <= '9') {
165 cntInt *= shift;
166 cntInt += str[i] - '0';
167 }
168 }
169 return std::to_string(cntInt);
170 }
171
ReplaceString(std::string & res)172 void SPUtils::ReplaceString(std::string &res)
173 {
174 std::string flagOne = "\r";
175 std::string flagTwo = "\n";
176 std::string::size_type ret = res.find(flagOne);
177 while (ret != res.npos) {
178 res.replace(ret, 1, "");
179 ret = res.find(flagOne);
180 }
181 ret = res.find(flagTwo);
182 while (ret != res.npos) {
183 res.replace(ret, 1, "");
184 ret = res.find(flagTwo);
185 }
186 }
187
GetCurTime()188 long long SPUtils::GetCurTime()
189 {
190 struct timeval tv;
191 gettimeofday(&tv, nullptr);
192 long long timestamp = tv.tv_sec * 1000 + tv.tv_usec / 1000;
193 return timestamp;
194 }
195
GetTopPkgName()196 std::string SPUtils::GetTopPkgName()
197 {
198 std::string cmd = "hidumper -s AbilityManagerService -a '-a' | grep 'bundle name' | head -n 1";
199 std::string curTopPkgStr = "";
200 LoadCmd(cmd, curTopPkgStr);
201 uint64_t left = curTopPkgStr.find_first_of("[");
202 uint64_t right = curTopPkgStr.find_first_of("]");
203 std::string topPkg = curTopPkgStr.substr(left + 1, right - left - 1);
204 return topPkg;
205 }
206
GetRadar()207 std::string SPUtils::GetRadar()
208 {
209 std::string cmd = "hisysevent -r -o PERFORMANCE -n APP_START";
210 std::string curRadar = "";
211 LoadCmd(cmd, curRadar);
212 return curRadar;
213 }
GetScreen()214 std::string SPUtils::GetScreen()
215 {
216 std::string cmd = "hidumper -s 10 -a screen";
217 std::string screenStr = "";
218 LoadCmd(cmd, screenStr);
219 uint64_t left = screenStr.find("activeMode");
220 uint64_t right = screenStr.find("capability");
221 std::string screen = screenStr.substr(left, right - left);
222 return screen;
223 }
GetRadarFrame()224 std::string SPUtils::GetRadarFrame()
225 {
226 std::string cmd = "hisysevent -r -o PERFORMANCE -n INTERACTION_JANK";
227 std::string curRadar = "";
228 LoadCmd(cmd, curRadar);
229 return curRadar;
230 }
GetRadarResponse()231 std::string SPUtils::GetRadarResponse()
232 {
233 std::string cmd = "hisysevent -r -n INTERACTION_RESPONSE_LATENCY";
234 std::string curRadar = "";
235 LoadCmd(cmd, curRadar);
236 return curRadar;
237 }
GetRadarComplete()238 std::string SPUtils::GetRadarComplete()
239 {
240 std::string cmd = "hisysevent -r -n INTERACTION_COMPLETED_LATENCY";
241 std::string curRadar = "";
242 LoadCmd(cmd, curRadar);
243 return curRadar;
244 }
GetSplitOne(std::string cmd)245 static std::string GetSplitOne(std::string cmd)
246 {
247 std::string result;
248 SPUtils::LoadCmd(cmd, result);
249 return result;
250 }
251
GetDeviceInfo()252 std::map<std::string, std::string> SPUtils::GetDeviceInfo()
253 {
254 std::map<std::string, std::string> resultMap;
255 std::string sn = GetSplitOne("param get ohos.boot.sn");
256 std::string deviceTypeName = GetSplitOne("param get ohos.boot.hardware");
257 std::string brand = GetSplitOne("param get const.product.brand");
258 std::string version = GetSplitOne("param get const.product.software.version");
259 resultMap["sn"] = sn;
260 resultMap["deviceTypeName"] = deviceTypeName;
261 resultMap["brand"] = brand;
262 resultMap["board"] = "hw";
263 resultMap["version"] = version;
264 return resultMap;
265 }
GetCpuInfo()266 std::map<std::string, std::string> SPUtils::GetCpuInfo()
267 {
268 std::vector<std::string> policyFiles;
269 std::map<std::string, std::string> resultMap;
270 std::string basePath = "/sys/devices/system/cpu/cpufreq/";
271 std::cout << "policyFiles size:" << policyFiles.size() << std::endl;
272 DIR *dir = opendir(basePath.c_str());
273 if (dir == nullptr) {
274 return resultMap;
275 }
276 while (true) {
277 struct dirent *ptr = readdir(dir);
278 if (ptr == nullptr) {
279 break;
280 }
281 if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0)) {
282 continue;
283 }
284 policyFiles.push_back(IncludePathDelimiter(basePath) + std::string(ptr->d_name));
285 }
286 for (size_t i = 0; i < policyFiles.size(); i++) {
287 std::string cpus;
288 LoadFile(policyFiles[i] + "/affected_cpus", cpus);
289 std::string max;
290 LoadFile(policyFiles[i] + "/cpuinfo_max_freq", max);
291 std::string min;
292 LoadFile(policyFiles[i] + "/cpuinfo_min_freq", min);
293 std::string nameBase = "cpu-c" + std::to_string(i + 1) + "-";
294 resultMap[nameBase + "cluster"] = cpus;
295 resultMap[nameBase + "max"] = max;
296 resultMap[nameBase + "min"] = min;
297 }
298 return resultMap;
299 }
GetGpuInfo()300 std::map<std::string, std::string> SPUtils::GetGpuInfo()
301 {
302 const std::vector<std::string> gpuCurFreqPaths = {
303 "/sys/class/devfreq/fde60000.gpu/",
304 "/sys/class/devfreq/gpufreq/",
305 };
306 std::map<std::string, std::string> resultMap;
307 for (auto path : gpuCurFreqPaths) {
308 if (FileAccess(path)) {
309 std::string max;
310 SPUtils::LoadFile(path + "/max_freq", max);
311 std::string min;
312 SPUtils::LoadFile(path + "/min_freq", min);
313 resultMap["gpu_max_freq"] = max;
314 resultMap["gpu_min_freq"] = min;
315 }
316 }
317 return resultMap;
318 }
319 }
320 }
321