1. if(rt_current_thread->current_priority < highest_ready_priority)

1.1 低优先级就绪

对于某一任务的阻塞，图例仅展示资源阻塞（调度），或者延时阻塞（调度）中的一种，下同，不再说明

1.2 当前运行任务的时间片用完

这两种情况，最后运行的还是当前任务

2. 当前优先级等于highest_ready_priority，且当前任务时间片未用完

1. if(rt_current_thread->current_priority == highest_ready_priority &&(rt_current_thread->stat & RT_THREAD_STAT_YIELD_MASK)==0)

最后运行的也当前任务

3 需要切换新的任务

可以直接列出剩余的三种情况，

3.1 当前优先级等于highest_ready_priority，且当前任务时间片用完

1. if(rt_current_thread->current_priority == highest_ready_priority &&(rt_current_thread->stat & RT_THREAD_STAT_YIELD_MASK)!=0)

需要礼让，把当前任务B插入对应优先级readylist后, 然后切换到C

3.2 当前优先级大于highest_ready_priority，且当前任务时间片用完

1. if(rt_current_thread->current_priority > highest_ready_priority &&(rt_current_thread->stat & RT_THREAD_STAT_YIELD_MASK)!=0)

1. if(rt_current_thread->current_priority > highest_ready_priority &&(rt_current_thread->stat & RT_THREAD_STAT_YIELD_MASK)==0)

rt_schedule_insert_thread

1. void rt_schedule_insert_thread(struct rt_thread *thread)

2. {

3. registerrt_base_t temp;

4.  

5. RT_ASSERT(thread != RT_NULL);

6.  

7. /* disable interrupt */

8. temp = rt_hw_interrupt_disable();

9.  

10. /* it's current thread, it should be RUNNING thread */

11. if(thread == rt_current_thread)

12. {

13. thread->stat = RT_THREAD_RUNNING |(thread->stat &~RT_THREAD_STAT_MASK);

14. goto __exit;

15. }

16.  

17. /* READY thread, insert to ready queue */

18. thread->stat = RT_THREAD_READY |(thread->stat &~RT_THREAD_STAT_MASK);

19. /* insert thread to ready list */

20. rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]),

21. &(thread->tlist));

22.  

23. RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,("insert thread[%.*s], the priority: %d ",

24. RT_NAME_MAX, thread->name, thread->current_priority));

25.  

26. /* set priority mask */

27. #if RT_THREAD_PRIORITY_MAX > 32

28. rt_thread_ready_table[thread->number]|= thread->high_mask;

29. #endif/* RT_THREAD_PRIORITY_MAX > 32 */

30. rt_thread_ready_priority_group |= thread->number_mask;

31.  

32. __exit:

33. /* enable interrupt */

34. rt_hw_interrupt_enable(temp);

35. }

问题

测试

创建线程

1. int main(void)

2. {

3. rt_thread_init(&rt_led1_thread,

4. "LED1",

5. led1_thread_entry,

6. RT_NULL,

7. &rt_led1_thread_stack[0],

8. sizeof(rt_led1_thread_stack),

9. 6,

10. 1);

11. rt_thread_startup(&rt_led1_thread);

12.  

13. rt_thread_init(&rt_led2_thread,

14. "LED2",

15. led2_thread_entry,

16. RT_NULL,

17. &rt_led2_thread_stack[0],

18. sizeof(rt_led2_thread_stack),

19. 11,

20. 4);

21. rt_thread_startup(&rt_led2_thread);

22.  

23.  

24. rt_thread_init(&rt_led3_thread,

25. "LED3",

26. led3_thread_entry,

27. RT_NULL,

28. &rt_led3_thread_stack[0],

29. sizeof(rt_led3_thread_stack),

30. 11,

31. 2);

32.  

33. rt_thread_startup(&rt_led3_thread);

34. while(1)

35. {

36. rt_thread_mdelay(1000);

37. }

38.  

39. return RT_EOK;

40. }

线程入口函数

1. /* customer short delay */

2. void delay (uint32_t count)

3. {

4. for(; count!=0; count--);

5. }

6.  

7. void led1_thread_entry(void*p_arg )

8. {

9. for(;;)

10. {

11. HAL_GPIO_WritePin(GPIOD, LD4_Pin, GPIO_PIN_SET);

12. rt_thread_delay(5);

13. HAL_GPIO_WritePin(GPIOD, LD4_Pin, GPIO_PIN_RESET);

14. rt_thread_delay(5);

15. }

16. }

17.  

18. void led2_thread_entry(void*p_arg )

19. {

20. for(;;)

21. {

22. HAL_GPIO_WritePin(GPIOD, LD5_Pin, GPIO_PIN_SET);

23. delay(300);

24. HAL_GPIO_WritePin(GPIOD, LD5_Pin, GPIO_PIN_RESET);

25. delay(300);

26. }

27. }

28.  

29. void led3_thread_entry(void*p_arg )

30. {

31. for(;;)

32. {

33. HAL_GPIO_WritePin(GPIOD, LD3_Pin, GPIO_PIN_SET);

34. delay(300);

35. HAL_GPIO_WritePin(GPIOD, LD3_Pin, GPIO_PIN_RESET);

36. delay(300);

37. }

38. }

不同时间片对调度的影响

1）t1 = 5, t2 = 4, t3=2

新就绪的任务优先级高于当前任务，当前任务时间片有剩余

通过逻辑分析仪抓取三个LED pin 电平

还记得我们上面提到了3.2 不能同时满足的条件吗？

1. if(rt_current_thread->current_priority > highest_ready_priority &&(rt_current_thread->stat & RT_THREAD_STAT_YIELD_MASK)!=0)

解决办法

方案一

这种做法应该没啥问题，暂未测试

方案二

直击问题本质，既然是插入的问题导致的，调整一下插入顺序即可

除了时间片使用完，需要yield，插入其readylist的末尾，其他情况均插入readylist的头部

再次测试t1 = 5, t2 = 5, t3=2，结果如下：

可以看到，ticks连续执行了，线程没有重复执行，没有跳过，也没有不被执行的，完美解决。

方案三

更近一步，可不可以不把运行的thread移除readylist呢？如果可以，没有remove,也就没有了insert,没有了issue

其实FreeRTOS使用的就是这种方案：

taskSELECT_HIGHEST_PRIORITY_TASK()

1. #define taskSELECT_HIGHEST_PRIORITY_TASK()

2. {

3. UBaseType_t uxTopPriority;

4.  

5. /* Find the highest priority list that contains ready tasks. */

6. portGET_HIGHEST_PRIORITY( uxTopPriority, uxTopReadyPriority );

7. configASSERT( listCURRENT_LIST_LENGTH(&( pxReadyTasksLists[ uxTopPriority ]))>0);

8. listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB,&( pxReadyTasksLists[ uxTopPriority ]));

9. }/* taskSELECT_HIGHEST_PRIORITY_TASK() */

listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList )

1. #define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList )

2. {

3. List_t*const pxConstList =( pxList );

4. /* Increment the index to the next item and return the item, ensuring */

5. /* we don't return the marker used at the end of the list. */

6. ( pxConstList )->pxIndex =( pxConstList )->pxIndex->pxNext;

7. if((void*)( pxConstList )->pxIndex ==(void*)&(( pxConstList )->xListEnd ))

8. {

9. ( pxConstList )->pxIndex =( pxConstList )->pxIndex->pxNext;

10. }

11. ( pxTCB )=( pxConstList )->pxIndex->pvOwner;

12. }

 https://github.com/RT-Thread/rt-thread/pull/5954 

rt_list_jump_next

1. /**

2.  

3. * @brief move the list to its next's next position

4. *

5. * @param l list to insert it

6. */

7. rt_inline void rt_list_jump_next(rt_list_t*l)

8. {

9. l->next->prev = l->prev;

10. l->prev->next= l->next;

11.  

12.  

13. l->prev = l->next;

14.  

15. l->next->next->prev = l;

16. l->next= l->next->next;

17.  

18. l->prev->next= l;

19.  

20. }

大致操作如下：

这种直接移动list head的做法，一次调度会有6次指针赋值操作，

而原来的一次调度remove（4次）, insert（4次）加起来是8次指针赋值操作

重定义_scheduler_get_highest_priority_thread

1. --- a/src/scheduler.c

2. +++ b/src/scheduler.c

3. @@-180,6+180,19@@staticstruct rt_thread* _scheduler_get_highest_priority_thread(rt_ubase_t*high

4. highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group)-1;

5. #endif/* RT_THREAD_PRIORITY_MAX > 32 */

6.  

7. +/* if current thread is yield , move the head of priority list to next and change its status to READY */

8. +if((rt_current_thread->stat & RT_THREAD_STAT_YIELD_MASK)!=0)

9. +{

10. +if(rt_current_thread->tlist.next!= rt_current_thread->tlist.prev)

11. +{

12. +/* multiple threads, move the list head to next */

13. + rt_list_jump_next(&rt_thread_priority_table[rt_current_thread->current_priority]);

14. +}

15. +

16. +/* clear YIELD and ready thread*/

17. + rt_current_thread->stat = RT_THREAD_READY |(rt_current_thread->stat &~(RT_THREAD_STAT_YIELD_MASK|RT_THREAD_STAT_MASK));

18. +}

19. +

20. /* get highest ready priority thread */

21. highest_priority_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,

22. struct rt_thread,

简化rt_schedule

1. @@-258,7+271,6@@void rt_system_scheduler_start(void)

2. rt_current_thread = to_thread;

3. #endif/* RT_USING_SMP */

4.  

5. - rt_schedule_remove_thread(to_thread);

6. to_thread->stat = RT_THREAD_RUNNING;

7.  

8. /* switch to new thread */

9. @@-436,28+448,8@@void rt_schedule(void)

10.  

11. if(rt_thread_ready_priority_group !=0)

12. {

13. -/* need_insert_from_thread: need to insert from_thread to ready queue */

14. -int need_insert_from_thread =0;

15. -

16. to_thread = _scheduler_get_highest_priority_thread(&highest_ready_priority);

17.  

18. -if((rt_current_thread->stat & RT_THREAD_STAT_MASK)== RT_THREAD_RUNNING)

19. -{

20. -if(rt_current_thread->current_priority < highest_ready_priority)

21. -{

22. - to_thread = rt_current_thread;

23. -}

24. -elseif(rt_current_thread->current_priority == highest_ready_priority &&(rt_current_thread->stat & RT_THREAD_STAT_YIELD_MASK)==0)

25. -{

26. - to_thread = rt_current_thread;

27. -}

28. -else

29. -{

30. - need_insert_from_thread =1;

31. -}

32. - rt_current_thread->stat &=~RT_THREAD_STAT_YIELD_MASK;

33. -}

34. -

35. if(to_thread != rt_current_thread)

36. {

37. /* if the destination thread is not the same as current thread */

38. @@-467,12+459,6@@void rt_schedule(void)

39.  

40. RT_OBJECT_HOOK_CALL(rt_scheduler_hook,(from_thread, to_thread));

41.  

42. -if(need_insert_from_thread)

43. -{

44. - rt_schedule_insert_thread(from_thread);

45. -}

46. -

47. - rt_schedule_remove_thread(to_thread);

48. to_thread->stat = RT_THREAD_RUNNING |(to_thread->stat &~RT_THREAD_STAT_MASK);

49.  

50. /* switch to new thread */

51. @@-531,7+517,6@@void rt_schedule(void)

52. }

53. else

54. {

55. - rt_schedule_remove_thread(rt_current_thread);

56. rt_current_thread->stat = RT_THREAD_RUNNING |(rt_current_thread->stat &~RT_THREAD_STAT_MASK);

57. }

58. }

59. (END)

rt_system_scheduler_start

1. @@-258,7+271,6@@void rt_system_scheduler_start(void)

2. rt_current_thread = to_thread;

3. #endif/* RT_USING_SMP */

4.  

5. - rt_schedule_remove_thread(to_thread);

6. to_thread->stat = RT_THREAD_RUNNING;

7.  

8. /* switch to new thread */

同样测试t1 = 5, t2 = 5, t3=2，结果正常如下：

　　审核编辑：汤梓红