本文将从调度器的创建为入口，通过分析定时器中断以及PendSV中断的原理，刨析任务调度的本质原理。
从上图可以看到，调度器是在main函数中初始化，同时初始化后会启动第一个任务函数；任务上下文切换实际也是借用了一个特殊的中断PendSV，此中断可以挂起，当有任务切换请求后，需要在没有更高优先级中断执行时才会执行PendSV。PendSV主要就是保存上文，切换到下文。
1.void vTaskStartScheduler( void )
函数实现流程及作用：
void vTaskStartScheduler( void )
{
BaseType_t xReturn;
/* Add the idle task at the lowest priority. */
#if( configSUPPORT_STATIC_ALLOCATION == 1 )
{
//如果宏开启，使用静态方式创建空闲任务
}
#else
{
//创建空闲任务，空闲任务主要工作是释放已经销毁的任务空间
xReturn = xTaskCreate( prvIdleTask,
"IDLE", configMINIMAL_STACK_SIZE,
( void * ) NULL,
( tskIDLE_PRIORITY | portPRIVILEGE_BIT ),
&xIdleTaskHandle );
}
#endif /* configSUPPORT_STATIC_ALLOCATION */
#if ( configUSE_TIMERS == 1 )
{
if( xReturn == pdPASS )
{//创建定时任务，也是系统中软定时的实现
xReturn = xTimerCreateTimerTask();
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
#endif /* configUSE_TIMERS */
if( xReturn == pdPASS )
{
//屏蔽freertos可控优先级及以下的中断，当启动第一个任务是会解除屏蔽
portDISABLE_INTERRUPTS();
#if ( configUSE_NEWLIB_REENTRANT == 1 )
{
/* Switch Newlib's _impure_ptr variable to point to the _reent
structure specific to the task that will run first. */
_impure_ptr = &( pxCurrentTCB->xNewLib_reent );
}
#endif /* configUSE_NEWLIB_REENTRANT */
//初始化一些全局变量
xNextTaskUnblockTime = portMAX_DELAY;
xSchedulerRunning = pdTRUE;
xTickCount = ( TickType_t ) 0U;
//设置时基定时器
portCONFIGURE_TIMER_FOR_RUN_TIME_STATS();
//设置PendSV中断和systick中断优先级，设置tick时间，启动第一个任务
if( xPortStartScheduler() != pdFALSE )
{
/* Should not reach here as if the scheduler is running the
function will not return. */
}
else
{
/* Should only reach here if a task calls xTaskEndScheduler(). */
}
}
else
{
/* This line will only be reached if the kernel could not be started,
because there was not enough FreeRTOS heap to create the idle task
or the timer task. */
configASSERT( xReturn != errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY );
}
/* Prevent compiler warnings if INCLUDE_xTaskGetIdleTaskHandle is set to 0,
meaning xIdleTaskHandle is not used anywhere else. */
( void ) xIdleTaskHandle;
}
2.BaseType_t xPortStartScheduler( void )
函数的功能及实现如下：
BaseType_t xPortStartScheduler( void )
{
/* configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to 0. See
http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
configASSERT( ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) );
#if( configASSERT_DEFINED == 1 )
{
//中断优先级寄存器0:IPR0
volatile uint32_t ulOriginalPriority;
volatile uint8_t * const pucFirstUserPriorityRegister = ( volatile uint8_t * ) ( portNVIC_IP_REGISTERS_OFFSET_16 + portFIRST_USER_INTERRUPT_NUMBER );
volatile uint8_t ucMaxPriorityValue;
/*这一大段代码用来确定一个最高ISR优先级,在这个ISR或者更低优先级的ISR中可以安全的调用以FromISR结尾的API函数.
保存中断优先级值,因为下面要覆写这个寄存器(IPR0)*/
ulOriginalPriority = *pucFirstUserPriorityRegister;
/* 确定有效的优先级位个数. 首先向所有位写1,然后再读出来,由于无效的优先级位读出为0,然后数一数有多少个1,就能知道有多少位优先级. */
*pucFirstUserPriorityRegister = portMAX_8_BIT_VALUE;
/* Read the value back to see how many bits stuck. */
ucMaxPriorityValue = *pucFirstUserPriorityRegister;
/*用来防止用户不正确的设置RTOS可屏蔽中断优先级值 . */
ucMaxSysCallPriority = configMAX_SYSCALL_INTERRUPT_PRIORITY & ucMaxPriorityValue;
/* 计算最大优先级组值 */
ulMaxPRIGROUPValue = portMAX_PRIGROUP_BITS;
while( ( ucMaxPriorityValue & portTOP_BIT_OF_BYTE ) == portTOP_BIT_OF_BYTE )
{
ulMaxPRIGROUPValue--;
ucMaxPriorityValue <<= ( uint8_t ) 0x01;
}
/* Shift the priority group value back to its position within the AIRCR
register. */
ulMaxPRIGROUPValue <<= portPRIGROUP_SHIFT;
ulMaxPRIGROUPValue &= portPRIORITY_GROUP_MASK;
/* 将IPR0寄存器的值复原. */
*pucFirstUserPriorityRegister = ulOriginalPriority;
}
#endif /* conifgASSERT_DEFINED */
/* 将PendSV和SysTick中断设置为最低优先级 */
portNVIC_SYSPRI2_REG |= portNVIC_PENDSV_PRI;
portNVIC_SYSPRI2_REG |= portNVIC_SYSTICK_PRI;
/* Configure the regions in the MPU that are common to all tasks. */
prvSetupMPU();
/* 启动系统节拍定时器,即SysTick定时器,初始化中断周期并使能定时器 */
prvSetupTimerInterrupt();
/* 初始化临界区嵌套计数器. */
uxCriticalNesting = 0;
/* Ensure the VFP is enabled - it should be anyway. */
vPortEnableVFP();
/* Lazy save always. */
*( portFPCCR ) |= portASPEN_AND_LSPEN_BITS;
/* 启动第一个任务 */
prvStartFirstTask();
/* Should not get here! */
return 0;
}
在初始化任务调度时，最后会执行prvStartFirstTask（）函数去启动第一个任务，此部分以cortex-m3为例；此部分是汇编实现
源码如下：
__asm void prvStartFirstTask( void )
{
PRESERVE8
/* Cortext-M3硬件中,0xE000ED08地址处为VTOR(向量表偏移量)寄存器,存储向量表起始地址. */
ldr r0, =0xE000ED08
ldr r0, [r0]
ldr r0, [r0]
/* 将堆栈地址存入主堆栈指针 */
msr msp, r0
/*使能全局中断. */
cpsie i
cpsie f
dsb
isb
/* 调用SVC启动第一个任务*/
svc 0
nop
nop
}
调用SVC将会执行SVC中断函数：
SVC中断服务函数一开始就使用全局指针pxCurrentTCB获得第一个要启动的任务TCB，从而获得任务的当前堆栈栈顶指针。先将人为入栈的寄存器R4~R11出栈，将最新的堆栈栈顶指针赋值给线程堆栈指针PSP，再取消中断掩蔽。到这里，只要发生中断，就都能够被响应了;
执行bx r14指令后，硬件自动将寄存器xPSR、PC、LR、R12、R3~R0出栈，这时任务的任务函数指针vTask_func会出栈到PC指针中，从而开始执行任务函数。
至此，任务获得CPU执行权，调度器正式开始工作。
__asm void vPortSVCHandler( void )
{
PRESERVE8
//将当前的运行态任务TCB地址赋值给r3，如果没有任务创建，则pxCurrentTCB 指向空闲任务
ldr r3, =pxCurrentTCB /* Restore the context. */
ldr r1, [r3] /* Use pxCurrentTCBConst to get the pxCurrentTCB address. */
ldr r0, [r1] /* 获取任务堆栈，TCB中第一个参数就是任务堆栈 */
ldmia r0!, {r4-r11} /* 出栈. */
msr psp, r0 /* 最新的栈顶指针赋给线程堆栈指针PSP */
isb
mov r0, #0
msr basepri, r0 //取消中断屏蔽
orr r14, #0xd //这里0x0d表示:返回后进入线程模式,从进程堆栈中做出栈操作,返回Thumb状态
bx r14
}
对于Cortex-M3架构，需要依次入栈xPSR、PC、LR、R12、R3-R0、R11-R4，其中r11~R4需要人为入栈，其它寄存器由硬件自动入栈。寄存器PC被初始化为任务函数指针vTask_func，这样当某次任务切换后，任务A获得CPU控制权，任务函数vTask_func被出栈到PC寄存器，之后会执行任务的代码；LR寄存器初始化为函数指针prvTaskExitError,这是由移植层提供的一个出错处理函数。
PendSV（可挂起系统调用）用于完成任务切换，它的最大特性是如果当前有优先级比它高的中断在运行，PendSV会推迟执行，直到高优先级中断执行完毕。
当进行任务切换请求时，实际上就是将PendSV的悬起位置1，在没有其它中断运行时执行PendSV中断服务函数，在这个中断函数中实现任务切换。
#define taskYIELD() portYIELD()
#define portYIELD() \
{ \
/* Set a PendSV to request a context switch. */ \
portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT; \
\
/* Barriers are normally not required but do ensure the code is completely \
within the specified behaviour for the architecture. */ \
__dsb( portSY_FULL_READ_WRITE ); \
__isb( portSY_FULL_READ_WRITE ); \
}
1.实际在任务创建以及恢复时，会判断新加入就绪态的任务优先级是否大于当前执行的任务优先级，如果大于就会调用上述宏，进行中断请求；
2.针对中断内使用FromISR版本的任务恢复函数，实际是没有立马进行设置PendSV悬挂位，而是待退出中断后，判断标志，若需要请求任务切换，则设置PendSV悬挂位。
3.定时器systick中断轮询，每1ms轮询一次，判断是否满足任务切换的条件，如果满足，则请求任务切换。
SysTick用于产生系统节拍时钟，提供一个时间片，如果多个任务共享同一个优先级，则每次SysTick中断，下一个任务将获得一个时间片。
初始化systick：
void vPortSetupTimerInterrupt( void )
{
/* 配置中断触发时间. */
portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT );
}
中断函数：
void SysTick_Handler(void)
{
if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
{
xPortSysTickHandler();
}
}
void xPortSysTickHandler( void )
{
/* 屏蔽freertos系统可控优先级及以下的中断 */
vPortRaiseBASEPRI();
{
/* 主要的执行函数*/
if( xTaskIncrementTick() != pdFALSE )
{
/* 有上下文切换的请求，置位PendSV的悬挂位. */
portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
}
}
//恢复屏蔽
vPortClearBASEPRIFromISR();
}
通过上面即可看出，systick定时中断主要操作是在xTaskIncrementTick
函数中执行的，且如果执行后返回值有任务上下文的请求，则进行PendSV请求。
下面分析xTaskIncrementTick函数
函数流程如下：
根据上述的函数流程图，相信看到下述代码不成问题。
BaseType_t xTaskIncrementTick( void )
{
TCB_t * pxTCB;
TickType_t xItemValue;
BaseType_t xSwitchRequired = pdFALSE;
/* Called by the portable layer each time a tick interrupt occurs.
Increments the tick then checks to see if the new tick value will cause any
tasks to be unblocked. */
traceTASK_INCREMENT_TICK( xTickCount );
if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
{
/* Minor optimisation. The tick count cannot change in this
block. */
const TickType_t xConstTickCount = xTickCount + 1;
/* Increment the RTOS tick, switching the delayed and overflowed
delayed lists if it wraps to 0. */
xTickCount = xConstTickCount;
if( xConstTickCount == ( TickType_t ) 0U )
{
taskSWITCH_DELAYED_LISTS();
}
else
{
mtCOVERAGE_TEST_MARKER();
}
/* See if this tick has made a timeout expire. Tasks are stored in
the queue in the order of their wake time - meaning once one task
has been found whose block time has not expired there is no need to
look any further down the list. */
if( xConstTickCount >= xNextTaskUnblockTime )
{
for( ;; )
{
if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )
{
/* The delayed list is empty. Set xNextTaskUnblockTime
to the maximum possible value so it is extremely
unlikely that the
if( xTickCount >= xNextTaskUnblockTime ) test will pass
next time through. */
xNextTaskUnblockTime = portMAX_DELAY; /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
break;
}
else
{
/* The delayed list is not empty, get the value of the
item at the head of the delayed list. This is the time
at which the task at the head of the delayed list must
be removed from the Blocked state. */
pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );
xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xStateListItem ) );
if( xConstTickCount < xItemValue )
{
/* It is not time to unblock this item yet, but the
item value is the time at which the task at the head
of the blocked list must be removed from the Blocked
state - so record the item value in
xNextTaskUnblockTime. */
xNextTaskUnblockTime = xItemValue;
break;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
/* It is time to remove the item from the Blocked state. */
( void ) uxListRemove( &( pxTCB->xStateListItem ) );
/* Is the task waiting on an event also? If so remove
it from the event list. */
if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
{
( void ) uxListRemove( &( pxTCB->xEventListItem ) );
}
else
{
mtCOVERAGE_TEST_MARKER();
}
/* Place the unblocked task into the appropriate ready
list. */
prvAddTaskToReadyList( pxTCB );
/* A task being unblocked cannot cause an immediate
context switch if preemption is turned off. */
#if ( configUSE_PREEMPTION == 1 )
{
/* Preemption is on, but a context switch should
only be performed if the unblocked task has a
priority that is equal to or higher than the
currently executing task. */
if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
{
xSwitchRequired = pdTRUE;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
#endif /* configUSE_PREEMPTION */
}
}
}
/* Tasks of equal priority to the currently running task will share
processing time (time slice) if preemption is on, and the application
writer has not explicitly turned time slicing off. */
#if ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) )
{
if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ pxCurrentTCB->uxPriority ] ) ) > ( UBaseType_t ) 1 )
{
xSwitchRequired = pdTRUE;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
#endif /* ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) ) */
#if ( configUSE_TICK_HOOK == 1 )
{
/* Guard against the tick hook being called when the pended tick
count is being unwound (when the scheduler is being unlocked). */
if( uxPendedTicks == ( UBaseType_t ) 0U )
{
vApplicationTickHook();
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
#endif /* configUSE_TICK_HOOK */
}
else
{
++uxPendedTicks;
/* The tick hook gets called at regular intervals, even if the
scheduler is locked. */
#if ( configUSE_TICK_HOOK == 1 )
{
vApplicationTickHook();
}
#endif
}
#if ( configUSE_PREEMPTION == 1 )
{
if( xYieldPending != pdFALSE )
{
xSwitchRequired = pdTRUE;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
#endif /* configUSE_PREEMPTION */
return xSwitchRequired;
}
本文部分引用了网友的此篇博客，也十分感谢他的分享：FreeRTOS调度器启动过程分析.