• Rt-Thread 5-调度

    目录

    1、rt_system_scheduler_init()函数

    2、rt_system_scheduler_start()函数 

    3、rt_schedule_insert_thread()函数

    4、rt_schedule_remove_thread()函数

    5、rt_schedule()函数

    6、_rt_scheduler_stack_check()函数

    7、rt_enter_critical()函数

    8、rt_exit_critical()函数

    9、rt_critical_level()函数

    10、rt_scheduler_sethook()函数 

    1、rt_system_scheduler_init()函数

    此函数用于初始化系统调度器。

    1）初始化线程优先级链表数组

    2）初始化当前线程优先级，当前线程控制块，线程就绪优先级组

    3）当最大线程数大于32时，初始化线程就绪表

    4）初始化线程僵尸链表

    1. void rt_system_scheduler_init(void)
    2. {
    3.     register rt_base_t offset;
    4.  
    5.     rt_scheduler_lock_nest = 0;
    6.  
    7.     RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("start scheduler: max priority 0x%02x\n",
    8.                                       RT_THREAD_PRIORITY_MAX));
    9.  
    10.     for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++)
    11.     {
    12.         rt_list_init(&rt_thread_priority_table[offset]); //初始化线程优先级链表数组
    13.     }
    14.  
    15.     rt_current_priority = RT_THREAD_PRIORITY_MAX - 1; //初始化当前线程优先级
    16.     rt_current_thread = RT_NULL; //初始化当前线程控制块
    17.  
    18.     rt_thread_ready_priority_group = 0; //初始化线程就绪优先级组
    19.  
    20. #if RT_THREAD_PRIORITY_MAX > 32 //最大线程数大于32
    21.     rt_memset(rt_thread_ready_table, 0, sizeof(rt_thread_ready_table)); //初始化线程就绪表
    22. #endif
    23.  
    24.     rt_list_init(&rt_thread_defunct); //初始化线程僵尸链表
    25. }

    2、rt_system_scheduler_start()函数 

    此函数用于启动调度器。

    1）计算最高就绪优先级

    2）获取要切换的线程

    3）切换到新的线程运行

    1. void rt_system_scheduler_start(void)
    2. {
    3.     register struct rt_thread *to_thread;
    4.     register rt_ubase_t highest_ready_priority;
    5.  
    6.     /* 计算最高就绪优先级 */
    7. #if RT_THREAD_PRIORITY_MAX > 32
    8.     register rt_ubase_t number;
    9.  
    10.     number = __rt_ffs(rt_thread_ready_priority_group) - 1;
    11.     highest_ready_priority = (number << 3) + __rt_ffs(rt_thread_ready_table[number]) - 1;
    12. #else
    13.     highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group) - 1;
    14. #endif
    15.  
    16.     /* 获取要切换的线程 */
    17.     to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
    18.                               struct rt_thread,
    19.                               tlist);
    20.  
    21.     rt_current_thread = to_thread;
    22.  
    23.     /* 切换到新线程 */
    24.     rt_hw_context_switch_to((rt_uint32_t)&to_thread->sp);
    25.  
    26.     /* never come back */
    27. }

    3、rt_schedule_insert_thread()函数

    此函数用于将线程加入到调度器。

    1）改变线程状态为RT_THREAD_READY

    2）将线程插入到就绪链链表

    3）设置优先级就绪相关变量(rt_thread_ready_table和rt_thread_ready_priority_group )

    1. void rt_schedule_insert_thread(struct rt_thread *thread)
    2. {
    3.     register rt_base_t temp;
    4.  
    5.     RT_ASSERT(thread != RT_NULL);
    6.  
    7.     temp = rt_hw_interrupt_disable(); //关中断
    8.  
    9.     thread->stat = RT_THREAD_READY | (thread->stat & ~RT_THREAD_STAT_MASK); //改变线程状态为RT_THREAD_READY
    10.  
    11.     rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]),
    12.                           &(thread->tlist)); //将线程插入到就绪链链表
    13.  
    14.     /* 打印信息 */
    15. #if RT_THREAD_PRIORITY_MAX <= 32
    16.     RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("insert thread[%.*s], the priority: %d\n",
    17.                                       RT_NAME_MAX, thread->name, thread->current_priority));
    18. #else
    19.     RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
    20.                  ("insert thread[%.*s], the priority: %d 0x%x %d\n",
    21.                   RT_NAME_MAX,
    22.                   thread->name,
    23.                   thread->number,
    24.                   thread->number_mask,
    25.                   thread->high_mask));
    26. #endif
    27.  
    28.     /* 设置优先级就绪相关变量 */
    29. #if RT_THREAD_PRIORITY_MAX > 32
    30.     rt_thread_ready_table[thread->number] |= thread->high_mask;
    31. #endif
    32.     rt_thread_ready_priority_group |= thread->number_mask; 
    33.  
    34.     rt_hw_interrupt_enable(temp); //开中断
    35. }

    4、rt_schedule_remove_thread()函数

    此函数用于从调度器移除线程。

    1）从就绪链表移除线程节点

    2）如果当前优先级没有其他就绪的线程，则取消该优先级的就绪

    1. void rt_schedule_remove_thread(struct rt_thread *thread)
    2. {
    3.     register rt_base_t temp;
    4.  
    5.     RT_ASSERT(thread != RT_NULL);
    6.  
    7.     temp = rt_hw_interrupt_disable(); //关中断
    8.  
    9.     /* 打印信息 */
    10. #if RT_THREAD_PRIORITY_MAX <= 32
    11.     RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("remove thread[%.*s], the priority: %d\n",
    12.                                       RT_NAME_MAX, thread->name,
    13.                                       thread->current_priority));
    14. #else
    15.     RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
    16.                  ("remove thread[%.*s], the priority: %d 0x%x %d\n",
    17.                   RT_NAME_MAX,
    18.                   thread->name,
    19.                   thread->number,
    20.                   thread->number_mask,
    21.                   thread->high_mask));
    22. #endif
    23.  
    24.     rt_list_remove(&(thread->tlist)); //从就绪链表移除线程节点
    25.  
    26.     /* 如果当前优先级没有其他就绪的线程，则取消该优先级的就绪 */
    27.     if (rt_list_isempty(&(rt_thread_priority_table[thread->current_priority])))
    28.     {
    29. #if RT_THREAD_PRIORITY_MAX > 32
    30.         rt_thread_ready_table[thread->number] &= ~thread->high_mask;
    31.         if (rt_thread_ready_table[thread->number] == 0)
    32.         {
    33.             rt_thread_ready_priority_group &= ~thread->number_mask;
    34.         }
    35. #else
    36.         rt_thread_ready_priority_group &= ~thread->number_mask;
    37. #endif
    38.     }
    39.  
    40.     rt_hw_interrupt_enable(temp); //开中断
    41. }

    5、rt_schedule()函数

    此函数用于进行一次调度。

    1）检查是否可以调度

    2）计算最高就绪优先级

    3）获取要切换的线程

    4）调用钩子回调函数

    5）如果使能栈检查，调用_rt_scheduler_stack_check()函数

    6）进行上下文切换

    1. void rt_schedule(void)
    2. {
    3.     rt_base_t level;
    4.     struct rt_thread *to_thread;
    5.     struct rt_thread *from_thread;
    6.  
    7.     level = rt_hw_interrupt_disable(); //关中断
    8.  
    9.     if (rt_scheduler_lock_nest == 0) //检查是否可以调度
    10.     {
    11.         register rt_ubase_t highest_ready_priority;
    12.         /* 计算最高就绪优先级 */
    13. #if RT_THREAD_PRIORITY_MAX <= 32
    14.         highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group) - 1;
    15. #else
    16.         register rt_ubase_t number;
    17.  
    18.         number = __rt_ffs(rt_thread_ready_priority_group) - 1;
    19.         highest_ready_priority = (number << 3) + __rt_ffs(rt_thread_ready_table[number]) - 1;
    20. #endif
    21.  
    22.         /* 获取要切换的线程 */
    23.         to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
    24.                                   struct rt_thread,
    25.                                   tlist);
    26.  
    27.         if (to_thread != rt_current_thread) //目标线程不等于当前线程
    28.         {
    29.             /* 设置当前优先级,当前线程控制块 */
    30.             rt_current_priority = (rt_uint8_t)highest_ready_priority; 
    31.             from_thread         = rt_current_thread; 
    32.             rt_current_thread   = to_thread;
    33.  
    34.             RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (from_thread, to_thread)); //调用回调函数
    35.  
    36.             /* 打印信息 */
    37.             RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
    38.                          ("[%d]switch to priority#%d "
    39.                           "thread:%.*s(sp:0x%p), "
    40.                           "from thread:%.*s(sp: 0x%p)\n",
    41.                           rt_interrupt_nest, highest_ready_priority,
    42.                           RT_NAME_MAX, to_thread->name, to_thread->sp,
    43.                           RT_NAME_MAX, from_thread->name, from_thread->sp));
    44.  
    45. #ifdef RT_USING_OVERFLOW_CHECK
    46.             _rt_scheduler_stack_check(to_thread);
    47. #endif
    48.  
    49.             /* 进行上下文切换 */
    50.             if (rt_interrupt_nest == 0)
    51.             {
    52.                 rt_hw_context_switch((rt_ubase_t)&from_thread->sp,
    53.                                      (rt_ubase_t)&to_thread->sp);
    54.  
    55.                 rt_hw_interrupt_enable(level); //开中断
    56.  
    57.                 return ;
    58.             }
    59.             else
    60.             {
    61.                 RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n"));
    62.  
    63.                 rt_hw_context_switch_interrupt((rt_ubase_t)&from_thread->sp,
    64.                                                (rt_ubase_t)&to_thread->sp);
    65.             }
    66.         }
    67.     }
    68.  
    69.     rt_hw_interrupt_enable(level); //开中断
    70. }

    6、_rt_scheduler_stack_check()函数

    此函数用于检查栈的情况。

    1. static void _rt_scheduler_stack_check(struct rt_thread *thread)
    2. {
    3.     RT_ASSERT(thread != RT_NULL);
    4.  
    5. #if defined(ARCH_CPU_STACK_GROWS_UPWARD)
    6.     if (*((rt_uint8_t *)((rt_ubase_t)thread->stack_addr + thread->stack_size - 1)) != '#' ||
    7. #else
    8.     if (*((rt_uint8_t *)thread->stack_addr) != '#' ||
    9. #endif
    10.         (rt_ubase_t)thread->sp <= (rt_ubase_t)thread->stack_addr ||
    11.         (rt_ubase_t)thread->sp >
    12.         (rt_ubase_t)thread->stack_addr + (rt_ubase_t)thread->stack_size)
    13.     {
    14.         rt_ubase_t level;
    15.  
    16.         rt_kprintf("thread:%s stack overflow\n", thread->name);
    17.  
    18.         level = rt_hw_interrupt_disable();
    19.         while (level);
    20.     }
    21. #if defined(ARCH_CPU_STACK_GROWS_UPWARD)
    22.     else if ((rt_ubase_t)thread->sp > ((rt_ubase_t)thread->stack_addr + thread->stack_size))
    23.     {
    24.         rt_kprintf("warning: %s stack is close to the top of stack address.\n",
    25.                    thread->name);
    26.     }
    27. #else
    28.     else if ((rt_ubase_t)thread->sp <= ((rt_ubase_t)thread->stack_addr + 32))
    29.     {
    30.         rt_kprintf("warning: %s stack is close to end of stack address.\n",
    31.                    thread->name);
    32.     }
    33. #endif
    34. }

    7、rt_enter_critical()函数

    当需要进入临界区时，调用此函数。

    1. void rt_enter_critical(void)
    2. {
    3.     register rt_base_t level;
    4.  
    5.     level = rt_hw_interrupt_disable(); //关中断
    6.  
    7.     rt_scheduler_lock_nest ++; //调度锁加1
    8.  
    9.     rt_hw_interrupt_enable(level); //开中断
    10. }

    8、rt_exit_critical()函数

    当需要退出临界区时，调用此函数。

    1. void rt_exit_critical(void)
    2. {
    3.     register rt_base_t level;
    4.  
    5.     level = rt_hw_interrupt_disable(); //关中断
    6.  
    7.     rt_scheduler_lock_nest --;
    8.     if (rt_scheduler_lock_nest <= 0)
    9.     {
    10.         rt_scheduler_lock_nest = 0;
    11.  
    12.         rt_hw_interrupt_enable(level); //开中断
    13.  
    14.         if (rt_current_thread)
    15.         {
    16.             rt_schedule(); //调度
    17.         }
    18.     }
    19.     else
    20.     {
    21.         rt_hw_interrupt_enable(level); //开中断
    22.     }
    23. }

    9、rt_critical_level()函数

    此函数用于返回rt_scheduler_lock_nest

    1. rt_uint16_t rt_critical_level(void)
    2. {
    3.     return rt_scheduler_lock_nest;
    4. }

    10、rt_scheduler_sethook()函数 

    设置调度锁回调钩子函数。

    1. void rt_scheduler_sethook(void (*hook)(struct rt_thread *from, struct rt_thread *to))
    2. {
    3.     rt_scheduler_hook = hook;
    4. }

  • 相关阅读:
    渗透测试流程是什么？7个步骤给你讲清楚！
    WebSocket编程golang
    websocket接口测试
    对话腾讯天琴董治：聊聊元宇宙与AI技术驱动虚拟人
    安装 DolphinDB Python API
    利用Helm在K8S上部署 PolarDB-X 集群（详细步骤--亲测！！！）
    树莓派4b装系统到运行 Blazor Linux 本地程序全记录
    Codeforces Round 848 (Div. 2)C
    Unity小技巧——清空所有事件中订阅的方法
    Python 和 Ruby 谁是最好的Web开发语言？
  • 原文地址：https://blog.csdn.net/qq_37932504/article/details/126477511