yystopf
/
openharmony_kernel_liteos_m
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 同步调度部分优化至liteos_m 

1.tick timer与调度进一步剥离
2.性能敏感函数内敛化

Signed-off-by: zhushengle <zhushengle@huawei.com>
Change-Id: I00c27216e286dd7ca9c02db3e2377707d628a786
This commit is contained in:
zhushengle 2022-02-10 20:43:54 +08:00
parent d1d412255c
commit fb11ab181e
25 changed files with 253 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
arch/arm/arm9/gcc/los_timer.c
View File

@ -52,7 +52,7 @@
#define OS_TIMER_READ_VAL_ADDR (OS_TIMER_REG_BASE + 20)
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -60,6 +60,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = OS_TIMER_IRQ_NUM,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -107,12 +108,17 @@ STATIC VOID SysTickClockIrqClear(VOID)
} while (status & mask);
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTickLock();
WRITE_UINT32(nextResponseTime, OS_TIMER_PERIOD_REG_ADDR);
WRITE_UINT32((UINT32)nextResponseTime, OS_TIMER_PERIOD_REG_ADDR);
SysTickClockIrqClear();
SysTickUnlock();
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

11
arch/arm/cortex-m3/keil/los_timer.c
View File

@ -37,7 +37,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -45,6 +45,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -76,13 +77,19 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

10
arch/arm/cortex-m33/gcc/NTZ/los_timer.c
View File

@ -36,7 +36,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -44,6 +44,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -75,13 +76,18 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

10
arch/arm/cortex-m33/gcc/TZ/non_secure/los_timer.c
View File

@ -35,7 +35,7 @@
#include "los_arch_interrupt.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -43,6 +43,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -74,13 +75,18 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

9
arch/arm/cortex-m33/iar/NTZ/los_timer.c
View File

@ -36,7 +36,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -44,6 +44,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -75,13 +76,17 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

10
arch/arm/cortex-m33/iar/TZ/non_secure/los_timer.c
View File

@ -36,7 +36,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -44,6 +44,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -75,13 +76,18 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

9
arch/arm/cortex-m4/gcc/los_timer.c
View File

@ -36,7 +36,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -44,6 +44,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -75,13 +76,17 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

9
arch/arm/cortex-m4/iar/los_timer.c
View File

@ -36,7 +36,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -44,6 +44,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -75,13 +76,17 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

8
arch/arm/cortex-m55/gcc/NTZ/los_timer.c
View File

@ -43,6 +43,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -74,13 +75,18 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

9
arch/arm/cortex-m7/gcc/los_timer.c
View File

@ -36,7 +36,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -44,6 +44,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -75,13 +76,17 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

9
arch/arm/cortex-m7/iar/los_timer.c
View File

@ -36,7 +36,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -44,6 +44,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTick_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -75,13 +76,17 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
NVIC_ClearPendingIRQ(SysTick_IRQn);
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

9
arch/csky/v2/gcc/los_timer.c
View File

@ -53,7 +53,7 @@ typedef struct {
#define TIM_INT_NUM 1
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -61,6 +61,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = TIM_INT_NUM,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -98,12 +99,16 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
SysTick->CTRL &= ~CORETIM_ENABLE;
SysTick->LOAD = (UINT32)(nextResponseTime - 1UL); /* set reload register */
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
SysTick->CTRL |= CORETIM_ENABLE;
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

3
arch/include/los_timer.h
View File

@ -56,9 +56,10 @@ extern "C" {
typedef struct {
UINT32 freq;
INT32 irqNum;
UINT64 periodMax;
UINT32 (*init)(HWI_PROC_FUNC tickHandler);
UINT64 (*getCycle)(UINT32 *period);
VOID (*reload)(UINT64 time);
UINT64 (*reload)(UINT64 time);
VOID (*lock)(VOID);
VOID (*unlock)(VOID);
HWI_PROC_FUNC tickHandler;

6
arch/risc-v/nuclei/gcc/los_timer.c
View File

@ -47,7 +47,7 @@ STATIC HWI_PROC_FUNC g_sysTickHandler = (HWI_PROC_FUNC)NULL;
extern UINT32 g_intCount;
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -55,6 +55,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = SysTimer_IRQn,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -95,9 +96,10 @@ void ArchTickSysTickHandler(void)
}
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
SysTick_Reload(nextResponseTime);
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

6
arch/risc-v/riscv32/gcc/los_timer.c
View File

@ -39,7 +39,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -47,6 +47,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = RISCV_MACH_TIMER_IRQ,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -75,7 +76,7 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
UINT64 timeMax = (UINT64)LOSCFG_BASE_CORE_TICK_RESPONSE_MAX - 1;
UINT64 timer;
@ -94,6 +95,7 @@ STATIC VOID SysTickReload(UINT64 nextResponseTime)
WRITE_UINT32((UINT32)timer, MTIMERCMP);
WRITE_UINT32((UINT32)(timer >> SHIFT_32_BIT), MTIMERCMP + MTIMER_HI_OFFSET);
HalIrqEnable(RISCV_MACH_TIMER_IRQ);
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

10
arch/xtensa/lx6/gcc/los_timer.c
View File

@ -37,7 +37,7 @@
#include "los_debug.h"
STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler);
STATIC VOID SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickReload(UINT64 nextResponseTime);
STATIC UINT64 SysTickCycleGet(UINT32 *period);
STATIC VOID SysTickLock(VOID);
STATIC VOID SysTickUnlock(VOID);
@ -45,6 +45,7 @@ STATIC VOID SysTickUnlock(VOID);
STATIC ArchTickTimer g_archTickTimer = {
.freq = 0,
.irqNum = OS_TICK_INT_NUM,
.periodMax = LOSCFG_BASE_CORE_TICK_RESPONSE_MAX,
.init = SysTickStart,
.getCycle = SysTickCycleGet,
.reload = SysTickReload,
@ -77,12 +78,17 @@ STATIC UINT32 SysTickStart(HWI_PROC_FUNC handler)
return LOS_OK;
}
STATIC VOID SysTickReload(UINT64 nextResponseTime)
STATIC UINT64 SysTickReload(UINT64 nextResponseTime)
{
UINT32 timerL;
if (nextResponseTime > g_archTickTimer.periodMax) {
nextResponseTime = g_archTickTimer.periodMax;
}
timerL = GetCcount();
timerL += nextResponseTime;
SetCcompare(timerL);
return nextResponseTime;
}
STATIC UINT64 SysTickCycleGet(UINT32 *period)

22
components/power/los_pm.c
View File

@ -31,8 +31,11 @@
#include "los_pm.h"
#include "securec.h"
#include "los_sched.h"
#include "los_timer.h"
#include "los_task.h"
#include "los_tick.h"
#include "los_event.h"
#include "los_sched.h"
#include "los_memory.h"
#include "los_swtmr.h"
@ -70,7 +73,6 @@ typedef struct {
STATIC EVENT_CB_S g_pmEvent;
STATIC LosPmCB g_pmCB;
STATIC LosPmSysctrl g_sysctrl;
STATIC UINT64 g_pmSleepTime;
STATIC VOID OsPmSysctrlInit(VOID)
{
@ -122,7 +124,7 @@ STATIC BOOL OsPmTickTimerStop(LosPmCB *pm)
{
#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0)
UINT64 sleepCycle;
UINT64 realSleepTime = g_pmSleepTime;
UINT64 realSleepTime = OsSchedGetNextExpireTime(OsGetCurrSchedTimeCycle());
#endif
LosPmTickTimer *tickTimer = pm->tickTimer;
@ -239,7 +241,6 @@ STATIC UINT32 OsPmSuspendSleep(LosPmCB *pm)
LOS_SysSleepEnum mode;
UINT32 prepare = 0;
BOOL tickTimerStop = FALSE;
UINT64 currTime;
ret = OsPmSuspendCheck(pm, &sysSuspendEarly, &deviceSuspend, &mode);
if (ret != LOS_OK) {
@ -261,9 +262,8 @@ STATIC UINT32 OsPmSuspendSleep(LosPmCB *pm)
tickTimerStop = OsPmTickTimerStop(pm);
if (!tickTimerStop) {
currTime = OsGetCurrSchedTimeCycle();
OsSchedResetSchedResponseTime(0);
OsSchedUpdateExpireTime(currTime);
OsSchedUpdateExpireTime();
}
OsPmCpuSuspend(pm);
@ -723,11 +723,6 @@ UINT32 LOS_PmSuspend(UINT32 wakeCount)
return OsPmSuspendSleep(&g_pmCB);
}
STATIC VOID OsPmSleepTimeSet(UINT64 sleepTime)
{
g_pmSleepTime = sleepTime;
}
BOOL OsIsPmMode(VOID)
{
LosPmCB *pm = &g_pmCB;
@ -752,11 +747,6 @@ UINT32 OsPmInit(VOID)
LOS_ListInit(&pm->lockList);
(VOID)LOS_EventInit(&g_pmEvent);
ret = OsSchedRealSleepTimeSet(OsPmSleepTimeSet);
if (ret != LOS_OK) {
return ret;
}
ret = OsPmEnterHandlerSet(OsPmNormalSleep);
if (ret != LOS_OK) {
return ret;

15
kernel/include/los_sched.h
View File

@ -43,21 +43,20 @@ extern "C" {
#endif /* __cplusplus */
#define OS_SCHED_MINI_PERIOD (g_sysClock / LOSCFG_BASE_CORE_TICK_PER_SECOND_MINI)
#define OS_TICK_RESPONSE_PRECISION (UINT32)((OS_SCHED_MINI_PERIOD * 75) / 100)
#define OS_SCHED_MAX_RESPONSE_TIME (UINT64)(((UINT64)-1) - 1U)
extern UINT32 g_taskScheduled;
typedef BOOL (*SchedScan)(VOID);
extern UINT64 g_sysSchedStartTime;
VOID OsSchedResetSchedResponseTime(UINT64 responseTime);
VOID OsSchedSetIdleTaskSchedParam(LosTaskCB *idleTask);
UINT32 OsSchedSwtmrScanRegister(SchedScan func);
VOID OsSchedUpdateExpireTime(UINT64 startTime);
VOID OsSchedUpdateExpireTime(VOID);
UINT64 OsSchedGetNextExpireTime(UINT64 startTime);
VOID OsSchedTaskDeQueue(LosTaskCB *taskCB);
@ -89,15 +88,9 @@ BOOL OsSchedTaskSwitch(VOID);
LosTaskCB *OsGetTopTask(VOID);
UINT32 OsSchedRealSleepTimeSet(VOID (*func)(UINT64));
STATIC INLINE UINT64 OsGetCurrSchedTimeCycle(VOID)
{
if (g_sysSchedStartTime != OS_64BIT_MAX) {
return (LOS_SysCycleGet() - g_sysSchedStartTime);
}
return 0;
return LOS_SysCycleGet();
}
/**

41
kernel/include/los_sortlink.h
View File

@ -55,10 +55,15 @@ typedef struct {
LOS_DL_LIST sortLink;
} SortLinkAttribute;
extern SortLinkAttribute g_taskSortLink;
extern SortLinkAttribute g_swtmrSortLink;
#define OS_SORT_LINK_INVALID_TIME ((UINT64)-1)
#define SET_SORTLIST_VALUE(sortList, value) (((SortLinkList *)(sortList))->responseTime = (value))
#define GET_SORTLIST_VALUE(sortList) (((SortLinkList *)(sortList))->responseTime)
#define OS_SORT_LINK_UINT64_MAX ((UINT64)-1)
STATIC INLINE UINT64 OsSortLinkGetRemainTime(UINT64 currTime, const SortLinkList *targetSortList)
{
if (currTime >= targetSortList->responseTime) {
@ -67,14 +72,42 @@ STATIC INLINE UINT64 OsSortLinkGetRemainTime(UINT64 currTime, const SortLinkList
return (targetSortList->responseTime - currTime);
}
STATIC INLINE VOID OsDeleteNodeSortLink(SortLinkList *sortList)
{
LOS_ListDelete(&sortList->sortLinkNode);
SET_SORTLIST_VALUE(sortList, OS_SORT_LINK_INVALID_TIME);
}
STATIC INLINE UINT64 GetSortLinkNextExpireTime(SortLinkAttribute *sortHeader, UINT64 startTime, UINT32 tickPrecision)
{
LOS_DL_LIST *head = &sortHeader->sortLink;
LOS_DL_LIST *list = head->pstNext;
if (LOS_ListEmpty(head)) {
return OS_SORT_LINK_UINT64_MAX - tickPrecision;
}
SortLinkList *listSorted = LOS_DL_LIST_ENTRY(list, SortLinkList, sortLinkNode);
if (listSorted->responseTime <= (startTime + tickPrecision)) {
return (startTime + tickPrecision);
}
return listSorted->responseTime;
}
STATIC INLINE UINT64 OsGetNextExpireTime(UINT64 startTime, UINT32 tickPrecision)
{
UINT64 taskExpireTime = GetSortLinkNextExpireTime(&g_taskSortLink, startTime, tickPrecision);
UINT64 swtmrExpireTime = GetSortLinkNextExpireTime(&g_swtmrSortLink, startTime, tickPrecision);
return (taskExpireTime < swtmrExpireTime) ? taskExpireTime : swtmrExpireTime;
}
SortLinkAttribute *OsGetSortLinkAttribute(SortLinkType type);
UINT64 OsGetNextExpireTime(UINT64 startTime);
UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader);
VOID OsDeleteNodeSortLink(SortLinkList *sortList);
VOID OsAdd2SortLink(SortLinkList *node, UINT64 startTime, UINT32 waitTicks, SortLinkType type);
VOID OsDeleteSortLink(SortLinkList *node);
UINT32 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList);
UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader);
UINT64 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList);
UINT64 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader);
#ifdef __cplusplus
#if __cplusplus

22
kernel/include/los_swtmr.h
View File

@ -500,27 +500,7 @@ extern UINT32 OsSwtmrInit(VOID);
*/
extern UINT32 OsSwtmrGetNextTimeout(VOID);
/**
* @ingroup los_swtmr
* @brief Adjust software timer list.
*
* @par Description:
* <ul>
* <li>This API is used to adjust software timer list.</li>
* </ul>
* @attention
* <ul>
* <li>None.</li>
* </ul>
*
* @param sleepTime [IN] UINT32 Sleep time.
*
* @retval UINT32 Sleep time.
* @par Dependency:
* <ul><li>los_swtmr.h: the header file that contains the API declaration.</li></ul>
* @see None.
*/
extern VOID OsSwtmrAdjust(UINT32 sleepTime);
extern VOID OsSwtmrResponseTimeReset(UINT64 startTime);
#ifdef __cplusplus
#if __cplusplus

4
kernel/include/los_tick.h
View File

@ -249,7 +249,7 @@ typedef struct TagSysTime {
UINT8 ucWeek; /**< value 0 - 6 */
} SYS_TIME_S;
VOID OsTickTimerReload(UINT64 responseTime);
UINT64 OsTickTimerReload(UINT64 period);
#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0)
VOID OsTickTimerBaseReset(UINT64 currTime);
@ -257,6 +257,8 @@ VOID OsTickTimerBaseReset(UINT64 currTime);
UINT32 OsTickTimerInit(VOID);
VOID OsTickSysTimerStartTimeSet(UINT64 currTime);
/**
* @ingroup los_tick
* @brief Obtain the number of Ticks.

127
kernel/src/los_sched.c
View File

@ -32,6 +32,7 @@
#include "los_sched.h"
#include "los_task.h"
#include "los_tick.h"
#include "los_swtmr.h"
#include "los_debug.h"
#include "los_hook.h"
#if (LOSCFG_KERNEL_PM == 1)
@ -49,6 +50,7 @@ extern "C" {
#define OS_SCHED_TIME_SLICES ((LOSCFG_BASE_CORE_TIMESLICE_TIMEOUT * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE)
#define OS_TIME_SLICE_MIN (INT32)((50 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /* 50us */
#define OS_TICK_RESPONSE_TIME_MAX LOSCFG_BASE_CORE_TICK_RESPONSE_MAX
#define OS_TICK_RESPONSE_PRECISION (UINT32)((OS_SCHED_MINI_PERIOD * 75) / 100)
#if (LOSCFG_BASE_CORE_TICK_RESPONSE_MAX == 0)
#error "Must specify the maximum value that tick timer counter supports!"
#endif
@ -63,25 +65,7 @@ STATIC UINT32 g_queueBitmap;
STATIC UINT32 g_schedResponseID = 0;
STATIC UINT16 g_tickIntLock = 0;
STATIC UINT64 g_tickStartTime = 0;
STATIC UINT64 g_schedResponseTime = OS_SCHED_MAX_RESPONSE_TIME;
STATIC VOID (*SchedRealSleepTimeSet)(UINT64) = NULL;
UINT64 g_sysSchedStartTime = OS_64BIT_MAX;
STATIC VOID OsSchedSetStartTime(UINT64 currCycle)
{
g_sysSchedStartTime = currCycle;
}
UINT32 OsSchedRealSleepTimeSet(VOID (*func)(UINT64))
{
if (func == NULL) {
return LOS_NOK;
}
SchedRealSleepTimeSet = func;
return LOS_OK;
}
VOID OsSchedResetSchedResponseTime(UINT64 responseTime)
{
@ -101,27 +85,21 @@ STATIC INLINE VOID OsTimeSliceUpdate(LosTaskCB *taskCB, UINT64 currTime)
taskCB->startTime = currTime;
}
STATIC INLINE VOID OsSchedTickReload(UINT64 nextResponseTime, UINT32 responseID, BOOL isTimeSlice)
STATIC INLINE VOID OsSchedSetNextExpireTime(UINT32 responseID, UINT64 taskEndTime)
{
UINT64 currTime, nextExpireTime;
UINT32 usedTime;
UINT64 nextResponseTime = 0;
BOOL isTimeSlice = FALSE;
currTime = OsGetCurrSchedTimeCycle();
if (g_tickStartTime != 0) {
usedTime = currTime - g_tickStartTime;
g_tickStartTime = 0;
} else {
usedTime = 0;
UINT64 currTime = OsGetCurrSchedTimeCycle();
UINT64 nextExpireTime = OsGetNextExpireTime(currTime, OS_TICK_RESPONSE_PRECISION);
/* The response time of the task time slice is aligned to the next response time in the delay queue */
if ((nextExpireTime > taskEndTime) && ((nextExpireTime - taskEndTime) > OS_SCHED_MINI_PERIOD)) {
nextExpireTime = taskEndTime;
isTimeSlice = TRUE;
}
if ((nextResponseTime > usedTime) && ((nextResponseTime - usedTime) > OS_TICK_RESPONSE_PRECISION)) {
nextResponseTime -= usedTime;
} else {
nextResponseTime = OS_TICK_RESPONSE_PRECISION;
}
nextExpireTime = currTime + nextResponseTime;
if (nextExpireTime >= g_schedResponseTime) {
if ((g_schedResponseTime <= nextExpireTime) ||
((g_schedResponseTime - nextExpireTime) < OS_TICK_RESPONSE_PRECISION)) {
return;
}
@ -131,46 +109,15 @@ STATIC INLINE VOID OsSchedTickReload(UINT64 nextResponseTime, UINT32 responseID,
} else {
g_schedResponseID = OS_INVALID;
}
g_schedResponseTime = nextExpireTime;
OsTickTimerReload(nextResponseTime);
nextResponseTime = nextExpireTime - currTime;
if (nextResponseTime < OS_TICK_RESPONSE_PRECISION) {
nextResponseTime = OS_TICK_RESPONSE_PRECISION;
}
g_schedResponseTime = currTime + OsTickTimerReload(nextResponseTime);
}
STATIC INLINE VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID, UINT64 taskEndTime)
{
UINT64 nextExpireTime;
UINT64 nextResponseTime = 0;
BOOL isTimeSlice = FALSE;
nextExpireTime = OsGetNextExpireTime(startTime);
/* The response time of the task time slice is aligned to the next response time in the delay queue */
if ((nextExpireTime > taskEndTime) && ((nextExpireTime - taskEndTime) > OS_SCHED_MINI_PERIOD)) {
nextExpireTime = taskEndTime;
isTimeSlice = TRUE;
}
if ((g_schedResponseTime > nextExpireTime) &&
((g_schedResponseTime - nextExpireTime) >= OS_TICK_RESPONSE_PRECISION)) {
nextResponseTime = nextExpireTime - startTime;
if (nextResponseTime > OS_TICK_RESPONSE_TIME_MAX) {
if (SchedRealSleepTimeSet != NULL) {
SchedRealSleepTimeSet(nextResponseTime);
}
nextResponseTime = OS_TICK_RESPONSE_TIME_MAX;
}
if (SchedRealSleepTimeSet != NULL) {
SchedRealSleepTimeSet(0);
}
} else {
/* There is no point earlier than the current expiration date */
g_tickStartTime = 0;
return;
}
OsSchedTickReload(nextResponseTime, responseID, isTimeSlice);
}
VOID OsSchedUpdateExpireTime(UINT64 startTime)
VOID OsSchedUpdateExpireTime(VOID)
{
UINT64 endTime;
BOOL isPmMode = FALSE;
@ -185,11 +132,11 @@ VOID OsSchedUpdateExpireTime(UINT64 startTime)
#endif
if ((runTask->taskID != g_idleTaskID) && !isPmMode) {
INT32 timeSlice = (runTask->timeSlice <= OS_TIME_SLICE_MIN) ? OS_SCHED_TIME_SLICES : runTask->timeSlice;
endTime = startTime + timeSlice;
endTime = runTask->startTime + timeSlice;
} else {
endTime = OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION;
}
OsSchedSetNextExpireTime(startTime, runTask->taskID, endTime);
OsSchedSetNextExpireTime(runTask->taskID, endTime);
}
STATIC INLINE VOID OsSchedPriQueueEnHead(LOS_DL_LIST *priqueueItem, UINT32 priority)
@ -468,6 +415,11 @@ UINT32 OsTaskNextSwitchTimeGet(VOID)
return ticks;
}
UINT64 OsSchedGetNextExpireTime(UINT64 startTime)
{
return OsGetNextExpireTime(startTime, OS_TICK_RESPONSE_PRECISION);
}
UINT32 OsSchedInit(VOID)
{
UINT16 pri;
@ -503,6 +455,8 @@ LosTaskCB *OsGetTopTask(VOID)
VOID OsSchedStart(VOID)
{
PRINTK("Entering scheduler\n");
(VOID)LOS_IntLock();
LosTaskCB *newTask = OsGetTopTask();
@ -510,18 +464,19 @@ VOID OsSchedStart(VOID)
g_losTask.newTask = newTask;
g_losTask.runTask = g_losTask.newTask;
/* Initialize the schedule timeline and enable scheduling */
g_taskScheduled = TRUE;
OsSchedSetStartTime(LOS_SysCycleGet());
newTask->startTime = OsGetCurrSchedTimeCycle();
OsSchedTaskDeQueue(newTask);
OsTickSysTimerStartTimeSet(newTask->startTime);
OsSwtmrResponseTimeReset(newTask->startTime);
/* Initialize the schedule timeline and enable scheduling */
g_taskScheduled = TRUE;
g_schedResponseTime = OS_SCHED_MAX_RESPONSE_TIME;
g_schedResponseID = OS_INVALID;
OsSchedSetNextExpireTime(newTask->startTime, newTask->taskID, newTask->startTime + newTask->timeSlice);
PRINTK("Entering scheduler\n");
OsSchedSetNextExpireTime(newTask->taskID, newTask->startTime + newTask->timeSlice);
}
BOOL OsSchedTaskSwitch(VOID)
@ -563,7 +518,7 @@ BOOL OsSchedTaskSwitch(VOID)
if (g_schedResponseID == runTask->taskID) {
g_schedResponseTime = OS_SCHED_MAX_RESPONSE_TIME;
}
OsSchedSetNextExpireTime(newTask->startTime, newTask->taskID, endTime);
OsSchedSetNextExpireTime(newTask->taskID, endTime);
return isTaskSwitch;
}
@ -595,7 +550,7 @@ VOID LOS_SchedTickHandler(VOID)
}
UINT32 intSave = LOS_IntLock();
g_tickStartTime = OsGetCurrSchedTimeCycle();
UINT64 tickStartTime = OsGetCurrSchedTimeCycle();
if (g_schedResponseID == OS_INVALID) {
g_tickIntLock++;
if (g_swtmrScan != NULL) {
@ -606,14 +561,14 @@ VOID LOS_SchedTickHandler(VOID)
g_tickIntLock--;
}
OsTimeSliceUpdate(g_losTask.runTask, g_tickStartTime);
OsTimeSliceUpdate(g_losTask.runTask, tickStartTime);
g_losTask.runTask->startTime = OsGetCurrSchedTimeCycle();
g_schedResponseTime = OS_SCHED_MAX_RESPONSE_TIME;
if (LOS_CHECK_SCHEDULE) {
ArchTaskSchedule();
} else {
OsSchedUpdateExpireTime(g_losTask.runTask->startTime);
OsSchedUpdateExpireTime();
}
LOS_IntRestore(intSave);

47
kernel/src/los_sortlink.c
View File

@ -39,8 +39,8 @@ extern "C" {
#endif
#endif /* __cplusplus */
STATIC SortLinkAttribute g_taskSortLink;
STATIC SortLinkAttribute g_swtmrSortLink;
SortLinkAttribute g_taskSortLink;
SortLinkAttribute g_swtmrSortLink;
UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader)
{
@ -78,29 +78,6 @@ STATIC INLINE VOID OsAddNode2SortLink(SortLinkAttribute *sortLinkHeader, SortLin
} while (1);
}
VOID OsDeleteNodeSortLink(SortLinkList *sortList)
{
LOS_ListDelete(&sortList->sortLinkNode);
SET_SORTLIST_VALUE(sortList, OS_SORT_LINK_INVALID_TIME);
}
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;
}
VOID OsAdd2SortLink(SortLinkList *node, UINT64 startTime, UINT32 waitTicks, SortLinkType type)
{
UINT32 intSave;
@ -144,30 +121,16 @@ SortLinkAttribute *OsGetSortLinkAttribute(SortLinkType type)
return NULL;
}
UINT64 OsGetNextExpireTime(UINT64 startTime)
{
UINT32 intSave;
SortLinkAttribute *taskHeader = &g_taskSortLink;
SortLinkAttribute *swtmrHeader = &g_swtmrSortLink;
intSave = LOS_IntLock();
UINT64 taskExpirTime = OsGetSortLinkNextExpireTime(taskHeader, startTime);
UINT64 swtmrExpirTime = OsGetSortLinkNextExpireTime(swtmrHeader, startTime);
LOS_IntRestore(intSave);
return (taskExpirTime < swtmrExpirTime) ? taskExpirTime : swtmrExpirTime;
}
UINT32 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList)
UINT64 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList)
{
if (currTime >= targetSortList->responseTime) {
return 0;
}
return (UINT32)(((targetSortList->responseTime - currTime) * LOSCFG_BASE_CORE_TICK_PER_SECOND) / g_sysClock);
return (targetSortList->responseTime - currTime);
}
UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader)
UINT64 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader)
{
LOS_DL_LIST *head = (LOS_DL_LIST *)&sortLinkHeader->sortLink;

37
kernel/src/los_swtmr.c
View File

@ -238,7 +238,7 @@ LITE_OS_SEC_TEXT VOID OsSwtmrStart(UINT64 currTime, SWTMR_CTRL_S *swtmr)
}
#endif
OsAdd2SortLink(&swtmr->stSortList, swtmr->startTime, swtmr->uwInterval, OS_SORT_LINK_SWTMR);
OsSchedUpdateExpireTime(currTime);
OsSchedUpdateExpireTime();
}
/*****************************************************************************
@ -274,7 +274,7 @@ LITE_OS_SEC_TEXT VOID OsSwtmrStop(SWTMR_CTRL_S *swtmr)
swtmr->ucState = OS_SWTMR_STATUS_CREATED;
swtmr->ucOverrun = 0;
OsSchedUpdateExpireTime(OsGetCurrSchedTimeCycle());
OsSchedUpdateExpireTime();
#if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].isAligned = 0;
#endif
@ -327,6 +327,24 @@ STATIC BOOL OsSwtmrScan(VOID)
return needSchedule;
}
LITE_OS_SEC_TEXT VOID OsSwtmrResponseTimeReset(UINT64 startTime)
{
LOS_DL_LIST *listHead = &g_swtmrSortLinkList->sortLink;
LOS_DL_LIST *listNext = listHead->pstNext;
while (listNext != listHead) {
SortLinkList *sortList = LOS_DL_LIST_ENTRY(listNext, SortLinkList, sortLinkNode);
SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
OsDeleteNodeSortLink(sortList);
#if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
g_swtmrAlignID[swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT].isAligned = 0;
#endif
swtmr->startTime = startTime;
OsSwtmrStart(startTime, swtmr);
listNext = listNext->pstNext;
}
}
/*****************************************************************************
Function : OsSwtmrGetNextTimeout
Description : Get next timeout
@ -337,14 +355,23 @@ Return : Count of the Timer list
LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID)
{
UINT32 intSave = LOS_IntLock();
UINT32 ticks = OsSortLinkGetNextExpireTime(g_swtmrSortLinkList);
UINT64 time = OsSortLinkGetNextExpireTime(g_swtmrSortLinkList);
LOS_IntRestore(intSave);
return ticks;
time = time / OS_CYCLE_PER_TICK;
if (time > OS_NULL_INT) {
time = OS_NULL_INT;
}
return time;
}
LITE_OS_SEC_TEXT UINT32 OsSwtmrTimeGet(const SWTMR_CTRL_S *swtmr)
{
return OsSortLinkGetTargetExpireTime(OsGetCurrSchedTimeCycle(), &swtmr->stSortList);
UINT64 time = OsSortLinkGetTargetExpireTime(OsGetCurrSchedTimeCycle(), &swtmr->stSortList);
time = time / OS_CYCLE_PER_TICK;
if (time > OS_NULL_INT) {
time = OS_NULL_INT;
}
return (UINT32)time;
}
/*****************************************************************************

19
kernel/src/los_tick.c
View File

@ -42,7 +42,8 @@ LITE_OS_SEC_BSS UINT32 g_ticksPerSec;
LITE_OS_SEC_BSS UINT32 g_uwCyclePerSec;
LITE_OS_SEC_BSS UINT32 g_cyclesPerTick;
LITE_OS_SEC_BSS UINT32 g_sysClock;
LITE_OS_SEC_BSS BOOL g_sysTimerIsInit = FALSE;
LITE_OS_SEC_BSS STATIC BOOL g_sysTimerIsInit = FALSE;
LITE_OS_SEC_BSS STATIC UINT64 g_tickTimerStartTime;
#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0)
STATIC UINT64 g_tickTimerBase;
@ -72,12 +73,12 @@ LITE_OS_SEC_TEXT VOID OsTickHandler(VOID)
LOS_SchedTickHandler();
}
LITE_OS_SEC_TEXT VOID OsTickTimerReload(UINT64 responseTime)
LITE_OS_SEC_TEXT UINT64 OsTickTimerReload(UINT64 period)
{
#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0)
g_tickTimerBase = LOS_SysCycleGet();
#endif
g_sysTickTimer->reload(responseTime);
return g_sysTickTimer->reload(period);
}
LITE_OS_SEC_TEXT UINT64 LOS_SysCycleGet(VOID)
@ -120,6 +121,10 @@ STATIC UINT32 TickTimerCheck(const ArchTickTimer *tick)
return LOS_ERRNO_TICK_CFG_INVALID;
}
if (tick->periodMax == 0) {
return LOS_ERRNO_TICK_CFG_INVALID;
}
if ((tick->init == NULL) || (tick->reload == NULL) ||
(tick->lock == NULL) || (tick->unlock == NULL) ||
(tick->getCycle == NULL)) {
@ -172,6 +177,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsTickTimerInit(VOID)
g_sysTimerIsInit = TRUE;
LOS_IntRestore(intSave);
return LOS_OK;
}
@ -223,6 +229,11 @@ LITE_OS_SEC_TEXT UINT32 LOS_TickTimerRegister(const ArchTickTimer *timer, const
return LOS_OK;
}
LITE_OS_SEC_TEXT_MINOR VOID OsTickSysTimerStartTimeSet(UINT64 currTime)
{
g_tickTimerStartTime = currTime;
}
/*****************************************************************************
Function : LOS_TickCountGet
Description : get current tick
@ -232,7 +243,7 @@ Return : current tick
*****************************************************************************/
LITE_OS_SEC_TEXT_MINOR UINT64 LOS_TickCountGet(VOID)
{
return LOS_SysCycleGet() / OS_CYCLE_PER_TICK;
return (LOS_SysCycleGet() - g_tickTimerStartTime) / OS_CYCLE_PER_TICK;
}
/*****************************************************************************