成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

鴻蒙輕內核M核源碼分析系列十五CPU使用率CPUP

作者：zhushangyuan
開發 前端
CPUP(Central Processing Unit Percentage，CPU占用率)分為系統CPU占用率和任務CPU占用率。用戶通過系統級的CPU占用率，判斷當前系統負載是否超出設計規格。

[[409327]]

想了解更多內容，請訪問：

51CTO和華為官方合作共建的鴻蒙技術社區

https://harmonyos.51cto.com

CPUP(Central Processing Unit Percentage，CPU占用率)分為系統CPU占用率和任務CPU占用率。用戶通過系統級的CPU占用率，判斷當前系統負載是否超出設計規格。通過系統中各個任務的CPU占用情況，判斷各個任務的CPU占用率是否符合設計的預期。

系統CPU占用率是指周期時間內系統的CPU占用率，用于表示系統一段時間內的閑忙程度，也表示CPU的負載情況。系統CPU占用率的有效表示范圍為0～100，其精度(可通過配置調整)為百分比。100表示系統滿負荷運轉。

任務CPU占用率指單個任務的CPU占用率，用于表示單個任務在一段時間內的閑忙程度。任務CPU占用率的有效表示范圍為0～100，其精度(可通過配置調整)為百分比。100表示在一段時間內系統一直在運行該任務。

本文通過分析鴻蒙輕內核CPUP擴展模塊的源碼。

CPUP模塊用任務級記錄的方式，在任務切換時，記錄任務啟動時間，任務切出或者退出時間，每次當任務退出時，系統會累加整個任務的占用時間。接下來，我們看下CPUP模塊支持的常見操作的源代碼。

1、CPUP結構體定義和常用宏定義

1.1 CPUP結構體定義

在文件components\cpup\los_cpup.h定義的CPUP控制塊結構體為OsCpupCB，結構體源代碼如下，allTime記錄該任務自系統啟動以來運行的cycle數，startTime記錄任務開始運行的時間，historyTime[]歷史運行時間數組的10個元素記錄最近10秒中每一秒中每個任務自系統啟動以來運行的cycle數，其他結構體成員的解釋見注釋部分。

  1. typedef struct { 
  2.     UINT32 cpupID;                                        /**< 任務編號 */ 
  3.     UINT16 status;                                        /**< 任務狀態 */ 
  4.     UINT64 allTime;                                       /**< 總共運行的時間 */ 
  5.     UINT64 startTime;                                     /**< 任務開始時間 */ 
  6.     UINT64 historyTime[OS_CPUP_HISTORY_RECORD_NUM];       /**< 歷史運行時間數組，其中OS_CPUP_HISTORY_RECORD_NUM為10 */ 
  7. } OsCpupCB; 

另外，還定義了一個結構體CPUP_INFO_S，如下：

  1. typedef struct tagCpupInfo { 
  2.     UINT16 usStatus;            /**< 保存當前運行任務狀態           */ 
  3.     UINT32 uwUsage;             /**< 使用情況，值范圍為 [0,1000].   */ 
  4. } CPUP_INFO_S; 

1.2 CPUP枚舉定義

CPUP頭文件components\cpup\los_cpup.h中還提供了相關的枚舉，CPUP占用率類型CPUP_TYPE_E，及CPUP統計時間間隔模式CPUP_MODE_E。

  1. typedef enum { 
  2.     SYS_CPU_USAGE = 0,   /* 系統CPUP */ 
  3.     TASK_CPU_USAGE,      /* 任務CPUP */ 
  4. } CPUP_TYPE_E; 
  5.  
  6. typedef enum { 
  7.     CPUP_IN_10S = 0,     /* CPUP統計周期10s */ 
  8.     CPUP_IN_1S,          /* CPUP統計周期1s */ 
  9.     CPUP_LESS_THAN_1S,   /* CPUP統計周期<1s */ 
  10. } CPUP_MODE_E; 

2、CPUP初始化

CPUP默認關閉，用戶可以通過宏LOSCFG_BASE_CORE_CPUP進行開啟。開啟CPUP的情況下，在系統啟動時，在kernel\src\los_init.c中調用OsCpupInit()進行CPUP模塊初始化。下面，我們分析下CPUP初始化的代碼。

⑴處計算CPUP結構體池需要的內存大小，然后為CPUP申請內存，如果申請失敗，則返回錯誤。⑵處初始化成功后，設置初始化標記g_cpupInitFlg。

  1. LITE_OS_SEC_TEXT_INIT UINT32 OsCpupInit() 
  2. { 
  3.     UINT32 size; 
  4.  
  5.     size = g_taskMaxNum * sizeof(OsCpupCB); 
  6. ⑴  g_cpup = (OsCpupCB *)LOS_MemAlloc(m_aucSysMem0, size); 
  7.  
  8.     if (g_cpup == NULL) { 
  9.         return LOS_ERRNO_CPUP_NO_MEMORY; 
  10.     } 
  11.  
  12.     (VOID)memset_s(g_cpup, size, 0, size); 
  13. ⑵  g_cpupInitFlg = 1; 
  14.  
  15.     return LOS_OK; 
  16. } 

3、CPUP常用操作

3.1 CPUP內部接口

我們先分析下內部接口，這些接口會被LOS_開頭的外部接口調用。

3.1.1 OsTskCycleStart記錄任務開始時間

CPUP模塊對外接口執行后期會調用該內部接口，設置下一個任務的開始運行時間。

⑴處先判斷CPUP是否已經初始化，如果沒有初始化過，退出該函數的執行。⑵處獲取新任務的任務編號。⑶處設置該任務對應的CPUP結構體的任務編號和開始時間。

  1. LITE_OS_SEC_TEXT_MINOR VOID OsTskCycleStart(VOID) 
  2. { 
  3.     UINT32 taskID; 
  4.  
  5. ⑴  if (g_cpupInitFlg == 0) { 
  6.         return; 
  7.     } 
  8.  
  9. ⑵  taskID = g_losTask.newTask->taskID; 
  10. ⑶  g_cpup[taskID].cpupID = taskID; 
  11.     g_cpup[taskID].startTime = LOS_SysCycleGet(); 
  12.  
  13.     return; 
  14. } 

3.1.2 OsTskCycleEnd記錄任務結束時間

CPUP模塊對外接口執行前期會調用該內部接口，獲取當前任務的結束時間，并統計當前任務的運行總時間。

⑴處先判斷CPUP是否已經初始化，如果沒有初始化過，退出該函數的執行。⑵處獲取當前任務的任務編號。⑶處如果該任務的開始時間為0，退出函數執行。⑷處獲取系統的當前cycle數。⑸如果獲取的小于任務CPUP開始時間，則把獲取的cycle數加上每個tick的cycle數。⑹處計算當前任務的運行的總時間，然后把開始時間置0。

  1. LITE_OS_SEC_TEXT_MINOR VOID OsTskCycleEnd(VOID) 
  2. { 
  3.     UINT32 taskID; 
  4.     UINT64 cpuCycle; 
  5.  
  6. ⑴  if (g_cpupInitFlg == 0) { 
  7.         return; 
  8.     } 
  9.  
  10. ⑵  taskID = g_losTask.runTask->taskID; 
  11.  
  12. ⑶  if (g_cpup[taskID].startTime == 0) { 
  13.         return; 
  14.     } 
  15.  
  16. ⑷  cpuCycle = LOS_SysCycleGet(); 
  17.  
  18. ⑸  if (cpuCycle < g_cpup[taskID].startTime) { 
  19.         cpuCycle += g_cyclesPerTick; 
  20.     } 
  21.  
  22. ⑹  g_cpup[taskID].allTime += (cpuCycle - g_cpup[taskID].startTime); 
  23.     g_cpup[taskID].startTime = 0; 
  24.  
  25.     return; 
  26. } 

3.1.3 OsTskCycleEndStart任務切換時更新任務歷史運行時間

該函數在任務調度切換時會被執行，計算當前運行任務的運行總時間，記錄新任務的開始時間，并更新所有任務的歷史運行時間。函數的示意圖如下：

鴻蒙輕內核M核源碼分析系列十五 CPU使用率CPUP-鴻蒙HarmonyOS技術社區

⑴處先判斷CPUP是否已經初始化，如果沒有初始化過，退出該函數的執行。

⑵處獲取當前任務的任務編號，然后獲取系統的當前cycle數。

⑶處如果當前任務的開始時間不為0，則計算當前任務的運行的總時間，然后把開始時間置0。

⑷處獲取新任務的任務編號。

⑸處設置該任務對應的CPUP結構體的任務編號和開始時間。

⑹處如果記錄間隔大于系統時鐘(即每秒的cycle數)，更新上次記錄時間。這意味著每個任務的historyTime[]數組中的每個元素表示1s多的周期內該任務的運行cycle數量，并不是非常精確的。然后執行⑺，記錄每一個任務對應的CPUP的歷史運行時間。⑻處更新歷史運行時間數組的當前索引值。

  1. LITE_OS_SEC_TEXT_MINOR VOID OsTskCycleEndStart(VOID) 
  2. { 
  3.     UINT32 taskID; 
  4.     UINT64 cpuCycle; 
  5.     UINT16 loopNum; 
  6.  
  7. ⑴  if (g_cpupInitFlg == 0) { 
  8.         return; 
  9.     } 
  10.  
  11. ⑵  taskID = g_losTask.runTask->taskID; 
  12.     cpuCycle = LOS_SysCycleGet(); 
  13.  
  14. ⑶  if (g_cpup[taskID].startTime != 0) { 
  15.         if (cpuCycle < g_cpup[taskID].startTime) { 
  16.             cpuCycle += g_cyclesPerTick; 
  17.         } 
  18.  
  19.         g_cpup[taskID].allTime += (cpuCycle - g_cpup[taskID].startTime); 
  20.         g_cpup[taskID].startTime = 0; 
  21.     } 
  22.  
  23. ⑷  taskID = g_losTask.newTask->taskID; 
  24. ⑸  g_cpup[taskID].cpupID = taskID; 
  25.     g_cpup[taskID].startTime = cpuCycle; 
  26.  
  27. ⑹  if ((cpuCycle - g_lastRecordTime) > OS_CPUP_RECORD_PERIOD) { 
  28.         g_lastRecordTime = cpuCycle; 
  29.  
  30.         for (loopNum = 0; loopNum < g_taskMaxNum; loopNum++) { 
  31. ⑺          g_cpup[loopNum].historyTime[g_hisPos] = g_cpup[loopNum].allTime; 
  32.         } 
  33.  
  34. ⑻      if (g_hisPos == (OS_CPUP_HISTORY_RECORD_NUM - 1)) { 
  35.             g_hisPos = 0; 
  36.         } else { 
  37.             g_hisPos++; 
  38.         } 
  39.     } 
  40.  
  41.     return; 
  42. } 

3.1.4 OsGetPrePos獲取歷史運行時間數組上一索引位置

代碼比較簡單，如果傳入參數curPos為0，則返回數組的最后一個索引位置OS_CPUP_HISTORY_RECORD_NUM - 1。否則返回減1返回。

  1. LITE_OS_SEC_TEXT_MINOR static inline UINT16 OsGetPrePos(UINT16 curPos) 
  2. { 
  3.     return (curPos == 0) ? (OS_CPUP_HISTORY_RECORD_NUM - 1) : (curPos - 1); 
  4. } 

3.1.5 OsGetPositions獲取歷史運行時間數組的當前及上一索引位置

根據CPUP統計時間間隔模式，獲取歷史運行時間數組的當前及上一索引位置。

⑴處獲取歷史運行時間數組的當前索引位置，⑵如果時間間隔模式為1秒，當前索引curPos位置為g_hisPos的上一索引位置，上一索引位置prePos需要繼續上前一位。⑶如果時間間隔模式小于1秒，當前索引curPos位置為g_hisPos的上一索引位置，上一索引位置prePos為0。如果時間間隔模式是10秒，當前索引curPos位置就等于g_hisPos，上一索引位置prePos為0。⑷處設置傳出參數。

  1. LITE_OS_SEC_TEXT_MINOR static VOID OsGetPositions(UINT16 mode, UINT16* curPosAddr, UINT16* prePosAddr) 
  2. { 
  3.     UINT16 curPos; 
  4.     UINT16 prePos = 0; 
  5.  
  6. ⑴  curPos = g_hisPos; 
  7.  
  8. ⑵  if (mode == CPUP_IN_1S) { 
  9.         curPos = OsGetPrePos(curPos); 
  10.         prePos = OsGetPrePos(curPos); 
  11. ⑶  } else if (mode == CPUP_LESS_THAN_1S) { 
  12.         curPos = OsGetPrePos(curPos); 
  13.     } 
  14.  
  15. ⑷  *curPosAddr = curPos; 
  16.     *prePosAddr = prePos; 
  17. } 

3.2 CPUP對外接口

我們先分析下外部接口，接口說明如下:

3.2.1 LOS_SysCpuUsage

該函數會統計當前系統CPU占用率，返回值基于千分率計算，取值范圍為[0,1000]。函數的示意圖如下：

鴻蒙輕內核M核源碼分析系列十五 CPU使用率CPUP-鴻蒙HarmonyOS技術社區

⑴處先判斷CPUP是否已經初始化，如果沒有初始化過，返回錯誤碼。

⑵處調用函數OsTskCycleEnd()獲取當前任務的結束時間，并計算出運行總時間。

⑶處統計所有任務的運行總時間，如果總時間不為0，執行⑷計算出系統的任務CPU占用率。

⑸處調用函數OsTskCycleStart()設置新任務的CPUP統計的開始時間。

  1. LITE_OS_SEC_TEXT_MINOR UINT32 LOS_SysCpuUsage(VOID) 
  2. { 
  3.     UINT64  cpuCycleAll = 0; 
  4.     UINT32  cpupRet = 0; 
  5.     UINT16  loopNum; 
  6.     UINT32 intSave; 
  7.  
  8. ⑴  if (g_cpupInitFlg == 0) { 
  9.         return LOS_ERRNO_CPUP_NO_INIT; 
  10.     } 
  11.  
  12.     intSave = LOS_IntLock(); 
  13. ⑵  OsTskCycleEnd(); 
  14.  
  15. ⑶  for (loopNum = 0; loopNum < g_taskMaxNum; loopNum++) { 
  16.         cpuCycleAll += g_cpup[loopNum].allTime; 
  17.     } 
  18.  
  19. ⑷  if (cpuCycleAll) { 
  20.         cpupRet = LOS_CPUP_PRECISION -  (UINT32)((LOS_CPUP_PRECISION * 
  21.             g_cpup[g_idleTaskID].allTime) / cpuCycleAll); 
  22.     } 
  23.  
  24. ⑸  OsTskCycleStart(); 
  25.     LOS_IntRestore(intSave); 
  26.  
  27.     return cpupRet; 
  28. } 

3.2.2 LOS_HistorySysCpuUsage

該函數獲取系統歷史CPU占用率，對于歷史CPU占用率，需要傳入時間間隔模式參數，支持10秒、1秒、小于1秒三種。

⑴處先判斷CPUP是否已經初始化，如果沒有初始化過，返回錯誤碼。⑵處調用函數OsTskCycleEnd()獲取當前任務的結束時間，并計算出運行總時間。⑶處調用函數OsGetPositions()計算出歷史運行時間數組索引位置。⑷處計算出各個任務的周期內運行總時間，如果時間間隔模式為1秒，取值兩個歷史運行時間之差，即為1秒內任務的運行時間數。對于時間間隔模式為10秒，historyTime[curPos]表示10秒前的自系統啟動以來的任務運行的時間數，計算出來的差值即為10秒內任務的運行時間數。對于時間間隔模式為小于1秒，historyTime[curPos]表示上一秒前的自系統啟動以來的任務運行的時間數，計算出來的差值即為小于1秒內任務的運行時間數。⑸處計算空閑任務周期內運行總時間。⑹處如果總時間不為0，計算出系統的任務歷史CPU占用率。最后，調用函數OsTskCycleStart()設置新任務的CPUP統計的開始時間。可以參考示意圖進行理解：

鴻蒙輕內核M核源碼分析系列十五 CPU使用率CPUP-鴻蒙HarmonyOS技術社區
  1. LITE_OS_SEC_TEXT_MINOR UINT32 LOS_HistorySysCpuUsage(UINT16 mode) 
  2. { 
  3.     UINT64  cpuCycleAll = 0; 
  4.     UINT64  idleCycleAll = 0; 
  5.     UINT32  cpupRet = 0; 
  6.     UINT16  loopNum; 
  7.     UINT16  curPos; 
  8.     UINT16  prePos = 0; 
  9.     UINT32 intSave; 
  10.  
  11. ⑴  if (g_cpupInitFlg == 0) { 
  12.         return LOS_ERRNO_CPUP_NO_INIT; 
  13.     } 
  14.  
  15.     // get end time of current task 
  16.     intSave = LOS_IntLock(); 
  17. ⑵  OsTskCycleEnd(); 
  18.  
  19. ⑶  OsGetPositions(mode, &curPos, &prePos); 
  20.  
  21.     for (loopNum = 0; loopNum < g_taskMaxNum; loopNum++) { 
  22. ⑷      if (mode == CPUP_IN_1S) { 
  23.             cpuCycleAll += g_cpup[loopNum].historyTime[curPos] - g_cpup[loopNum].historyTime[prePos]; 
  24.         } else { 
  25.             cpuCycleAll += g_cpup[loopNum].allTime - g_cpup[loopNum].historyTime[curPos]; 
  26.         } 
  27.     } 
  28.  
  29. ⑸  if (mode == CPUP_IN_1S) { 
  30.         idleCycleAll += g_cpup[g_idleTaskID].historyTime[curPos] - 
  31.                            g_cpup[g_idleTaskID].historyTime[prePos]; 
  32.     } else { 
  33.         idleCycleAll += g_cpup[g_idleTaskID].allTime - g_cpup[g_idleTaskID].historyTime[curPos]; 
  34.     } 
  35.  
  36. ⑹  if (cpuCycleAll) { 
  37.         cpupRet = (LOS_CPUP_PRECISION -  (UINT32)((LOS_CPUP_PRECISION * idleCycleAll) / cpuCycleAll)); 
  38.     } 
  39.  
  40.     OsTskCycleStart(); 
  41.     LOS_IntRestore(intSave); 
  42.  
  43.     return cpupRet; 
  44. } 

3.2.3 LOS_TaskCpuUsage

該函數會統計指定任務的CPU占用率，和函數LOS_SysCpuUsage()代碼相似度高，可以參考上文對該函數的講解。

  1. LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskCpuUsage(UINT32 taskID) 
  2. { 
  3.     UINT64  cpuCycleAll = 0; 
  4.     UINT16  loopNum; 
  5.     UINT32 intSave; 
  6.     UINT32  cpupRet = 0; 
  7.  
  8.     if (g_cpupInitFlg == 0) { 
  9.         return LOS_ERRNO_CPUP_NO_INIT; 
  10.     } 
  11.     if (OS_TSK_GET_INDEX(taskID) >= g_taskMaxNum) { 
  12.         return LOS_ERRNO_CPUP_TSK_ID_INVALID; 
  13.     } 
  14.     if (g_cpup[taskID].cpupID != taskID) { 
  15.         return LOS_ERRNO_CPUP_THREAD_NO_CREATED; 
  16.     } 
  17.     if ((g_cpup[taskID].status & OS_TASK_STATUS_UNUSED) || (g_cpup[taskID].status == 0)) { 
  18.         return LOS_ERRNO_CPUP_THREAD_NO_CREATED; 
  19.     } 
  20.     intSave = LOS_IntLock(); 
  21.     OsTskCycleEnd(); 
  22.  
  23.     for (loopNum = 0; loopNum < g_taskMaxNum; loopNum++) { 
  24.         if ((g_cpup[loopNum].status & OS_TASK_STATUS_UNUSED) || (g_cpup[loopNum].status == 0)) { 
  25.             continue; 
  26.         } 
  27.         cpuCycleAll += g_cpup[loopNum].allTime; 
  28.     } 
  29.  
  30.     if (cpuCycleAll) { 
  31.         cpupRet = (UINT32)((LOS_CPUP_PRECISION * g_cpup[taskID].allTime) / cpuCycleAll); 
  32.     } 
  33.  
  34.     OsTskCycleStart(); 
  35.     LOS_IntRestore(intSave); 
  36.  
  37.     return cpupRet; 
  38. } 

3.2.4 LOS_HistoryTaskCpuUsage

該函數獲取指定任務的歷史CPU占用率，和函數LOS_HistorySysCpuUsage()代碼相似度高，可以參考上文對該函數的講解。

  1. LITE_OS_SEC_TEXT_MINOR UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskID, UINT16 mode) 
  2. { 
  3.     UINT64  cpuCycleAll = 0; 
  4.     UINT64  cpuCycleCurTsk = 0; 
  5.     UINT16  loopNum, curPos; 
  6.     UINT16  prePos = 0; 
  7.     UINT32 intSave; 
  8.     UINT32  cpupRet = 0; 
  9.  
  10.    if (g_cpupInitFlg == 0) { 
  11.         return LOS_ERRNO_CPUP_NO_INIT; 
  12.     } 
  13.     if (OS_TSK_GET_INDEX(taskID) >= g_taskMaxNum) { 
  14.         return LOS_ERRNO_CPUP_TSK_ID_INVALID; 
  15.     } 
  16.     if (g_cpup[taskID].cpupID != taskID) { 
  17.         return LOS_ERRNO_CPUP_THREAD_NO_CREATED; 
  18.     } 
  19.     if ((g_cpup[taskID].status & OS_TASK_STATUS_UNUSED) || (g_cpup[taskID].status == 0)) { 
  20.         return LOS_ERRNO_CPUP_THREAD_NO_CREATED; 
  21.     } 
  22.     intSave = LOS_IntLock(); 
  23.     OsTskCycleEnd(); 
  24.  
  25.     OsGetPositions(mode, &curPos, &prePos); 
  26.  
  27.     for (loopNum = 0; loopNum < g_taskMaxNum; loopNum++) { 
  28.         if ((g_cpup[loopNum].status & OS_TASK_STATUS_UNUSED) || (g_cpup[loopNum].status == 0)) { 
  29.             continue; 
  30.         } 
  31.  
  32.         if (mode == CPUP_IN_1S) { 
  33.             cpuCycleAll += g_cpup[loopNum].historyTime[curPos] - g_cpup[loopNum].historyTime[prePos]; 
  34.         } else { 
  35.             cpuCycleAll += g_cpup[loopNum].allTime - g_cpup[loopNum].historyTime[curPos]; 
  36.         } 
  37.     } 
  38.  
  39.     if (mode == CPUP_IN_1S) { 
  40.         cpuCycleCurTsk += g_cpup[taskID].historyTime[curPos] - g_cpup[taskID].historyTime[prePos]; 
  41.     } else { 
  42.         cpuCycleCurTsk += g_cpup[taskID].allTime - g_cpup[taskID].historyTime[curPos]; 
  43.     } 
  44.     if (cpuCycleAll) { 
  45.         cpupRet = (UINT32)((LOS_CPUP_PRECISION * cpuCycleCurTsk) / cpuCycleAll); 
  46.     } 
  47.  
  48.     OsTskCycleStart(); 
  49.     LOS_IntRestore(intSave); 
  50.  
  51.     return cpupRet; 
  52. } 

3.2.5 LOS_AllTaskCpuUsage

該函數獲取全部任務的CPU占用率，獲取的CPU占用率信息保存在傳出參數結構體CPUP_INFO_S *cpupInfo指向的內存區域里，需要注意這個內存區域的大小需要等于sizeof(CPUP_INFO_S) * g_taskMaxNum。還需要傳入時間間隔模式參數，支持10秒、1秒、小于1秒三種。

⑴處先判斷CPUP是否已經初始化，如果沒有初始化過，返回錯誤碼。傳出參數cpupInfo指針不能為空，否則返回錯誤碼。⑵處調用函數OsTskCycleEnd()獲取當前任務的結束時間，并計算出運行總時間。⑶處調用函數OsGetPositions()計算出歷史運行時間數組索引位置。⑷處計算出各個任務的周期內運行總時間，如果時間間隔模式為1秒，取值兩個歷史運行時間之差，否則取值XX。⑸處設置每一個任務的狀態，然后計算出每一個任務的CPU占用率。最后，調用函數OsTskCycleStart()設置新任務的CPUP統計的開始時間。

  1. LITE_OS_SEC_TEXT_MINOR UINT32 LOS_AllTaskCpuUsage(CPUP_INFO_S *cpupInfo, UINT16 mode) 
  2. { 
  3.     UINT16  loopNum; 
  4.     UINT16  curPos; 
  5.     UINT16  prePos = 0; 
  6.     UINT32 intSave; 
  7.     UINT64  cpuCycleAll = 0; 
  8.     UINT64  cpuCycleCurTsk = 0; 
  9.  
  10. ⑴  if (g_cpupInitFlg == 0) { 
  11.         return  LOS_ERRNO_CPUP_NO_INIT; 
  12.     } 
  13.  
  14.     if (cpupInfo == NULL) { 
  15.         return LOS_ERRNO_CPUP_TASK_PTR_NULL; 
  16.     } 
  17.  
  18.     intSave = LOS_IntLock(); 
  19. ⑵  OsTskCycleEnd(); 
  20.  
  21. ⑶  OsGetPositions(mode, &curPos, &prePos); 
  22.  
  23.     for (loopNum = 0; loopNum < g_taskMaxNum; loopNum++) { 
  24.         if ((g_cpup[loopNum].status & OS_TASK_STATUS_UNUSED) || 
  25.             (g_cpup[loopNum].status == 0)) { 
  26.             continue; 
  27.         } 
  28.  
  29.         if (mode == CPUP_IN_1S) { 
  30.             cpuCycleAll += g_cpup[loopNum].historyTime[curPos] - g_cpup[loopNum].historyTime[prePos]; 
  31.         } else { 
  32.             cpuCycleAll += g_cpup[loopNum].allTime - g_cpup[loopNum].historyTime[curPos]; 
  33.         } 
  34.     } 
  35.  
  36. ⑷  for (loopNum = 0; loopNum < g_taskMaxNum; loopNum++) { 
  37.         if ((g_cpup[loopNum].status & OS_TASK_STATUS_UNUSED) || 
  38.             (g_cpup[loopNum].status == 0)) { 
  39.             continue; 
  40.         } 
  41.  
  42.         if (mode == CPUP_IN_1S) { 
  43.             cpuCycleCurTsk += g_cpup[loopNum].historyTime[curPos] - g_cpup[loopNum].historyTime[prePos]; 
  44.         } else { 
  45.             cpuCycleCurTsk += g_cpup[loopNum].allTime - g_cpup[loopNum].historyTime[curPos]; 
  46.         } 
  47. ⑸      cpupInfo[loopNum].usStatus = g_cpup[loopNum].status; 
  48.         if (cpuCycleAll) { 
  49.             cpupInfo[loopNum].uwUsage = (UINT32)((LOS_CPUP_PRECISION * cpuCycleCurTsk) / cpuCycleAll); 
  50.         } 
  51.  
  52.         cpuCycleCurTsk = 0; 
  53.     } 
  54.  
  55.     OsTskCycleStart(); 
  56.     LOS_IntRestore(intSave); 
  57.  
  58.     return LOS_OK; 
  59. } 

3.2.6 LOS_CpupUsageMonitor

該函數獲取歷史CPU占用率并打印輸出，傳入參數有三個：CPU占用率類型，CPUP時間周期模式，指定的任務編號。對于任務CPU占用率，才需要指定有效的任務編號。

⑴處處理CPU占用率類型為系統CPU占用率的情況。

⑵處打印使用的CPUP時間周期模式。

⑶處通過調用函數LOS_HistorySysCpuUsage()獲取系統歷史CPU占用率，然后執行⑷打印輸出CPU占用率結果，輸出結果范圍為[0,100]。

⑸處理CPU占用率類型為指定任務CPU占用率的情況，首先判斷下任務編號的有效性，校驗任務是否創建等。

⑹處打印使用的CPUP時間周期模式。

⑺處通過調用函數LOS_HistoryTaskCpuUsage()獲取指定任務的歷史CPU占用率，然后執行⑻打印輸出CPU占用率結果，輸出結果范圍為[0,100]。

  1. LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CpupUsageMonitor(CPUP_TYPE_E type, CPUP_MODE_E mode, UINT32 taskID) 
  2. { 
  3.     UINT32 ret; 
  4.     LosTaskCB *taskCB = NULL; 
  5.  
  6.     switch (type) { 
  7. ⑴      case SYS_CPU_USAGE: 
  8. ⑵          if (mode == CPUP_IN_10S) { 
  9.                 PRINTK("\nSysCpuUsage in 10s: "); 
  10.             } else if (mode == CPUP_IN_1S) { 
  11.                 PRINTK("\nSysCpuUsage in 1s: "); 
  12.             } else { 
  13.                 PRINTK("\nSysCpuUsage in <1s: "); 
  14.             } 
  15. ⑶          ret = LOS_HistorySysCpuUsage(mode); 
  16. ⑷          PRINTK("%d.%d", ret / LOS_CPUP_PRECISION_MULT, ret % LOS_CPUP_PRECISION_MULT); 
  17.             break; 
  18.  
  19. ⑸      case TASK_CPU_USAGE: 
  20.             if (taskID > LOSCFG_BASE_CORE_TSK_LIMIT) { 
  21.                 PRINT_ERR("\nThe taskid is invalid.\n"); 
  22.                 return OS_ERROR; 
  23.             } 
  24.             taskCB = OS_TCB_FROM_TID(taskID); 
  25.             if ((taskCB->taskStatus & OS_TASK_STATUS_UNUSED)) { 
  26.                 PRINT_ERR("\nThe taskid is invalid.\n"); 
  27.                 return OS_ERROR; 
  28.             } 
  29. ⑹          if (mode == CPUP_IN_10S) { 
  30.                 PRINTK("\nCPUusage of taskID %d in 10s: ", taskID); 
  31.             } else if (mode == CPUP_IN_1S) { 
  32.                 PRINTK("\nCPUusage of taskID %d in 1s: ", taskID); 
  33.             } else { 
  34.                 PRINTK("\nCPUusage of taskID %d in <1s: ", taskID); 
  35.             } 
  36. ⑺          ret = LOS_HistoryTaskCpuUsage(taskID, mode); 
  37. ⑻          PRINTK("%u.%u", ret / LOS_CPUP_PRECISION_MULT, ret % LOS_CPUP_PRECISION_MULT); 
  38.             break; 
  39.  
  40.         default: 
  41.             PRINT_ERR("\nThe type is invalid.\n"); 
  42.             return OS_ERROR; 
  43.     } 
  44.  
  45.     return LOS_OK; 
  46. } 

小結

本文帶領大家一起剖析了鴻蒙輕內核的CPUP擴展模塊的源代碼。

想了解更多內容，請訪問：

51CTO和華為官方合作共建的鴻蒙技術社區

https://harmonyos.51cto.com

 

責任編輯：jianghua 來源： 鴻蒙社區
鴻蒙HarmonyOS應用
相關推薦

2021-06-04 09:57:49

鴻蒙HarmonyOS應用

2022-01-10 15:31:44

鴻蒙HarmonyOS應用

2022-01-12 10:50:23

鴻蒙HarmonyOS應用

2021-05-25 09:28:34

鴻蒙HarmonyOS應用

2021-10-20 16:08:57

鴻蒙HarmonyOS應用

2021-05-08 15:14:50

鴻蒙HarmonyOS應用

2021-06-04 14:15:10

鴻蒙HarmonyOS應用

2021-05-17 09:28:59

鴻蒙HarmonyOS應用

2021-05-31 20:30:55

鴻蒙HarmonyOS應用

2022-04-13 11:02:12

鴻蒙事件模塊事件Event

2022-03-03 18:28:28

Harmony進程任務管理模塊

2022-03-11 20:23:14

鴻蒙源碼分析進程管理

2021-05-11 09:54:55

鴻蒙HarmonyOS應用

2021-05-27 09:43:56

鴻蒙HarmonyOS應用

2021-06-09 09:48:01

鴻蒙HarmonyOS應用

2021-05-21 09:25:11

鴻蒙HarmonyOS應用

2021-09-22 14:36:32

鴻蒙HarmonyOS應用

2021-05-12 09:45:20

鴻蒙HarmonyOS應用

2021-04-30 15:06:34

鴻蒙HarmonyOS應用

2022-01-14 08:39:47

鴻蒙HarmonyOS應用
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 亚洲精品一区二区网址 | 欧美一级电影免费 | 高清成人av | 国产精品特级毛片一区二区三区 | 日本一道本视频 | 久久99精品久久久水蜜桃 | 性做久久久久久免费观看欧美 | 午夜婷婷激情 | 中文精品视频 | 国产精品视频一区二区三区, | 精品国产伦一区二区三区观看体验 | 欧美久久久久 | www.久草.com | 91九色porny首页最多播放 | 久久久av | 91精品国产综合久久香蕉922 | 在线观看三级av | 亚洲视频一区二区三区 | 99久久免费精品 | 亚洲国产中文字幕 | 精品国产视频 | 欧美乱码精品一区二区三区 | 天天综合网天天综合 | 久久久国产精品一区 | 综合久久av | 天堂色 | 中文欧美日韩 | 视频精品一区二区三区 | 91偷拍精品一区二区三区 | 99久久精品免费看国产免费软件 | 在线黄| 成人精品网 | 97成人精品 | 国产精品久久久久久久 | 少妇精品久久久久久久久久 | 五月天天丁香婷婷在线中 | 色综合天天网 | 国产激情精品视频 | 精品一区二区三区91 | 免费在线看黄视频 | 日韩精品色网 |