src/kernel_liteos_a/kernel/base/sched/los_idle.c

@@ -44,7 +44,7 @@ STATIC VOID IdleTimeSliceUpdate(SchedRunqueue *rq, LosTaskCB *taskCB, UINT64 cur
 STATIC INT32 IdleParamCompare(const SchedPolicy *sp1, const SchedPolicy *sp2);
 STATIC VOID IdlePriorityInheritance(LosTaskCB *owner, const SchedParam *param);
 STATIC VOID IdlePriorityRestore(LosTaskCB *owner, const LOS_DL_LIST *list, const SchedParam *param);
-//空闲调度
+
 const STATIC SchedOps g_idleOps = {
     .dequeue = IdleDequeue,
     .enqueue = IdleEnqueue,

src/kernel_liteos_a/kernel/base/sched/los_priority.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2022-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -43,8 +43,6 @@
 #define OS_SCHED_READY_MAX         30
 #define OS_TIME_SLICE_MIN          (INT32)((50 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /* 50us */
 
-//基于优先数调度算法 Highest-Priority-First (HPF)
-
 STATIC HPFRunqueue g_schedHPF;
 
 STATIC VOID HPFDequeue(SchedRunqueue *rq, LosTaskCB *taskCB);
@@ -65,7 +63,7 @@ STATIC VOID HPFTimeSliceUpdate(SchedRunqueue *rq, LosTaskCB *taskCB, UINT64 curr
 STATIC INT32 HPFParamCompare(const SchedPolicy *sp1, const SchedPolicy *sp2);
 STATIC VOID HPFPriorityInheritance(LosTaskCB *owner, const SchedParam *param);
 STATIC VOID HPFPriorityRestore(LosTaskCB *owner, const LOS_DL_LIST *list, const SchedParam *param);
-//优先级调度算法操作
+
 const STATIC SchedOps g_priorityOps = {
     .dequeue = HPFDequeue,
     .enqueue = HPFEnqueue,
@@ -245,7 +243,7 @@ STATIC INLINE VOID PriQueInsert(HPFRunqueue *rq, LosTaskCB *taskCB)
     taskCB->taskStatus &= ~OS_TASK_STATUS_BLOCKED;
     taskCB->taskStatus |= OS_TASK_STATUS_READY;
 }
-//入就绪队列
+
 STATIC VOID HPFEnqueue(SchedRunqueue *rq, LosTaskCB *taskCB)
 {
 #ifdef LOSCFG_SCHED_HPF_DEBUG
@@ -255,14 +253,14 @@ STATIC VOID HPFEnqueue(SchedRunqueue *rq, LosTaskCB *taskCB)
 #endif
     PriQueInsert(rq->hpfRunqueue, taskCB);
 }
-//出就绪队列
+
 STATIC VOID HPFDequeue(SchedRunqueue *rq, LosTaskCB *taskCB)
 {
     SchedHPF *sched = (SchedHPF *)&taskCB->sp;
 
-    if (taskCB->taskStatus & OS_TASK_STATUS_READY) {//是否有就绪状态
+    if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
         PriQueDelete(rq->hpfRunqueue, sched->basePrio, &taskCB->pendList, sched->priority);
-        taskCB->taskStatus &= ~OS_TASK_STATUS_READY;//更新成非就绪状态
+        taskCB->taskStatus &= ~OS_TASK_STATUS_READY;
     }
 }
 
@@ -477,7 +475,7 @@ STATIC VOID HPFPriorityInheritance(LosTaskCB *owner, const SchedParam *param)
     LOS_BitmapSet(&sp->priBitmap, sp->priority);
     sp->priority = param->priority;
 }
-/// 恢复任务优先级
+
 STATIC VOID HPFPriorityRestore(LosTaskCB *owner, const LOS_DL_LIST *list, const SchedParam *param)
 {
     UINT16 priority;
@@ -500,8 +498,8 @@ STATIC VOID HPFPriorityRestore(LosTaskCB *owner, const LOS_DL_LIST *list, const
     }
 
     if ((list != NULL) && !LOS_ListEmpty((LOS_DL_LIST *)list)) {
-        priority = LOS_HighBitGet(sp->priBitmap);//获取在历史调度中最高优先级
-        LOS_DL_LIST_FOR_EACH_ENTRY(pendedTask, list, LosTaskCB, pendList) {//遍历链表
+        priority = LOS_HighBitGet(sp->priBitmap);
+        LOS_DL_LIST_FOR_EACH_ENTRY(pendedTask, list, LosTaskCB, pendList) {
             SchedHPF *pendSp = (SchedHPF *)&pendedTask->sp;
             if ((pendedTask->ops == owner->ops) && (priority != pendSp->priority)) {
                 LOS_BitmapClr(&sp->priBitmap, pendSp->priority);
@@ -539,7 +537,7 @@ VOID HPFProcessDefaultSchedParamGet(SchedParam *param)
 {
     param->basePrio = OS_USER_PROCESS_PRIORITY_HIGHEST;
 }
-//HPF 调度策略初始化
+
 VOID HPFSchedPolicyInit(SchedRunqueue *rq)
 {
     if (ArchCurrCpuid() > 0) {

src/kernel_liteos_a/kernel/base/sched/los_sortlink.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -30,7 +30,7 @@
  */
 
 #include "los_sortlink_pri.h"
-/// 排序链表初始化
+
 VOID OsSortLinkInit(SortLinkAttribute *sortLinkHeader)
 {
     LOS_ListInit(&sortLinkHeader->sortLink);
@@ -38,47 +38,38 @@ VOID OsSortLinkInit(SortLinkAttribute *sortLinkHeader)
     sortLinkHeader->nodeNum = 0;
 }
 
-/*!
- * @brief OsAddNode2SortLink 向链表中插入结点,并按时间顺序排列	
- *
- * @param sortLinkHeader 被插入的链表	
- * @param sortList	要插入的结点
- * @return	
- *
- * @see
- */
 STATIC INLINE VOID AddNode2SortLink(SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
 {
-    LOS_DL_LIST *head = (LOS_DL_LIST *)&sortLinkHeader->sortLink; //获取双向链表 
+    LOS_DL_LIST *head = (LOS_DL_LIST *)&sortLinkHeader->sortLink;
 
-    if (LOS_ListEmpty(head)) { //空链表,直接插入
-        LOS_ListHeadInsert(head, &sortList->sortLinkNode);//插入结点
-        sortLinkHeader->nodeNum++;//CPU的工作量增加了
+    if (LOS_ListEmpty(head)) {
+        LOS_ListHeadInsert(head, &sortList->sortLinkNode);
+        sortLinkHeader->nodeNum++;
         return;
     }
-	//链表不为空时,插入分三种情况, responseTime 大于,等于,小于的处理
+
     SortLinkList *listSorted = LOS_DL_LIST_ENTRY(head->pstNext, SortLinkList, sortLinkNode);
-    if (listSorted->responseTime > sortList->responseTime) {//如果要插入的节点 responseTime 最小 
-        LOS_ListAdd(head, &sortList->sortLinkNode);//能跑进来说明是最小的,直接插入到第一的位置
-        sortLinkHeader->nodeNum++;//CPU的工作量增加了
-        return;//直接返回了
-    } else if (listSorted->responseTime == sortList->responseTime) {//相等的情况
-        LOS_ListAdd(head->pstNext, &sortList->sortLinkNode);//插到第二的位置
+    if (listSorted->responseTime > sortList->responseTime) {
+        LOS_ListAdd(head, &sortList->sortLinkNode);
+        sortLinkHeader->nodeNum++;
+        return;
+    } else if (listSorted->responseTime == sortList->responseTime) {
+        LOS_ListAdd(head->pstNext, &sortList->sortLinkNode);
         sortLinkHeader->nodeNum++;
         return;
     }
-	//处理大于链表中第一个responseTime的情况,需要遍历链表
-    LOS_DL_LIST *prevNode = head->pstPrev;//注意这里用的前一个结点,也就是说前一个结点中的responseTime 是最大的
-    do { // @note_good 这里写的有点妙,也是双向链表的魅力所在
-        listSorted = LOS_DL_LIST_ENTRY(prevNode, SortLinkList, sortLinkNode);//一个个遍历,先比大的再比小的
-        if (listSorted->responseTime <= sortList->responseTime) {//如果时间比你小,就插到后面
+
+    LOS_DL_LIST *prevNode = head->pstPrev;
+    do {
+        listSorted = LOS_DL_LIST_ENTRY(prevNode, SortLinkList, sortLinkNode);
+        if (listSorted->responseTime <= sortList->responseTime) {
             LOS_ListAdd(prevNode, &sortList->sortLinkNode);
             sortLinkHeader->nodeNum++;
             break;
         }
 
-        prevNode = prevNode->pstPrev;//再拿上一个更小的responseTime进行比较
-    } while (1);//死循环
+        prevNode = prevNode->pstPrev;
+    } while (1);
 }
 
 VOID OsAdd2SortLink(SortLinkAttribute *head, SortLinkList *node, UINT64 responseTime, UINT16 idleCpu)