ruanjiangongcheng/sched/sched_sq/los_sortlink.c

/*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
 * Copyright (c) 2020-2021 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:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of
 *    conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
 *    of conditions and the following disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "los_sortlink_pri.h"
#include "los_memory.h"
#include "los_exc.h"
#include "los_percpu_pri.h"
#include "los_sched_pri.h"
#include "los_mp.h"
UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader)
{
    LOS_ListInit(&sortLinkHeader->sortLink); // 初始化排序链表头
    sortLinkHeader->nodeNum = 0; // 初始化节点数量为0
    return LOS_OK;
}

STATIC INLINE VOID OsAddNode2SortLink(SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
{
    LOS_DL_LIST *head = (LOS_DL_LIST *)&sortLinkHeader->sortLink; // 获取排序链表头指针

    if (LOS_ListEmpty(head)) { // 如果链表为空
        LOS_ListHeadInsert(head, &sortList->sortLinkNode); // 将节点插入链表头
        sortLinkHeader->nodeNum++; // 节点数量加1
        return;
    }

    SortLinkList *listSorted = LOS_DL_LIST_ENTRY(head->pstNext, SortLinkList, sortLinkNode); // 获取链表中的第一个节点
    if (listSorted->responseTime > sortList->responseTime) { // 如果插入节点的响应时间小于第一个节点的响应时间
        LOS_ListAdd(head, &sortList->sortLinkNode); // 将节点插入链表头之前
        sortLinkHeader->nodeNum++; // 节点数量加1
        return;
    } else if (listSorted->responseTime == sortList->responseTime) { // 如果插入节点的响应时间等于第一个节点的响应时间
        LOS_ListAdd(head->pstNext, &sortList->sortLinkNode); // 将节点插入第一个节点之后
        sortLinkHeader->nodeNum++; // 节点数量加1
        return;
    }

    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++; // 节点数量加1
            break;
        }

        prevNode = prevNode->pstPrev; // 继续向前遍历
    } while (1);
}
/*OsSortLinkInit函数用于初始化排序链表头。在函数中，它调用LOS_ListInit函数初始化排序链表头，并将节点数量设置为0，然后返回LOS_OK。

OsAddNode2SortLink函数用于将节点插入排序链表中。在函数中，首先获取排序链表头指针。然后，如果链表为空，将节点插入链表头，并增加节点数量，
然后返回。如果链表不为空，获取链表中的第一个节点，并比较插入节点的响应时间与第一个节点的响应时间。如果插入节点的响应时间小于第一个节点的
响应时间，将节点插入链表头之前，并增加节点数量，然后返回。如果插入节点的响应时间等于第一个节点的响应时间，将节点插入第一个节点之后，
并增加节点数量，然后返回。如果插入节点的响应时间大于第一个节点的响应时间，获取链表中的最后一个节点，并从链表尾部向前遍历。在遍历过程中，
如果插入节点的响应时间小于等于当前节点的响应时间，将节点插入当前节点之前，并增加节点数量，然后退出循环。最后，返回。*/
VOID OsDeleteNodeSortLink(SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
{
    LOS_ListDelete(&sortList->sortLinkNode); // 从排序链表中删除节点
    SET_SORTLIST_VALUE(sortList, OS_SORT_LINK_INVALID_TIME); // 将节点的响应时间设置为无效值
    sortLinkHeader->nodeNum--; // 节点数量减1
}

STATIC INLINE UINT64 OsGetSortLinkNextExpireTime(SortLinkAttribute *sortHeader, UINT64 startTime)
{
    LOS_DL_LIST *head = &sortHeader->sortLink; // 获取排序链表头指针
    LOS_DL_LIST *list = head->pstNext; // 获取链表中的第一个节点

    if (LOS_ListEmpty(head)) { // 如果链表为空
        return OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION; // 返回最大响应时间减去精度
    }

    SortLinkList *listSorted = LOS_DL_LIST_ENTRY(list, SortLinkList, sortLinkNode); // 获取第一个节点
    if (listSorted->responseTime <= (startTime + OS_TICK_RESPONSE_PRECISION)) { // 如果第一个节点的响应时间小于等于（开始时间加上精度）
        return startTime + OS_TICK_RESPONSE_PRECISION; // 返回开始时间加上精度
    }

    return listSorted->responseTime; // 返回第一个节点的响应时间
}

STATIC Percpu *OsFindIdleCpu(UINT16 *idleCpuID)
{
    Percpu *idleCpu = OsPercpuGetByID(0); // 获取CPU 0 的PerCPU结构体指针
    *idleCpuID = 0; // 将空闲CPU的ID设置为0
/*OsDeleteNodeSortLink函数用于从排序链表中删除节点。在函数中，它调用LOS_ListDelete函数删除节点，并将节点的响应时间设置为无效值，然后将节点数量减1。

OsGetSortLinkNextExpireTime函数用于获取排序链表中下一个即将到期的节点的响应时间。在函数中，首先获取排序链表头指针和链表中的第一个节点。
然后，如果链表为空，返回最大响应时间减去精度。如果第一个节点的响应时间小于等于（开始时间加上精度），返回开始时间加上精度。否则，返回第一个节点的响应时间。

OsFindIdleCpu函数用于查找空闲的CPU。在函数中，它通过调用OsPercpuGetByID函数获取CPU 0 的PerCPU结构体指针，并将空闲CPU的ID设置为0。*/

#ifdef LOSCFG_KERNEL_SMP
    UINT16 cpuID = 1; // 初始化CPU ID为1
    UINT32 nodeNum = idleCpu->taskSortLink.nodeNum + idleCpu->swtmrSortLink.nodeNum; // 获取当前CPU的任务排序链表和软件定时器排序链表的节点数量之和

    do {
        Percpu *cpu = OsPercpuGetByID(cpuID); // 获取指定CPU的PerCPU结构体指针
        UINT32 temp = cpu->taskSortLink.nodeNum + cpu->swtmrSortLink.nodeNum; // 获取指定CPU的任务排序链表和软件定时器排序链表的节点数量之和
        if (nodeNum > temp) { // 如果当前CPU的节点数量之和大于指定CPU的节点数量之和
            idleCpu = cpu; // 更新空闲CPU指针
            *idleCpuID = cpuID; // 更新空闲CPU的ID
        }

        cpuID++; // 继续遍历下一个CPU
    } while (cpuID < LOSCFG_KERNEL_CORE_NUM); // 遍历完所有的CPU
#endif

    return idleCpu; // 返回空闲CPU的指针
}

VOID OsAdd2SortLink(SortLinkList *node, UINT64 startTime, UINT32 waitTicks, SortLinkType type)
{
    UINT32 intSave;
    Percpu *cpu = NULL;
    SortLinkAttribute *sortLinkHeader = NULL;
    SPIN_LOCK_S *spinLock = NULL;
    UINT16 idleCpu;

    if (OS_SCHEDULER_ACTIVE) { // 如果调度器处于活动状态
        cpu = OsFindIdleCpu(&idleCpu); // 查找空闲的CPU
    } else {
        idleCpu = ArchCurrCpuid(); // 获取当前CPU的ID
        cpu = OsPercpuGet(); // 获取当前CPU的PerCPU结构体指针
    }

    if (type == OS_SORT_LINK_TASK) {
        sortLinkHeader = &cpu->taskSortLink; // 获取任务排序链表头指针
        spinLock = &cpu->taskSortLinkSpin; // 获取任务排序链表自旋锁
    } else if (type == OS_SORT_LINK_SWTMR) {
        sortLinkHeader = &cpu->swtmrSortLink; // 获取软件定时器排序链表头指针
        spinLock = &cpu->swtmrSortLinkSpin; // 获取软件定时器排序链表自旋锁
    } else {
        LOS_Panic("Sort link type error : %u\n", type); // 报错，排序链表类型错误
    }

    LOS_SpinLockSave(spinLock, &intSave); // 保存自旋锁状态并禁止中断
    SET_SORTLIST_VALUE(node, startTime + (UINT64)waitTicks * OS_CYCLE_PER_TICK); // 设置节点的响应时间
    OsAddNode2SortLink(sortLinkHeader, node); // 将节点插入排序链表中
#ifdef LOSCFG_KERNEL_SMP
    node->cpuid = idleCpu; // 设置节点的CPU ID为空闲CPU的ID
    if (idleCpu != ArchCurrCpuid()) { // 如果空闲CPU的ID不等于当前CPU的ID
        LOS_MpSchedule(CPUID_TO_AFFI_MASK(idleCpu)); // 调度空闲CPU执行任务
    }
#endif
    LOS_SpinUnlockRestore(spinLock, intSave); // 恢复自旋锁状态并允许中断
}

VOID OsDeleteSortLink(SortLinkList *node, SortLinkType type)
{
    UINT32 intSave;
#ifdef LOSCFG_KERNEL_SMP
    Percpu *cpu = OsPercpuGetByID(node->cpuid); // 获取节点所在CPU的PerCPU结构体指针
#else
    Percpu *cpu = OsPercpuGetByID(0); // 获取CPU 0 的PerCPU结构体指针
#endif
/*OsAdd2SortLink函数用于将节点插入排序链表中。在函数中，首先根据调度器的活动状态选择空闲的CPU。
如果调度器处于活动状态，调用OsFindIdleCpu函数查找空闲的CPU；否则，获取当前CPU的ID，
并通过OsPercpuGet函数获取当前CPU的PerCPU结构体指针。然后，根据排序链表类型选择相应的排序链表头指针和自旋锁。
接下来，保存自旋锁状态并禁止中断，设置节点的响应时间，将节点插入排序链表中，根据SMP配置设置节点的CPU ID，
并如果空闲CPU的ID不等于当前CPU的ID，调度空闲CPU执行任务。最后，恢复自旋锁状态并允许中断。

OsDeleteSortLink函数用于从排序链表中删除节点。在函数中，首先保存自旋锁状态并禁止中断。如果SMP配置开启，
根据节点的CPU ID获取节点所在CPU的PerCPU结构体指针；否则，获取CPU 0 的PerCPU结构体指针。*/

    SPIN_LOCK_S *spinLock = NULL;
    SortLinkAttribute *sortLinkHeader = NULL;
    if (type == OS_SORT_LINK_TASK) {
        sortLinkHeader = &cpu->taskSortLink; // 获取任务排序链表头指针
        spinLock = &cpu->taskSortLinkSpin; // 获取任务排序链表自旋锁
    } else if (type == OS_SORT_LINK_SWTMR) {
        sortLinkHeader = &cpu->swtmrSortLink; // 获取软件定时器排序链表头指针
        spinLock = &cpu->swtmrSortLinkSpin; // 获取软件定时器排序链表自旋锁
    } else {
        LOS_Panic("Sort link type error : %u\n", type); // 报错，排序链表类型错误
    }

    LOS_SpinLockSave(spinLock, &intSave); // 保存自旋锁状态并禁止中断
    if (node->responseTime != OS_SORT_LINK_INVALID_TIME) { // 如果节点的响应时间不为无效时间
        OsDeleteNodeSortLink(sortLinkHeader, node); // 从排序链表中删除节点
    }
    LOS_SpinUnlockRestore(spinLock, intSave); // 恢复自旋锁状态并允许中断
}
UINT64 OsGetNextExpireTime(UINT64 startTime)
{
    UINT32 intSave;
    Percpu *cpu = OsPercpuGet(); // 获取当前CPU的PerCPU结构体指针
    SortLinkAttribute *taskHeader = &cpu->taskSortLink; // 获取任务排序链表头指针
    SortLinkAttribute *swtmrHeader = &cpu->swtmrSortLink; // 获取软件定时器排序链表头指针

    LOS_SpinLockSave(&cpu->taskSortLinkSpin, &intSave); // 保存任务排序链表自旋锁状态并禁止中断
    UINT64 taskExpirTime = OsGetSortLinkNextExpireTime(taskHeader, startTime); // 获取任务排序链表中下一个过期时间
    LOS_SpinUnlockRestore(&cpu->taskSortLinkSpin, intSave); // 恢复任务排序链表自旋锁状态并允许中断

    LOS_SpinLockSave(&cpu->swtmrSortLinkSpin, &intSave); // 保存软件定时器排序链表自旋锁状态并禁止中断
    UINT64 swtmrExpirTime = OsGetSortLinkNextExpireTime(swtmrHeader, startTime); // 获取软件定时器排序链表中下一个过期时间
    LOS_SpinUnlockRestore(&cpu->swtmrSortLinkSpin, intSave); // 恢复软件定时器排序链表自旋锁状态并允许中断

    return (taskExpirTime < swtmrExpirTime) ? taskExpirTime : swtmrExpirTime; // 返回较小的过期时间
}

UINT32 OsSortLinkGetTargetExpireTime(const SortLinkList *targetSortList)
{
    UINT64 currTimes = OsGetCurrSchedTimeCycle(); // 获取当前调度时间
    if (currTimes >= targetSortList->responseTime) { // 如果当前时间大于等于目标排序链表节点的响应时间
        return 0; // 返回0，表示已经过期
    }

    return (UINT32)(targetSortList->responseTime - currTimes) / OS_CYCLE_PER_TICK; // 计算剩余的滴答数
}

UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader)
{
    LOS_DL_LIST *head = (LOS_DL_LIST *)&sortLinkHeader->sortLink; // 获取排序链表头节点

    if (LOS_ListEmpty(head)) { // 如果排序链表为空
        return 0; // 返回0，表示没有过期时间
    }

    SortLinkList *listSorted = LOS_DL_LIST_ENTRY(head->pstNext, SortLinkList, sortLinkNode); // 获取排序链表中的第一个节点
    return OsSortLinkGetTargetExpireTime(listSorted); // 获取目标排序链表节点的过期时间
}