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 <cinttypes>
16 #include <thread>
17 #include "distributed_test_sysinfo.h"
18 #include "distributeddb_data_generator.h"
19 #include "securec.h"
20
21 const uint64_t PERCENTAGE_FACTOR = 100;
22 const float FLOAT_RET_ERROR = -1.0f;
23
DistributedTestSysInfo()24 DistributedTestSysInfo::DistributedTestSysInfo()
25 {
26 #if defined(RUNNING_ON_LINUX)
27 if ((memset_s(&memStatFirst_, sizeof(memStatFirst_), 0, sizeof(memStatFirst_)) != EOK) &&
28 (memset_s(&memStatSecond_, sizeof(memStatSecond_), 0, sizeof(memStatSecond_)) != EOK) &&
29 (memset_s(&cpuStatFirst_, sizeof(cpuStatFirst_), 0, sizeof(cpuStatFirst_)) != EOK) &&
30 (memset_s(&cpuStatSecond_, sizeof(cpuStatSecond_), 0, sizeof(cpuStatSecond_)) != EOK)) {
31 MST_LOG("distribute info set 0 failed!");
32 }
33 #elif defined RUNNING_ON_WIN
34 #endif
35 cpuStatFirstUsage_ = 0.0f;
36 cpuStatSecondUsage_ = 0.0f;
37 powerStatFirst_ = 0.0f;
38 powerStatSecond_ = 0.0f;
39 val_ = 0.0f;
40 }
41
42 #if defined(RUNNING_ON_LINUX)
GetSysMemOccpy(SeqNo seqNo)43 void DistributedTestSysInfo::GetSysMemOccpy(SeqNo seqNo)
44 {
45 MemOccupy* memOccupy = nullptr;
46 if (seqNo == FIRST) {
47 memOccupy = &memStatFirst_;
48 } else {
49 memOccupy = &memStatSecond_;
50 }
51
52 FILE *fp = nullptr;
53 char buff[PROC_BUFFER_LENGTH] = { 0 };
54
55 fp = fopen(SYS_MEM_FILE.c_str(), FILE_READ_PERMISSION.c_str());
56 if (fp == nullptr) {
57 perror("fopen:");
58 return;
59 }
60
61 (void)fgets(buff, sizeof(buff), fp);
62 int result1 = sscanf_s(buff, "%s %llu ",
63 memOccupy->memTotalName_, sizeof(memOccupy->memTotalName_), &memOccupy->memTotal_);
64 (void)fgets(buff, sizeof(buff), fp);
65 int result2 = sscanf_s(buff, "%s %llu ",
66 memOccupy->memFreeName_, sizeof(memOccupy->memFreeName_), &memOccupy->memFree_);
67 (void)fgets(buff, sizeof(buff), fp);
68 int result3 = sscanf_s(buff, "%s %llu ",
69 memOccupy->buffersName_, sizeof(memOccupy->buffersName_), &memOccupy->buffers_);
70 (void)fgets(buff, sizeof(buff), fp);
71 int result4 = sscanf_s(buff, "%s %llu ",
72 memOccupy->cachedName_, sizeof(memOccupy->cachedName_), &memOccupy->cached_);
73 (void)fgets(buff, sizeof(buff), fp);
74 int result5 = sscanf_s(buff, "%s %llu",
75 memOccupy->swapCachedName_, sizeof(memOccupy->swapCachedName_), &memOccupy->swapCached_);
76 if (result1 != 2 || result2 != 2) { // there are 2 incoming param.
77 MST_LOG("get mem1 info failed.");
78 }
79 if (result3 != 2 || result4 != 2 || result5 != 2) { // there are 2 incoming param.
80 MST_LOG("get mem2 info failed.");
81 }
82 MST_LOG(" [MemTotal] = %" PRIu64 " \n [MemFree] = %" PRIu64 " \n [Buffers] = %" PRIu64 " \n [Cached] = %" PRIu64 \
83 " \n [SwapCached] = %" PRIu64, memOccupy->memTotal_, memOccupy->memFree_, memOccupy->buffers_,
84 memOccupy->cached_, memOccupy->swapCached_);
85 (void)fclose(fp);
86 fp = nullptr;
87 }
88
GetSysCpuInfo(CpuOccupy & cpuStatFirst_,CpuOccupy & cpuStatSecond_,uint64_t microSeconds,float * & cpuStatUsage)89 void GetSysCpuInfo(CpuOccupy &cpuStatFirst_, CpuOccupy &cpuStatSecond_, uint64_t microSeconds, float *&cpuStatUsage)
90 {
91 FILE *fp = nullptr;
92 char buff[PROC_BUFFER_LENGTH] = { 0 };
93 fp = fopen(SYS_CPU_FILE.c_str(), FILE_READ_PERMISSION.c_str());
94 if (fp == nullptr) {
95 perror("fopen:");
96 exit(0);
97 }
98 (void)fgets(buff, sizeof(buff), fp);
99 int result = sscanf_s(buff, "%s %llu %llu %llu %llu %llu %llu %llu",
100 cpuStatFirst_.name_, sizeof(cpuStatFirst_.name_),
101 &cpuStatFirst_.user_, &cpuStatFirst_.nice_,
102 &cpuStatFirst_.system_, &cpuStatFirst_.idle_, &cpuStatFirst_.iowait_,
103 &cpuStatFirst_.irq_, &cpuStatFirst_.softirq_);
104 if (result != 8) { // there are 8 incoming param.
105 (void)fclose(fp);
106 return;
107 }
108 uint64_t allFirst = cpuStatFirst_.user_ + cpuStatFirst_.nice_ + cpuStatFirst_.system_ + cpuStatFirst_.idle_ +
109 cpuStatFirst_.iowait_ + cpuStatFirst_.irq_ + cpuStatFirst_.softirq_;
110 uint64_t idleFirst = cpuStatFirst_.idle_;
111 rewind(fp);
112 std::this_thread::sleep_for(std::chrono::microseconds(microSeconds));
113 if (memset_s(buff, sizeof(buff), 0, sizeof(buff)) != EOK) {
114 MST_LOG("set buffer to 0 failed!");
115 (void)fclose(fp);
116 return;
117 }
118 (void)fgets(buff, sizeof(buff), fp);
119 result = sscanf_s(buff, "%s %llu %llu %llu %llu %llu %llu %llu",
120 cpuStatSecond_.name_, sizeof(cpuStatSecond_.name_),
121 &cpuStatSecond_.user_, &cpuStatSecond_.nice_,
122 &cpuStatSecond_.system_, &cpuStatSecond_.idle_, &cpuStatSecond_.iowait_,
123 &cpuStatSecond_.irq_, &cpuStatSecond_.softirq_);
124 if (result < 0) {
125 (void)fclose(fp);
126 return;
127 }
128
129 uint64_t allSecond = cpuStatSecond_.user_ + cpuStatSecond_.nice_ + cpuStatSecond_.system_ + cpuStatSecond_.idle_ +
130 cpuStatSecond_.iowait_ + cpuStatSecond_.irq_ + cpuStatSecond_.softirq_;
131 uint64_t idleSecond = cpuStatSecond_.idle_;
132 *cpuStatUsage = (static_cast<float>(allSecond - allFirst - (idleSecond - idleFirst)))
133 / (allSecond - allFirst) * PERCENTAGE_FACTOR;
134 MST_LOG(" [CpuUsage] = %.2f%%", *cpuStatUsage);
135 (void)fclose(fp);
136 fp = nullptr;
137 return;
138 }
GetSysCpuUsage(SeqNo seqNo,uint64_t microSeconds)139 void DistributedTestSysInfo::GetSysCpuUsage(SeqNo seqNo, uint64_t microSeconds)
140 {
141 float *cpuStatUsage = nullptr;
142 if (seqNo == FIRST) {
143 cpuStatUsage = &cpuStatFirstUsage_;
144 } else {
145 cpuStatUsage = &cpuStatSecondUsage_;
146 }
147 GetSysCpuInfo(cpuStatFirst_, cpuStatSecond_, microSeconds, cpuStatUsage);
148 if ((memset_s(&cpuStatFirst_, sizeof(cpuStatFirst_), 0, sizeof(cpuStatFirst_)) != EOK) &&
149 (memset_s(&cpuStatSecond_, sizeof(cpuStatSecond_), 0, sizeof(cpuStatSecond_)) != EOK)) {
150 MST_LOG("set cpu to 0 failed!");
151 }
152 }
153
ReadSysValFromFile(const std::string & filePath)154 float DistributedTestSysInfo::ReadSysValFromFile(const std::string &filePath)
155 {
156 FILE *fp = nullptr;
157 char buff[SYSTEM_INFO_BUFFER_SIZE] = { 0 };
158
159 char path[PATH_MAX] = { 0 };
160 if (realpath(filePath.c_str(), path) == nullptr) {
161 MST_LOG("path error.");
162 return FLOAT_RET_ERROR;
163 }
164
165 fp = fopen(filePath.c_str(), FILE_READ_PERMISSION.c_str());
166 if (fp == nullptr) {
167 perror("fopen:");
168 return FLOAT_RET_ERROR;
169 }
170
171 (void)fgets(buff, sizeof(buff), fp);
172 if (sscanf_s(buff, "%f", &val_) != 1) {
173 (void)fclose(fp);
174 return FLOAT_RET_ERROR;
175 }
176 (void)fclose(fp);
177 return val_;
178 }
179
GetSysMeanCurrentVal(const std::string & filePath,int totalCount,uint64_t microSeconds)180 float DistributedTestSysInfo::GetSysMeanCurrentVal(
181 const std::string &filePath, int totalCount, uint64_t microSeconds)
182 {
183 float meanVal = 0.0f;
184 if (totalCount <= 0 || microSeconds <= 0) {
185 return 0.0f;
186 }
187
188 for (int cnt = 0; cnt < totalCount; cnt++) {
189 float val = ReadSysValFromFile(filePath.c_str());
190 if (val < 1e-4) {
191 continue;
192 }
193 meanVal += val;
194 std::this_thread::sleep_for(std::chrono::microseconds(microSeconds));
195 }
196 return meanVal / totalCount;
197 }
198
GetSysCurrentPower(SeqNo seqNo,int totalCount,uint64_t microSeconds)199 void DistributedTestSysInfo::GetSysCurrentPower(SeqNo seqNo, int totalCount, uint64_t microSeconds)
200 {
201 float* powerCons = nullptr;
202 if (seqNo == FIRST) {
203 powerCons = &powerStatFirst_;
204 } else {
205 powerCons = &powerStatSecond_;
206 }
207
208 *powerCons = GetSysMeanCurrentVal(POWER_FOLLOW_FILE, totalCount, microSeconds) \
209 * GetSysMeanCurrentVal(VOLTAGE_FILE, totalCount, microSeconds);
210 MST_LOG(" [Power] = %.2f", *powerCons);
211 }
212
GetFirstMemFree() const213 uint64_t DistributedTestSysInfo::GetFirstMemFree() const
214 {
215 return memStatFirst_.memFree_;
216 }
217
GetSecondMemFree() const218 uint64_t DistributedTestSysInfo::GetSecondMemFree() const
219 {
220 return memStatSecond_.memFree_;
221 }
222
223 #elif defined RUNNING_ON_WIN
GetSysMemOccpy(SeqNo seqNo)224 void DistributedTestSysInfo::GetSysMemOccpy(SeqNo seqNo)
225 {
226 (void)seqNo;
227 }
228
GetSysCpuUsage(SeqNo seqNo,uint64_t microSeconds)229 void DistributedTestSysInfo::GetSysCpuUsage(SeqNo seqNo, uint64_t microSeconds)
230 {
231 (void)seqNo;
232 (void)microSeconds;
233 }
234
ReadSysValFromFile(const std::string & filePath)235 float DistributedTestSysInfo::ReadSysValFromFile(const std::string &filePath)
236 {
237 (void)filePath;
238 return 0.0f;
239 }
240
GetSysMeanCurrentVal(const std::string & filePath,int totalCount,uint64_t microSeconds)241 float DistributedTestSysInfo::GetSysMeanCurrentVal(
242 const std::string &filePath, int totalCount, uint64_t microSeconds)
243 {
244 (void)filePath;
245 (void)totalCount;
246 (void)microSeconds;
247 return 0.0f;
248 }
GetSysCurrentPower(SeqNo seqNo,int totalCount,uint64_t microSeconds)249 void DistributedTestSysInfo::GetSysCurrentPower(SeqNo seqNo, int totalCount, uint64_t microSeconds)
250 {
251 (void)seqNo;
252 (void)totalCount;
253 (void)microSeconds;
254 }
255
GetFirstMemFree() const256 uint64_t DistributedTestSysInfo::GetFirstMemFree() const
257 {
258 return 0;
259 }
260
GetSecondMemFree() const261 uint64_t DistributedTestSysInfo::GetSecondMemFree() const
262 {
263 return 0;
264 }
265 #endif
266
GetFirstCpuUsage() const267 float DistributedTestSysInfo::GetFirstCpuUsage() const
268 {
269 return cpuStatFirstUsage_;
270 }
271
GetSecondCpuUsage() const272 float DistributedTestSysInfo::GetSecondCpuUsage() const
273 {
274 return cpuStatSecondUsage_;
275 }
276
GetFirstPower() const277 float DistributedTestSysInfo::GetFirstPower() const
278 {
279 return powerStatFirst_;
280 }
281
GetSecondPower() const282 float DistributedTestSysInfo::GetSecondPower() const
283 {
284 return powerStatSecond_;
285 }
286
287 #if defined(RUNNING_ON_LINUX)
SaveSecondToFirst()288 void DistributedTestSysInfo::SaveSecondToFirst()
289 {
290 if ((memcpy_s(&memStatFirst_, sizeof(memStatFirst_), &memStatSecond_, sizeof(struct MemOccupy)) != EOK) &&
291 memcpy_s(&cpuStatFirst_, sizeof(cpuStatFirst_), &cpuStatSecond_, sizeof(struct CpuOccupy)) != EOK) {
292 MST_LOG("set mem or cpu state failed.");
293 }
294 cpuStatFirstUsage_ = cpuStatSecondUsage_;
295 powerStatFirst_ = powerStatSecond_;
296 }
297 #elif defined RUNNING_ON_WIN
SaveSecondToFirst()298 void DistributedTestSysInfo::SaveSecondToFirst()
299 {
300 }
301 #endif
302