1 /*
2 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
3 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this list of
9 * conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
12 * of conditions and the following disclaimer in the documentation and/or other materials
13 * provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
16 * to endorse or promote products derived from this software without specific prior written
17 * permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include "los_cpup_pri.h"
33 #include "los_base.h"
34 #include "los_init.h"
35 #include "los_process_pri.h"
36 #include "los_swtmr.h"
37
38
39 #ifdef LOSCFG_KERNEL_CPUP
40
41 LITE_OS_SEC_BSS STATIC UINT16 cpupSwtmrID;
42 LITE_OS_SEC_BSS STATIC UINT16 cpupInitFlg = 0;
43 LITE_OS_SEC_BSS OsIrqCpupCB *g_irqCpup = NULL;
44 LITE_OS_SEC_BSS STATIC UINT16 cpupMaxNum;
45 LITE_OS_SEC_BSS STATIC UINT16 cpupHisPos = 0; /* current Sampling point of historyTime */
46 LITE_OS_SEC_BSS STATIC UINT64 cpuHistoryTime[OS_CPUP_HISTORY_RECORD_NUM + 1];
47 LITE_OS_SEC_BSS STATIC UINT32 runningTasks[LOSCFG_KERNEL_CORE_NUM];
48 LITE_OS_SEC_BSS STATIC UINT64 cpupStartCycles = 0;
49 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
50 LITE_OS_SEC_BSS UINT64 timeInIrqSwitch[LOSCFG_KERNEL_CORE_NUM];
51 LITE_OS_SEC_BSS STATIC UINT64 cpupIntTimeStart[LOSCFG_KERNEL_CORE_NUM];
52 #endif
53
54 #define INVALID_ID ((UINT32)-1)
55
56 #define OS_CPUP_UNUSED 0x0U
57 #define OS_CPUP_USED 0x1U
58 #define HIGH_BITS 32
59
60 #define CPUP_PRE_POS(pos) (((pos) == 0) ? (OS_CPUP_HISTORY_RECORD_NUM - 1) : ((pos) - 1))
61 #define CPUP_POST_POS(pos) (((pos) == (OS_CPUP_HISTORY_RECORD_NUM - 1)) ? 0 : ((pos) + 1))
62
OsGetCpuCycle(VOID)63 STATIC UINT64 OsGetCpuCycle(VOID)
64 {
65 UINT32 high;
66 UINT32 low;
67 UINT64 cycles;
68
69 LOS_GetCpuCycle(&high, &low);
70 cycles = ((UINT64)high << HIGH_BITS) + low;
71 if (cpupStartCycles == 0) {
72 cpupStartCycles = cycles;
73 }
74
75 /*
76 * The cycles should keep growing, if the checking failed,
77 * it mean LOS_GetCpuCycle has the problem which should be fixed.
78 */
79 LOS_ASSERT(cycles >= cpupStartCycles);
80
81 return (cycles - cpupStartCycles);
82 }
83
OsCpupGuard(VOID)84 LITE_OS_SEC_TEXT_INIT VOID OsCpupGuard(VOID)
85 {
86 UINT16 prevPos;
87 UINT32 loop;
88 UINT32 runTaskID;
89 UINT32 intSave;
90 UINT64 cycle, cycleIncrement;
91 LosTaskCB *taskCB = NULL;
92 LosProcessCB *processCB = NULL;
93
94 SCHEDULER_LOCK(intSave);
95
96 cycle = OsGetCpuCycle();
97 prevPos = cpupHisPos;
98 cpupHisPos = CPUP_POST_POS(cpupHisPos);
99 cpuHistoryTime[prevPos] = cycle;
100
101 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
102 for (loop = 0; loop < cpupMaxNum; loop++) {
103 g_irqCpup[loop].cpup.historyTime[prevPos] = g_irqCpup[loop].cpup.allTime;
104 }
105 #endif
106
107 for (loop = 0; loop < g_processMaxNum; loop++) {
108 processCB = OS_PCB_FROM_PID(loop);
109 if (processCB->processCpup == NULL) {
110 continue;
111 }
112 processCB->processCpup->historyTime[prevPos] = processCB->processCpup->allTime;
113 }
114
115 for (loop = 0; loop < g_taskMaxNum; loop++) {
116 taskCB = OS_TCB_FROM_TID(loop);
117 taskCB->taskCpup.historyTime[prevPos] = taskCB->taskCpup.allTime;
118 }
119
120 for (loop = 0; loop < LOSCFG_KERNEL_CORE_NUM; loop++) {
121 runTaskID = runningTasks[loop];
122 if (runTaskID == INVALID_ID) {
123 continue;
124 }
125 taskCB = OS_TCB_FROM_TID(runTaskID);
126
127 /* reacquire the cycle to prevent flip */
128 cycle = OsGetCpuCycle();
129 cycleIncrement = cycle - taskCB->taskCpup.startTime;
130 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
131 cycleIncrement -= timeInIrqSwitch[loop];
132 #endif
133 taskCB->taskCpup.historyTime[prevPos] += cycleIncrement;
134 processCB = OS_PCB_FROM_PID(taskCB->processID);
135 processCB->processCpup->historyTime[prevPos] += cycleIncrement;
136 }
137
138 SCHEDULER_UNLOCK(intSave);
139 }
140
OsCpupGuardCreator(VOID)141 LITE_OS_SEC_TEXT_INIT UINT32 OsCpupGuardCreator(VOID)
142 {
143 (VOID)LOS_SwtmrCreate(LOSCFG_BASE_CORE_TICK_PER_SECOND, LOS_SWTMR_MODE_PERIOD,
144 (SWTMR_PROC_FUNC)OsCpupGuard, &cpupSwtmrID, 0);
145
146 (VOID)LOS_SwtmrStart(cpupSwtmrID);
147
148 return LOS_OK;
149 }
150
151 LOS_MODULE_INIT(OsCpupGuardCreator, LOS_INIT_LEVEL_KMOD_TASK);
152
153 /*
154 * Description: initialization of CPUP
155 * Return : LOS_OK or Error Information
156 */
OsCpupInit(VOID)157 LITE_OS_SEC_TEXT_INIT UINT32 OsCpupInit(VOID)
158 {
159 UINT16 loop;
160 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
161 UINT32 size;
162
163 cpupMaxNum = OS_HWI_MAX_NUM;
164
165 /* every process has only one record, and it won't operated at the same time */
166 size = cpupMaxNum * sizeof(OsIrqCpupCB);
167 g_irqCpup = (OsIrqCpupCB *)LOS_MemAlloc(m_aucSysMem0, size);
168 if (g_irqCpup == NULL) {
169 PRINT_ERR("OsCpupInit error\n");
170 return LOS_ERRNO_CPUP_NO_MEMORY;
171 }
172
173 (VOID)memset_s(g_irqCpup, size, 0, size);
174 #endif
175
176 for (loop = 0; loop < LOSCFG_KERNEL_CORE_NUM; loop++) {
177 runningTasks[loop] = INVALID_ID;
178 }
179 cpupInitFlg = 1;
180 return LOS_OK;
181 }
182
183 LOS_MODULE_INIT(OsCpupInit, LOS_INIT_LEVEL_KMOD_EXTENDED);
184
OsResetCpup(OsCpupBase * cpup,UINT64 cycle)185 STATIC VOID OsResetCpup(OsCpupBase *cpup, UINT64 cycle)
186 {
187 UINT16 loop;
188
189 cpup->startTime = cycle;
190 cpup->allTime = cycle;
191 for (loop = 0; loop < (OS_CPUP_HISTORY_RECORD_NUM + 1); loop++) {
192 cpup->historyTime[loop] = cycle;
193 }
194 }
195
LOS_CpupReset(VOID)196 LITE_OS_SEC_TEXT_INIT VOID LOS_CpupReset(VOID)
197 {
198 LosProcessCB *processCB = NULL;
199 LosTaskCB *taskCB = NULL;
200 UINT32 index;
201 UINT64 cycle;
202 UINT32 intSave;
203
204 cpupInitFlg = 0;
205 intSave = LOS_IntLock();
206 (VOID)LOS_SwtmrStop(cpupSwtmrID);
207 cycle = OsGetCpuCycle();
208
209 for (index = 0; index < (OS_CPUP_HISTORY_RECORD_NUM + 1); index++) {
210 cpuHistoryTime[index] = cycle;
211 }
212
213 for (index = 0; index < g_processMaxNum; index++) {
214 processCB = OS_PCB_FROM_PID(index);
215 if (processCB->processCpup == NULL) {
216 continue;
217 }
218 OsResetCpup(processCB->processCpup, cycle);
219 }
220
221 for (index = 0; index < g_taskMaxNum; index++) {
222 taskCB = OS_TCB_FROM_TID(index);
223 OsResetCpup(&taskCB->taskCpup, cycle);
224 }
225
226 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
227 if (g_irqCpup != NULL) {
228 for (index = 0; index < cpupMaxNum; index++) {
229 OsResetCpup(&g_irqCpup[index].cpup, cycle);
230 }
231
232 for (index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) {
233 timeInIrqSwitch[index] = 0;
234 }
235 }
236 #endif
237
238 (VOID)LOS_SwtmrStart(cpupSwtmrID);
239 LOS_IntRestore(intSave);
240 cpupInitFlg = 1;
241
242 return;
243 }
244
OsCpupCycleEndStart(UINT32 runTaskID,UINT32 newTaskID)245 VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID)
246 {
247 /* OsCurrTaskGet and OsCurrProcessGet are not allowed to be called. */
248 LosTaskCB *runTask = OS_TCB_FROM_TID(runTaskID);
249 OsCpupBase *runTaskCpup = &runTask->taskCpup;
250 OsCpupBase *newTaskCpup = (OsCpupBase *)&(OS_TCB_FROM_TID(newTaskID)->taskCpup);
251 OsCpupBase *processCpup = OS_PCB_FROM_PID(runTask->processID)->processCpup;
252 UINT64 cpuCycle, cycleIncrement;
253 UINT16 cpuID = ArchCurrCpuid();
254
255 if (cpupInitFlg == 0) {
256 return;
257 }
258
259 cpuCycle = OsGetCpuCycle();
260 if (runTaskCpup->startTime != 0) {
261 cycleIncrement = cpuCycle - runTaskCpup->startTime;
262 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
263 cycleIncrement -= timeInIrqSwitch[cpuID];
264 timeInIrqSwitch[cpuID] = 0;
265 #endif
266 runTaskCpup->allTime += cycleIncrement;
267 if (processCpup != NULL) {
268 processCpup->allTime += cycleIncrement;
269 }
270 runTaskCpup->startTime = 0;
271 }
272
273 newTaskCpup->startTime = cpuCycle;
274 runningTasks[cpuID] = newTaskID;
275 }
276
OsCpupGetPos(UINT16 mode,UINT16 * curPosPointer,UINT16 * prePosPointer)277 LITE_OS_SEC_TEXT_MINOR STATIC VOID OsCpupGetPos(UINT16 mode, UINT16 *curPosPointer, UINT16 *prePosPointer)
278 {
279 UINT16 curPos;
280 UINT16 tmpPos;
281 UINT16 prePos;
282
283 tmpPos = cpupHisPos;
284 curPos = CPUP_PRE_POS(tmpPos);
285
286 /*
287 * The current position has nothing to do with the CPUP modes,
288 * however, the previous position differs.
289 */
290 switch (mode) {
291 case CPUP_LAST_ONE_SECONDS:
292 prePos = CPUP_PRE_POS(curPos);
293 break;
294 case CPUP_LAST_TEN_SECONDS:
295 prePos = tmpPos;
296 break;
297 case CPUP_ALL_TIME:
298 /* fall-through */
299 default:
300 prePos = OS_CPUP_HISTORY_RECORD_NUM;
301 break;
302 }
303
304 *curPosPointer = curPos;
305 *prePosPointer = prePos;
306
307 return;
308 }
309
OsCalculateCpupUsage(const OsCpupBase * cpup,UINT16 pos,UINT16 prePos,UINT64 allCycle)310 STATIC INLINE UINT32 OsCalculateCpupUsage(const OsCpupBase *cpup, UINT16 pos, UINT16 prePos, UINT64 allCycle)
311 {
312 UINT32 usage = 0;
313 UINT64 cpuCycle = cpup->historyTime[pos] - cpup->historyTime[prePos];
314
315 if (allCycle) {
316 usage = (UINT32)((LOS_CPUP_SINGLE_CORE_PRECISION * cpuCycle) / allCycle);
317 }
318 return usage;
319 }
320
OsHistorySysCpuUsageUnsafe(UINT16 mode)321 STATIC UINT32 OsHistorySysCpuUsageUnsafe(UINT16 mode)
322 {
323 UINT64 cpuAllCycle;
324 UINT16 pos;
325 UINT16 prePos;
326 UINT32 idleProcessID;
327 OsCpupBase *processCpup = NULL;
328
329 if (cpupInitFlg == 0) {
330 return LOS_ERRNO_CPUP_NO_INIT;
331 }
332
333 OsCpupGetPos(mode, &pos, &prePos);
334 cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
335
336 idleProcessID = OsGetIdleProcessID();
337 processCpup = OS_PCB_FROM_PID(idleProcessID)->processCpup;
338 return (LOS_CPUP_PRECISION - OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle));
339 }
340
LOS_HistorySysCpuUsage(UINT16 mode)341 LITE_OS_SEC_TEXT_MINOR UINT32 LOS_HistorySysCpuUsage(UINT16 mode)
342 {
343 UINT32 cpup;
344 UINT32 intSave;
345
346 /* get end time of current process */
347 SCHEDULER_LOCK(intSave);
348 cpup = OsHistorySysCpuUsageUnsafe(mode);
349 SCHEDULER_UNLOCK(intSave);
350 return cpup;
351 }
352
OsHistoryProcessCpuUsageUnsafe(UINT32 pid,UINT16 mode)353 STATIC UINT32 OsHistoryProcessCpuUsageUnsafe(UINT32 pid, UINT16 mode)
354 {
355 LosProcessCB *processCB = NULL;
356 UINT64 cpuAllCycle;
357 UINT16 pos, prePos;
358
359 if (cpupInitFlg == 0) {
360 return LOS_ERRNO_CPUP_NO_INIT;
361 }
362
363 if (OS_PID_CHECK_INVALID(pid)) {
364 return LOS_ERRNO_CPUP_ID_INVALID;
365 }
366
367 processCB = OS_PCB_FROM_PID(pid);
368 if (OsProcessIsUnused(processCB)) {
369 return LOS_ERRNO_CPUP_NO_CREATED;
370 }
371
372 if (processCB->processCpup == NULL) {
373 return LOS_ERRNO_CPUP_ID_INVALID;
374 }
375
376 OsCpupGetPos(mode, &pos, &prePos);
377 cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
378
379 return OsCalculateCpupUsage(processCB->processCpup, pos, prePos, cpuAllCycle);
380 }
381
LOS_HistoryProcessCpuUsage(UINT32 pid,UINT16 mode)382 LITE_OS_SEC_TEXT_MINOR UINT32 LOS_HistoryProcessCpuUsage(UINT32 pid, UINT16 mode)
383 {
384 UINT32 cpup;
385 UINT32 intSave;
386
387 SCHEDULER_LOCK(intSave);
388 cpup = OsHistoryProcessCpuUsageUnsafe(pid, mode);
389 SCHEDULER_UNLOCK(intSave);
390 return cpup;
391 }
392
OsHistoryTaskCpuUsageUnsafe(UINT32 tid,UINT16 mode)393 STATIC UINT32 OsHistoryTaskCpuUsageUnsafe(UINT32 tid, UINT16 mode)
394 {
395 LosTaskCB *taskCB = NULL;
396 UINT64 cpuAllCycle;
397 UINT16 pos, prePos;
398
399 if (cpupInitFlg == 0) {
400 return LOS_ERRNO_CPUP_NO_INIT;
401 }
402
403 if (OS_TID_CHECK_INVALID(tid)) {
404 return LOS_ERRNO_CPUP_ID_INVALID;
405 }
406
407 taskCB = OS_TCB_FROM_TID(tid);
408 if (OsTaskIsUnused(taskCB)) {
409 return LOS_ERRNO_CPUP_NO_CREATED;
410 }
411
412 OsCpupGetPos(mode, &pos, &prePos);
413 cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
414
415 return OsCalculateCpupUsage(&taskCB->taskCpup, pos, prePos, cpuAllCycle);
416 }
417
LOS_HistoryTaskCpuUsage(UINT32 tid,UINT16 mode)418 LITE_OS_SEC_TEXT_MINOR UINT32 LOS_HistoryTaskCpuUsage(UINT32 tid, UINT16 mode)
419 {
420 UINT32 intSave;
421 UINT32 cpup;
422
423 SCHEDULER_LOCK(intSave);
424 cpup = OsHistoryTaskCpuUsageUnsafe(tid, mode);
425 SCHEDULER_UNLOCK(intSave);
426 return cpup;
427 }
428
OsCpupUsageParamCheckAndReset(CPUP_INFO_S * cpupInfo,UINT32 len,UINT32 number)429 STATIC UINT32 OsCpupUsageParamCheckAndReset(CPUP_INFO_S *cpupInfo, UINT32 len, UINT32 number)
430 {
431 if (cpupInitFlg == 0) {
432 return LOS_ERRNO_CPUP_NO_INIT;
433 }
434
435 if ((cpupInfo == NULL) || (len < (sizeof(CPUP_INFO_S) * number))) {
436 return LOS_ERRNO_CPUP_PTR_ERR;
437 }
438
439 (VOID)memset_s(cpupInfo, len, 0, len);
440 return LOS_OK;
441 }
442
OsGetAllProcessCpuUsageUnsafe(UINT16 mode,CPUP_INFO_S * cpupInfo,UINT32 len)443 LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
444 {
445 LosProcessCB *processCB = NULL;
446 UINT64 cpuAllCycle;
447 UINT16 pos, prePos;
448 UINT32 processID;
449 UINT32 ret;
450
451 ret = OsCpupUsageParamCheckAndReset(cpupInfo, len, g_processMaxNum);
452 if (ret != LOS_OK) {
453 return ret;
454 }
455
456 OsCpupGetPos(mode, &pos, &prePos);
457 cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
458
459 for (processID = 0; processID < g_processMaxNum; processID++) {
460 processCB = OS_PCB_FROM_PID(processID);
461 if (OsProcessIsUnused(processCB) || (processCB->processCpup == NULL)) {
462 continue;
463 }
464
465 cpupInfo[processID].usage = OsCalculateCpupUsage(processCB->processCpup, pos, prePos, cpuAllCycle);
466 cpupInfo[processID].status = OS_CPUP_USED;
467 }
468
469 return LOS_OK;
470 }
471
LOS_GetAllProcessCpuUsage(UINT16 mode,CPUP_INFO_S * cpupInfo,UINT32 len)472 LITE_OS_SEC_TEXT_MINOR UINT32 LOS_GetAllProcessCpuUsage(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
473 {
474 UINT32 intSave;
475 UINT32 ret;
476
477 SCHEDULER_LOCK(intSave);
478 ret = OsGetAllProcessCpuUsageUnsafe(mode, cpupInfo, len);
479 SCHEDULER_UNLOCK(intSave);
480 return ret;
481 }
482
OsGetAllProcessAndTaskCpuUsageUnsafe(UINT16 mode,CPUP_INFO_S * cpupInfo,UINT32 len)483 LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessAndTaskCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
484 {
485 UINT64 cpuAllCycle;
486 UINT16 pos, prePos;
487 UINT32 taskID;
488 UINT32 ret;
489 LosTaskCB *taskCB = NULL;
490 OsCpupBase *processCpupBase = NULL;
491 CPUP_INFO_S *processCpup = cpupInfo;
492 CPUP_INFO_S *taskCpup = (CPUP_INFO_S *)((UINTPTR)cpupInfo + sizeof(CPUP_INFO_S) * g_processMaxNum);
493
494 ret = OsCpupUsageParamCheckAndReset(cpupInfo, len, g_taskMaxNum + g_processMaxNum);
495 if (ret != LOS_OK) {
496 return ret;
497 }
498
499 OsCpupGetPos(mode, &pos, &prePos);
500 cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
501
502 for (taskID = 0; taskID < g_taskMaxNum; taskID++) {
503 taskCB = OS_TCB_FROM_TID(taskID);
504 if (OsTaskIsUnused(taskCB)) {
505 continue;
506 }
507
508 taskCpup[taskID].usage = OsCalculateCpupUsage(&taskCB->taskCpup, pos, prePos, cpuAllCycle);
509 taskCpup[taskID].status = OS_CPUP_USED;
510 if (processCpup[taskCB->processID].status == OS_CPUP_UNUSED) {
511 processCpupBase = OS_PCB_FROM_PID(taskCB->processID)->processCpup;
512 if (processCpupBase != NULL) {
513 processCpup[taskCB->processID].usage = OsCalculateCpupUsage(processCpupBase, pos, prePos, cpuAllCycle);
514 processCpup[taskCB->processID].status = OS_CPUP_USED;
515 }
516 }
517 }
518
519 return LOS_OK;
520 }
521
522 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
OsCpupIrqStart(VOID)523 LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqStart(VOID)
524 {
525 UINT32 high;
526 UINT32 low;
527
528 LOS_GetCpuCycle(&high, &low);
529 cpupIntTimeStart[ArchCurrCpuid()] = ((UINT64)high << HIGH_BITS) + low;
530 return;
531 }
532
OsCpupIrqEnd(UINT32 intNum)533 LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqEnd(UINT32 intNum)
534 {
535 UINT32 high;
536 UINT32 low;
537 UINT64 intTimeEnd;
538 UINT32 cpuID = ArchCurrCpuid();
539
540 LOS_GetCpuCycle(&high, &low);
541 intTimeEnd = ((UINT64)high << HIGH_BITS) + low;
542
543 g_irqCpup[intNum].id = intNum;
544 g_irqCpup[intNum].status = OS_CPUP_USED;
545 timeInIrqSwitch[cpuID] += (intTimeEnd - cpupIntTimeStart[cpuID]);
546 g_irqCpup[intNum].cpup.allTime += (intTimeEnd - cpupIntTimeStart[cpuID]);
547
548 return;
549 }
550
OsGetIrqCpupArrayBase(VOID)551 LITE_OS_SEC_TEXT_MINOR OsIrqCpupCB *OsGetIrqCpupArrayBase(VOID)
552 {
553 return g_irqCpup;
554 }
555
OsGetAllIrqCpuUsageUnsafe(UINT16 mode,CPUP_INFO_S * cpupInfo,UINT32 len)556 LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllIrqCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
557 {
558 UINT16 pos, prePos;
559 UINT64 cpuAllCycle;
560 UINT32 loop;
561 UINT32 ret;
562
563 ret = OsCpupUsageParamCheckAndReset(cpupInfo, len, cpupMaxNum);
564 if (ret != LOS_OK) {
565 return ret;
566 }
567
568 OsCpupGetPos(mode, &pos, &prePos);
569 cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
570
571 for (loop = 0; loop < cpupMaxNum; loop++) {
572 if (g_irqCpup[loop].status == OS_CPUP_UNUSED) {
573 continue;
574 }
575
576 cpupInfo[loop].usage = OsCalculateCpupUsage(&g_irqCpup[loop].cpup, pos, prePos, cpuAllCycle);
577 cpupInfo[loop].status = g_irqCpup[loop].status;
578 }
579
580 return LOS_OK;
581 }
582
LOS_GetAllIrqCpuUsage(UINT16 mode,CPUP_INFO_S * cpupInfo,UINT32 len)583 LITE_OS_SEC_TEXT_MINOR UINT32 LOS_GetAllIrqCpuUsage(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
584 {
585 UINT32 intSave;
586 UINT32 ret;
587
588 SCHEDULER_LOCK(intSave);
589 ret = OsGetAllIrqCpuUsageUnsafe(mode, cpupInfo, len);
590 SCHEDULER_UNLOCK(intSave);
591 return ret;
592 }
593 #endif
594
595 #endif /* LOSCFG_KERNEL_CPUP */
596