p2gpamesw
/
LiteOS-Reading
2
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

何佳聪

Browse Source
hejiacong_branch
he 1 year ago
parent 6412ea5ff6
commit 2178a790e5
16 changed files with 505 additions and 326 deletions
Show Stats Download Patch File Download Diff File

18
src/kernel/extended/.vscode/c_cpp_properties.json vendored
Unescape View File

@ -0,0 +1,18 @@
{
"configurations": [
{
"name": "windows-gcc-x64",
"includePath": [
"${workspaceFolder}/**"
],
"compilerPath": "D:/mingw64/bin/gcc.exe",
"cStandard": "${default}",
"cppStandard": "${default}",
"intelliSenseMode": "windows-gcc-x64",
"compilerArgs": [
""
]
}
],
"version": 4
}

24
src/kernel/extended/.vscode/launch.json vendored
Unescape View File

@ -0,0 +1,24 @@
{
"version": "0.2.0",
"configurations": [
{
"name": "C/C++ Runner: Debug Session",
"type": "cppdbg",
"request": "launch",
"args": [],
"stopAtEntry": false,
"externalConsole": true,
"cwd": "h:/ruanjian/LiteOS-Reading/src/kernel/extended/perf/pmu",
"program": "h:/ruanjian/LiteOS-Reading/src/kernel/extended/perf/pmu/build/Debug/outDebug",
"MIMode": "gdb",
"miDebuggerPath": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
}
]
}

59
src/kernel/extended/.vscode/settings.json vendored
Unescape View File

@ -0,0 +1,59 @@
{
"C_Cpp_Runner.cCompilerPath": "gcc",
"C_Cpp_Runner.cppCompilerPath": "g++",
"C_Cpp_Runner.debuggerPath": "gdb",
"C_Cpp_Runner.cStandard": "",
"C_Cpp_Runner.cppStandard": "",
"C_Cpp_Runner.msvcBatchPath": "",
"C_Cpp_Runner.useMsvc": false,
"C_Cpp_Runner.warnings": [
"-Wall",
"-Wextra",
"-Wpedantic",
"-Wshadow",
"-Wformat=2",
"-Wcast-align",
"-Wconversion",
"-Wsign-conversion",
"-Wnull-dereference"
],
"C_Cpp_Runner.msvcWarnings": [
"/W4",
"/permissive-",
"/w14242",
"/w14287",
"/w14296",
"/w14311",
"/w14826",
"/w44062",
"/w44242",
"/w14905",
"/w14906",
"/w14263",
"/w44265",
"/w14928"
],
"C_Cpp_Runner.enableWarnings": true,
"C_Cpp_Runner.warningsAsError": false,
"C_Cpp_Runner.compilerArgs": [],
"C_Cpp_Runner.linkerArgs": [],
"C_Cpp_Runner.includePaths": [],
"C_Cpp_Runner.includeSearch": [
"*",
"**/*"
],
"C_Cpp_Runner.excludeSearch": [
"**/build",
"**/build/**",
"**/.*",
"**/.*/**",
"**/.vscode",
"**/.vscode/**"
],
"C_Cpp_Runner.useAddressSanitizer": false,
"C_Cpp_Runner.useUndefinedSanitizer": false,
"C_Cpp_Runner.useLeakSanitizer": false,
"C_Cpp_Runner.showCompilationTime": false,
"C_Cpp_Runner.useLinkTimeOptimization": false,
"C_Cpp_Runner.msvcSecureNoWarnings": false
}

34
src/kernel/extended/lowpower/los_lowpower.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*低功耗管理*/
#include "los_lowpower_pri.h" #include "los_lowpower_pri.h"
#ifdef LOSCFG_KERNEL_TICKLESS #ifdef LOSCFG_KERNEL_TICKLESS
#include "los_tickless_pri.h" #include "los_tickless_pri.h"
@ -36,10 +36,10 @@
__attribute__((section(".data"))) STATIC const PowerMgrOps *g_pmOps = NULL; __attribute__((section(".data"))) STATIC const PowerMgrOps *g_pmOps = NULL;
VOID OsLowpowerInit(const PowerMgrOps *pmOps) VOID OsLowpowerInit(const PowerMgrOps *pmOps) /*初始化低功耗管理*/
{ {
if (pmOps == NULL) { if (pmOps == NULL) {
#ifdef LOSCFG_KERNEL_POWER_MGR #ifdef LOSCFG_KERNEL_POWER_MGR/*是否配置了低功耗内核管理*/
PRINT_ERR("\r\n [PM] PowerMgrOps must be non-null.\n"); PRINT_ERR("\r\n [PM] PowerMgrOps must be non-null.\n");
return; return;
#endif #endif
@ -55,27 +55,27 @@ VOID OsLowpowerInit(const PowerMgrOps *pmOps)
g_pmOps = pmOps; g_pmOps = pmOps;
LOS_LowpowerHookReg(OsPowerMgrProcess); LOS_LowpowerHookReg(OsPowerMgrProcess);
/*注册低功耗处理函数和终端唤醒处理函数*/
LOS_IntWakeupHookReg(OsPowerMgrWakeUpFromInterrupt); LOS_IntWakeupHookReg(OsPowerMgrWakeUpFromInterrupt);
} }
VOID OsPowerMgrProcess(VOID) VOID OsPowerMgrProcess(VOID) /*执行低功耗管理的处理过程*/
{ {
#ifdef LOSCFG_KERNEL_POWER_MGR #ifdef LOSCFG_KERNEL_POWER_MGR/*判断是否配置了内核低功耗管理*/
CALL_PMOPS_FUNC_VOID(process); CALL_PMOPS_FUNC_VOID(process);
#else #else
if (g_pmOps == NULL) { if (g_pmOps == NULL) {
#ifdef LOSCFG_KERNEL_TICKLESS #ifdef LOSCFG_KERNEL_TICKLESS
OsTicklessOpen(); OsTicklessOpen();
wfi(); wfi(); /*管理进程进入睡眠状态*/
#endif #endif
} else { } else {
CALL_PMOPS_FUNC_VOID(process); CALL_PMOPS_FUNC_VOID(process);/*执行低功耗管理*/
} }
#endif #endif
} }
VOID OsPowerMgrWakeUpFromInterrupt(UINT32 intNum) VOID OsPowerMgrWakeUpFromInterrupt(UINT32 intNum) /*从中断唤醒处理*/
{ {
#ifdef LOSCFG_KERNEL_POWER_MGR #ifdef LOSCFG_KERNEL_POWER_MGR
CALL_PMOPS_FUNC_VOID(resumeFromInterrupt, intNum); CALL_PMOPS_FUNC_VOID(resumeFromInterrupt, intNum);
@ -90,44 +90,44 @@ VOID OsPowerMgrWakeUpFromInterrupt(UINT32 intNum)
#endif #endif
} }
VOID OsPowerMgrWakeupFromReset(VOID) VOID OsPowerMgrWakeupFromReset(VOID) /*从复位唤醒处理*/
{ {
CALL_PMOPS_FUNC_VOID(wakeupFromReset); CALL_PMOPS_FUNC_VOID(wakeupFromReset);
} }
VOID LOS_PowerMgrChangeFreq(LosFreqMode freq) VOID LOS_PowerMgrChangeFreq(LosFreqMode freq)/*改变系统频率*/
{ {
CALL_PMOPS_FUNC_VOID(changeFreq, freq); CALL_PMOPS_FUNC_VOID(changeFreq, freq);
} }
VOID LOS_PowerMgrDeepSleepVoteBegin(VOID) VOID LOS_PowerMgrDeepSleepVoteBegin(VOID)/*开始深度睡眠设置*/
{ {
CALL_PMOPS_FUNC_VOID(deepSleepVoteBegin); CALL_PMOPS_FUNC_VOID(deepSleepVoteBegin);
} }
VOID LOS_PowerMgrDeepSleepVoteEnd(VOID) VOID LOS_PowerMgrDeepSleepVoteEnd(VOID)/*结束深度睡眠状态*/
{ {
CALL_PMOPS_FUNC_VOID(deepSleepVoteEnd); CALL_PMOPS_FUNC_VOID(deepSleepVoteEnd);
} }
VOID LOS_PowerMgrSleepDelay(UINT32 tick) VOID LOS_PowerMgrSleepDelay(UINT32 tick)/*延迟进入睡眠状态*/
{ {
CALL_PMOPS_FUNC_VOID(deepSleepVoteDelay, tick); CALL_PMOPS_FUNC_VOID(deepSleepVoteDelay, tick);
} }
VOID LOS_PowerMgrRegisterExtVoter(UINT32 (*callback)(VOID)) VOID LOS_PowerMgrRegisterExtVoter(UINT32 (*callback)(VOID))/*注册外部投票者*/
{ {
CALL_PMOPS_FUNC_VOID(registerExternalVoter, callback); CALL_PMOPS_FUNC_VOID(registerExternalVoter, callback);
} }
UINT32 LOS_PowerMgrGetSleepMode(VOID) UINT32 LOS_PowerMgrGetSleepMode(VOID)/*获取睡眠模式*/
{ {
UINT32 ret = 0; UINT32 ret = 0;
CALL_PMOPS_FUNC_RET(getSleepMode, ret); CALL_PMOPS_FUNC_RET(getSleepMode, ret);
return ret; return ret;
} }
UINT32 LOS_PowerMgrGetDeepSleepVoteCount(VOID) UINT32 LOS_PowerMgrGetDeepSleepVoteCount(VOID)/*获取深度睡眠的投票计数*/
{ {
UINT32 ret = 0; UINT32 ret = 0;
CALL_PMOPS_FUNC_RET(getDeepSleepVoteCount, ret); CALL_PMOPS_FUNC_RET(getDeepSleepVoteCount, ret);

222
src/kernel/extended/lowpower/powermgr/los_lowpower_impl.c
Unescape View File

@ -44,7 +44,7 @@
#endif #endif
#if defined(LOSCFG_KERNEL_RUNSTOP) || defined(LOSCFG_KERNEL_DEEPSLEEP) #if defined(LOSCFG_KERNEL_RUNSTOP) || defined(LOSCFG_KERNEL_DEEPSLEEP)
/* Is system is up from the memory image, then this flag should be 1; else 0 */ /* 如果系统是从内存映像中启动的，则该标志应为1；否则为0。*/
#ifdef LOSCFG_AARCH64 #ifdef LOSCFG_AARCH64
__attribute__((section(".data"))) INT64 g_resumeFromImg = LOS_COLD_RESET; __attribute__((section(".data"))) INT64 g_resumeFromImg = LOS_COLD_RESET;
__attribute__((section(".data"))) STATIC INT64 g_otherCoreResume = 0; __attribute__((section(".data"))) STATIC INT64 g_otherCoreResume = 0;
@ -55,8 +55,8 @@ __attribute__((section(".data"))) INT32 g_otherCoreResume = 0;
#ifdef LOSCFG_AARCH64 #ifdef LOSCFG_AARCH64
/* /*
* 16: The number of aligned memory, * 16: 对齐内存的数量,
* 34: The number of task context registers(X0~X30, SP, DAIF, NZCV) * 34: 任务上下文寄存器的数量，指寄存器的集合(X0~X30, SP, DAIF, NZCV)
*/ */
LITE_OS_SEC_DATA_MINOR __attribute__((aligned(16))) UINT64 g_saveSRContext[34]; LITE_OS_SEC_DATA_MINOR __attribute__((aligned(16))) UINT64 g_saveSRContext[34];
/* 3: The number of available universal registers(X0, X1, X2) temporarily saved */ /* 3: The number of available universal registers(X0, X1, X2) temporarily saved */
@ -161,24 +161,24 @@ STATIC PowerMgrRunOps g_pmRunOps = {
.postConfig = OsPostConfigDefault, .postConfig = OsPostConfigDefault,
}; };
STATIC VOID OsLightSleepDefault(VOID) STATIC VOID OsLightSleepDefault(VOID)/*轻量级睡眠函数，执行wfi指令，让处理器进入睡眠状态*/
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
wfi(); wfi();
} }
STATIC VOID OsSetWakeUpTimerDefault(UINT32 sleepTick) STATIC VOID OsSetWakeUpTimerDefault(UINT32 sleepTick)/*设置唤醒定时器，默认实现为空函数*/
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
STATIC UINT32 OsWithrawWakeUpTimerDefault(VOID) STATIC UINT32 OsWithrawWakeUpTimerDefault(VOID)/*撤销唤醒定时器，默认实现返回0*/
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
return 0; return 0;
} }
STATIC UINT32 OsGetSleepTimeDefault(VOID) STATIC UINT32 OsGetSleepTimeDefault(VOID)/*获取当前任务休眠时间*/
{ {
#ifdef LOSCFG_KERNEL_TICKLESS #ifdef LOSCFG_KERNEL_TICKLESS
return OsSleepTicksGet(); return OsSleepTicksGet();
@ -187,12 +187,12 @@ STATIC UINT32 OsGetSleepTimeDefault(VOID)
#endif #endif
} }
STATIC UINT32 OsSelectSleepModeDefault(UINT32 sleepTicks) STATIC UINT32 OsSelectSleepModeDefault(UINT32 sleepTicks)/*选择合适的休眠模式*/
{ {
if (sleepTicks < g_pmMgr.minSleepTicks) { if (sleepTicks < g_pmMgr.minSleepTicks) {
return LOS_INTERMIT_NONE; return LOS_INTERMIT_NONE;
} }
/*默认实现根据休眠时间和当前系统状态选择轻量级睡眠或者深度睡眠模式*/
if (g_pmMgr.deepSleepOps != NULL && sleepTicks >= g_pmMgr.minDeepSleepTicks && if (g_pmMgr.deepSleepOps != NULL && sleepTicks >= g_pmMgr.minDeepSleepTicks &&
g_pmRunOps.getDeepSleepVoteCount() == 0) { g_pmRunOps.getDeepSleepVoteCount() == 0) {
return LOS_INTERMIT_DEEP_SLEEP; return LOS_INTERMIT_DEEP_SLEEP;
@ -201,73 +201,73 @@ STATIC UINT32 OsSelectSleepModeDefault(UINT32 sleepTicks)
return LOS_INTERMIT_LIGHT_SLEEP; return LOS_INTERMIT_LIGHT_SLEEP;
} }
STATIC VOID OsChangeFreqDefault(UINT8 freq) STATIC VOID OsChangeFreqDefault(UINT8 freq)/*改变处理器频率*/
{ {
(VOID)freq; (VOID)freq;
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
STATIC VOID OsEnterDeepSleepDefault(VOID) STATIC VOID OsEnterDeepSleepDefault(VOID)// 进入深度睡眠模式函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
wfi(); wfi();
} }
STATIC UINT32 OsPreConfigDefault(VOID) STATIC UINT32 OsPreConfigDefault(VOID)//电源管理模块预配置函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
return 1; return 1;
} }
STATIC VOID OsPostConfigDefault(VOID) STATIC VOID OsPostConfigDefault(VOID)//电源管理模块后配置函数
{ {
} }
#ifdef LOSCFG_KERNEL_DEEPSLEEP #ifdef LOSCFG_KERNEL_DEEPSLEEP
STATIC BOOL OsCouldDeepSleepDefault(VOID) STATIC BOOL OsCouldDeepSleepDefault(VOID)// 判断是否可以进入深度睡眠模式
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
return true; return true;
} }
STATIC BOOL OsSuspendPreConfigDefault(VOID) STATIC BOOL OsSuspendPreConfigDefault(VOID)// 休眠前的预配置函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
return true; return true;
} }
STATIC VOID OsSuspendDeviceDefault(VOID) STATIC VOID OsSuspendDeviceDefault(VOID)//休眠时设备挂起函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
STATIC VOID OsRollBackDefault(VOID) STATIC VOID OsRollBackDefault(VOID)//唤醒后的回滚函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
STATIC VOID OsResumeDeviceDefault(VOID) STATIC VOID OsResumeDeviceDefault(VOID)//唤醒后的设备恢复函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
STATIC VOID OsResumePostConfigDefault(VOID) STATIC VOID OsResumePostConfigDefault(VOID)//唤醒后电源管理模块后配置函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
STATIC VOID OsSystemWakeupDefault(VOID) STATIC VOID OsSystemWakeupDefault(VOID)//系统唤醒函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
STATIC VOID OsResumeCallBackDefault(VOID) STATIC VOID OsResumeCallBackDefault(VOID)//唤醒后回调函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
STATIC VOID OsOtherCoreResumeDefault(VOID) STATIC VOID OsOtherCoreResumeDefault(VOID)//其他核心唤醒函数
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
@ -275,18 +275,18 @@ STATIC VOID OsOtherCoreResumeDefault(VOID)
STATIC VOID OsDeepSleepResume(VOID); STATIC VOID OsDeepSleepResume(VOID);
STATIC PowerMgrDeepSleepOps g_deepSleepOps = { STATIC PowerMgrDeepSleepOps g_deepSleepOps = {
.couldDeepSleep = OsCouldDeepSleepDefault, .couldDeepSleep = OsCouldDeepSleepDefault, //判断是否可以进入深度睡眠模式的函数指针
.systemWakeup = OsSystemWakeupDefault, .systemWakeup = OsSystemWakeupDefault,//唤醒函数的函数指针
.suspendPreConfig = OsSuspendPreConfigDefault, .suspendPreConfig = OsSuspendPreConfigDefault,//修面前的预配置函数的函数指针
.suspendDevice = OsSuspendDeviceDefault, .suspendDevice = OsSuspendDeviceDefault,//设备挂起函数的函数指针
.rollback = OsRollBackDefault, .rollback = OsRollBackDefault,//唤醒后的回滚函数的函数指针
.resumeDevice = OsResumeDeviceDefault, .resumeDevice = OsResumeDeviceDefault,//设备回复函数的函数指针
.resumePostConfig = OsResumePostConfigDefault, .resumePostConfig = OsResumePostConfigDefault,//唤醒后电源管理模块后配置函数的函数指针
.resumeCallBack = OsResumeCallBackDefault, .resumeCallBack = OsResumeCallBackDefault,//唤醒后回调函数的函数指针
.otherCoreResume = OsOtherCoreResumeDefault .otherCoreResume = OsOtherCoreResumeDefault//其他核心唤醒函数的函数指针
}; };
STATIC INLINE VOID OsTickResume(UINT32 sleepTicks) STATIC INLINE VOID OsTickResume(UINT32 sleepTicks)//用于更新系统始终，根据休眠时间调整系统时钟
{ {
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
if (sleepTicks > g_pmMgr.sleepTime[cpuid]) { if (sleepTicks > g_pmMgr.sleepTime[cpuid]) {
@ -297,7 +297,7 @@ STATIC INLINE VOID OsTickResume(UINT32 sleepTicks)
OsSysTimeUpdate(sleepTicks); OsSysTimeUpdate(sleepTicks);
} }
STATIC VOID OsDeepSleepResume(VOID) STATIC VOID OsDeepSleepResume(VOID)//深度睡眠唤醒后的处理函数
{ {
DEEPOPS_CALL_FUNC_VOID(resumeFromReset); DEEPOPS_CALL_FUNC_VOID(resumeFromReset);
LOS_AtomicSet(&g_pmMgr.resumeSleepCores, OS_MP_CPU_ALL); LOS_AtomicSet(&g_pmMgr.resumeSleepCores, OS_MP_CPU_ALL);
@ -305,30 +305,32 @@ STATIC VOID OsDeepSleepResume(VOID)
#ifdef LOSCFG_KERNEL_CPUP #ifdef LOSCFG_KERNEL_CPUP
OsSetCpuCycle(0); OsSetCpuCycle(0);
#endif #endif
//恢复设置，恢复其他核心进程
#if (LOSCFG_KERNEL_SMP == YES) #if (LOSCFG_KERNEL_SMP == YES)
release_secondary_cores(); release_secondary_cores();
#endif #endif
OsSRRestoreRegister(); OsSRRestoreRegister();
} }
STATIC INLINE VOID OsEnterDeepSleepMainCore(VOID) STATIC INLINE VOID OsEnterDeepSleepMainCore(VOID)//用于主核心进入深度睡眠
{ {
//挂起预配置
LOS_AtomicAdd(&g_pmMgr.deepSleepCores, 1); LOS_AtomicAdd(&g_pmMgr.deepSleepCores, 1);
g_deepSleepOps.suspendPreConfig(); g_deepSleepOps.suspendPreConfig();
//是否可以进入神对睡眠判断
if (g_pmMgr.deepSleepCores == LOSCFG_KERNEL_CORE_NUM && g_deepSleepOps.couldDeepSleep()) { if (g_pmMgr.deepSleepCores == LOSCFG_KERNEL_CORE_NUM && g_deepSleepOps.couldDeepSleep()) {
g_deepSleepOps.suspendDevice(); g_deepSleepOps.suspendDevice();
g_pmRunOps.setWakeUpTimer(g_pmMgr.sleepTime[0]); g_pmRunOps.setWakeUpTimer(g_pmMgr.sleepTime[0]);
g_resumeFromImg = LOS_COLD_RESET; g_resumeFromImg = LOS_COLD_RESET;
OsSRSaveRegister(); OsSRSaveRegister();
//进入深度睡眠，进行回滚操作，保存上下文
if (g_resumeFromImg == LOS_COLD_RESET) { if (g_resumeFromImg == LOS_COLD_RESET) {
g_resumeFromImg = LOS_DEEP_SLEEP_RESET; g_resumeFromImg = LOS_DEEP_SLEEP_RESET;
CALL_RUN_OPS_FUNC_NO_RETURN(contextSave); CALL_RUN_OPS_FUNC_NO_RETURN(contextSave);
g_pmRunOps.enterDeepSleep(); g_pmRunOps.enterDeepSleep();
g_deepSleepOps.rollback(); g_deepSleepOps.rollback();
} }
//设置唤醒定时器
g_deepSleepOps.resumeDevice(); g_deepSleepOps.resumeDevice();
UINT32 sleepTicks = g_pmRunOps.withdrawWakeUpTimer(); UINT32 sleepTicks = g_pmRunOps.withdrawWakeUpTimer();
OsSysTimeUpdate(sleepTicks); OsSysTimeUpdate(sleepTicks);
@ -342,42 +344,43 @@ STATIC INLINE VOID OsEnterDeepSleepMainCore(VOID)
LOS_AtomicSub(&g_pmMgr.deepSleepCores, 1); LOS_AtomicSub(&g_pmMgr.deepSleepCores, 1);
} }
STATIC INLINE VOID OsEnterSleepMode(VOID) STATIC INLINE VOID OsEnterSleepMode(VOID)//进入睡眠模式，包括主核心和其他核心的不同处理
{ {
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
UINT32 currCpuid = ArchCurrCpuid(); UINT32 currCpuid = ArchCurrCpuid();
if (currCpuid == 0) { if (currCpuid == 0) { //如果是0则进入主核心深度睡眠
#endif #endif
OsEnterDeepSleepMainCore(); OsEnterDeepSleepMainCore();
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP //如果当前核心不是主核心，则直接返回，因为其他核心的睡眠处理逻辑不在此函数中处理
return; return;
} }
UINT32 cpuMask = 1 << currCpuid; UINT32 cpuMask = 1 << currCpuid;
LOS_AtomicAdd(&g_pmMgr.deepSleepCores, 1); LOS_AtomicAdd(&g_pmMgr.deepSleepCores, 1);
OsSRSaveRegister(); OsSRSaveRegister();//保存相关寄存器状态并判断是否需要唤醒当前核心。
if (g_pmMgr.resumeSleepCores & cpuMask) { if (g_pmMgr.resumeSleepCores & cpuMask) {
INT32 val; INT32 val;
do { do { //，将 g_pmMgr.resumeSleepCores 的值中当前核心的位清零，表示该核心已被唤醒。
val = LOS_AtomicRead(&g_pmMgr.resumeSleepCores); val = LOS_AtomicRead(&g_pmMgr.resumeSleepCores);
} while (LOS_AtomicCmpXchg32bits(&g_pmMgr.resumeSleepCores, val & (~cpuMask), val)); } while (LOS_AtomicCmpXchg32bits(&g_pmMgr.resumeSleepCores, val & (~cpuMask), val));
g_deepSleepOps.otherCoreResume(); g_deepSleepOps.otherCoreResume();
UINT32 sleepTicks = g_pmRunOps.withdrawWakeUpTimer(); UINT32 sleepTicks = g_pmRunOps.withdrawWakeUpTimer();
OsTickResume(sleepTicks); OsTickResume(sleepTicks);
//执行其他核心的恢复操作，并从唤醒定时器中获取休眠时间，然后调用 OsTickResume 函数更新系统时钟。
} else { } else {
if (g_pmMgr.deepSleepCores == LOSCFG_KERNEL_CORE_NUM) { if (g_pmMgr.deepSleepCores == LOSCFG_KERNEL_CORE_NUM) {//如果不需要唤醒，则判断是否所有核心都进入了深度睡眠
LOS_MpSchedule(1 << 0); LOS_MpSchedule(1 << 0);//调用函数选择一个核心唤醒系统
} }
#ifdef LOSCFG_KERNEL_TICKLESS #ifdef LOSCFG_KERNEL_TICKLESS
OsTicklessOpen(); OsTicklessOpen();//开启节能模式
#endif #endif
g_pmRunOps.enterLightSleep(); g_pmRunOps.enterLightSleep();
} }
LOS_AtomicSub(&g_pmMgr.deepSleepCores, 1); LOS_AtomicSub(&g_pmMgr.deepSleepCores, 1);//将 g_pmMgr.deepSleepCores 的值减1，表示当前核心已经处理完睡眠状态
#endif // LOSCFG_KERNEL_SMP #endif // LOSCFG_KERNEL_SMP
} }
STATIC INLINE VOID OsSystemSuspend(LosIntermitMode *mode) STATIC INLINE VOID OsSystemSuspend(LosIntermitMode *mode)//选择合适的低功耗模式（深度，轻度
{ {
// If enterShutdownMode is not defined, will fall through to standby mode // If enterShutdownMode is not defined, will fall through to standby mode
// If enterStandbyMode is not defined, will fall through to stop mode // If enterStandbyMode is not defined, will fall through to stop mode
@ -402,10 +405,10 @@ STATIC INLINE VOID OsSystemSuspend(LosIntermitMode *mode)
} }
#endif #endif
STATIC VOID OsLowpowerLightSleep(UINT32 mode, UINT32 cpuid, UINT32 sleepTicks) STATIC VOID OsLowpowerLightSleep(UINT32 mode, UINT32 cpuid, UINT32 sleepTicks)//轻度睡眠中的模式调整
{ {
if (g_pmRunOps.preConfig != NULL) { if (g_pmRunOps.preConfig != NULL) {
sleepTicks = g_pmRunOps.getSleepTime(); sleepTicks = g_pmRunOps.getSleepTime();//获取休眠时间
} }
if (sleepTicks > 1) { if (sleepTicks > 1) {
g_pmMgr.sleepMode[cpuid] = (mode & 0x0FF); g_pmMgr.sleepMode[cpuid] = (mode & 0x0FF);
@ -414,18 +417,19 @@ STATIC VOID OsLowpowerLightSleep(UINT32 mode, UINT32 cpuid, UINT32 sleepTicks)
OsTicklessOpen(); OsTicklessOpen();
#endif #endif
if (mode == LOS_INTERMIT_LIGHT_SLEEP && g_pmRunOps.enterLightSleep != NULL) { if (mode == LOS_INTERMIT_LIGHT_SLEEP && g_pmRunOps.enterLightSleep != NULL) {
g_pmRunOps.enterLightSleep(); g_pmRunOps.enterLightSleep();//进入轻度睡眠
} else { } else {
wfi(); wfi();
} }
} else { } else {
g_pmMgr.sleepMode[cpuid] = LOS_INTERMIT_NONE; g_pmMgr.sleepMode[cpuid] = LOS_INTERMIT_NONE;//等待中断事件
g_pmMgr.sleepTime[cpuid] = 0; g_pmMgr.sleepTime[cpuid] = 0;
wfi(); wfi();
} }
} }
STATIC VOID OsLowpowerDeepSleep(LosIntermitMode *mode, UINT32 cpuid, UINT32 sleepTicks) STATIC VOID OsLowpowerDeepSleep(LosIntermitMode *mode, UINT32 cpuid, UINT32 sleepTicks)
//深度睡眠设置
{ {
#ifdef LOSCFG_KERNEL_DEEPSLEEP #ifdef LOSCFG_KERNEL_DEEPSLEEP
if (g_pmRunOps.enterDeepSleep == NULL) { if (g_pmRunOps.enterDeepSleep == NULL) {
@ -438,27 +442,31 @@ STATIC VOID OsLowpowerDeepSleep(LosIntermitMode *mode, UINT32 cpuid, UINT32 slee
OsSystemSuspend(mode); OsSystemSuspend(mode);
} }
#else #else
*mode = LOS_INTERMIT_LIGHT_SLEEP; *mode = LOS_INTERMIT_LIGHT_SLEEP;//若不支持深度睡眠则强制进入轻度睡眠
#endif #endif
} }
STATIC VOID OsLowpowerProcess(VOID) STATIC VOID OsLowpowerProcess(VOID)//处理系统进入低功耗模式的过程
{ {
#ifdef LOSCFG_KERNEL_RUNSTOP #ifdef LOSCFG_KERNEL_RUNSTOP//检查系统是否需要在进入低功耗模式前保存系统消息
if (OsWowSysDoneFlagGet() == OS_STORE_SYSTEM) { if (OsWowSysDoneFlagGet() == OS_STORE_SYSTEM) {
OsStoreSystemInfoBeforeSuspend(); OsStoreSystemInfoBeforeSuspend();
} }
#endif #endif
/* Change frequency is pended, need to change the freq here. */ /* Change frequency is pended, need to change the freq here. */
if ((g_pmRunOps.changeFreq != NULL)) { if ((g_pmRunOps.changeFreq != NULL)) {//如果需要改变频率则调整切换
OsChangeFreq(); OsChangeFreq();
} }
//禁止中断，锁住任务调度，并获取当前CPUID和休眠时间
UINT32 intSave = LOS_IntLock(); UINT32 intSave = LOS_IntLock();
LOS_TaskLock(); LOS_TaskLock();
RUNOPS_CALL_FUNC_VOID(preConfig); RUNOPS_CALL_FUNC_VOID(preConfig);
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
UINT32 sleepTicks = g_pmRunOps.getSleepTime(); UINT32 sleepTicks = g_pmRunOps.getSleepTime();
/*如果休眠时间小于等于最小休眠时间（g_pmMgr.minSleepTicks）
或者有任务请求不进入深度睡眠（LOS_PowerMgrGetDeepSleepVoteCount 返回值不为0），
则将当前 CPU 设置为不进入任何中断模式，清零休眠时间，
并调用 postConfig 函数。*/
if (sleepTicks <= g_pmMgr.minSleepTicks || LOS_PowerMgrGetDeepSleepVoteCount() != 0) { if (sleepTicks <= g_pmMgr.minSleepTicks || LOS_PowerMgrGetDeepSleepVoteCount() != 0) {
g_pmMgr.sleepMode[cpuid] = LOS_INTERMIT_NONE; g_pmMgr.sleepMode[cpuid] = LOS_INTERMIT_NONE;
g_pmMgr.sleepTime[cpuid] = 0; g_pmMgr.sleepTime[cpuid] = 0;
@ -477,23 +485,23 @@ STATIC VOID OsLowpowerProcess(VOID)
sleepTicks = g_pmMgr.maxSleepCount; sleepTicks = g_pmMgr.maxSleepCount;
} }
UINT32 mode = g_pmRunOps.selectSleepMode(sleepTicks); UINT32 mode = g_pmRunOps.selectSleepMode(sleepTicks);
if (mode >= LOS_INTERMIT_DEEP_SLEEP) { if (mode >= LOS_INTERMIT_DEEP_SLEEP) {//如果支持深度睡眠
g_pmMgr.sleepTime[cpuid] = g_pmRunOps.withdrawWakeUpTimer(); g_pmMgr.sleepTime[cpuid] = g_pmRunOps.withdrawWakeUpTimer();
OsLowpowerDeepSleep(&mode, cpuid, sleepTicks); OsLowpowerDeepSleep(&mode, cpuid, sleepTicks);
} }
RUNOPS_CALL_FUNC_VOID(postConfig); RUNOPS_CALL_FUNC_VOID(postConfig);
if (mode < LOS_INTERMIT_DEEP_SLEEP) { if (mode < LOS_INTERMIT_DEEP_SLEEP) {//进入轻度睡眠
OsLowpowerLightSleep(mode, cpuid, sleepTicks); OsLowpowerLightSleep(mode, cpuid, sleepTicks);
} }
} }
LOS_TaskUnlock(); LOS_TaskUnlock();
LOS_IntRestore(intSave); LOS_IntRestore(intSave);//解锁任务调度并恢复中断
} }
STATIC VOID OsLowpowerWakeupFromReset(VOID) STATIC VOID OsLowpowerWakeupFromReset(VOID)//处理系统从重置状态唤醒的情况
{ {
#ifdef LOSCFG_KERNEL_RUNSTOP #ifdef LOSCFG_KERNEL_RUNSTOP
if (g_resumeFromImg == LOS_RUN_STOP_RESET) { if (g_resumeFromImg == LOS_RUN_STOP_RESET) {
@ -508,7 +516,7 @@ STATIC VOID OsLowpowerWakeupFromReset(VOID)
#endif #endif
} }
STATIC VOID OsLowpowerWakeupFromInterrupt(UINT32 intNum) STATIC VOID OsLowpowerWakeupFromInterrupt(UINT32 intNum)//用于处理系统从重置状态唤醒的情况
{ {
#ifdef LOSCFG_KERNEL_TICKLESS #ifdef LOSCFG_KERNEL_TICKLESS
OsTicklessUpdate(intNum); OsTicklessUpdate(intNum);
@ -517,26 +525,27 @@ STATIC VOID OsLowpowerWakeupFromInterrupt(UINT32 intNum)
#endif #endif
} }
STATIC VOID OsChangeFreq(VOID) STATIC VOID OsChangeFreq(VOID)//处理改变系统频率的操作
{ {
UINT32 freq; UINT32 freq;
BOOL ret; BOOL ret;
do { do {//尝试获取频率切换的自旋锁（通过原子操作实现）
//如果成功获取锁，则说明没有其他线程正在频率切换过程中，可以继续执行
ret = LOS_AtomicCmpXchg32bits(&g_pmMgr.freeLock, LOCK_ON, LOCK_OFF); ret = LOS_AtomicCmpXchg32bits(&g_pmMgr.freeLock, LOCK_ON, LOCK_OFF);
if (ret) { if (ret) {
return; return;
} }
freq = (UINT32)g_pmMgr.freqPending; freq = (UINT32)g_pmMgr.freqPending;//获取频率切换的目标频率，并进行频率切换
if (freq != (UINT32)g_pmMgr.freq) { if (freq != (UINT32)g_pmMgr.freq) {
g_pmRunOps.changeFreq(freq); g_pmRunOps.changeFreq(freq);//更新频率
LOS_AtomicSet(&g_pmMgr.freq, (INT32)freq); LOS_AtomicSet(&g_pmMgr.freq, (INT32)freq);
} }
LOS_AtomicSet(&g_pmMgr.freeLock, LOCK_OFF); LOS_AtomicSet(&g_pmMgr.freeLock, LOCK_OFF);//释放自旋锁
} while (FreqHigher(g_pmMgr.freqPending, freq)); } while (FreqHigher(g_pmMgr.freqPending, freq));
} }
STATIC VOID OsLowpowerChangeFreq(LosFreqMode freq) STATIC VOID OsLowpowerChangeFreq(LosFreqMode freq)//改变系统频率
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
if (g_pmRunOps.changeFreq == NULL) { if (g_pmRunOps.changeFreq == NULL) {
@ -554,36 +563,36 @@ STATIC VOID OsLowpowerChangeFreq(LosFreqMode freq)
// We get a high frequency request, then change it // We get a high frequency request, then change it
if (FreqHigher(g_pmMgr.freqPending, g_pmMgr.freq) && g_pmRunOps.changeFreq != NULL) { if (FreqHigher(g_pmMgr.freqPending, g_pmMgr.freq) && g_pmRunOps.changeFreq != NULL) {
OsChangeFreq(); OsChangeFreq();//如果目标频率高于当前频率，并且 g_pmRunOps.changeFreq 不为空，则调用 OsChangeFreq 函数进行频率切换。
} }
} }
STATIC VOID OsLowpowerDeepSleepVoteBegin(VOID) STATIC VOID OsLowpowerDeepSleepVoteBegin(VOID)//开始深度睡眠投票
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
LOS_AtomicInc(&g_pmMgr.sleepVoteCount); LOS_AtomicInc(&g_pmMgr.sleepVoteCount);//用原子操作将 g_pmMgr.sleepVoteCount 加一，并断言 g_pmMgr.sleepVoteCount 大于零。
LOS_ASSERT(g_pmMgr.sleepVoteCount > 0); LOS_ASSERT(g_pmMgr.sleepVoteCount > 0);
} }
STATIC VOID OsLowpowerDeepSleepVoteEnd(VOID) STATIC VOID OsLowpowerDeepSleepVoteEnd(VOID)//结束深度睡眠投票
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
LOS_AtomicDec(&g_pmMgr.sleepVoteCount); LOS_AtomicDec(&g_pmMgr.sleepVoteCount);//原子操作将 g_pmMgr.sleepVoteCount 减一，并断言 g_pmMgr.sleepVoteCount 大于等于零。
LOS_ASSERT(g_pmMgr.sleepVoteCount >= 0); LOS_ASSERT(g_pmMgr.sleepVoteCount >= 0);
} }
STATIC VOID OsLowpowerDeepSleepVoteDelay(UINT32 delayTicks) STATIC VOID OsLowpowerDeepSleepVoteDelay(UINT32 delayTicks)//延迟深度睡眠投票
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
} }
STATIC VOID OsLowpowerRegisterExternalVoter(LowpowerExternalVoterHandle callback) STATIC VOID OsLowpowerRegisterExternalVoter(LowpowerExternalVoterHandle callback)//注册外部投票者
{ {
TRACE_FUNC_CALL(); TRACE_FUNC_CALL();
g_pmMgr.exVoterHandle = callback; g_pmMgr.exVoterHandle = callback;
} }
STATIC UINT32 OsLowpowerGetDeepSleepVoteCount(VOID) STATIC UINT32 OsLowpowerGetDeepSleepVoteCount(VOID)//获取深度睡眠投票数
{ {
if (g_pmMgr.exVoterHandle == NULL) { if (g_pmMgr.exVoterHandle == NULL) {
return (UINT32)g_pmMgr.sleepVoteCount; return (UINT32)g_pmMgr.sleepVoteCount;
@ -593,22 +602,26 @@ STATIC UINT32 OsLowpowerGetDeepSleepVoteCount(VOID)
} }
STATIC PowerMgrOps g_pmOps = { STATIC PowerMgrOps g_pmOps = {
.process = OsLowpowerProcess, .process = OsLowpowerProcess, //该函数指针用于处理低功耗过程，即在进入低功耗模式前需要执行的操作
.wakeupFromReset = OsLowpowerWakeupFromReset, .wakeupFromReset = OsLowpowerWakeupFromReset,//该函数指针用于处理从复位状态唤醒时的操作
.resumeFromInterrupt = OsLowpowerWakeupFromInterrupt, .resumeFromInterrupt = OsLowpowerWakeupFromInterrupt,//该函数指针用于处理从中断状态恢复时的操作。
.changeFreq = OsLowpowerChangeFreq, .changeFreq = OsLowpowerChangeFreq,//该函数指针用于改变系统频率的操作，可以根据需要调整系统的工作频率
.deepSleepVoteBegin = OsLowpowerDeepSleepVoteBegin, .deepSleepVoteBegin = OsLowpowerDeepSleepVoteBegin,//该函数指针用于开始深度休眠投票，即在进入深度休眠模式前需要执行的操作
.deepSleepVoteEnd = OsLowpowerDeepSleepVoteEnd, .deepSleepVoteEnd = OsLowpowerDeepSleepVoteEnd,//该函数指针用于结束深度休眠投票，即在退出深度休眠模式后需要执行的操作
.deepSleepVoteDelay = OsLowpowerDeepSleepVoteDelay, .deepSleepVoteDelay = OsLowpowerDeepSleepVoteDelay,//该函数指针用于处理深度休眠投票延迟的操作，可以根据需要延迟深度休眠的投票
.registerExternalVoter = OsLowpowerRegisterExternalVoter, .registerExternalVoter = OsLowpowerRegisterExternalVoter,//该函数指针用于注册外部投票者，即在系统中存在其他模块也需要参与低功耗投票时的操作
.getDeepSleepVoteCount = OsLowpowerGetDeepSleepVoteCount, .getDeepSleepVoteCount = OsLowpowerGetDeepSleepVoteCount,//该函数指针用于获取当前深度休眠投票的数量，可以用来监控系统中参与休眠投票的模块数量
.getSleepMode = NULL, .getSleepMode = NULL,//该函数指针用于获取当前的睡眠模式，即获取系统当前是否处于睡眠状态
.setSleepMode = NULL, .setSleepMode = NULL,//该函数指针用于设置睡眠模式，即将系统设置为指定的睡眠模式
//以上提及的函数均为函数指针
}; };
#define FORCE_NULL_CALLBACK (void *)0x3f3f3f3f #define FORCE_NULL_CALLBACK (void *)0x3f3f3f3f
//以下定义是用于给结构体成员赋值，如果某个回调函数指针为特殊空值，则将相应的成员置为空，否则进行赋值
#define ASSIGN_MEMBER(lhs, rhs, member) \ #define ASSIGN_MEMBER(lhs, rhs, member)
//lhs 是左操作数，表示要赋值的结构体指针；
//rhs 是右操作数，表示要赋给成员的值；
//member 是要赋值的结构体成员
do { \ do { \
if ((rhs)->member == FORCE_NULL_CALLBACK) { \ if ((rhs)->member == FORCE_NULL_CALLBACK) { \
(lhs)->member = NULL; \ (lhs)->member = NULL; \
@ -631,16 +644,16 @@ VOID LOS_PowerMgrInit(const PowerMgrParameter *para)
const PowerMgrRunOps *runOps = NULL; const PowerMgrRunOps *runOps = NULL;
const PowerMgrDeepSleepOps *deepSleepOps = NULL; const PowerMgrDeepSleepOps *deepSleepOps = NULL;
(void)deepSleepOps; (void)deepSleepOps;
if (para != NULL) { if (para != NULL) { //如果para为空，则运行操作和深度睡眠操作都为空指针
runOps = &para->runOps; runOps = &para->runOps;
#ifdef LOSCFG_KERNEL_DEEPSLEEP #ifdef LOSCFG_KERNEL_DEEPSLEEP
deepSleepOps = &para->deepSleepOps; deepSleepOps = &para->deepSleepOps;
#endif #endif
g_pmMgr.minSleepTicks = para->config.minLightSleepTicks; g_pmMgr.minSleepTicks = para->config.minLightSleepTicks;//记录了系统中需要从睡眠状态唤醒的 CPU 核心数
g_pmMgr.maxSleepCount = para->config.maxDeepSleepTicks; g_pmMgr.maxSleepCount = para->config.maxDeepSleepTicks;//用于保护电源管理模块在多线程环境下的并发访问
g_pmMgr.minDeepSleepTicks = para->config.minDeepSleepTicks; g_pmMgr.minDeepSleepTicks = para->config.minDeepSleepTicks;//记录自旋锁是否被释放
} }
//将传入的运行操作和深度睡眠操作分别赋值给全局变量 g_pmRunOps 和 g_deepSleepOps
LOS_AtomicSet(&g_pmMgr.resumeSleepCores, 0); LOS_AtomicSet(&g_pmMgr.resumeSleepCores, 0);
LOS_SpinInit(&g_pmMgr.lock); LOS_SpinInit(&g_pmMgr.lock);
@ -648,25 +661,25 @@ VOID LOS_PowerMgrInit(const PowerMgrParameter *para)
// verify and assign input operators. // verify and assign input operators.
if (runOps != NULL) { if (runOps != NULL) {
ASSIGN_MEMBER(&g_pmRunOps, runOps, changeFreq); ASSIGN_MEMBER(&g_pmRunOps, runOps, changeFreq);//改变CPU频率
ASSIGN_MEMBER(&g_pmRunOps, runOps, enterLightSleep); ASSIGN_MEMBER(&g_pmRunOps, runOps, enterLightSleep);//进入浅度睡眠
#ifdef LOSCFG_KERNEL_DEEPSLEEP #ifdef LOSCFG_KERNEL_DEEPSLEEP
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, enterDeepSleep); ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, enterDeepSleep);//进入深度睡眠
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, setWakeUpTimer); ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, setWakeUpTimer);//设置唤醒定时器
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, withdrawWakeUpTimer); ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, withdrawWakeUpTimer);//撤销定时器
#else #else
ASSIGN_MEMBER(&g_pmRunOps, runOps, enterDeepSleep); ASSIGN_MEMBER(&g_pmRunOps, runOps, enterDeepSleep);
ASSIGN_MEMBER(&g_pmRunOps, runOps, setWakeUpTimer); ASSIGN_MEMBER(&g_pmRunOps, runOps, setWakeUpTimer);
ASSIGN_MEMBER(&g_pmRunOps, runOps, withdrawWakeUpTimer); ASSIGN_MEMBER(&g_pmRunOps, runOps, withdrawWakeUpTimer);
#endif #endif
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, getSleepTime); ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, getSleepTime);//货的睡眠时间
ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, selectSleepMode); ASSIGN_MEMBER_NOT_NULL(&g_pmRunOps, runOps, selectSleepMode);//选择不同的睡眠模式
ASSIGN_MEMBER(&g_pmRunOps, runOps, preConfig); ASSIGN_MEMBER(&g_pmRunOps, runOps, preConfig);//预配置
ASSIGN_MEMBER(&g_pmRunOps, runOps, postConfig); ASSIGN_MEMBER(&g_pmRunOps, runOps, postConfig);//后配置
} }
#ifdef LOSCFG_KERNEL_DEEPSLEEP #ifdef LOSCFG_KERNEL_DEEPSLEEP
if (deepSleepOps != NULL) { if (deepSleepOps != NULL) {//进入深度睡眠
ASSIGN_MEMBER(&g_deepSleepOps, deepSleepOps, couldDeepSleep); ASSIGN_MEMBER(&g_deepSleepOps, deepSleepOps, couldDeepSleep);
ASSIGN_MEMBER(&g_deepSleepOps, deepSleepOps, systemWakeup); ASSIGN_MEMBER(&g_deepSleepOps, deepSleepOps, systemWakeup);
ASSIGN_MEMBER(&g_deepSleepOps, deepSleepOps, suspendPreConfig); ASSIGN_MEMBER(&g_deepSleepOps, deepSleepOps, suspendPreConfig);
@ -680,4 +693,7 @@ VOID LOS_PowerMgrInit(const PowerMgrParameter *para)
#endif #endif
// Register PowerMgr to Low-Power Framework. // Register PowerMgr to Low-Power Framework.
LOS_LowpowerInit(&g_pmOps); LOS_LowpowerInit(&g_pmOps);
//将电源管理模块注册到低功耗框架中。
//低功耗框架是一个用于管理处理器和设备进入低功耗模式的软件框架，
//它能够最大限度地降低系统能耗，提高系统的电池寿命
} }

137
src/kernel/extended/lowpower/runstop/src/los_runstop.c
Unescape View File

@ -51,22 +51,28 @@ extern "C" {
/* If core is ready for imaging */ /* If core is ready for imaging */
LITE_OS_SEC_DATA_MINOR STATIC UINT32 g_sysDoneFlag[LOSCFG_KERNEL_CORE_NUM] = { LITE_OS_SEC_DATA_MINOR STATIC UINT32 g_sysDoneFlag[LOSCFG_KERNEL_CORE_NUM] = {
[0 ... (LOSCFG_KERNEL_CORE_NUM - 1)] = OS_NO_STORE_SYSTEM [0 ... (LOSCFG_KERNEL_CORE_NUM - 1)] = OS_NO_STORE_SYSTEM
}; }; /*标记数组状态，用来表示系统是否加载完成*/
/* Start position of flash to write image */ /* Start position of flash to write image */
LITE_OS_SEC_DATA_MINOR STATIC UINTPTR g_flashImgAddr; LITE_OS_SEC_DATA_MINOR STATIC UINTPTR g_flashImgAddr;
/*flash图像地址和大小，用于存储flash相关信息。*/
/* Start position of heap memory after carry the image from flash to memory */ /* Start position of heap memory after carry the image from flash to memory */
LITE_OS_SEC_DATA_MINOR STATIC const VOID *g_heapMemStart = NULL; LITE_OS_SEC_DATA_MINOR STATIC const VOID *g_heapMemStart = NULL;
/*初始化图像地址*/
/* Size of heap memory in image */ /* Size of heap memory in image */
LITE_OS_SEC_DATA_MINOR STATIC size_t g_heapMemSize = 0; LITE_OS_SEC_DATA_MINOR STATIC size_t g_heapMemSize = 0;
/*初始化定义图像大小*/
#ifdef LOSCFG_EXC_INTERACTION #ifdef LOSCFG_EXC_INTERACTION
/* Start position of exc interaction heap memory after carry the image from flash to memory */ /* Start position of exc interaction heap memory after carry the image from flash to memory */
LITE_OS_SEC_DATA_MINOR STATIC const VOID *g_excInteractionMemStart = NULL; LITE_OS_SEC_DATA_MINOR STATIC const VOID *g_excInteractionMemStart = NULL;
/*在存储器映像从闪存复制到内存之后异常交互堆的起始位置变量*/
/* Size of exc interaction heap memory in image */ /* Size of exc interaction heap memory in image */
LITE_OS_SEC_DATA_MINOR STATIC size_t g_excInteractionMemSize = 0; LITE_OS_SEC_DATA_MINOR STATIC size_t g_excInteractionMemSize = 0;
/*异常交互堆内存在储存器映像中的大小*/
#endif #endif
/* Size of wow image */ /* Size of wow image */
LITE_OS_SEC_DATA_MINOR STATIC size_t g_wowImgSize = 0; LITE_OS_SEC_DATA_MINOR STATIC size_t g_wowImgSize = 0;
@ -76,15 +82,17 @@ LITE_OS_SEC_DATA_MINOR STATIC EVENT_CB_S g_suspendResumeEvent;
LITE_OS_SEC_DATA_MINOR STATIC EVENT_CB_S g_writeFlashEvent; LITE_OS_SEC_DATA_MINOR STATIC EVENT_CB_S g_writeFlashEvent;
typedef struct { typedef struct {
UINTPTR memStart; UINTPTR memStart; /*内存起始地址*/
UINTPTR flashStart; UINTPTR flashStart; /*闪存起始地址*/
size_t memSize; size_t memSize; /*存储空间大小*/
} FlashWriteParam; } FlashWriteParam;
BOOL IsImageResume(VOID) BOOL IsImageResume(VOID)
{ {
return (g_resumeFromImg != LOS_COLD_RESET); return (g_resumeFromImg != LOS_COLD_RESET);
} }
/*判断系统是否从存储器映像中恢复的，功能是当系统异常启动或者需要重启的时候就会从内存将其数据保存到闪存中
此函数就是判断系统是否是从存储器映像回复的，从而确定是否需要对系统状态进行恢复*/
LITE_OS_SEC_TEXT_MINOR STATIC VOID OsDoWriteWow2Flash(FLASH_WRITE_FUNC flashWriteFunc, LITE_OS_SEC_TEXT_MINOR STATIC VOID OsDoWriteWow2Flash(FLASH_WRITE_FUNC flashWriteFunc,
const FlashWriteParam *wowSection, const FlashWriteParam *wowSection,
@ -109,29 +117,32 @@ LITE_OS_SEC_TEXT_MINOR STATIC VOID OsDoWriteWow2Flash(FLASH_WRITE_FUNC flashWrit
return; return;
} }
} }
/*首先检查内存中的大小是否为0
LITE_OS_SEC_TEXT_MINOR VOID OsWriteWow2Flash(VOID) 若不为0则将wowsection、excheapsection、heapmemsection中的静态数据和代码存储在系统启动的时候将其从闪存加入到内存中*/
LITE_OS_SEC_TEXT_MINOR VOID OsWriteWow2Flash(VOID) /*根据指定的内存区域，在闪存中写入相应的数据，完成写入操作*/
{ {
FlashWriteParam wowSection; FlashWriteParam wowSection;
FlashWriteParam excHeapSection = {0}; FlashWriteParam excHeapSection = {0};
FlashWriteParam heapMemSection; FlashWriteParam heapMemSection; /*这是三种闪存内部独立的堆专用的内存区域对应的闪存写入参数*/
size_t eraseAlignSize; size_t eraseAlignSize; /*表示闪存擦除时的对齐大小*/
size_t writeAlignSize; size_t writeAlignSize; /*闪存写入时的对齐大小*/
FLASH_WRITE_FUNC flashWriteFunc = g_runstopParam.pfFlashWriteFunc; FLASH_WRITE_FUNC flashWriteFunc = g_runstopParam.pfFlashWriteFunc;
eraseAlignSize = g_runstopParam.uwFlashEraseAlignSize; eraseAlignSize = g_runstopParam.uwFlashEraseAlignSize; /*用来指定擦除和写入时的对齐大小，通常设置为扇区大小的整数倍*/
writeAlignSize = g_runstopParam.uwFlashWriteAlignSize; writeAlignSize = g_runstopParam.uwFlashWriteAlignSize; /*为了避免出现擦除或写入不规则数据的情况，
需要将操作的地址向下或向上舍入到扇区大小的整数倍
从而避免因为不规则的操作而导致数据的错误或损坏。*/
writeAlignSize = (writeAlignSize >= eraseAlignSize) ? writeAlignSize : eraseAlignSize; writeAlignSize = (writeAlignSize >= eraseAlignSize) ? writeAlignSize : eraseAlignSize;
if (flashWriteFunc == NULL) { if (flashWriteFunc == NULL) {
PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__); PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
return; return;
} }
wowSection.memStart = (UINTPTR)&__ram_vectors_vma; wowSection.memStart = (UINTPTR)&__ram_vectors_vma;/*初始化wowSection，为内存中起始地址*/
wowSection.flashStart = g_flashImgAddr; wowSection.flashStart = g_flashImgAddr; /*为闪存中起始地址*/
wowSection.memSize = ((UINTPTR)&__wow_end) - ((UINTPTR)&__ram_vectors_vma); wowSection.memSize = ((UINTPTR)&__wow_end) - ((UINTPTR)&__ram_vectors_vma);
wowSection.memSize = (wowSection.memSize + writeAlignSize - 1) & ~(writeAlignSize - 1); wowSection.memSize = (wowSection.memSize + writeAlignSize - 1) & ~(writeAlignSize - 1);
/*计算了wowSection大小，通过与运算保证每次写入的数据都是整个扇区的倍数*/
#ifdef LOSCFG_EXC_INTERACTION #ifdef LOSCFG_EXC_INTERACTION
excHeapSection.memStart = (UINTPTR)m_aucSysMem0; excHeapSection.memStart = (UINTPTR)m_aucSysMem0;
excHeapSection.flashStart = g_flashImgAddr + wowSection.memSize; excHeapSection.flashStart = g_flashImgAddr + wowSection.memSize;
@ -152,39 +163,41 @@ LITE_OS_SEC_TEXT_MINOR VOID OsWriteWow2Flash(VOID)
g_wowImgSize = wowSection.memSize + heapMemSection.memSize + excHeapSection.memSize; g_wowImgSize = wowSection.memSize + heapMemSection.memSize + excHeapSection.memSize;
OsDoWriteWow2Flash(flashWriteFunc, &wowSection, &excHeapSection, &heapMemSection); OsDoWriteWow2Flash(flashWriteFunc, &wowSection, &excHeapSection, &heapMemSection);
/*将变量传输给函数，由其实现相应的写入操作*/
} }
LITE_OS_SEC_TEXT_MINOR VOID OsSystemSuspend(VOID) LITE_OS_SEC_TEXT_MINOR VOID OsSystemSuspend(VOID) /*实现系统的挂起操作*/
{ {
UINT32 cpuid; UINT32 cpuid; /*获取当前CPU的ID*/
(VOID)LOS_IntLock(); (VOID)LOS_IntLock();
LOS_TaskLock(); LOS_TaskLock();
cpuid = ArchCurrCpuid(); cpuid = ArchCurrCpuid();
/*禁止中断并锁定任务调度器，确保在执行挂起操作期间不会被打断*/
g_sysDoneFlag[cpuid] = OS_NO_STORE_SYSTEM; /*将当前CPU的系统挂起标志设置为不需要保存系统状态*/
g_saveTsk[cpuid] = OsCurrTaskGet(); /*保存当前任务指针到savetask变量中*/
g_sysDoneFlag[cpuid] = OS_NO_STORE_SYSTEM; OsSRSaveRegister(); /*保存当前CPU的寄存器状态，以便在恢复系统时能够正确恢复到挂起前的状态*/
g_saveTsk[cpuid] = OsCurrTaskGet();
OsSRSaveRegister();
/* If 1 core, only to save registers */ /* If 1 core, only to save registers */
if (cpuid != 0) { if (cpuid != 0) { /*若此CPU部位0号内核*/
if (g_otherCoreResume != 0) { if (g_otherCoreResume != 0) { /*说明其他多核核心需要恢复运行*/
HalIrqInitPercpu(); HalIrqInitPercpu();
OsTickStart(); OsTickStart();
LOS_TaskUnlock(); LOS_TaskUnlock();
(VOID)LOS_IntUnLock(); (VOID)LOS_IntUnLock();
return; return;
} }
g_sysDoneFlag[cpuid - 1] = OS_STORE_SYSTEM; g_sysDoneFlag[cpuid - 1] = OS_STORE_SYSTEM; /*需要初始化中断并启动系统时钟，并最终解锁任务调度器并恢复中断*/
while (1) {} while (1) {}
} }
if (g_resumeFromImg) { if (g_resumeFromImg) { /*如果是 0 号 CPU，且系统需要从镜像中恢复（g_resumeFromImg 为真）*/
OsWriteWow2Flash(); OsWriteWow2Flash();
LOS_TaskUnlock(); LOS_TaskUnlock();
(VOID)LOS_IntUnLock(); (VOID)LOS_IntUnLock();
(VOID)LOS_EventWrite(&g_suspendResumeEvent, FLASH_IMG_SUCCESS); (VOID)LOS_EventWrite(&g_suspendResumeEvent, FLASH_IMG_SUCCESS);
} else { /*调用 OsWriteWow2Flash 函数将数据写入闪存，并发送 FLASH_IMG_SUCCESS 事件信号，表示成功从镜像中恢复*/
} else { /*不需要从镜像中恢复*/
OsTickStart(); OsTickStart();
LOS_TaskUnlock(); LOS_TaskUnlock();
(VOID)LOS_IntUnLock(); (VOID)LOS_IntUnLock();
@ -194,9 +207,15 @@ LITE_OS_SEC_TEXT_MINOR VOID OsSystemSuspend(VOID)
} }
(VOID)LOS_EventWrite(&g_suspendResumeEvent, WAKEUP_FROM_SUSPEND); (VOID)LOS_EventWrite(&g_suspendResumeEvent, WAKEUP_FROM_SUSPEND);
} }
/*启动系统时钟，解锁任务调度器和中断，并根据是否设置了空闲唤醒回调函数来执行相应的操作，
最后发送 WAKEUP_FROM_SUSPEND 事件信号，表示从挂起状态唤醒*/
} }
LITE_OS_SEC_TEXT VOID OsWriteToFlashTask(VOID) LITE_OS_SEC_TEXT VOID OsWriteToFlashTask(VOID)
/*初始化了一个事件对象 g_writeFlashEvent
并且在循环中调用 LOS_EventRead 函数等待事件的发生，
并以 OR 模式和清除模式等待事件的标志位为 0x01。
一旦事件发生，它调用 OsSystemSuspend 函数将系统挂起。*/
{ {
(VOID)LOS_EventInit(&g_writeFlashEvent); (VOID)LOS_EventInit(&g_writeFlashEvent);
@ -207,6 +226,10 @@ LITE_OS_SEC_TEXT VOID OsWriteToFlashTask(VOID)
} }
LITE_OS_SEC_TEXT VOID OsStoreSystemInfoBeforeSuspend(VOID) LITE_OS_SEC_TEXT VOID OsStoreSystemInfoBeforeSuspend(VOID)
/*根据当前 CPU 的 ID 判断是否需要挂起系统。
如果当前 CPU 不是 0 号 CPU，直接调用 OsSystemSuspend 函数挂起系统。
如果是 0 号 CPU，则调用 LOS_EventWrite 函数向事件对象 g_writeFlashEvent 发送一个事件，
唤醒 OsWriteToFlashTask 任务来执行挂起操作。*/
{ {
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
if (cpuid != 0) { if (cpuid != 0) {
@ -218,6 +241,9 @@ LITE_OS_SEC_TEXT VOID OsStoreSystemInfoBeforeSuspend(VOID)
} }
LITE_OS_SEC_TEXT_MINOR VOID OsSystemWakeup(VOID) LITE_OS_SEC_TEXT_MINOR VOID OsSystemWakeup(VOID)
/*是系统从挂起状态唤醒后的处理函数。*/
{ {
UINT32 cpuid; UINT32 cpuid;
errno_t err; errno_t err;
@ -225,7 +251,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsSystemWakeup(VOID)
if (!g_resumeFromImg) { if (!g_resumeFromImg) {
return; return;
} }
/*进行一些内存数据的复制操作，然后设置当前 CPU 的任务指针，*/
#ifdef LOSCFG_EXC_INTERACTION #ifdef LOSCFG_EXC_INTERACTION
err = memmove_s(m_aucSysMem0, g_excInteractMemSize, g_excInteractionMemStart, g_excInteractionMemSize); err = memmove_s(m_aucSysMem0, g_excInteractMemSize, g_excInteractionMemStart, g_excInteractionMemSize);
if (err != EOK) { if (err != EOK) {
@ -243,6 +269,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsSystemWakeup(VOID)
cpuid = ArchCurrCpuid(); cpuid = ArchCurrCpuid();
OsCurrTaskSet(g_saveTsk[cpuid]); OsCurrTaskSet(g_saveTsk[cpuid]);
/*设置系统计数器频率。接着，它重置内存池的末尾节点，清零 BSS 区域的数据，重新初始化中断*/
/* Set system counter freq */ /* Set system counter freq */
HalClockFreqWrite(OS_SYS_CLOCK); HalClockFreqWrite(OS_SYS_CLOCK);
dsb(); dsb();
@ -270,7 +297,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsSystemWakeup(VOID)
#ifdef LOSCFG_KERNEL_CPUP #ifdef LOSCFG_KERNEL_CPUP
OsSetCpuCycle(0); OsSetCpuCycle(0);
#endif #endif
/*并调用 OsSRRestoreRegister 函数恢复寄存器状态*/
#if (LOSCFG_KERNEL_SMP == YES) #if (LOSCFG_KERNEL_SMP == YES)
release_secondary_cores(); release_secondary_cores();
#endif #endif
@ -281,32 +308,33 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsWaitImagingDone(UINTPTR wowFlashAddr, size_t *wo
{ {
UINT32 ret; UINT32 ret;
g_flashImgAddr = wowFlashAddr; g_flashImgAddr = wowFlashAddr; /*烧录的flash地址*/
(VOID)LOS_EventInit(&g_suspendResumeEvent); (VOID)LOS_EventInit(&g_suspendResumeEvent); /*指向用于存储烧录镜像大小的变量的指针*/
// This flag will be stored into flash, and will affect the wakeup procedure when cpu is rebooting. // 这个标志将被存储到闪存中，当 CPU 重新启动时，它将影响唤醒流程。
g_resumeFromImg = LOS_RUN_STOP_RESET; g_resumeFromImg = LOS_RUN_STOP_RESET;
// This flag affects the suspending procedure later, // 这个标志会影响之后的挂起过程，并且在 CPU 重新启动时根据 'g_resumeFromImg' 的值进行重置
// and will be reset depending on 'g_resumeFromImg' when cpu is rebooting.
g_otherCoreResume = 0; g_otherCoreResume = 0;
g_sysDoneFlag[LOSCFG_KERNEL_CORE_NUM - 1] = OS_STORE_SYSTEM; g_sysDoneFlag[LOSCFG_KERNEL_CORE_NUM - 1] = OS_STORE_SYSTEM; /*表示系统状态需要被保存*/
ret = LOS_EventRead(&g_suspendResumeEvent, 0xFF, LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER); ret = LOS_EventRead(&g_suspendResumeEvent, 0xFF, LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
/*等待事件发生*/
if (wowImgSize != NULL) { if (wowImgSize != NULL) {
*wowImgSize = g_wowImgSize; *wowImgSize = g_wowImgSize;
} }/*保证能够在烧录完成之后正确的保存和恢复状态*/
return ret; return ret;
} }
LITE_OS_SEC_TEXT_MINOR VOID OsCarryLeftScatter(VOID) LITE_OS_SEC_TEXT_MINOR VOID OsCarryLeftScatter(VOID) /*将位于RAM的数据从指定位置复制到Flash存储器中*/
{ {
size_t size; size_t size;
UINTPTR memAddr; UINTPTR memAddr;
size_t wowSize; size_t wowSize;/*等待复制数据的大小*/
size_t readAlignSize; size_t readAlignSize;/*读取对齐大小*/
size_t eraseAlignSize; size_t eraseAlignSize;/*擦除对齐大小*/
size_t writeAlignSize; size_t writeAlignSize;/*写入对齐大小*/
/*读取所有参数的初始状态*/
UINTPTR imageFlashAddr; UINTPTR imageFlashAddr;
FLASH_READ_FUNC flashReadFunc = g_runstopParam.pfFlashReadFunc; FLASH_READ_FUNC flashReadFunc = g_runstopParam.pfFlashReadFunc;
@ -315,18 +343,19 @@ LITE_OS_SEC_TEXT_MINOR VOID OsCarryLeftScatter(VOID)
eraseAlignSize = g_runstopParam.uwFlashEraseAlignSize; eraseAlignSize = g_runstopParam.uwFlashEraseAlignSize;
writeAlignSize = g_runstopParam.uwFlashWriteAlignSize; writeAlignSize = g_runstopParam.uwFlashWriteAlignSize;
writeAlignSize = (writeAlignSize >= eraseAlignSize) ? writeAlignSize : eraseAlignSize; writeAlignSize = (writeAlignSize >= eraseAlignSize) ? writeAlignSize : eraseAlignSize;
/*计算wowsize的大小，根据对齐大小调整值*/
wowSize = ((UINTPTR)&__wow_end) - ((UINTPTR)&__ram_vectors_vma); wowSize = ((UINTPTR)&__wow_end) - ((UINTPTR)&__ram_vectors_vma);
wowSize = (wowSize + writeAlignSize - 1) & ~(writeAlignSize - 1); wowSize = (wowSize + writeAlignSize - 1) & ~(writeAlignSize - 1);
imageFlashAddr += wowSize; imageFlashAddr += wowSize;
/*检查memaddr是否超出了BSS段的起始地址*/
memAddr = ((UINTPTR)&__ram_vectors_vma) + wowSize; memAddr = ((UINTPTR)&__ram_vectors_vma) + wowSize;
if (memAddr >= ((UINTPTR)&__bss_start)) { if (memAddr >= ((UINTPTR)&__bss_start)) {
return; return;
} }
/*计算了要复制的数据大小，在磁盘中根据对齐大小调整size*/
size = ((UINTPTR)&__int_stack_start) - memAddr; size = ((UINTPTR)&__int_stack_start) - memAddr;
size = (size + readAlignSize - 1) & ~(readAlignSize - 1); size = (size + readAlignSize - 1) & ~(readAlignSize - 1);
/*将RAM中的数据从memaddr复制到flash存储器的imageflashaddr，进行缓存和同步操作*/
if ((flashReadFunc != NULL) && (flashReadFunc((VOID *)memAddr, imageFlashAddr, size) != 0)) { if ((flashReadFunc != NULL) && (flashReadFunc((VOID *)memAddr, imageFlashAddr, size) != 0)) {
PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__); PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
} }
@ -336,6 +365,8 @@ LITE_OS_SEC_TEXT_MINOR VOID OsCarryLeftScatter(VOID)
} }
LITE_OS_SEC_TEXT_MINOR VOID OsRunstopParamInit(const RUNSTOP_PARAM_S *runstopParam) LITE_OS_SEC_TEXT_MINOR VOID OsRunstopParamInit(const RUNSTOP_PARAM_S *runstopParam)
/*初始化运行暂停功能所需的参数，保存在全局变量g_中，以便告诉计算机目前的系统转台
包含了运行暂停功能所需的各个回调函数和对齐大小等参数*/
{ {
g_runstopParam.pfIdleWakeupCallback = runstopParam->pfIdleWakeupCallback; g_runstopParam.pfIdleWakeupCallback = runstopParam->pfIdleWakeupCallback;
g_runstopParam.pfWakeupCallback = runstopParam->pfWakeupCallback; g_runstopParam.pfWakeupCallback = runstopParam->pfWakeupCallback;
@ -350,28 +381,31 @@ LITE_OS_SEC_TEXT_MINOR VOID OsRunstopParamInit(const RUNSTOP_PARAM_S *runstopPar
} }
LITE_OS_SEC_TEXT_MINOR VOID LOS_MakeImage(RUNSTOP_PARAM_S *runstopParam) LITE_OS_SEC_TEXT_MINOR VOID LOS_MakeImage(RUNSTOP_PARAM_S *runstopParam)
/*用于除法运行暂停功能的操作，并根据返回值进行相应处理*/
{ {
UINT32 ret; UINT32 ret;
size_t imgSize; size_t imgSize;
/*检查是否需要暂停*/
if (runstopParam == NULL) { if (runstopParam == NULL) {
return; return;
} }
/*调用函数，将传入的runstopparam转换为全局变量*/
OsRunstopParamInit(runstopParam); OsRunstopParamInit(runstopParam);
ret = OsWaitImagingDone(g_runstopParam.uwWowFlashAddr, &imgSize); ret = OsWaitImagingDone(g_runstopParam.uwWowFlashAddr, &imgSize);
if (ret == WAKEUP_FROM_SUSPEND) { /*用于等待图像转移完成，范围相应的状态码ret和图像大小imgsize*/
if (ret == WAKEUP_FROM_SUSPEND) { /*从暂停状态唤醒，并查看系统是否需要空闲唤醒回调*/
if (g_runstopParam.pfWakeupCallback != NULL) { if (g_runstopParam.pfWakeupCallback != NULL) {
g_runstopParam.pfWakeupCallback(); g_runstopParam.pfWakeupCallback();
} }
OsCarryLeftScatter(); OsCarryLeftScatter(); /*将RAM中的数据复制到Flash存储器*/
PRINT_INFO("Resume ok!\n"); PRINT_INFO("Resume ok!\n");
} else if (ret == FLASH_IMG_SUCCESS) { } else if (ret == FLASH_IMG_SUCCESS) { /*闪存图像成功*/
if (g_runstopParam.pfImageDoneCallback != NULL) { if (g_runstopParam.pfImageDoneCallback != NULL) {
g_runstopParam.pfImageDoneCallback(); g_runstopParam.pfImageDoneCallback();
} }
PRINT_INFO("Flash ok! Image length 0x%x\n", imgSize); PRINT_INFO("Flash ok! Image length 0x%x\n", imgSize);/*图像转移成功，并打印图像大小*/
} }
} }
@ -380,8 +414,9 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsWowWriteFlashTaskCreate(VOID)
UINT32 ret; UINT32 ret;
UINT32 writeFlashTaskId; UINT32 writeFlashTaskId;
TSK_INIT_PARAM_S taskInitParam; TSK_INIT_PARAM_S taskInitParam;
/*首先对任务初始化参数进行了清零操作*/
(VOID)memset_s((VOID *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S)); (VOID)memset_s((VOID *)(&taskInitParam), sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
/*设置了任务入口函数，并且制定了任务的堆栈大小，任务名和优先级*/
taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsWriteToFlashTask; taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsWriteToFlashTask;
taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE; taskInitParam.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
taskInitParam.pcName = "WowWriteFlashTask"; taskInitParam.pcName = "WowWriteFlashTask";
@ -389,24 +424,28 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsWowWriteFlashTaskCreate(VOID)
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(0); taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(0);
#endif #endif
/*创建任务，返回结果*/
ret = LOS_TaskCreate(&writeFlashTaskId, &taskInitParam); ret = LOS_TaskCreate(&writeFlashTaskId, &taskInitParam);
return ret; return ret;
} }
LITE_OS_SEC_TEXT_MINOR size_t OsWowImageSizeGet(VOID) LITE_OS_SEC_TEXT_MINOR size_t OsWowImageSizeGet(VOID)
/*获取wow图像的大小，返回全局变量*/
{ {
return g_wowImgSize; return g_wowImgSize;
} }
LITE_OS_SEC_TEXT_MINOR UINT32 OsWowSysDoneFlagGet(VOID) LITE_OS_SEC_TEXT_MINOR UINT32 OsWowSysDoneFlagGet(VOID)
/*获取wow系统完成的标志*/
{ {
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
return g_sysDoneFlag[cpuid]; return g_sysDoneFlag[cpuid];
} }
LITE_OS_SEC_TEXT_MINOR VOID OsWowOtherCoreResume(UINT32 cpuid) LITE_OS_SEC_TEXT_MINOR VOID OsWowOtherCoreResume(UINT32 cpuid)
/*唤醒其他的核心*/
{ {
if (g_otherCoreResume == 1) { if (g_otherCoreResume == 1) { /*全局变量的值为1则表示需要唤醒其他核心*/
OsCurrTaskSet(g_saveTsk[cpuid]); OsCurrTaskSet(g_saveTsk[cpuid]);
OsSRRestoreRegister(); OsSRRestoreRegister();
} }

29
src/kernel/extended/lowpower/tickless/los_tickless.c
Unescape View File

@ -46,17 +46,18 @@ STATIC volatile UINT32 g_sleepTicks[LOSCFG_KERNEL_CORE_NUM] = {0};
(((GET_SYS_CLOCK()) / (g_tickPerSecond)) - (cyclesCur)) : \ (((GET_SYS_CLOCK()) / (g_tickPerSecond)) - (cyclesCur)) : \
((((GET_SYS_CLOCK()) / (g_tickPerSecond)) << 1) - (cyclesCur))) ((((GET_SYS_CLOCK()) / (g_tickPerSecond)) << 1) - (cyclesCur)))
LITE_OS_SEC_TEXT VOID LOS_TicklessEnable(VOID) LITE_OS_SEC_TEXT VOID LOS_TicklessEnable(VOID) /*开启Tickless功能*/
{ {
g_ticklessFlag = TRUE; g_ticklessFlag = TRUE;
/*变量表示Tickless功能的开启状态，为TRUE表示已开启，为FALSE表示已关闭。*/
} }
LITE_OS_SEC_TEXT VOID LOS_TicklessDisable(VOID) LITE_OS_SEC_TEXT VOID LOS_TicklessDisable(VOID) /*开启Tickless功能*/
{ {
g_ticklessFlag = FALSE; g_ticklessFlag = FALSE;
} }
LITE_OS_SEC_TEXT BOOL OsTicklessFlagGet(VOID) LITE_OS_SEC_TEXT BOOL OsTicklessFlagGet(VOID) /*用于获取Tickless标志的状态*/
{ {
return g_ticklessFlag; return g_ticklessFlag;
} }
@ -64,24 +65,27 @@ LITE_OS_SEC_TEXT BOOL OsTicklessFlagGet(VOID)
LITE_OS_SEC_TEXT BOOL OsTickIrqFlagGet(VOID) LITE_OS_SEC_TEXT BOOL OsTickIrqFlagGet(VOID)
{ {
return g_tickIrqFlag[ArchCurrCpuid()]; return g_tickIrqFlag[ArchCurrCpuid()];
/*数组表示每个核心的Tick中断标志的状态，
为TRUE表示中断正在处理中，为FALSE表示中断未处理。*/
} }
LITE_OS_SEC_TEXT VOID OsTickIrqFlagSet(BOOL tickIrqFlag) LITE_OS_SEC_TEXT VOID OsTickIrqFlagSet(BOOL tickIrqFlag) /*用于设置当前核心的时钟中断标志*/
{ {
g_tickIrqFlag[ArchCurrCpuid()] = tickIrqFlag; g_tickIrqFlag[ArchCurrCpuid()] = tickIrqFlag;
} }
LITE_OS_SEC_TEXT UINT32 OsTicklessSleepTickGet(VOID) LITE_OS_SEC_TEXT UINT32 OsTicklessSleepTickGet(VOID) /*用于获取当前系统的睡眠计时器的数值*/
{ {
return g_sleepTicks[ArchCurrCpuid()]; return g_sleepTicks[ArchCurrCpuid()];
} }
LITE_OS_SEC_TEXT VOID OsTicklessSleepTickSet(UINT32 sleeptick) LITE_OS_SEC_TEXT VOID OsTicklessSleepTickSet(UINT32 sleeptick) /*设置当前核心得到睡眠计时器的数值*/
{ {
g_sleepTicks[ArchCurrCpuid()] = sleeptick; g_sleepTicks[ArchCurrCpuid()] = sleeptick;
} }
LITE_OS_SEC_TEXT UINT32 OsSleepTicksGet(VOID) LITE_OS_SEC_TEXT UINT32 OsSleepTicksGet(VOID) /*函数用于获取当前需要休眠的ticks数，通过查询任务链表和软件定时器链表，
找到最小的定时器到期时间，作为休眠时长。*/
{ {
UINT32 tskSortLinkTicks, sleepTicks; UINT32 tskSortLinkTicks, sleepTicks;
@ -104,7 +108,8 @@ LITE_OS_SEC_TEXT UINT32 OsSleepTicksGet(VOID)
return sleepTicks; return sleepTicks;
} }
LITE_OS_SEC_TEXT VOID OsSysTimeUpdate(UINT32 sleepTicks) LITE_OS_SEC_TEXT VOID OsSysTimeUpdate(UINT32 sleepTicks) /*用于更新系统时间，
根据休眠时长更新全局计数器和任务链表、软件定时器链表的到期时间*/
{ {
UINT32 intSave; UINT32 intSave;
@ -127,7 +132,7 @@ LITE_OS_SEC_TEXT VOID OsSysTimeUpdate(UINT32 sleepTicks)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
VOID OsTicklessUpdate(UINT32 irqnum) VOID OsTicklessUpdate(UINT32 irqnum) /*OsTicklessUpdate函数用于在发生中断时更新系统时间*/
{ {
UINT32 cycles, ticks; UINT32 cycles, ticks;
UINT32 cyclesPertick; UINT32 cyclesPertick;
@ -165,7 +170,8 @@ VOID OsTicklessUpdate(UINT32 irqnum)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
VOID OsTicklessStart(VOID) VOID OsTicklessStart(VOID) /*Tickless模式的入口函数，根据休眠时长计算需要延迟的周期数，
并设置定时器的重载值，启动Tickless模式。*/
{ {
UINT32 intSave; UINT32 intSave;
/* /*
@ -202,7 +208,8 @@ VOID OsTicklessStart(VOID)
return; return;
} }
VOID OsTicklessOpen(VOID) VOID OsTicklessOpen(VOID) /*在Tick中断处理函数中开启Tickless模式。
当Tick中断处理函数检测到Tickless标志为1时，调用该函数启动Tickless模式。*/
{ {
if (OsTickIrqFlagGet()) { if (OsTickIrqFlagGet()) {
OsTickIrqFlagSet(0); OsTickIrqFlagSet(0);

101
src/kernel/extended/perf/los_perf.c
Unescape View File

@ -37,10 +37,11 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#ifdef LOSCFG_KERNEL_PERF #ifdef LOSCFG_KERNEL_PERF
STATIC Pmu *g_pmu = NULL; STATIC Pmu *g_pmu = NULL;//用于保存当前系统中所使用的硬件性能计数器
STATIC PerfCB g_perfCb = {0}; STATIC PerfCB g_perfCb = {0};//保存了性能测量回调函数和一些测量结果数据
LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_perfSpin); LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_perfSpin);
//定义了一个自旋锁 g_perfSpin，用于保护性能测量模块在多线程环境下的并发访问
#define PERF_LOCK(state) LOS_SpinLockSave(&g_perfSpin, &(state)) #define PERF_LOCK(state) LOS_SpinLockSave(&g_perfSpin, &(state))
#define PERF_UNLOCK(state) LOS_SpinUnlockRestore(&g_perfSpin, (state)) #define PERF_UNLOCK(state) LOS_SpinUnlockRestore(&g_perfSpin, (state))
@ -55,8 +56,9 @@ STATIC INLINE UINT64 OsPerfGetCurrTime(VOID)
#endif #endif
} }
STATIC UINT32 OsPmuInit(VOID) STATIC UINT32 OsPmuInit(VOID)//初始化性能计数器
{ {
//判断是否开启了计数器
#ifdef LOSCFG_PERF_HW_PMU #ifdef LOSCFG_PERF_HW_PMU
if (OsHwPmuInit() != LOS_OK) { if (OsHwPmuInit() != LOS_OK) {
return LOS_ERRNO_PERF_HW_INIT_ERROR; return LOS_ERRNO_PERF_HW_INIT_ERROR;
@ -77,13 +79,13 @@ STATIC UINT32 OsPmuInit(VOID)
return LOS_OK; return LOS_OK;
} }
STATIC UINT32 OsPerfConfig(PerfEventConfig *eventsCfg) STATIC UINT32 OsPerfConfig(PerfEventConfig *eventsCfg)//配置性能计数器
{ {
UINT32 i; UINT32 i;
UINT32 ret; UINT32 ret;
g_pmu = OsPerfPmuGet(eventsCfg->type); g_pmu = OsPerfPmuGet(eventsCfg->type);
if (g_pmu == NULL) { if (g_pmu == NULL) {//根据配置的类型获取对应的性能计数器对象
PRINT_ERR("perf config type error %u!\n", eventsCfg->type); PRINT_ERR("perf config type error %u!\n", eventsCfg->type);
return LOS_ERRNO_PERF_INVALID_PMU; return LOS_ERRNO_PERF_INVALID_PMU;
} }
@ -92,6 +94,7 @@ STATIC UINT32 OsPerfConfig(PerfEventConfig *eventsCfg)
(VOID)memset_s(&g_pmu->events, sizeof(PerfEvent), 0, sizeof(PerfEvent)); (VOID)memset_s(&g_pmu->events, sizeof(PerfEvent), 0, sizeof(PerfEvent));
//根据配置信息设置各性能事件的参数，调用性能计数器对象的配置函数进行配置
for (i = 0; i < eventNum; i++) { for (i = 0; i < eventNum; i++) {
g_pmu->events.per[i].eventId = eventsCfg->events[i].eventId; g_pmu->events.per[i].eventId = eventsCfg->events[i].eventId;
g_pmu->events.per[i].period = eventsCfg->events[i].period; g_pmu->events.per[i].period = eventsCfg->events[i].period;
@ -109,13 +112,13 @@ STATIC UINT32 OsPerfConfig(PerfEventConfig *eventsCfg)
return LOS_OK; return LOS_OK;
} }
STATIC VOID OsPerfPrintCount(VOID) STATIC VOID OsPerfPrintCount(VOID)//用于打印性能计数器的统计信息
{ {
UINT32 index; UINT32 index;
UINT32 intSave; UINT32 intSave;
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
PerfEvent *events = &g_pmu->events; PerfEvent *events = &g_pmu->events;//获取性能计数器对象的性能时间数组和事件数量
UINT32 eventNum = events->nr; UINT32 eventNum = events->nr;
PERF_LOCK(intSave); PERF_LOCK(intSave);
@ -123,7 +126,7 @@ STATIC VOID OsPerfPrintCount(VOID)
Event *event = &(events->per[index]); Event *event = &(events->per[index]);
/* filter out event counter with no event binded. */ /* filter out event counter with no event binded. */
if (event->period == 0) { if (event->period == 0) { //事件周期
continue; continue;
} }
PRINT_EMG("[%s] eventType: 0x%x [core %u]: %llu\n", g_pmu->getName(event), event->eventId, cpuid, PRINT_EMG("[%s] eventType: 0x%x [core %u]: %llu\n", g_pmu->getName(event), event->eventId, cpuid,
@ -132,7 +135,7 @@ STATIC VOID OsPerfPrintCount(VOID)
PERF_UNLOCK(intSave); PERF_UNLOCK(intSave);
} }
STATIC INLINE VOID OsPerfPrintTs(VOID) STATIC INLINE VOID OsPerfPrintTs(VOID)//打印时间信息
{ {
#ifdef LOSCFG_PERF_CALC_TIME_BY_TICK #ifdef LOSCFG_PERF_CALC_TIME_BY_TICK
DOUBLE time = (g_perfCb.endTime - g_perfCb.startTime) * 1.0 / LOSCFG_BASE_CORE_TICK_PER_SECOND; DOUBLE time = (g_perfCb.endTime - g_perfCb.startTime) * 1.0 / LOSCFG_BASE_CORE_TICK_PER_SECOND;
@ -142,7 +145,7 @@ STATIC INLINE VOID OsPerfPrintTs(VOID)
PRINT_EMG("time used: %.6f(s)\r\n", time); PRINT_EMG("time used: %.6f(s)\r\n", time);
} }
STATIC VOID OsPerfStart(VOID) STATIC VOID OsPerfStart(VOID)//启动及更新CPU和计数器状态
{ {
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
@ -152,7 +155,7 @@ STATIC VOID OsPerfStart(VOID)
} }
if (g_perfCb.pmuStatusPerCpu[cpuid] != PERF_PMU_STARTED) { if (g_perfCb.pmuStatusPerCpu[cpuid] != PERF_PMU_STARTED) {
UINT32 ret = g_pmu->start(); UINT32 ret = g_pmu->start();//若计数器未启动则启动
if (ret != LOS_OK) { if (ret != LOS_OK) {
PRINT_ERR("perf start on core:%u failed, ret = 0x%x\n", cpuid, ret); PRINT_ERR("perf start on core:%u failed, ret = 0x%x\n", cpuid, ret);
return; return;
@ -164,7 +167,7 @@ STATIC VOID OsPerfStart(VOID)
} }
} }
STATIC VOID OsPerfStop(VOID) STATIC VOID OsPerfStop(VOID)//停止性能计数器
{ {
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
@ -191,19 +194,21 @@ STATIC VOID OsPerfStop(VOID)
} }
STATIC UINT32 OsPerfBackTrace(UINTPTR *callChain, UINT32 maxDepth, PerfRegs *regs) STATIC UINT32 OsPerfBackTrace(UINTPTR *callChain, UINT32 maxDepth, PerfRegs *regs)
//获取当前函数调用链的信息，并将结果存储在 callChain 数组中
{ {
UINT32 i; UINT32 i;
UINT32 count = ArchBackTraceGet(regs->fp, callChain, maxDepth); UINT32 count = ArchBackTraceGet(regs->fp, callChain, maxDepth);//获取当前状态的帧指针值
PRINT_DEBUG("backtrace depth = %u, fp = 0x%x\n", count, regs->fp); PRINT_DEBUG("backtrace depth = %u, fp = 0x%x\n", count, regs->fp);
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
PRINT_DEBUG("ip[%u]: 0x%x\n", i, callChain[i]); PRINT_DEBUG("ip[%u]: 0x%x\n", i, callChain[i]);//打印调用链中每个函数的指令地址
} }
return count; return count;//返回用链的深度
} }
STATIC UINT32 OsPerfCollectData(Event *event, PerfSampleData *data, PerfRegs *regs) STATIC UINT32 OsPerfCollectData(Event *event, PerfSampleData *data, PerfRegs *regs)
//收集性能计数器的数据，并将其存储在 data 结构体中
{ {
UINT32 size = 0; UINT32 size = 0;
UINT32 depth; UINT32 depth;
@ -211,12 +216,12 @@ STATIC UINT32 OsPerfCollectData(Event *event, PerfSampleData *data, PerfRegs *re
CHAR *p = (CHAR *)data; CHAR *p = (CHAR *)data;
if (sampleType & PERF_RECORD_CPU) { if (sampleType & PERF_RECORD_CPU) {
*(UINT32 *)(p + size) = ArchCurrCpuid(); *(UINT32 *)(p + size) = ArchCurrCpuid();//函数获取当前CPU的ID，并存储在 data->cpuid 字段中
size += sizeof(data->cpuid); size += sizeof(data->cpuid);
} }
if (sampleType & PERF_RECORD_TID) { if (sampleType & PERF_RECORD_TID) {
*(UINT32 *)(p + size) = LOS_CurTaskIDGet(); *(UINT32 *)(p + size) = LOS_CurTaskIDGet();// 函数获取当前任务的ID，并存储在 data->taskId 字段中
size += sizeof(data->taskId); size += sizeof(data->taskId);
} }
@ -231,7 +236,7 @@ STATIC UINT32 OsPerfCollectData(Event *event, PerfSampleData *data, PerfRegs *re
} }
if (sampleType & PERF_RECORD_TIMESTAMP) { if (sampleType & PERF_RECORD_TIMESTAMP) {
*(UINT64 *)(p + size) = OsPerfGetCurrTime(); *(UINT64 *)(p + size) = OsPerfGetCurrTime();//获取当前时间戳，并存储在 data->time 字段中
size += sizeof(data->time); size += sizeof(data->time);
} }
@ -254,7 +259,7 @@ STATIC UINT32 OsPerfCollectData(Event *event, PerfSampleData *data, PerfRegs *re
* return TRUE if user haven't specified any taskId(which is supposed * return TRUE if user haven't specified any taskId(which is supposed
* to instrument the whole system) * to instrument the whole system)
*/ */
STATIC BOOL OsPerfTaskFilter(UINT32 taskId) STATIC BOOL OsPerfTaskFilter(UINT32 taskId)//过滤任务ID，判断一个给定的任务ID是否需要进行性能优化
{ {
UINT32 i; UINT32 i;
@ -262,7 +267,7 @@ STATIC BOOL OsPerfTaskFilter(UINT32 taskId)
return TRUE; return TRUE;
} }
for (i = 0; i < g_perfCb.taskIdsNr; i++) { for (i = 0; i < g_perfCb.taskIdsNr; i++) { //储存允许过滤任务ID的列表
if (g_perfCb.taskIds[i] == taskId) { if (g_perfCb.taskIds[i] == taskId) {
return TRUE; return TRUE;
} }
@ -270,7 +275,7 @@ STATIC BOOL OsPerfTaskFilter(UINT32 taskId)
return FALSE; return FALSE;
} }
STATIC INLINE UINT32 OsPerfParamValid(VOID) STATIC INLINE UINT32 OsPerfParamValid(VOID)//检查性能函数的有效性
{ {
UINT32 index; UINT32 index;
UINT32 res = 0; UINT32 res = 0;
@ -287,7 +292,7 @@ STATIC INLINE UINT32 OsPerfParamValid(VOID)
return res; return res;
} }
STATIC UINT32 OsPerfHdrInit(UINT32 id) STATIC UINT32 OsPerfHdrInit(UINT32 id)//初始化性能数据的头部信息
{ {
PerfDataHdr head = { PerfDataHdr head = {
.magic = PERF_DATA_MAGIC_WORD, .magic = PERF_DATA_MAGIC_WORD,
@ -299,7 +304,7 @@ STATIC UINT32 OsPerfHdrInit(UINT32 id)
return OsPerfOutPutWrite((CHAR *)&head, head.len); return OsPerfOutPutWrite((CHAR *)&head, head.len);
} }
VOID OsPerfUpdateEventCount(Event *event, UINT32 value) VOID OsPerfUpdateEventCount(Event *event, UINT32 value)//更新上传事件的技术
{ {
if (event == NULL) { if (event == NULL) {
return; return;
@ -307,46 +312,46 @@ VOID OsPerfUpdateEventCount(Event *event, UINT32 value)
event->count[ArchCurrCpuid()] += (value & 0xFFFFFFFF); /* event->count is UINT64 */ event->count[ArchCurrCpuid()] += (value & 0xFFFFFFFF); /* event->count is UINT64 */
} }
VOID OsPerfHandleOverFlow(Event *event, PerfRegs *regs) VOID OsPerfHandleOverFlow(Event *event, PerfRegs *regs)//处理性能计数器溢出的情况
{ {
PerfSampleData data; PerfSampleData data;
UINT32 len; UINT32 len;
(VOID)memset_s(&data, sizeof(PerfSampleData), 0, sizeof(PerfSampleData)); (VOID)memset_s(&data, sizeof(PerfSampleData), 0, sizeof(PerfSampleData));
if ((g_perfCb.needSample) && OsPerfTaskFilter(LOS_CurTaskIDGet())) { if ((g_perfCb.needSample) && OsPerfTaskFilter(LOS_CurTaskIDGet())) {//判断是否优化
len = OsPerfCollectData(event, &data, regs); len = OsPerfCollectData(event, &data, regs);
OsPerfOutPutWrite((CHAR *)&data, len); OsPerfOutPutWrite((CHAR *)&data, len);
} }
} }
UINT32 LOS_PerfInit(VOID *buf, UINT32 size) UINT32 LOS_PerfInit(VOID *buf, UINT32 size)//初始化性能统计模块
{ {
UINT32 ret; UINT32 ret;
UINT32 intSave; UINT32 intSave;
PERF_LOCK(intSave); PERF_LOCK(intSave);//保存中断状态
if (g_perfCb.status != PERF_UNINIT) { if (g_perfCb.status != PERF_UNINIT) {
ret = LOS_ERRNO_PERF_STATUS_INVALID; ret = LOS_ERRNO_PERF_STATUS_INVALID;
goto PERF_INIT_ERROR; goto PERF_INIT_ERROR;
} }
ret = OsPmuInit(); ret = OsPmuInit();//函数性能计数器初始化
if (ret != LOS_OK) { if (ret != LOS_OK) {
goto PERF_INIT_ERROR; goto PERF_INIT_ERROR;
} }
ret = OsPerfOutPutInit(buf, size); ret = OsPerfOutPutInit(buf, size);//性能输出缓冲区进行初始化
if (ret != LOS_OK) { if (ret != LOS_OK) {
ret = LOS_ERRNO_PERF_BUF_ERROR; ret = LOS_ERRNO_PERF_BUF_ERROR;
goto PERF_INIT_ERROR; goto PERF_INIT_ERROR;
} }
g_perfCb.status = PERF_STOPED; g_perfCb.status = PERF_STOPED;
PERF_INIT_ERROR: PERF_INIT_ERROR:
PERF_UNLOCK(intSave); PERF_UNLOCK(intSave);//解锁中断处理
return ret; return ret;
} }
UINT32 LOS_PerfConfig(PerfConfigAttr *attr) UINT32 LOS_PerfConfig(PerfConfigAttr *attr)//配置性能统计模块的属性
{ {
UINT32 ret; UINT32 ret;
UINT32 intSave; UINT32 intSave;
@ -355,20 +360,20 @@ UINT32 LOS_PerfConfig(PerfConfigAttr *attr)
return LOS_ERRNO_PERF_CONFIG_NULL; return LOS_ERRNO_PERF_CONFIG_NULL;
} }
PERF_LOCK(intSave); PERF_LOCK(intSave);//保存中断状态
if (g_perfCb.status != PERF_STOPED) { if (g_perfCb.status != PERF_STOPED) {
ret = LOS_ERRNO_PERF_STATUS_INVALID; ret = LOS_ERRNO_PERF_STATUS_INVALID;
PRINT_ERR("perf config status error : 0x%x\n", g_perfCb.status); PRINT_ERR("perf config status error : 0x%x\n", g_perfCb.status);
goto PERF_CONFIG_ERROR; goto PERF_CONFIG_ERROR;
} }
g_pmu = NULL; g_pmu = NULL;//将全局标量PMU计数器置零
g_perfCb.needSample = attr->needSample; g_perfCb.needSample = attr->needSample;
g_perfCb.taskFilterEnable = attr->taskFilterEnable; g_perfCb.taskFilterEnable = attr->taskFilterEnable;
g_perfCb.sampleType = attr->sampleType; g_perfCb.sampleType = attr->sampleType;
if (attr->taskFilterEnable) { if (attr->taskFilterEnable) {//开启任务过滤功能
ret = memcpy_s(g_perfCb.taskIds, PERF_MAX_FILTER_TSKS * sizeof(UINT32), attr->taskIds, ret = memcpy_s(g_perfCb.taskIds, PERF_MAX_FILTER_TSKS * sizeof(UINT32), attr->taskIds,
g_perfCb.taskIdsNr * sizeof(UINT32)); g_perfCb.taskIdsNr * sizeof(UINT32));
if (ret != EOK) { if (ret != EOK) {
@ -377,29 +382,29 @@ UINT32 LOS_PerfConfig(PerfConfigAttr *attr)
} }
g_perfCb.taskIdsNr = MIN(attr->taskIdsNr, PERF_MAX_FILTER_TSKS); g_perfCb.taskIdsNr = MIN(attr->taskIdsNr, PERF_MAX_FILTER_TSKS);
} }
ret = OsPerfConfig(&attr->eventsCfg); ret = OsPerfConfig(&attr->eventsCfg);//对事件配置进行处理
PERF_CONFIG_ERROR: PERF_CONFIG_ERROR:
PERF_UNLOCK(intSave); PERF_UNLOCK(intSave);
return ret; return ret;
} }
VOID LOS_PerfStart(UINT32 sectionId) VOID LOS_PerfStart(UINT32 sectionId)//启动性能统计模块
{ {
UINT32 intSave; UINT32 intSave;
UINT32 ret; UINT32 ret;
PERF_LOCK(intSave); PERF_LOCK(intSave);
if (g_perfCb.status != PERF_STOPED) { if (g_perfCb.status != PERF_STOPED) {//判断统计模块是否打开
PRINT_ERR("perf start status error : 0x%x\n", g_perfCb.status); PRINT_ERR("perf start status error : 0x%x\n", g_perfCb.status);
goto PERF_START_ERROR; goto PERF_START_ERROR;
} }
if (!OsPerfParamValid()) { if (!OsPerfParamValid()) {//检车行呢个统计模块的参数是否有效
PRINT_ERR("forgot call `LOS_Config(...)` before instrumenting?\n"); PRINT_ERR("forgot call `LOS_Config(...)` before instrumenting?\n");
goto PERF_START_ERROR; goto PERF_START_ERROR;
} }
if (g_perfCb.needSample) { if (g_perfCb.needSample) {//判断是否需要抽样
ret = OsPerfHdrInit(sectionId); /* section header init */ ret = OsPerfHdrInit(sectionId); /* section header init */
if (ret != LOS_OK) { if (ret != LOS_OK) {
PRINT_ERR("perf hdr init error 0x%x\n", ret); PRINT_ERR("perf hdr init error 0x%x\n", ret);
@ -407,7 +412,7 @@ VOID LOS_PerfStart(UINT32 sectionId)
} }
} }
SMP_CALL_PERF_FUNC(OsPerfStart); /* send to all cpu to start pmu */ SMP_CALL_PERF_FUNC(OsPerfStart); /* 所有CPU开始PMU计数器，启动性能统计模块i奥 */
g_perfCb.status = PERF_STARTED; g_perfCb.status = PERF_STARTED;
g_perfCb.startTime = OsPerfGetCurrTime(); g_perfCb.startTime = OsPerfGetCurrTime();
PERF_START_ERROR: PERF_START_ERROR:
@ -415,7 +420,7 @@ PERF_START_ERROR:
return; return;
} }
VOID LOS_PerfStop(VOID) VOID LOS_PerfStop(VOID)//停止性能统计模块的运行，进行一些清理操作
{ {
UINT32 intSave; UINT32 intSave;
@ -427,12 +432,12 @@ VOID LOS_PerfStop(VOID)
SMP_CALL_PERF_FUNC(OsPerfStop); /* send to all cpu to stop pmu */ SMP_CALL_PERF_FUNC(OsPerfStop); /* send to all cpu to stop pmu */
OsPerfOutPutFlush(); OsPerfOutPutFlush();//刷新输出操作
if (g_perfCb.needSample) { if (g_perfCb.needSample) {
OsPerfOutPutInfo(); OsPerfOutPutInfo();
} }
//更新了两个全局变量的值，表示性能统计模块已经在状态上和时间上停止了
g_perfCb.status = PERF_STOPED; g_perfCb.status = PERF_STOPED;
g_perfCb.endTime = OsPerfGetCurrTime(); g_perfCb.endTime = OsPerfGetCurrTime();
@ -442,21 +447,21 @@ PERF_STOP_ERROR:
return; return;
} }
UINT32 LOS_PerfDataRead(CHAR *dest, UINT32 size) UINT32 LOS_PerfDataRead(CHAR *dest, UINT32 size)//从性能统计门票快的输出缓冲区中读取数据到指定的内存
{ {
return OsPerfOutPutRead(dest, size); return OsPerfOutPutRead(dest, size);
} }
VOID LOS_PerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func) VOID LOS_PerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func)//注册型那个统计模块的通知hook函数
{ {
UINT32 intSave; UINT32 intSave;
//保存中断状态，恢复中断状态
PERF_LOCK(intSave); PERF_LOCK(intSave);
OsPerfNotifyHookReg(func); OsPerfNotifyHookReg(func);
PERF_UNLOCK(intSave); PERF_UNLOCK(intSave);
} }
VOID LOS_PerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func) VOID LOS_PerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func)//刷新hook
{ {
UINT32 intSave; UINT32 intSave;
@ -465,7 +470,7 @@ VOID LOS_PerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func)
PERF_UNLOCK(intSave); PERF_UNLOCK(intSave);
} }
VOID OsPerfSetIrqRegs(UINTPTR pc, UINTPTR fp) VOID OsPerfSetIrqRegs(UINTPTR pc, UINTPTR fp)//设置中断相关的寄存器，用于中断时的性能统计
{ {
LosTaskCB *runTask = (LosTaskCB *)ArchCurrTaskGet(); LosTaskCB *runTask = (LosTaskCB *)ArchCurrTaskGet();
runTask->pc = pc; runTask->pc = pc;

22
src/kernel/extended/perf/perf_output.c
Unescape View File

@ -39,11 +39,14 @@ STATIC PERF_BUF_FLUSH_HOOK g_perfBufFlushHook = NULL;
STATIC PerfOutputCB g_perfOutputCb; STATIC PerfOutputCB g_perfOutputCb;
STATIC VOID OsPerfDefaultNotify(VOID) STATIC VOID OsPerfDefaultNotify(VOID)
//默认的性能缓冲区通知回调函数，在性能缓冲区的水位线达到一定值时打印一条信息
{ {
PRINT_INFO("perf buf waterline notify!\n"); PRINT_INFO("perf buf waterline notify!\n");
} }
UINT32 OsPerfOutPutInit(VOID *buf, UINT32 size) UINT32 OsPerfOutPutInit(VOID *buf, UINT32 size)
//初始化性能输出模块。如果传入的缓冲区指针为空，则使用LOS_MemAlloc函数动态分配内存。
//然后初始化环形缓冲区，设置水位线，并注册默认的性能缓冲区通知回调函数
{ {
UINT32 ret; UINT32 ret;
BOOL releaseFlag = FALSE; BOOL releaseFlag = FALSE;
@ -69,21 +72,22 @@ RELEASE:
return ret; return ret;
} }
VOID OsPerfOutPutFlush(VOID) VOID OsPerfOutPutFlush(VOID)//刷新性能输出缓冲区
{ {
if (g_perfBufFlushHook != NULL) { if (g_perfBufFlushHook != NULL) {
g_perfBufFlushHook(g_perfOutputCb.ringbuf.fifo, g_perfOutputCb.ringbuf.size); g_perfBufFlushHook(g_perfOutputCb.ringbuf.fifo, g_perfOutputCb.ringbuf.size);
} }
} }
UINT32 OsPerfOutPutRead(CHAR *dest, UINT32 size) UINT32 OsPerfOutPutRead(CHAR *dest, UINT32 size)//从性能输出缓冲区中读取数据
{ {
OsPerfOutPutFlush(); OsPerfOutPutFlush();
return LOS_RingbufRead(&g_perfOutputCb.ringbuf, dest, size); return LOS_RingbufRead(&g_perfOutputCb.ringbuf, dest, size);
} }
STATIC BOOL OsPerfOutPutBegin(UINT32 size) STATIC BOOL OsPerfOutPutBegin(UINT32 size)//开始写入性能输出缓冲区
{ {
//检查是否有足够空间
if (g_perfOutputCb.ringbuf.remain < size) { if (g_perfOutputCb.ringbuf.remain < size) {
PRINT_INFO("perf buf has no enough space for 0x%x\n", size); PRINT_INFO("perf buf has no enough space for 0x%x\n", size);
return FALSE; return FALSE;
@ -91,9 +95,9 @@ STATIC BOOL OsPerfOutPutBegin(UINT32 size)
return TRUE; return TRUE;
} }
STATIC VOID OsPerfOutPutEnd(VOID) STATIC VOID OsPerfOutPutEnd(VOID)//结束性能输出
{ {
OsPerfOutPutFlush(); OsPerfOutPutFlush();//刷新缓冲区
if (LOS_RingbufUsedSize(&g_perfOutputCb.ringbuf) >= g_perfOutputCb.waterMark) { if (LOS_RingbufUsedSize(&g_perfOutputCb.ringbuf) >= g_perfOutputCb.waterMark) {
if (g_perfBufNotifyHook != NULL) { if (g_perfBufNotifyHook != NULL) {
g_perfBufNotifyHook(); g_perfBufNotifyHook();
@ -101,7 +105,7 @@ STATIC VOID OsPerfOutPutEnd(VOID)
} }
} }
UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size) UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size)//将数据写入性能输入缓冲区
{ {
if (!OsPerfOutPutBegin(size)) { if (!OsPerfOutPutBegin(size)) {
return LOS_NOK; return LOS_NOK;
@ -113,17 +117,17 @@ UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size)
return LOS_OK; return LOS_OK;
} }
VOID OsPerfOutPutInfo(VOID) VOID OsPerfOutPutInfo(VOID)//打印性能输出缓冲区的信息，包括地址和长度
{ {
PRINT_EMG("dump section data, addr: %p length: %#x \r\n", g_perfOutputCb.ringbuf.fifo, g_perfOutputCb.ringbuf.size); PRINT_EMG("dump section data, addr: %p length: %#x \r\n", g_perfOutputCb.ringbuf.fifo, g_perfOutputCb.ringbuf.size);
} }
VOID OsPerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func) VOID OsPerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func)//注册性能缓冲区通知
{ {
g_perfBufNotifyHook = func; g_perfBufNotifyHook = func;
} }
VOID OsPerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func) VOID OsPerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func)//注册性能缓冲区刷新的函数
{ {
g_perfBufFlushHook = func; g_perfBufFlushHook = func;
} }

14
src/kernel/extended/perf/perf_output_pri.h
Unescape View File

@ -43,13 +43,13 @@ typedef struct {
UINT32 waterMark; /* notify water mark */ UINT32 waterMark; /* notify water mark */
} PerfOutputCB; } PerfOutputCB;
extern UINT32 OsPerfOutPutInit(VOID *buf, UINT32 size); extern UINT32 OsPerfOutPutInit(VOID *buf, UINT32 size);//初始化性能输出模块
extern UINT32 OsPerfOutPutRead(CHAR *dest, UINT32 size); extern UINT32 OsPerfOutPutRead(CHAR *dest, UINT32 size);//从性能输出缓冲区中读取数据，将数据拷贝到指定的目标缓冲区中
extern UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size); extern UINT32 OsPerfOutPutWrite(CHAR *data, UINT32 size);//将数据写入性能输出缓冲区
extern VOID OsPerfOutPutInfo(VOID); extern VOID OsPerfOutPutInfo(VOID);//输出性能统计信息
extern VOID OsPerfOutPutFlush(VOID); extern VOID OsPerfOutPutFlush(VOID);//刷新性能输出缓冲区
extern VOID OsPerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func); extern VOID OsPerfNotifyHookReg(const PERF_BUF_NOTIFY_HOOK func);//注册性能输出缓冲区通知
extern VOID OsPerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func); extern VOID OsPerfFlushHookReg(const PERF_BUF_FLUSH_HOOK func);//注册性能输出缓冲区刷新
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus

13
src/kernel/extended/perf/perf_pmu.c
Unescape View File

@ -36,11 +36,11 @@ extern "C" {
STATIC Pmu *g_pmuMgr[PERF_EVENT_TYPE_MAX] = {NULL}; STATIC Pmu *g_pmuMgr[PERF_EVENT_TYPE_MAX] = {NULL};
UINT32 OsPerfPmuRegister(Pmu *pmu) UINT32 OsPerfPmuRegister(Pmu *pmu)//注册性能计数器
{ {
UINT32 type; UINT32 type;
if ((pmu == NULL) || (pmu->type >= PERF_EVENT_TYPE_MAX)) { if ((pmu == NULL) || (pmu->type >= PERF_EVENT_TYPE_MAX)) {//如果传入PMU为空指针或者type超出了有效范围
return LOS_NOK; return LOS_NOK;
} }
@ -52,19 +52,20 @@ UINT32 OsPerfPmuRegister(Pmu *pmu)
return LOS_NOK; return LOS_NOK;
} }
Pmu *OsPerfPmuGet(UINT32 type) Pmu *OsPerfPmuGet(UINT32 type)//获取指定类型的性能计数器
{ {
if (type >= PERF_EVENT_TYPE_MAX) { if (type >= PERF_EVENT_TYPE_MAX) {
return NULL; return NULL;
} }
if (type == PERF_EVENT_TYPE_RAW) { /* process hardware raw events with hard pmu */ if (type == PERF_EVENT_TYPE_RAW) { //如果是原始事件类型
type = PERF_EVENT_TYPE_HW; /* process hardware raw events with hard pmu */
type = PERF_EVENT_TYPE_HW;//则将其转化为硬件事件类型
} }
return g_pmuMgr[type]; return g_pmuMgr[type];
} }
VOID OsPerfPmuRm(UINT32 type) VOID OsPerfPmuRm(UINT32 type)//删除指定类型的性能计数器
{ {
if (type >= PERF_EVENT_TYPE_MAX) { if (type >= PERF_EVENT_TYPE_MAX) {
return; return;

38
src/kernel/extended/perf/perf_pmu_pri.h
Unescape View File

@ -53,7 +53,7 @@ typedef struct {
VOID (*setPeriod)(Event *event); VOID (*setPeriod)(Event *event);
UINTPTR (*readCnt)(Event *event); UINTPTR (*readCnt)(Event *event);
UINT32 (*mapEvent)(UINT32 eventType, BOOL reverse); UINT32 (*mapEvent)(UINT32 eventType, BOOL reverse);
} HwPmu; } HwPmu;//硬件性能计数器结构体，包括硬件计数器、计数器是否能被分频、分频系数、启用、禁用、开始、停止、清除、设置周期、读取计数器值和事件映射等函数指针
typedef struct { typedef struct {
Pmu pmu; Pmu pmu;
@ -69,35 +69,35 @@ typedef struct {
}; };
#endif #endif
}; };
} SwPmu; } SwPmu;//软件性能计数器结构体，包括软件计数器、是否启用标志位、定时器配置时间
#define GET_HW_PMU(item) LOS_DL_LIST_ENTRY(item, HwPmu, pmu) #define GET_HW_PMU(item) LOS_DL_LIST_ENTRY(item, HwPmu, pmu)
#define TIMER_PERIOD_LOWER_BOUND_US 100 #define TIMER_PERIOD_LOWER_BOUND_US 100//定时器最小周期
#define CCNT_FULL 0xFFFFFFFF #define CCNT_FULL 0xFFFFFFFF//计数器最大值
#define CCNT_PERIOD_LOWER_BOUND 0x00000000 #define CCNT_PERIOD_LOWER_BOUND 0x00000000//最小周期
#define CCNT_PERIOD_UPPER_BOUND 0xFFFFFF00 #define CCNT_PERIOD_UPPER_BOUND 0xFFFFFF00//最大周期
#define PERIOD_CALC(p) (CCNT_FULL - (p)) #define PERIOD_CALC(p) (CCNT_FULL - (p))//计算给定周期对应的计数器值
#define VALID_PERIOD(p) ((PERIOD_CALC(p) > CCNT_PERIOD_LOWER_BOUND) \ #define VALID_PERIOD(p) ((PERIOD_CALC(p) > CCNT_PERIOD_LOWER_BOUND) \
&& (PERIOD_CALC(p) < CCNT_PERIOD_UPPER_BOUND)) && (PERIOD_CALC(p) < CCNT_PERIOD_UPPER_BOUND))//判断给定周期是否合法
#define PERF_HW_INVAILD_EVENT_TYPE 0xFFFFFFFF #define PERF_HW_INVAILD_EVENT_TYPE 0xFFFFFFFF//无效的事件类型
#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0])) #define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
extern UINT32 OsPerfPmuRegister(Pmu *pmu); extern UINT32 OsPerfPmuRegister(Pmu *pmu);//注册硬件性能计数器
extern VOID OsPerfPmuRm(UINT32 type); extern VOID OsPerfPmuRm(UINT32 type);//删除硬件性能计数器
extern Pmu *OsPerfPmuGet(UINT32 type); extern Pmu *OsPerfPmuGet(UINT32 type);//获取指定类型的硬件性能计数器
extern UINT32 OsHwPmuInit(VOID); extern UINT32 OsHwPmuInit(VOID);//初始化硬件性能计数器
extern UINT32 OsSwPmuInit(VOID); extern UINT32 OsSwPmuInit(VOID);//初始化软件性能计数器
extern UINT32 OsTimedPmuInit(VOID); extern UINT32 OsTimedPmuInit(VOID);//初始化定时器性能计数器
extern UINT32 OsGetPmuCounter0(VOID); extern UINT32 OsGetPmuCounter0(VOID);//获取0核计数器值
extern UINT32 OsGetPmuMaxCounter(VOID); extern UINT32 OsGetPmuMaxCounter(VOID);//获取最大计数器数
extern UINT32 OsGetPmuCycleCounter(VOID); extern UINT32 OsGetPmuCycleCounter(VOID);//获取周期性计数器值
extern UINT32 OsPerfHwInit(HwPmu *hwPmu); extern UINT32 OsPerfHwInit(HwPmu *hwPmu);//初始化硬件性能计数器
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus

50
src/kernel/extended/perf/pmu/perf_hw_pmu.c
Unescape View File

@ -34,7 +34,7 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
STATIC Pmu *g_perfHw = NULL; STATIC Pmu *g_perfHw = NULL;//指向性能计数器相关的数据结构或对象
STATIC CHAR *g_eventName[PERF_COUNT_HW_MAX] = { STATIC CHAR *g_eventName[PERF_COUNT_HW_MAX] = {
[PERF_COUNT_HW_CPU_CYCLES] = "cycles", [PERF_COUNT_HW_CPU_CYCLES] = "cycles",
@ -53,39 +53,41 @@ STATIC CHAR *g_eventName[PERF_COUNT_HW_MAX] = {
* 2.Find available counter for each event. * 2.Find available counter for each event.
* 3.Decide whether this hardware pmu need prescaler (once every 64 cycle counts). * 3.Decide whether this hardware pmu need prescaler (once every 64 cycle counts).
*/ */
STATIC UINT32 OsPerfHwConfig(VOID) STATIC UINT32 OsPerfHwConfig(VOID)//性能计数器的配置函数，用于初始化和配置硬件性能计数器
{ {
UINT32 i; UINT32 i;
HwPmu *armPmu = GET_HW_PMU(g_perfHw); HwPmu *armPmu = GET_HW_PMU(g_perfHw);
UINT32 maxCounter = OsGetPmuMaxCounter(); UINT32 maxCounter = OsGetPmuMaxCounter();//获得最大计数器数量
UINT32 counter = OsGetPmuCounter0(); UINT32 counter = OsGetPmuCounter0();//获取0核计数器的值
UINT32 cycleCounter = OsGetPmuCycleCounter(); UINT32 cycleCounter = OsGetPmuCycleCounter();//周期计数器的值
UINT32 cycleCode = armPmu->mapEvent(PERF_COUNT_HW_CPU_CYCLES, PERF_EVENT_TO_CODE); UINT32 cycleCode = armPmu->mapEvent(PERF_COUNT_HW_CPU_CYCLES, PERF_EVENT_TO_CODE);
if (cycleCode == PERF_HW_INVAILD_EVENT_TYPE) { if (cycleCode == PERF_HW_INVAILD_EVENT_TYPE) {
return LOS_NOK; return LOS_NOK;
} }
//获取性能事件的列表的和数量并进行遍历
PerfEvent *events = &g_perfHw->events; PerfEvent *events = &g_perfHw->events;
UINT32 eventNum = events->nr; UINT32 eventNum = events->nr;
for (i = 0; i < eventNum; i++) { for (i = 0; i < eventNum; i++) {
Event *event = &(events->per[i]); Event *event = &(events->per[i]);
if (!VALID_PERIOD(event->period)) { if (!VALID_PERIOD(event->period)) {//检查事件周期是否合法
PRINT_ERR("Config period: 0x%x invalid, should be in (%#x, %#x)\n", event->period, PRINT_ERR("Config period: 0x%x invalid, should be in (%#x, %#x)\n", event->period,
PERIOD_CALC(CCNT_PERIOD_UPPER_BOUND), PERIOD_CALC(CCNT_PERIOD_LOWER_BOUND)); PERIOD_CALC(CCNT_PERIOD_UPPER_BOUND), PERIOD_CALC(CCNT_PERIOD_LOWER_BOUND));
return LOS_NOK; return LOS_NOK;
} }
if (g_perfHw->type == PERF_EVENT_TYPE_HW) { /* do map */ if (g_perfHw->type == PERF_EVENT_TYPE_HW) { /* do map */
//映射编码
UINT32 eventId = armPmu->mapEvent(event->eventId, PERF_EVENT_TO_CODE); UINT32 eventId = armPmu->mapEvent(event->eventId, PERF_EVENT_TO_CODE);
if (eventId == PERF_HW_INVAILD_EVENT_TYPE) { if (eventId == PERF_HW_INVAILD_EVENT_TYPE) {
return LOS_NOK; return LOS_NOK;
} }
event->eventId = eventId; event->eventId = eventId;
} }
//函数根据事件编码是否与周期计数器的事件编码相同，来确定该事件使用的计数器。
//如果相同，则使用周期计数器；否则，使用普通计数器，并递增计数器的值。
if (event->eventId == cycleCode) { if (event->eventId == cycleCode) {
event->counter = cycleCounter; event->counter = cycleCounter;
} else { } else {
@ -93,11 +95,11 @@ STATIC UINT32 OsPerfHwConfig(VOID)
counter++; counter++;
} }
if (counter >= maxCounter) { if (counter >= maxCounter) {//检查计数器是否超过了最大计数器数量
PRINT_ERR("max events: %u excluding cycle event\n", maxCounter - 1); PRINT_ERR("max events: %u excluding cycle event\n", maxCounter - 1);
return LOS_NOK; return LOS_NOK;
} }
//打印结果，设置根据平台支持的分频
PRINT_DEBUG("Perf Config %u eventId = 0x%x, counter = 0x%x, period = 0x%x\n", i, event->eventId, event->counter, PRINT_DEBUG("Perf Config %u eventId = 0x%x, counter = 0x%x, period = 0x%x\n", i, event->eventId, event->counter,
event->period); event->period);
} }
@ -106,21 +108,21 @@ STATIC UINT32 OsPerfHwConfig(VOID)
return LOS_OK; return LOS_OK;
} }
STATIC UINT32 OsPerfHwStart(VOID) STATIC UINT32 OsPerfHwStart(VOID)//用于启动硬件性能计数器
{ {
UINT32 i; UINT32 i;
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
HwPmu *armPmu = GET_HW_PMU(g_perfHw); HwPmu *armPmu = GET_HW_PMU(g_perfHw);//获取硬件性能计数器的指针
PerfEvent *events = &g_perfHw->events; PerfEvent *events = &g_perfHw->events;
UINT32 eventNum = events->nr; UINT32 eventNum = events->nr;
armPmu->clear(); armPmu->clear();//清零计数器
for (i = 0; i < eventNum; i++) { for (i = 0; i < eventNum; i++) {
Event *event = &(events->per[i]); Event *event = &(events->per[i]);
armPmu->setPeriod(event); armPmu->setPeriod(event);//设置事件的计数周期
armPmu->enable(event); armPmu->enable(event);//启用事件的计数器
event->count[cpuid] = 0; event->count[cpuid] = 0;
} }
@ -128,7 +130,7 @@ STATIC UINT32 OsPerfHwStart(VOID)
return LOS_OK; return LOS_OK;
} }
STATIC UINT32 OsPerfHwStop(VOID) STATIC UINT32 OsPerfHwStop(VOID)//停止硬件性能计数器
{ {
UINT32 i; UINT32 i;
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
@ -148,7 +150,9 @@ STATIC UINT32 OsPerfHwStop(VOID)
/* multiplier of cycle counter */ /* multiplier of cycle counter */
UINT32 eventId = armPmu->mapEvent(event->eventId, PERF_CODE_TO_EVENT); UINT32 eventId = armPmu->mapEvent(event->eventId, PERF_CODE_TO_EVENT);
if ((eventId == PERF_COUNT_HW_CPU_CYCLES) && (armPmu->cntDivided != 0)) { if ((eventId == PERF_COUNT_HW_CPU_CYCLES) && (armPmu->cntDivided != 0)) {
//如果该事件的事件ID与周期计数器事件ID相同，并且硬件性能计数器的分频设置armPmu->cntDivided不为0
PRINT_DEBUG("perf stop is cycle\n"); PRINT_DEBUG("perf stop is cycle\n");
//此处将该事件的计数值左移6位，相当于乘以64
event->count[cpuid] = event->count[cpuid] << 6; /* CCNT counts every 64th cpu cycle */ event->count[cpuid] = event->count[cpuid] << 6; /* CCNT counts every 64th cpu cycle */
} }
PRINT_DEBUG("perf stop eventCount[0x%x] : [%s] = %llu\n", event->eventId, g_eventName[eventId], PRINT_DEBUG("perf stop eventCount[0x%x] : [%s] = %llu\n", event->eventId, g_eventName[eventId],
@ -157,11 +161,11 @@ STATIC UINT32 OsPerfHwStop(VOID)
return LOS_OK; return LOS_OK;
} }
STATIC CHAR *OsPerfGetEventName(Event *event) STATIC CHAR *OsPerfGetEventName(Event *event)//获取事件名称
{ {
UINT32 eventId; UINT32 eventId;
HwPmu *armPmu = GET_HW_PMU(g_perfHw); HwPmu *armPmu = GET_HW_PMU(g_perfHw);//获取PMU上的事件信息
eventId = armPmu->mapEvent(event->eventId, PERF_CODE_TO_EVENT); eventId = armPmu->mapEvent(event->eventId, PERF_CODE_TO_EVENT);//将事件ID映射位对应计数器事件ID
if (eventId < PERF_COUNT_HW_MAX) { if (eventId < PERF_COUNT_HW_MAX) {
return g_eventName[eventId]; return g_eventName[eventId];
} else { } else {
@ -169,21 +173,21 @@ STATIC CHAR *OsPerfGetEventName(Event *event)
} }
} }
UINT32 OsPerfHwInit(HwPmu *hwPmu) UINT32 OsPerfHwInit(HwPmu *hwPmu)//初始化性能计数器
{ {
UINT32 ret; UINT32 ret;
if (hwPmu == NULL) { if (hwPmu == NULL) {
return LOS_NOK; return LOS_NOK;
} }
//设置性能计数器的类型，配置函数，启动函数，停止函数，获取事件名称函数
hwPmu->pmu.type = PERF_EVENT_TYPE_HW; hwPmu->pmu.type = PERF_EVENT_TYPE_HW;
hwPmu->pmu.config = OsPerfHwConfig; hwPmu->pmu.config = OsPerfHwConfig;
hwPmu->pmu.start = OsPerfHwStart; hwPmu->pmu.start = OsPerfHwStart;
hwPmu->pmu.stop = OsPerfHwStop; hwPmu->pmu.stop = OsPerfHwStop;
hwPmu->pmu.getName = OsPerfGetEventName; hwPmu->pmu.getName = OsPerfGetEventName;
//将硬件性能计数器的事件数据结构清零
(VOID)memset_s(&hwPmu->pmu.events, sizeof(PerfEvent), 0, sizeof(PerfEvent)); (VOID)memset_s(&hwPmu->pmu.events, sizeof(PerfEvent), 0, sizeof(PerfEvent));
ret = OsPerfPmuRegister(&hwPmu->pmu); ret = OsPerfPmuRegister(&hwPmu->pmu);//注册硬件性能计数器，将其存储在全局变量中
g_perfHw = OsPerfPmuGet(PERF_EVENT_TYPE_HW); g_perfHw = OsPerfPmuGet(PERF_EVENT_TYPE_HW);
return ret; return ret;

20
src/kernel/extended/perf/pmu/perf_sw_pmu.c
Unescape View File

@ -51,7 +51,7 @@ STATIC CHAR* g_eventName[PERF_COUNT_SW_MAX] = {
[PERF_COUNT_SW_MUX_PEND] = "mux pend", [PERF_COUNT_SW_MUX_PEND] = "mux pend",
}; };
VOID OsPerfHook(UINT32 eventType) VOID OsPerfHook(UINT32 eventType)//软件性能计数器的事件处理函数
{ {
if (!g_perfSw.enable) { if (!g_perfSw.enable) {
return; return;
@ -69,7 +69,7 @@ VOID OsPerfHook(UINT32 eventType)
if (event->counter == eventType) { if (event->counter == eventType) {
OsPerfUpdateEventCount(event, 1); OsPerfUpdateEventCount(event, 1);
if (event->count[ArchCurrCpuid()] % event->period == 0) { if (event->count[ArchCurrCpuid()] % event->period == 0) {
OsPerfFetchCallerRegs(&regs); OsPerfFetchCallerRegs(&regs);//获取寄存器信息
OsPerfHandleOverFlow(event, &regs); OsPerfHandleOverFlow(event, &regs);
} }
return; return;
@ -77,7 +77,7 @@ VOID OsPerfHook(UINT32 eventType)
} }
} }
STATIC UINT32 OsPerfSwConfig(VOID) STATIC UINT32 OsPerfSwConfig(VOID)//对软件性能计数器进行配置
{ {
UINT32 i; UINT32 i;
PerfEvent *events = &g_perfSw.pmu.events; PerfEvent *events = &g_perfSw.pmu.events;
@ -94,29 +94,29 @@ STATIC UINT32 OsPerfSwConfig(VOID)
return LOS_OK; return LOS_OK;
} }
STATIC UINT32 OsPerfSwStart(VOID) STATIC UINT32 OsPerfSwStart(VOID)//启动软件性能计数器
{ {
UINT32 i; UINT32 i;
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
PerfEvent *events = &g_perfSw.pmu.events; PerfEvent *events = &g_perfSw.pmu.events;
UINT32 eventNum = events->nr; UINT32 eventNum = events->nr;
for (i = 0; i < eventNum; i++) { for (i = 0; i < eventNum; i++) {//遍历所有事件
Event *event = &(events->per[i]); Event *event = &(events->per[i]);
event->count[cpuid] = 0; event->count[cpuid] = 0;//清零当前事件在CPU中的计数器
} }
g_perfSw.enable = TRUE; g_perfSw.enable = TRUE;//启动计数器
return LOS_OK; return LOS_OK;
} }
STATIC UINT32 OsPerfSwStop(VOID) STATIC UINT32 OsPerfSwStop(VOID)//关闭软件性能计数器
{ {
g_perfSw.enable = FALSE; g_perfSw.enable = FALSE;
return LOS_OK; return LOS_OK;
} }
STATIC CHAR *OsPerfGetEventName(Event *event) STATIC CHAR *OsPerfGetEventName(Event *event)//获取事件的名称
{ {
UINT32 eventId = event->eventId; UINT32 eventId = event->eventId;
if (eventId < PERF_COUNT_SW_MAX) { if (eventId < PERF_COUNT_SW_MAX) {
@ -125,7 +125,7 @@ STATIC CHAR *OsPerfGetEventName(Event *event)
return "unknown"; return "unknown";
} }
UINT32 OsSwPmuInit(VOID) UINT32 OsSwPmuInit(VOID)//对PMU计数器进行初始化
{ {
g_perfSw.pmu = (Pmu) { g_perfSw.pmu = (Pmu) {
.type = PERF_EVENT_TYPE_SW, .type = PERF_EVENT_TYPE_SW,

40
src/kernel/extended/perf/pmu/perf_timed_pmu.c
Unescape View File

@ -39,12 +39,12 @@ extern "C" {
STATIC SwPmu g_perfTimed; STATIC SwPmu g_perfTimed;
STATIC BOOL OsPerfTimedPeriodValid(UINT32 period) STATIC BOOL OsPerfTimedPeriodValid(UINT32 period)//验证定时器中的时间周期是否合法
{ {
return period >= TIMER_PERIOD_LOWER_BOUND_US; return period >= TIMER_PERIOD_LOWER_BOUND_US;
} }
STATIC UINT32 OsPerfTimedStart(VOID) STATIC UINT32 OsPerfTimedStart(VOID)//启动定时器事件
{ {
UINT32 i; UINT32 i;
UINT32 cpuid = ArchCurrCpuid(); UINT32 cpuid = ArchCurrCpuid();
@ -74,7 +74,7 @@ STATIC UINT32 OsPerfTimedStart(VOID)
return LOS_OK; return LOS_OK;
} }
STATIC UINT32 OsPerfTimedConfig(VOID) STATIC UINT32 OsPerfTimedConfig(VOID)//配置定时器，检验是否合法
{ {
UINT32 i; UINT32 i;
PerfEvent *events = &g_perfTimed.pmu.events; PerfEvent *events = &g_perfTimed.pmu.events;
@ -101,7 +101,7 @@ STATIC UINT32 OsPerfTimedConfig(VOID)
return LOS_NOK; return LOS_NOK;
} }
STATIC UINT32 OsPerfTimedStop(VOID) STATIC UINT32 OsPerfTimedStop(VOID)//关闭定时器设置
{ {
UINT32 ret; UINT32 ret;
if (ArchCurrCpuid() != 0) { /* only need stop on one core */ if (ArchCurrCpuid() != 0) { /* only need stop on one core */
@ -116,7 +116,7 @@ STATIC UINT32 OsPerfTimedStop(VOID)
return LOS_OK; return LOS_OK;
} }
STATIC VOID OsPerfTimedHandle(VOID) STATIC VOID OsPerfTimedHandle(VOID)//处理定时器事件
{ {
UINT32 index; UINT32 index;
PerfRegs regs; PerfRegs regs;
@ -125,7 +125,7 @@ STATIC VOID OsPerfTimedHandle(VOID)
UINT32 eventNum = events->nr; UINT32 eventNum = events->nr;
(VOID)memset_s(&regs, sizeof(PerfRegs), 0, sizeof(PerfRegs)); (VOID)memset_s(&regs, sizeof(PerfRegs), 0, sizeof(PerfRegs));
OsPerfFetchIrqRegs(&regs); OsPerfFetchIrqRegs(&regs);//获取当前寄存器状态
for (index = 0; index < eventNum; index++) { for (index = 0; index < eventNum; index++) {
Event *event = &(events->per[index]); Event *event = &(events->per[index]);
@ -134,48 +134,50 @@ STATIC VOID OsPerfTimedHandle(VOID)
} }
} }
STATIC enum hrtimer_restart OsPerfHrtimer(struct hrtimer *hrtimer) STATIC enum hrtimer_restart OsPerfHrtimer(struct hrtimer *hrtimer)//高精度定时器(hrtimer)的回调函数
{ {
SMP_CALL_PERF_FUNC(OsPerfTimedHandle); /* send to all cpu to collect data */ SMP_CALL_PERF_FUNC(OsPerfTimedHandle); /* send to all cpu to collect data */
//将定时器事件的处理发送给所有CPU进行数据收集
return HRTIMER_RESTART; return HRTIMER_RESTART;
} }
STATIC CHAR *OsPerfGetEventName(Event *event) STATIC CHAR *OsPerfGetEventName(Event *event)//获取事件名称
{ {
if (event->eventId == PERF_COUNT_CPU_CLOCK) { if (event->eventId == PERF_COUNT_CPU_CLOCK) {//读取事件ID是否与计数器中的事件记录相同
return "timed"; return "timed";
} else { } else {
return "unknown"; return "unknown";
} }
} }
UINT32 OsTimedPmuInit(VOID) UINT32 OsTimedPmuInit(VOID)//初始化定时器
{ {
UINT32 ret; UINT32 ret;
g_perfTimed.time = (union ktime) { g_perfTimed.time = (union ktime) {//保存定时器信息
.tv.sec = 0, .tv.sec = 0,
.tv.usec = HRTIMER_DEFAULT_PERIOD_US, .tv.usec = HRTIMER_DEFAULT_PERIOD_US,
}; };
hrtimer_init(&g_perfTimed.hrtimer, 1, HRTIMER_MODE_REL); hrtimer_init(&g_perfTimed.hrtimer, 1, HRTIMER_MODE_REL);//第一个参数代表定时器对象，第二个参数为时间源类型，代表的是相对时间，最后一个参数代表定时器模式，这里使用的是相对时间模式
ret = hrtimer_create(&g_perfTimed.hrtimer, g_perfTimed.time, OsPerfHrtimer); ret = hrtimer_create(&g_perfTimed.hrtimer, g_perfTimed.time, OsPerfHrtimer);//创建定时器
if (ret != LOS_OK) { if (ret != LOS_OK) {
return ret; return ret;
} }
g_perfTimed.pmu = (Pmu) { g_perfTimed.pmu = (Pmu) {
.type = PERF_EVENT_TYPE_TIMED, .type = PERF_EVENT_TYPE_TIMED,//此性能计数器是定时器类型
.config = OsPerfTimedConfig, .config = OsPerfTimedConfig,//性能计数器的事件配置
.start = OsPerfTimedStart, .start = OsPerfTimedStart,//启动
.stop = OsPerfTimedStop, .stop = OsPerfTimedStop,//停止
.getName = OsPerfGetEventName, .getName = OsPerfGetEventName,//获取事件名称
}; };
(VOID)memset_s(&g_perfTimed.pmu.events, sizeof(PerfEvent), 0, sizeof(PerfEvent)); (VOID)memset_s(&g_perfTimed.pmu.events, sizeof(PerfEvent), 0, sizeof(PerfEvent));
//执行完之后清零事件结构体，并在下面进行状态码的注册读取
ret = OsPerfPmuRegister(&g_perfTimed.pmu); ret = OsPerfPmuRegister(&g_perfTimed.pmu);
return ret; return ret;//返回值为初始化状态码
} }
#ifdef __cplusplus #ifdef __cplusplus

BIN
src/kernel/extended/软件工程代码阅读（初稿）-何佳聪-.docx
View File

Binary file not shown.
Write Preview
Loading…
Cancel
Save